Main Page   Namespace List   Class Hierarchy   Compound List   File List   Namespace Members   Compound Members  

SIG_Program.cpp

00001 #include "SIGEL_Program/SIG_Program.h"
00002 #include "SIGEL_Program/SIG_ProgramLine.h"
00003 #include "SIGEL_Tools/SIG_Randomizer.h"
00004 #include "SIGEL_Tools/SIG_IO.h"
00005 
00006 #include "stdlib.h"
00007 #include "iostream.h" 
00008 
00009 #include <qprogressdialog.h> 
00010 
00011 
00012 SIGEL_Program::SIG_Program& SIGEL_Program::SIG_Program::operator =(SIGEL_Program::SIG_Program &prg)
00013 { 
00014   clear();
00015 
00016 #ifdef SIG_DEBUG
00017   for ( long int i=0; i<lines.size(); i++ )
00018     if (!lines[i])
00019       {
00020         SIGEL_Tools::SIG_IO::cerr << "Ouch [1] !!!! " << i << "\n";
00021         exit(1);
00022       };
00023 #endif
00024 
00025   for( long i=0; i<prg.getProgramLength(); i++ )
00026   {
00027      SIG_ProgramLine *newProgLine = new SIG_ProgramLine();
00028      *newProgLine = *prg.getLine( i );
00029      appendLine( newProgLine );
00030   }
00031 
00032 #ifdef SIG_DEBUG
00033   if( prg.getProgramLength() != lines.size() )
00034     {
00035       SIGEL_Tools::SIG_IO::cerr << "Ouch [2] !!!!\n"; 
00036       exit(1);
00037     };
00038 #endif
00039 
00040 #ifdef SIG_DEBUG
00041   for ( long int i=0; i<lines.size(); i++ )
00042     if (!lines[i])
00043       {
00044         SIGEL_Tools::SIG_IO::cerr << "Ouch [3] !!!! " << i << "\n";
00045         exit(1);
00046       };
00047 #endif
00048 
00049   return *this;
00050 }
00051 
00052 long SIGEL_Program::SIG_Program::getProgramLength()
00053 {
00054      return lines.size();
00055 }
00056 
00057 vector<SIGEL_Program::SIG_ProgramLine*> &SIGEL_Program::SIG_Program::getPrgLines()
00058 {
00059      return lines;
00060 }
00061 
00062 void SIGEL_Program::SIG_Program::printToString( QString &str )
00063 {
00064   
00065   for( long i=0; i<lines.size(); i++ )
00066     {
00067       QString buffer;
00068       lines[i]->printToString(buffer);
00069       str += buffer;
00070     };
00071 
00072 }
00073 
00074 void SIGEL_Program::SIG_Program::print()
00075 {
00076 
00077   for (int i=0; i<lines.size(); i++ ) lines[i]->print();
00078 
00079 }
00080 
00081 void SIGEL_Program::SIG_Program::writeToFile( QTextStream &file )
00082 {
00083   for( long i=0; i<getProgramLength(); i++ )
00084     {
00085       lines[i]->writeToFile(file);
00086     }
00087 
00088 }
00089 
00090 void SIGEL_Program::SIG_Program::clear()
00091 {
00092     for (int i=0; i<lines.size(); i++ ) delete lines[i];
00093     lines.clear();
00094 }
00095 
00096 void SIGEL_Program::SIG_Program::readFromFile( QTextStream &file )
00097 { 
00098    QString                         tmpLine,prg;
00099    int                             pos=-1;
00100    int                             oldpos=0;
00101    int                             lineCnt=0;
00102    SIGEL_Program::SIG_ProgramLine *prgLine;
00103  
00104 #ifdef SIG_DEBUG
00105 
00106    SIGEL_Tools::SIG_IO::cerr << "Reading Program: ... ";
00107    
00108 
00109 #endif
00110 
00111    if( getProgramLength() > 0 ) clear();
00112    
00113    prg=file.read();
00114 
00115 #ifdef SIG_DEBUG
00116 
00117    // SIGEL_Tools::SIG_IO::cerr << "The received program:\n";
00118    // cout<<"["<<prg<<"]\n\n";
00119 
00120 #endif
00121    
00122    while((pos=prg.find('\n',oldpos,false))!=-1)
00123      {
00124         tmpLine = prg.mid( oldpos, pos - oldpos );
00125         prgLine = new SIGEL_Program::SIG_ProgramLine();
00126         if( prgLine->readFromFile( tmpLine, prgLine ) )
00127           {
00128             appendLine( prgLine );
00129             lineCnt++;
00130           }
00131         oldpos = pos + 1;
00132      }
00133 
00134 #ifdef SIG_DEBUG
00135 
00136    SIGEL_Tools::SIG_IO::cerr << lineCnt << " LINES READ.\n";
00137 
00138 #endif
00139    
00140 }
00141 
00142 
00143 SIGEL_Program::SIG_ProgramLine *SIGEL_Program::SIG_Program::getLine( long no )
00144 {
00145 
00146 #ifdef SIG_DEBUG
00147   if ((no < 0) || (no >= lines.size()) || (!lines[no]))
00148   {
00149     SIGEL_Tools::SIG_IO::cerr << "Ouch [4] ! " << no << " " << lines[no] << "\n";
00150     exit(1);
00151   };
00152 #endif
00153 
00154   return lines[no];
00155 }
00156 
00157 
00158 void SIGEL_Program::SIG_Program::deleteLine( long no )
00159 {
00160   if( no<lines.size() )
00161     {
00162       delete lines[no];
00163   
00164       for( long i=no; i<lines.size()-1; i++)
00165          lines[ i ]=lines[ i + 1 ];  
00166 
00167       lines.resize( lines.size() - 1 );
00168     }
00169 }
00170 
00171 
00172 void SIGEL_Program::SIG_Program::appendLine( SIGEL_Program::SIG_ProgramLine *l )
00173 {
00174   lines.resize( getProgramLength() + 1 );
00175   lines[ getProgramLength() - 1 ] = l; 
00176 
00177 #ifdef SIG_DEBUG
00178   for ( long int i=0; i<lines.size(); i++ )
00179     if (!lines[i])
00180       {
00181         SIGEL_Tools::SIG_IO::cerr << "Ouch [5] ! " << i << "\n";
00182         exit(1);
00183       };
00184 #endif
00185 }
00186 
00187 void SIGEL_Program::SIG_Program::insertLine( long no, SIGEL_Program::SIG_ProgramLine *l )
00188 {
00189   lines.resize( getProgramLength() + 1 );
00190 
00191   for( long i=lines.size()-1; i>no; i--)
00192          lines[ i ]=lines[ i - 1 ];  
00193 
00194   lines[no] = l;
00195 }
00196 
00197    
00198 void SIGEL_Program::SIG_Program::importProgram( QString& filename )
00199 {
00200    QFile prgFile( filename );
00201 
00202    if( prgFile.open( IO_ReadOnly ) )
00203      {
00204        clear();
00205        QTextStream buffer( &prgFile );
00206        readFromFile( buffer );
00207        prgFile.close();
00208      }
00209    else
00210      SIGEL_Tools::SIG_IO::cerr << "Could not import program from "
00211                                << filename
00212                                << "!\n";  
00213 
00214 }
00215 
00216 void SIGEL_Program::SIG_Program::exportProgram( QString& filename )
00217 {
00218    QFile prgFile( filename );
00219 
00220    if( prgFile.open( IO_WriteOnly ) )
00221      {
00222        QTextStream buffer( &prgFile );
00223        writeToFile( buffer );
00224        prgFile.close();
00225      }
00226    else
00227      SIGEL_Tools::SIG_IO::cerr << "Could not export program to "
00228                                << filename
00229                                << "!\n";  
00230 }
00231 
00232 
00233 SIGEL_Program::SIG_Program::SIG_Program()
00234   : lines()
00235 {
00236 
00237 #ifdef SIG_DEBUG
00238   for ( long int i=0; i<lines.size(); i++ )
00239     if (!lines[i])
00240       {
00241         SIGEL_Tools::SIG_IO::cerr << "Ouch [4] ! " << i << "\n";
00242         exit(1);
00243       };
00244 #endif
00245 }
00246 
00247 
00248 void SIGEL_Program::SIG_Program::checkLength( long minimumLength, 
00249                                               long maximumLength, 
00250                                               SIGEL_Tools::SIG_Randomizer &r, 
00251                                               SIGEL_Robot::SIG_LanguageParameters &languageP,
00252                                               QArray< int > &prob,
00253                                               int &historyInfo )
00254 {
00255   long prgLength = getProgramLength();
00256   historyInfo    = 0;
00257 
00258   if( minimumLength > 0 )
00259     if( prgLength < minimumLength )
00260       {
00261 
00262 #ifdef SIG_DEBUG
00263 
00264        SIGEL_Tools::SIG_IO::cerr << "\n\n--> PROGRAM LENGTH ("
00265                                  << prgLength
00266                                  << ") TOO SHORT (minimum="
00267                                  << minimumLength
00268                                  << "): ";
00269 
00270 #endif   
00271        historyInfo = minimumLength - prgLength;
00272 
00273        for( long i = 0; i < minimumLength - prgLength; i++ )
00274          {
00275           SIG_ProgramLine *newLine = new SIGEL_Program::SIG_ProgramLine( r, 
00276                                                                          languageP,
00277                                                                          prob );
00278 
00279           // If there is a problem during the evolution, try to delete the following
00280           // instruction:
00281 
00282           newLine->setRobotinstruction( SIGEL_Program::NOP, 0, 0 );
00283 
00284           // If the problem is still existing, please try to delete the line 135 (resizeElements( 0 );)
00285           // within the function SIGEL_Program::SIG_ProgramLine::setRobotinstruction.
00286   
00287           appendLine( newLine );
00288          } 
00289 
00290 #ifdef SIG_DEBUG
00291 
00292        SIGEL_Tools::SIG_IO::cerr << "Program increased to " 
00293                                  << getProgramLength()
00294                                  << " lines.\n";
00295 #endif
00296        
00297       }
00298 
00299   prgLength = getProgramLength();
00300 
00301   if( maximumLength > 0 )
00302     if( prgLength > maximumLength )
00303       {
00304 
00305 #ifdef SIG_DEBUG
00306 
00307        SIGEL_Tools::SIG_IO::cerr << "\n\n--> PROGRAM LENGTH ("
00308                                  << prgLength
00309                                  << ") TOO LONG (maximum="
00310                                  << maximumLength
00311                                  << "): ";
00312 
00313 #endif 
00314        historyInfo = - prgLength - maximumLength; 
00315 
00316        for( long i = prgLength; i >= maximumLength; i-- )
00317           deleteLine( i );
00318 
00319 #ifdef SIG_DEBUG
00320 
00321        SIGEL_Tools::SIG_IO::cerr << "Program decreased to " 
00322                                  << getProgramLength()
00323                                  << " lines.\n";
00324 #endif
00325        historyInfo = 2;
00326       }
00327 }
00328 
00329 SIGEL_Program::SIG_Program::SIG_Program( SIGEL_GP::SIG_GPParameter &param, 
00330                                          SIGEL_Robot::SIG_LanguageParameters &languageP, 
00331                                          SIGEL_Tools::SIG_Randomizer& random )
00332   : lines()
00333 {
00334   generateRandomProgram( param, languageP, random );
00335 }
00336 
00337 void SIGEL_Program::SIG_Program::generateRandomProgram( SIGEL_GP::SIG_GPParameter &param, 
00338                                                         SIGEL_Robot::SIG_LanguageParameters &languageP, 
00339                                                         SIGEL_Tools::SIG_Randomizer& random )
00340 {
00341     clear();
00342 
00343     long n = param.getMinIndLength() + 
00344              random.getRandomInt( param.getMaxIndLength() - param.getMinIndLength() );
00345 
00346     for( long x=0; x<n; x++ )
00347       {
00348         SIG_ProgramLine *newLine = new SIGEL_Program::SIG_ProgramLine( random, 
00349                                                                        languageP,
00350                                                                        param.getInstructionProbabilities() );
00351 
00352         appendLine( newLine );
00353 
00354       }
00355 }
00356    
00357 SIGEL_Program::SIG_Program::~SIG_Program()
00358 {
00359 #ifdef SIG_DEBUG
00360 
00361   //  SIGEL_Tools::SIG_IO::cerr << "\nDestructor of PROGRAMM called!\n";
00362 
00363 #endif
00364   
00365    clear();
00366 }

Generated at Mon Sep 3 01:32:28 2001 for PG 368 - SIGEL by doxygen1.2.3 written by Dimitri van Heesch, © 1997-2000