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
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
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
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
00238
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 ®)
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
00352
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
00365
00366
00367
00368 #endif
00369
00370 }
00371
00372 void SIGEL_Program::SIG_ProgramLine::readOneRegisterAndIntegerConstant(QString &str,int ®1,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
00384
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
00403
00404
00405
00406
00407
00408
00409 #endif
00410
00411 }
00412
00413 void SIGEL_Program::SIG_ProgramLine::readTwoRegisters(QString &str,int ®1,int ®2)
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
00426
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
00445
00446
00447
00448
00449
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
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
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
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
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