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

SIG_ProgramLine.cpp

00001 #include "SIGEL_Program/SIG_ProgramLine.h"
00002 #include "SIGEL_Tools/SIG_Randomizer.h"
00003 #include "SIGEL_Tools/SIG_IO.h"
00004 
00005 #include "stdlib.h"
00006 #include "iostream.h"
00007 #include <qtextstream.h>
00008 
00009 SIGEL_Program::SIG_ProgramLine& SIGEL_Program::SIG_ProgramLine::operator =(SIGEL_Program::SIG_ProgramLine const & prgLine)
00010 { 
00011   SIG_ProgramLine &tmpPrgLine = const_cast< SIG_ProgramLine& >( prgLine );
00012 
00013   setRobotinstructionType( tmpPrgLine.getRobotinstructionType() );
00014 
00015   element.resize( tmpPrgLine.getNumberOfElements() );
00016 
00017   for( int i=0;i<tmpPrgLine.getNumberOfElements();i++ )
00018     setElement( i, tmpPrgLine.getElement(i) );
00019        
00020   return *this;
00021 }
00022 
00023 SIGEL_Program::SIG_ProgramLine::SIG_ProgramLine()
00024 {}
00025 
00026 SIGEL_Program::SIG_ProgramLine::~SIG_ProgramLine()
00027 {}
00028 
00029 void SIGEL_Program::SIG_ProgramLine::clearLine()
00030 {
00031   element.resize(0);
00032 }
00033 
00034 SIGEL_Program::SIG_ProgramLine::SIG_ProgramLine(SIGEL_Tools::SIG_Randomizer &r, 
00035                                                 SIGEL_Robot::SIG_LanguageParameters &languageP,
00036                                                 QArray< int > &prob )
00037 {
00038    generateRandomRobotInstruction(languageP, r, prob );
00039 }
00040 
00041 void SIGEL_Program::SIG_ProgramLine::setRobotinstructionType( Robotinstruction instr )
00042 {
00043   instructionType = instr;
00044 }
00045 
00046 void SIGEL_Program::SIG_ProgramLine::setRobotinstruction(SIGEL_Program::Robotinstruction instr, 
00047                                                          int op1,
00048                                                          int op2)
00049 {   
00050     setRobotinstructionType( instr );     
00051 
00052     switch( instr )
00053     {
00054        case SIGEL_Program::COPY:
00055             resizeElements( 2 );
00056             setElement( 0, op1 );
00057             setElement( 1, op2 );
00058             break;
00059 
00060        case SIGEL_Program::LOAD: 
00061             resizeElements( 2 );
00062             setElement( 0, op1 );
00063             setElement( 1, op2 );
00064             break;
00065 
00066        case SIGEL_Program::ADD:
00067             resizeElements( 2 );
00068             setElement( 0, op1 );
00069             setElement( 1, op2 );
00070             break;
00071 
00072        case SIGEL_Program::SUB: 
00073             resizeElements( 2 );
00074             setElement( 0, op1 );
00075             setElement( 1, op2 );
00076             break;
00077 
00078        case SIGEL_Program::MUL: 
00079             resizeElements( 2 );
00080             setElement( 0, op1 );
00081             setElement( 1, op2 );
00082             break;
00083 
00084        case SIGEL_Program::DIV: 
00085             resizeElements( 2 );
00086             setElement( 0, op1 );
00087             setElement( 1, op2 );
00088             break;
00089 
00090        case SIGEL_Program::MIN: 
00091             resizeElements( 2 );
00092             setElement( 0, op1 );
00093             setElement( 1, op2 );
00094             break;
00095 
00096        case SIGEL_Program::MAX: 
00097             resizeElements( 2 );
00098             setElement( 0, op1 );
00099             setElement( 1, op2 );
00100             break;
00101 
00102        case SIGEL_Program::CMP:
00103             resizeElements( 2 );
00104             setElement( 0, op1 );
00105             setElement( 1, op2 );
00106             break;
00107 
00108        case SIGEL_Program::JMP: 
00109             resizeElements( 1 );
00110             setElement( 0, op1 );
00111             break;
00112 
00113        case SIGEL_Program::SENSE:
00114             resizeElements( 1 );
00115             setElement( 0, op1);
00116             break;
00117 
00118        case SIGEL_Program::MOVE:
00119             resizeElements( 1 );
00120             setElement( 0, op1 );
00121             break;
00122 
00123        case SIGEL_Program::DELAY:
00124             resizeElements( 1 );
00125             setElement( 0, op1 ); 
00126             break;
00127 
00128        case SIGEL_Program::MOD: 
00129             resizeElements( 2 );
00130             setElement( 0, op1 );
00131             setElement( 1, op2 );
00132             break;
00133 
00134        case SIGEL_Program::NOP:  
00135             resizeElements( 0 );
00136             break;
00137      }
00138 }
00139 
00140 SIGEL_Program::Robotinstruction SIGEL_Program::SIG_ProgramLine::getRobotinstructionType()
00141 {
00142      return instructionType;
00143 }
00144 
00145 int SIGEL_Program::SIG_ProgramLine::getInstructionElement( int no )
00146 {
00147   if( no < element.size() )
00148     {
00149       return element[no];
00150     }
00151   else
00152     {
00153 
00154 #ifdef SIG_DEBUG
00155 
00156       SIGEL_Tools::SIG_IO::cerr << "\n[ProgramLine.cpp<getInstructionElement>]: Invalid access, no="
00157                                 << no << ", elementNo=" 
00158                                 << getNumberOfElements() << "\n";
00159 #endif
00160 
00161       // ToDo: Exception ???
00162       return 0;
00163     }  
00164 }
00165 
00166 QArray< int > SIGEL_Program::SIG_ProgramLine::getElementsArray()
00167 {
00168      return element;
00169 }
00170 
00171 int SIGEL_Program::SIG_ProgramLine::getElement( int no )
00172 {
00173   if( no < element.size() )
00174     {
00175       return element[no];
00176     }
00177   else
00178     {
00179 
00180 #ifdef SIG_DEBUG
00181 
00182       SIGEL_Tools::SIG_IO::cerr << "\n[ProgramLine.cpp<getInstructionElement>]: Invalid access, no="
00183                                 << no << ", elementNo=" 
00184                                 << getNumberOfElements() << "\n";
00185       
00186 #endif
00187 
00188       // ToDo: Exception ???
00189       return 0;
00190     }
00191 }
00192 
00193 void SIGEL_Program::SIG_ProgramLine::setElement(int no, int value)
00194 {
00195   if( no < element.size() )
00196     {
00197      element[no] = value;
00198     }
00199  
00200   else
00201     {
00202       element[no] = 0;
00203       // ToDo: Exception!
00204 
00205 #ifdef SIG_DEBUG
00206 
00207       SIGEL_Tools::SIG_IO::cerr << "\n[ProgramLine.cpp<setElement>]: Invalid access, no="
00208                                 << no << ", elementNo=" 
00209                                 << getNumberOfElements() << "\n";
00210      
00211 #endif
00212 
00213     }
00214 }
00215 
00216 int SIGEL_Program::SIG_ProgramLine::getNumberOfElements()
00217 {
00218   return element.size();
00219 }
00220 
00221 void SIGEL_Program::SIG_ProgramLine::print()
00222 {
00223   QString prgLine = "";
00224 
00225   printToString( prgLine );
00226   SIGEL_Tools::SIG_IO::cerr << prgLine;
00227 
00228 }
00229 
00230 void SIGEL_Program::SIG_ProgramLine::printToString(QString &lineStr)
00231 {
00232   
00233   bool ok = false;
00234 
00235 #ifdef SIG_DEBUG
00236 
00237   //SIGEL_Tools::SIG_IO::cerr << "\n LINE: ";
00238   //print(); 
00239  
00240 #endif
00241 
00242    lineStr="";
00243 
00244    switch( getRobotinstructionType() )
00245      {
00246      case SIGEL_Program::COPY:
00247           lineStr = "COPY " + lineStr.number( getElement( 0 ) ) + ","
00248                             + lineStr.number( getElement( 1 ) ) + "\n";
00249           ok = true;
00250           break;
00251 
00252      case SIGEL_Program::LOAD:
00253           lineStr = "LOAD " + lineStr.number( getElement( 0 ) ) + ","
00254                             + lineStr.number( getElement( 1 ) ) + "\n";
00255           ok = true;
00256           break;
00257 
00258      case SIGEL_Program::ADD:
00259           lineStr = "ADD " + lineStr.number( getElement( 0 ) ) + ","
00260                            + lineStr.number( getElement( 1 ) ) + "\n";
00261           ok = true;
00262           break;
00263 
00264      case SIGEL_Program::SUB:
00265           lineStr = "SUB " + lineStr.number( getElement( 0 ) ) + ","
00266                            + lineStr.number( getElement( 1 ) ) + "\n";
00267           ok = true;
00268           break;
00269 
00270      case SIGEL_Program::MUL:
00271           lineStr = "MUL " + lineStr.number( getElement( 0 ) ) + ","
00272                            + lineStr.number( getElement( 1 ) ) + "\n";
00273           ok = true;
00274           break;
00275 
00276      case SIGEL_Program::DIV:
00277           lineStr = "DIV " + lineStr.number( getElement( 0 ) ) + ", "
00278                            + lineStr.number( getElement( 1 ) ) + "\n";
00279           ok = true;
00280           break;
00281 
00282      case SIGEL_Program::MIN:
00283           lineStr = "MIN " + lineStr.number( getElement( 0 ) ) + ","
00284                            + lineStr.number( getElement( 1 ) ) + "\n";
00285           ok = true;
00286           break;
00287 
00288      case SIGEL_Program::MAX:
00289           lineStr = "MAX " + lineStr.number( getElement( 0 ) ) + ","
00290                            + lineStr.number( getElement( 1 ) ) + "\n";
00291           ok = true;
00292           break;
00293 
00294      case SIGEL_Program::CMP:
00295           lineStr = "CMP " + lineStr.number( getElement( 0 ) ) + ","
00296                            + lineStr.number( getElement( 1 ) ) + "\n";
00297           ok = true;
00298           break;
00299 
00300      case SIGEL_Program::JMP:
00301           lineStr = "JMP " + lineStr.number( getElement( 0 ) ) + "\n";
00302           ok = true;
00303           break;
00304 
00305      case SIGEL_Program::SENSE:
00306           lineStr = "SENSE " + lineStr.number( getElement( 0 ) ) + "\n";
00307           ok = true;
00308           break;
00309 
00310      case SIGEL_Program::MOVE:
00311           lineStr = "MOVE " + lineStr.number( getElement( 0 ) )+ "\n";
00312           ok = true;
00313           break;
00314 
00315      case SIGEL_Program::DELAY:
00316           lineStr = "DELAY " + lineStr.number( getElement( 0 ) ) + "\n";
00317           ok = true;
00318           break;
00319 
00320      case SIGEL_Program::MOD:
00321           lineStr = "MOD " + lineStr.number( getElement( 0 ) ) + ","
00322                            + lineStr.number( getElement( 1 ) ) + "\n";
00323           ok = true;
00324           break;
00325 
00326      case SIGEL_Program::NOP:
00327           lineStr = "NOP\n";
00328           ok = true;
00329           break;
00330 
00331      }
00332 
00333   if( !ok ) lineStr = "#INVALID LINE#\n";  
00334 }
00335 
00336 void SIGEL_Program::SIG_ProgramLine::resizeElements(int size)
00337 {
00338   element.resize(size);
00339 }
00340 
00341 void SIGEL_Program::SIG_ProgramLine::readOneRegister(QString &str, int &reg)
00342 {
00343      int     pos1 = -1,pos2 = -1;
00344      QString regStr1;
00345      bool    ok;
00346 
00347      str=str.simplifyWhiteSpace() + '\n' ;
00348 
00349 #ifdef SIG_DEBUG
00350 
00351      // SIGEL_Tools::SIG_IO::cerr << "\nLINE TO READ: ";    
00352      // SIGEL_Tools::SIG_IO::cerr << str;
00353      
00354 #endif     
00355 
00356      pos1    = str.find( ' ', 1, false );
00357      pos2    = str.find( '\n', 1, false );
00358 
00359      regStr1 = str.mid( pos1 + 1, pos2 - pos1 - 1 );
00360      reg     = regStr1.toInt( &ok, 10 );
00361 
00362 #ifdef SIG_DEBUG     
00363 
00364      // SIGEL_Tools::SIG_IO::cerr << " One Register <"
00365      //                           << regStr1
00366      //                           << "> found.";
00367 
00368 #endif
00369 
00370 }
00371 
00372 void SIGEL_Program::SIG_ProgramLine::readOneRegisterAndIntegerConstant(QString &str,int &reg1,int &cnst)
00373 {
00374      int     pos1=-1, pos2=-1, pos3=-1, pos4=-1;
00375      QString regStr1;
00376      QString cnstStr1;
00377      bool    ok;
00378 
00379      str=str.simplifyWhiteSpace() + '\n';
00380 
00381 #ifdef SIG_DEBUG
00382 
00383      // SIGEL_Tools::SIG_IO::cerr << "\nLINE TO READ: ";    
00384      // SIGEL_Tools::SIG_IO::cerr << str;
00385      
00386 #endif
00387   
00388      pos1     = str.find( ' ' , 1, false );
00389      pos2     = str.find( ',' , pos1, false );
00390 
00391      pos3     = pos2;
00392      pos4     = str.find( '\n' , pos2 + 1 , false );
00393 
00394      regStr1  = str.mid( pos1 + 1, pos2 - pos1 - 1 );        
00395      reg1     = regStr1.toInt( &ok, 10 );
00396 
00397      cnstStr1 = str.mid( pos3 + 1, pos4 - pos3 - 1 );         
00398      cnst     = cnstStr1.toInt( &ok, 10 );
00399 
00400 #ifdef SIG_DEBUG
00401 
00402      // SIGEL_Tools::SIG_IO::cerr << " One Register <"
00403      //                           << regStr1
00404      //                           << "> and one constant ";
00405      // SIGEL_Tools::SIG_IO::cerr << "<"
00406      //                           << cnstStr1
00407      //                           << "> found.";
00408      
00409 #endif
00410 
00411 }
00412 
00413 void SIGEL_Program::SIG_ProgramLine::readTwoRegisters(QString &str,int &reg1,int &reg2)
00414 {
00415      int     pos1 = -1, pos2 = -1, pos3 = -1, pos4 = -1;
00416      bool    ok;
00417      QString regStr1,regStr2;
00418 
00419      str  = str.simplifyWhiteSpace() + '\n';
00420 
00421      pos1 = str.find( ' ', pos1, false );
00422 
00423 #ifdef SIG_DEBUG
00424 
00425      // SIGEL_Tools::SIG_IO::cerr << "\nLINE TO READ: ";    
00426      // SIGEL_Tools::SIG_IO::cerr << str;
00427      
00428 #endif
00429 
00430      pos1    = str.find( ' ', 1, false );
00431      pos2    = str.find( ',', pos1, false );
00432 
00433      pos3    = pos2;
00434      pos4    = str.find( '\n', pos2 + 1, false );
00435 
00436      regStr1 = str.mid( pos1 + 1, pos2 - pos1 - 1 );        
00437      reg1    = regStr1.toInt( &ok, 10);
00438 
00439      regStr2 = str.mid( pos3 + 1, pos4 - pos3 - 1 );         
00440      reg2    = regStr2.toInt( &ok, 10 );
00441 
00442 #ifdef SIG_DEBUG
00443 
00444      // SIGEL_Tools::SIG_IO::cerr << " Two Registers <"
00445      //                           << regStr1
00446      //                           << "> and ";
00447      // SIGEL_Tools::SIG_IO::cerr << "<"
00448      //                           << regStr2
00449      //                           << "> found.";
00450      
00451 #endif
00452 
00453 }
00454 
00455 
00456 bool SIGEL_Program::SIG_ProgramLine::readFromFile(QString &str, SIGEL_Program::SIG_ProgramLine *line)
00457 {
00458      int  reg1=0, reg2=0;
00459      int  cnst1=0;
00460      bool lineOK = false;
00461 
00462 #ifdef SIG_DEBUG
00463 
00464      //     SIGEL_Tools::SIG_IO::cerr << ".";
00465      
00466 #endif
00467 
00468      if(str.contains("COPY",false))
00469         {
00470            readTwoRegisters(str,reg1,reg2);
00471            line->setRobotinstruction( SIGEL_Program::COPY, reg1, reg2 );
00472            lineOK = true;
00473         }
00474      if(str.contains("LOAD",false))
00475         {
00476            readOneRegisterAndIntegerConstant(str,reg1,cnst1);
00477            line->setRobotinstruction( SIGEL_Program::LOAD, reg1, cnst1 );
00478            lineOK = true;
00479         }
00480      if(str.contains("ADD",false))
00481         {
00482            readTwoRegisters(str,reg1,reg2);
00483            line->setRobotinstruction( SIGEL_Program::ADD, reg1, reg2 );
00484            lineOK = true;
00485         }
00486      if(str.contains("SUB",false))
00487         { 
00488            readTwoRegisters(str,reg1,reg2);
00489            line->setRobotinstruction( SIGEL_Program::SUB, reg1, reg2 );
00490            lineOK = true;
00491         }
00492      if(str.contains("MUL",false))
00493         {
00494            readTwoRegisters(str,reg1,reg2);
00495            line->setRobotinstruction( SIGEL_Program::MUL, reg1, reg2 );
00496            lineOK = true;
00497         }
00498      if(str.contains("DIV",false))
00499         {
00500            readTwoRegisters(str,reg1,reg2);
00501            line->setRobotinstruction( SIGEL_Program::DIV, reg1, reg2 );
00502            lineOK = true;
00503         }
00504      if(str.contains("MIN",false))
00505         {
00506            readTwoRegisters(str,reg1,reg2);
00507            line->setRobotinstruction( SIGEL_Program::MIN, reg1, reg2 );
00508            lineOK = true;
00509         }
00510      if(str.contains("MAX",false))
00511         {
00512            readTwoRegisters(str,reg1,reg2);
00513            line->setRobotinstruction( SIGEL_Program::MAX, reg1, reg2 );
00514            lineOK = true;
00515         }
00516      if(str.contains("CMP",false))
00517         {
00518            readTwoRegisters(str,reg1,reg2);
00519            line->setRobotinstruction( SIGEL_Program::CMP, reg1, reg2 );
00520            lineOK = true;
00521         }
00522      if(str.contains("MOVE",false))
00523         {
00524            readOneRegister(str,reg1);
00525            line->setRobotinstruction( SIGEL_Program::MOVE, reg1, reg2 );
00526            lineOK = true;
00527         }
00528      if(str.contains("SENSE",false))
00529         {
00530            readOneRegister(str,reg1);
00531            line->setRobotinstruction( SIGEL_Program::SENSE, reg1, reg2 );
00532            lineOK = true;
00533         }
00534      if(str.contains("DELAY",false))
00535         {
00536            readOneRegister(str,reg1);
00537            line->setRobotinstruction( SIGEL_Program::DELAY, reg1, reg2 );
00538            lineOK = true;
00539         }
00540      if(str.contains("JMP",false))
00541         {
00542            readOneRegister(str,reg1);
00543            line->setRobotinstruction( SIGEL_Program::JMP, reg1, reg2 );
00544            lineOK = true;
00545         }
00546      if(str.contains("MOD",false))
00547         {
00548            readTwoRegisters(str,reg1,reg2);
00549            line->setRobotinstruction( SIGEL_Program::MOD, reg1, reg2 );
00550            lineOK = true;
00551         }
00552      if(str.contains("NOP",false))
00553         {
00554           line->setRobotinstruction( SIGEL_Program::NOP, reg1, reg2 );
00555           lineOK = true;
00556         }
00557 
00558      return lineOK;
00559 }
00560 
00561 
00562 
00563 void  SIGEL_Program::SIG_ProgramLine::writeToFile(QTextStream &file)
00564 {
00565 
00566    file<<"       ";
00567 
00568    switch( getRobotinstructionType() )
00569    {
00570       case SIGEL_Program::COPY:
00571            file << "COPY " 
00572                 << getElement( 0 ) << "," 
00573                 << getElement( 1 ) << '\n';
00574            break;
00575 
00576       case SIGEL_Program::LOAD:
00577            file << "LOAD " 
00578                 << getElement( 0 ) << "," 
00579                 << getElement( 1 ) << '\n';
00580            break;
00581  
00582       case SIGEL_Program::ADD:
00583            file << "ADD " 
00584                 << getElement( 0 ) << "," 
00585                 << getElement( 1 ) << '\n';
00586            break;
00587 
00588       case SIGEL_Program::SUB:
00589            file << "SUB " 
00590                 << getElement( 0 ) << "," 
00591                 << getElement( 1 ) << '\n';
00592            break;
00593 
00594       case SIGEL_Program::MUL:
00595            file << "MUL "
00596                 << getElement( 0 ) << ","
00597                 << getElement( 1 ) << '\n';
00598            break;
00599 
00600       case SIGEL_Program::DIV:
00601            file << "DIV "
00602                 << getElement( 0 ) << ","
00603                 << getElement( 1 ) << '\n';
00604            break;
00605 
00606       case SIGEL_Program::MIN:
00607            file << "MIN "
00608                 << getElement( 0 ) << ","
00609                 << getElement( 1 ) << '\n';
00610            break;
00611 
00612       case SIGEL_Program::MAX:
00613            file << "MAX "
00614                 << getElement( 0 ) << ","
00615                 << getElement( 1 ) << '\n';
00616            break;
00617 
00618       case SIGEL_Program::CMP:
00619            file << "CMP "
00620                 << getElement( 0 ) << ","
00621                 << getElement( 1 ) << '\n';
00622            break;
00623 
00624       case SIGEL_Program::JMP:
00625            file << "JMP "
00626                 << getElement( 0 ) << '\n';
00627            break;
00628 
00629       case SIGEL_Program::SENSE:
00630            file << "SENSE "
00631                 << getElement( 0 ) << '\n';
00632            break;
00633 
00634       case SIGEL_Program::MOVE:
00635            file << "MOVE "
00636                 << getElement( 0 ) << '\n';
00637            break;
00638 
00639       case SIGEL_Program::DELAY:
00640            file << "DELAY "
00641                 << getElement( 0 ) << '\n';
00642            break;
00643 
00644       case SIGEL_Program::MOD:
00645            file << "MOD "
00646                 << getElement( 0 ) << ","
00647                 << getElement( 1 ) << '\n';
00648            break;
00649  
00650       case SIGEL_Program::NOP:
00651            file <<"NOP " <<'\n';
00652            break;
00653       }
00654 }
00655 
00656 
00657 void SIGEL_Program::SIG_ProgramLine::randomRobotinstruction(SIGEL_Robot::SIG_LanguageParameters &languageP,
00658                                                             SIGEL_Tools::SIG_Randomizer &r,
00659                                                             QArray< int > &prob   )
00660 {
00661      // QArray<int> instr;
00662 
00663      int          maximum = 32000; 
00664      int          op1 = 0, 
00665                   op2 = 0, 
00666                   iType = 0,
00667                   n = 0;
00668      long         maximumValue = 0,
00669                   randomValue = 0,
00670                   accuValue = 0;
00671      bool         cont = true;
00672      QArray<bool> hasCommand;
00673 
00674      hasCommand.resize( 15 );
00675      hasCommand.fill( false );
00676 
00677      // getAllowedRobotinstructionsWithProb( instr, languageP, prob );
00678      
00679      op1 = r.getRandomInt( maximum );
00680      op2 = r.getRandomInt( maximum );
00681 
00682      if( r.getRandomInt(2) == 1 ) op1 = (-1) * op1;
00683      if( r.getRandomInt(2) == 1 ) op2 = (-1) * op2;
00684 
00685      if( languageP.hasCommand("COPY") )
00686        {
00687          maximumValue += prob[0];
00688          hasCommand[0] = true;
00689        }
00690          
00691      if( languageP.hasCommand("LOAD") )
00692        { 
00693          maximumValue += prob[1];
00694          hasCommand[1] = true;
00695        }
00696 
00697      if( languageP.hasCommand("ADD") ) 
00698        {
00699          maximumValue += prob[2];
00700          hasCommand[2] = true;
00701        }
00702 
00703      if( languageP.hasCommand("SUB") ) 
00704        {
00705          maximumValue += prob[3];
00706          hasCommand[3] = true;
00707        }
00708 
00709      if( languageP.hasCommand("MUL") )
00710        {
00711          maximumValue +=  prob[4];
00712          hasCommand[4] = true;
00713        }
00714 
00715      if( languageP.hasCommand("DIV") )
00716        {
00717          maximumValue += prob[5];
00718          hasCommand[5] = true;
00719        }
00720 
00721      if( languageP.hasCommand("MOD") )
00722        {
00723          maximumValue += prob[6];
00724          hasCommand[6] = true;
00725        }
00726 
00727      if( languageP.hasCommand("MIN") ) 
00728        {
00729          maximumValue += prob[7];
00730          hasCommand[7] = true;
00731        }
00732 
00733      if( languageP.hasCommand("MAX") ) 
00734        {
00735          maximumValue +=  prob[8];
00736          hasCommand[8] = true;
00737        }
00738 
00739      if( languageP.hasCommand("CMP") )
00740        {
00741          maximumValue +=  prob[9];
00742          hasCommand[9] = true;
00743        }
00744 
00745      if( languageP.hasCommand("JMP") ) 
00746        {
00747          maximumValue +=  prob[10];
00748          hasCommand[10] = true;
00749        }
00750 
00751      if( languageP.hasCommand("SENSE") ) 
00752        {
00753          maximumValue +=  prob[11];
00754          hasCommand[11] = true;
00755        }
00756 
00757      if( languageP.hasCommand("MOVE") )
00758        {
00759          maximumValue +=  prob[12];
00760          hasCommand[12] = true;
00761        }
00762 
00763      if( languageP.hasCommand("DELAY") )
00764        {
00765          maximumValue +=  prob[13];
00766          hasCommand[13] = true;
00767        }
00768 
00769      if( languageP.hasCommand("NOP") )
00770        {
00771          maximumValue += prob[14];
00772          hasCommand[14] = true;
00773        }
00774                 
00775      if( maximumValue == 0 )
00776         SIGEL_Tools::SIG_IO::cerr << "\nERROR: If no instructions are allowed, no instructions can be used !\n";
00777 
00778      randomValue = r.getRandomLong( maximumValue );
00779   
00780      while( cont )
00781        { 
00782          if( (hasCommand[0]) && (n == 0) ) accuValue += prob[0];
00783          if( (hasCommand[1]) && (n == 1) ) accuValue += prob[1];
00784          if( (hasCommand[2]) && (n == 2) ) accuValue += prob[2];
00785          if( (hasCommand[3]) && (n == 3) ) accuValue += prob[3];
00786          if( (hasCommand[4]) && (n == 4) ) accuValue += prob[4];
00787          if( (hasCommand[5]) && (n == 5) ) accuValue += prob[5];
00788          if( (hasCommand[6]) && (n == 6) ) accuValue += prob[6];
00789          if( (hasCommand[7]) && (n == 7) ) accuValue += prob[7];
00790          if( (hasCommand[8]) && (n == 8) ) accuValue += prob[8];
00791          if( (hasCommand[9]) && (n == 9) ) accuValue += prob[9];
00792          if( (hasCommand[10]) && (n == 10) ) accuValue += prob[10];
00793          if( (hasCommand[11]) && (n == 11) ) accuValue += prob[11];
00794          if( (hasCommand[12]) && (n == 12) ) accuValue += prob[12];
00795          if( (hasCommand[13]) && (n == 13) ) accuValue += prob[13];
00796          if( (hasCommand[14]) && (n == 14) ) accuValue += prob[14];
00797 
00798          if( n == 14 ) cont = false;
00799          
00800          if( randomValue < accuValue )
00801            {
00802              cont  = false;
00803              iType = n;
00804            }
00805          
00806          n++;
00807        }
00808        
00809      
00810 
00811      // iType = instr[r.getRandomInt( instr.size() )]; 
00812 
00813      switch( iType )
00814        {
00815         case 0: setRobotinstruction( SIGEL_Program::COPY, op1, op2 );
00816                 break;
00817         case 1: setRobotinstruction( SIGEL_Program::LOAD, op1, op2 );
00818                 break;
00819         case 2: setRobotinstruction( SIGEL_Program::ADD, op1, op2 );
00820                 break;
00821         case 3: setRobotinstruction( SIGEL_Program::SUB, op1, op2 );
00822                 break;
00823         case 4: setRobotinstruction( SIGEL_Program::MUL, op1, op2 );
00824                 break;
00825         case 5: setRobotinstruction( SIGEL_Program::DIV, op1, op2 );
00826                 break;
00827         case 6: setRobotinstruction( SIGEL_Program::MOD, op1, op2 );
00828                 break;
00829         case 7: setRobotinstruction( SIGEL_Program::MIN, op1, op2 );
00830                 break;
00831         case 8: setRobotinstruction( SIGEL_Program::MAX, op1, op2 );
00832                 break;
00833         case 9: setRobotinstruction( SIGEL_Program::CMP, op1, op2 );
00834                 break;
00835         case 10:setRobotinstruction( SIGEL_Program::JMP, op1, op2 );
00836                 break;
00837         case 11:setRobotinstruction( SIGEL_Program::SENSE, op1, op2 );
00838                 break;
00839         case 12:setRobotinstruction( SIGEL_Program::MOVE, op1, op2 );
00840                 break;
00841         case 13:setRobotinstruction( SIGEL_Program::DELAY, op1, op2 );
00842                 break;
00843         case 14:setRobotinstruction( SIGEL_Program::NOP, op1, op2 );
00844                 break;
00845        }
00846 
00847 }
00848 
00849 void SIGEL_Program::SIG_ProgramLine::generateRandomRobotInstruction(SIGEL_Robot::SIG_LanguageParameters &languageP,
00850                                                                     SIGEL_Tools::SIG_Randomizer &r,
00851                                                                     QArray< int > &prob   )
00852 {
00853      randomRobotinstruction(languageP, r, prob);
00854 }
00855 
00856 
00857 void SIGEL_Program::SIG_ProgramLine::copyLine(SIGEL_Program::SIG_ProgramLine *source,SIGEL_Program::SIG_ProgramLine *destination)
00858 {
00859    *destination=*source;
00860 };
00861 
00862 
00863 
00864 
00865 
00866 
00867 
00868 
00869 

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