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

SIG_GPParameter.cpp

00001 #include "SIGEL_GP/SIG_GPParameter.h"
00002 
00003 
00004 SIGEL_GP::SIG_GPParameter::SIG_GPParameter()
00005 : randomSeed(0),
00006   minIndLength(3),
00007   maxIndLength(1024),
00008   reproductionProb(340),
00009   xoverProb(330),
00010   mutationProb(330),
00011   tournamentsPerGeneration(0.5),
00012   maxAge(50),
00013   maxFitness(50),
00014   liveUndead(false),
00015   poolImageGeneration(0),
00016   saveExit(true),
00017   terminationGenerationNo(0),
00018   terminationModel(byUser),
00019   fitnessName( "SimpleFitnessFunction" ),
00020   parsimonyPressure(false),
00021   terminationUsesDate(true),
00022   terminationDurationDays(0),
00023   terminationDurationHours(0),
00024   terminationDurationMinutes(0),
00025   terminationDurationSeconds(0),
00026   timeOutMinutes(0),
00027   hostList()
00028 {
00029   hostList.setAutoDelete( true );
00030   terminationTime=terminationTime.currentDateTime();
00031   setPriority(veryLow);
00032   instructionProb.resize( 15 );
00033   instructionProb.fill( 1000 );
00034 };
00035 
00036 SIGEL_GP::SIG_GPParameter::SIG_GPParameter(QString parameter)
00037 { };
00038 
00039 SIGEL_GP::SIG_GPParameter::~SIG_GPParameter()
00040 { };
00041 
00042 void SIGEL_GP::SIG_GPParameter::setRandomSeed (int seed)
00043 {
00044     randomSeed=seed;
00045 };
00046 
00047 int SIGEL_GP::SIG_GPParameter::getRandomSeed() const
00048 { 
00049    return randomSeed;
00050 };
00051 
00052 bool SIGEL_GP::SIG_GPParameter::getParsimonyPressure()
00053 {
00054     return parsimonyPressure;
00055 };
00056   
00057  
00058 void SIGEL_GP::SIG_GPParameter::setParsimonyPressure( bool pressure )
00059 {
00060     parsimonyPressure = pressure;
00061 };
00062 
00063 void SIGEL_GP::SIG_GPParameter::setMinIndLength (int minIndLen)
00064 {
00065     minIndLength=minIndLen; 
00066 };
00067 
00068 int SIGEL_GP::SIG_GPParameter::getMinIndLength() const
00069 {
00070     return minIndLength;
00071 };
00072 
00073 void SIGEL_GP::SIG_GPParameter::setMaxIndLength (int maxIndLen)
00074 {
00075     maxIndLength=maxIndLen;
00076 };
00077 
00078 int SIGEL_GP::SIG_GPParameter::getMaxIndLength() const
00079 {
00080    return maxIndLength;
00081 };
00082 
00083 void SIGEL_GP::SIG_GPParameter::setReproductionProb(int prob)
00084 {
00085     reproductionProb=prob;
00086 };
00087 
00088 int SIGEL_GP::SIG_GPParameter::getReproductionProb() const
00089 {
00090    return reproductionProb;
00091 };
00092 
00093 void SIGEL_GP::SIG_GPParameter::setXoverProb(int prob)
00094 {
00095    xoverProb=prob;
00096 };
00097 
00098 int SIGEL_GP::SIG_GPParameter::getXoverProb() const
00099 {
00100    return xoverProb;
00101 };
00102 
00103 void SIGEL_GP::SIG_GPParameter::setMutationProb(int prob)
00104 {
00105    mutationProb=prob;
00106 };
00107 
00108 int  SIGEL_GP::SIG_GPParameter::getMutationProb() const
00109 {
00110    return mutationProb;
00111 };
00112 
00113 void  SIGEL_GP::SIG_GPParameter::setTournamentsPerGeneration(double prob)
00114 {
00115    tournamentsPerGeneration=prob;
00116 };
00117 
00118 double  SIGEL_GP::SIG_GPParameter::getTournamentsPerGeneration() const
00119 {
00120    return tournamentsPerGeneration;
00121 };
00122 
00123 void SIGEL_GP::SIG_GPParameter::setMaxAge(long int age)
00124 {
00125    maxAge=age;
00126 };
00127 
00128 long int SIGEL_GP::SIG_GPParameter::getMaxAge() const
00129 {
00130    return maxAge;
00131 };
00132 
00133 void SIGEL_GP::SIG_GPParameter::setPassiveTime(unsigned long pTime)
00134 {
00135    passiveTime=pTime;
00136 };
00137 
00138 unsigned long SIGEL_GP::SIG_GPParameter::getPassiveTime() const
00139 {
00140    return passiveTime;
00141 };
00142 
00143 void SIGEL_GP::SIG_GPParameter::setMaxTouchsPerLoop(int touchs)
00144 {
00145   maxTouchsPerLoop=touchs;
00146 };
00147 
00148 int SIGEL_GP::SIG_GPParameter::getMaxTouchsPerLoop() const
00149 {
00150    return maxTouchsPerLoop;
00151 };
00152 
00153 void SIGEL_GP::SIG_GPParameter::setToDoSweepsPerLoop(int sweeps)
00154 {
00155    toDoSweepsPerLoop=sweeps;
00156 };
00157 
00158 int SIGEL_GP::SIG_GPParameter::getToDoSweepsPerLoop() const
00159 {
00160    return toDoSweepsPerLoop;
00161 };
00162 
00163 void SIGEL_GP::SIG_GPParameter::setTerminationTime(QDateTime tTime)
00164 {
00165    terminationTime=tTime;
00166 };
00167 
00168 QDateTime SIGEL_GP::SIG_GPParameter::getTerminationTime() const
00169 {
00170    return terminationTime;
00171 };
00172 
00173 void SIGEL_GP::SIG_GPParameter::setTerminationDurationDays( int newValue )
00174 {
00175   terminationDurationDays = newValue;
00176 };
00177 
00178 int SIGEL_GP::SIG_GPParameter::getTerminationDurationDays() const
00179 {
00180   return terminationDurationDays;
00181 };
00182 
00183 void SIGEL_GP::SIG_GPParameter::setTerminationDurationHours( int newValue )
00184 {
00185   terminationDurationHours = newValue;
00186 };
00187 
00188 int SIGEL_GP::SIG_GPParameter::getTerminationDurationHours() const
00189 {
00190   return terminationDurationHours;
00191 };
00192 
00193 void SIGEL_GP::SIG_GPParameter::setTerminationDurationMinutes( int newValue )
00194 {
00195   terminationDurationMinutes = newValue;
00196 };
00197 
00198 int SIGEL_GP::SIG_GPParameter::getTerminationDurationMinutes() const
00199 {
00200   return terminationDurationMinutes;
00201 };
00202 
00203 void SIGEL_GP::SIG_GPParameter::setTerminationDurationSeconds( int newValue )
00204 {
00205   terminationDurationSeconds = newValue;
00206 };
00207 
00208 int SIGEL_GP::SIG_GPParameter::getTerminationDurationSeconds() const
00209 {
00210   return terminationDurationSeconds;
00211 };
00212 
00213 void SIGEL_GP::SIG_GPParameter::setTerminationGenerationNo (int tGenNo)
00214 {
00215     terminationGenerationNo=tGenNo;
00216 };
00217 
00218 int SIGEL_GP::SIG_GPParameter::getTerminationGenerationNo() const
00219 {
00220    return terminationGenerationNo;
00221 };
00222 
00223 void SIGEL_GP::SIG_GPParameter::setTerminationModel(terminationType termi)
00224 {
00225    terminationModel=termi;
00226 };
00227 
00228 SIGEL_GP::SIG_GPParameter::terminationType SIGEL_GP::SIG_GPParameter::getTerminationModel() const
00229 {
00230    return terminationModel;
00231 };
00232 
00233 void SIGEL_GP::SIG_GPParameter::setSaveExit(bool sexit)
00234 {
00235    saveExit=sexit;
00236 };
00237 
00238 bool SIGEL_GP::SIG_GPParameter::getSaveExit() const
00239 {
00240    return saveExit;
00241 };
00242 
00243 void SIGEL_GP::SIG_GPParameter::setGraveYardDirectory(QDir directory)
00244 {
00245    graveYardDirectory=directory;
00246 };
00247 
00248 QDir SIGEL_GP::SIG_GPParameter::getGraveYardDirectory() const
00249 {
00250    return graveYardDirectory;
00251 };
00252 
00253 void SIGEL_GP::SIG_GPParameter::setLiveUndead(bool grave)
00254 {
00255    liveUndead=grave;
00256 };
00257 
00258 bool SIGEL_GP::SIG_GPParameter::getLiveUndead() const
00259 {
00260    return liveUndead;
00261 };
00262 
00263 void SIGEL_GP::SIG_GPParameter::setPoolImageDirectory(QDir PIDir)
00264 {
00265    poolImageDirectory=PIDir;
00266 };
00267 
00268 QDir SIGEL_GP::SIG_GPParameter::getPoolImageDirectory() const
00269 {
00270    return poolImageDirectory;
00271 };
00272 
00273 void SIGEL_GP::SIG_GPParameter::setPoolImageGeneration(int gener)
00274 {
00275    poolImageGeneration=gener;
00276 };
00277 
00278 int SIGEL_GP::SIG_GPParameter::getPoolImageGeneration() const
00279 {
00280    return poolImageGeneration;
00281 };
00282   
00283 void SIGEL_GP::SIG_GPParameter::setPriority(priorityLevel prio)
00284 {
00285     priority=prio;
00286 
00287     // for each case, a special set of commands is given, depending on
00288     // the right configuration of each prioritylevel, which sets the
00289     // secondary priority values. these are:
00290     // passiveTime unsigned long
00291     // maxTouchesPerLoop int
00292     // toDoSweepsPerLoop int
00293  
00294     switch (priority)
00295       {
00296       case veryLow:
00297         setPassiveTime(1000);
00298         setMaxTouchsPerLoop(-1);
00299         setToDoSweepsPerLoop(1);
00300         break;
00301       case low:
00302         setPassiveTime(100);
00303         setMaxTouchsPerLoop(-1);
00304         setToDoSweepsPerLoop(1);
00305         break;
00306       case normal:
00307         setPassiveTime(50);
00308         setMaxTouchsPerLoop(-1);
00309         setToDoSweepsPerLoop(1);
00310         break;
00311       case high:
00312         setPassiveTime(10);
00313         setMaxTouchsPerLoop(-1);
00314         setToDoSweepsPerLoop(1);
00315         break;
00316       case veryHigh:
00317         setPassiveTime(1);
00318         setMaxTouchsPerLoop(-1);
00319         setToDoSweepsPerLoop(1);
00320         break;
00321       };
00322 };  
00323   
00324 SIGEL_GP::SIG_GPParameter::priorityLevel SIGEL_GP::SIG_GPParameter::getPriority() const
00325 {
00326    return priority;
00327 };
00328 
00329 double SIGEL_GP::SIG_GPParameter::getMaxFitness() const
00330 {
00331    return maxFitness;
00332    
00333 };
00334 
00335 void SIGEL_GP::SIG_GPParameter::setMaxFitness(double maxfit)
00336 {
00337    maxFitness=maxfit;
00338 };
00339 
00340 
00341 QString SIGEL_GP::SIG_GPParameter::getFitnessName() const
00342 {
00343    return fitnessName;
00344 };
00345 
00346 void SIGEL_GP::SIG_GPParameter::setFitnessName(QString name)
00347 {
00348    fitnessName=name;
00349 };
00350 
00351 void SIGEL_GP::SIG_GPParameter::readFromFile(QTextStream & file)
00352 {
00353   QString s;
00354   s=file.readLine(); //RANDOMSEED
00355   s=file.readLine();
00356   randomSeed=s.toInt();
00357   s=file.readLine(); //MININDLENGTH
00358   s=file.readLine();
00359   minIndLength=s.toInt();
00360   s=file.readLine(); //MAXINDLENGTH
00361   s=file.readLine();
00362   maxIndLength=s.toInt();
00363   s=file.readLine(); //REPRODUCTIONPROB
00364   s=file.readLine();
00365   reproductionProb=s.toInt();
00366   s=file.readLine(); //XOVERPROB
00367   s=file.readLine();
00368   xoverProb=s.toInt();
00369   s=file.readLine(); //MUTATIONPROB
00370   s=file.readLine();
00371   mutationProb=s.toInt();
00372   s=file.readLine(); //TOURNAMENTSPERGENERATION
00373   s=file.readLine();
00374   tournamentsPerGeneration=s.toDouble();
00375   s=file.readLine(); //MAXAGE
00376   s=file.readLine();
00377   maxAge=s.toInt();
00378   s=file.readLine(); //TERMINATIONTIME
00379   s=file.readLine();
00380   int year=s.toInt();
00381   s=file.readLine();
00382   int month=s.toInt();
00383   s=file.readLine();
00384   int day=s.toInt();
00385   s=file.readLine();
00386   int hour=s.toInt();
00387   s=file.readLine();
00388   int minute=s.toInt();
00389   s=file.readLine();
00390   int second=s.toInt();
00391   QDate date(year,month,day);
00392   QTime time(hour,minute,second,0);
00393   terminationTime.setDate(date);
00394   terminationTime.setTime(time);
00395   s=file.readLine(); //TERMINATIONGENERATIONNO
00396   s=file.readLine();
00397   terminationGenerationNo=s.toInt();
00398   s=file.readLine(); //TERMINATIONMODEL
00399   s=file.readLine();
00400   terminationModel=static_cast<terminationType>(s.toInt());
00401   s=file.readLine(); //SAVEEXIT
00402   s=file.readLine();
00403   int se=s.toInt();
00404   if (se==1)
00405     saveExit=true;
00406   else
00407     saveExit=false;  
00408   s=file.readLine(); //GRAVEYARDDIRECTORY
00409   s=file.readLine();
00410   graveYardDirectory.setPath(s);
00411   s=file.readLine(); //LIVEUNDEAD
00412   s=file.readLine();
00413   int lu=s.toInt();
00414   if (lu==1)
00415     liveUndead=true;
00416   else
00417     liveUndead=false;  
00418   s=file.readLine(); //POOLIMAGEDIRECTORY
00419   s=file.readLine();
00420   poolImageDirectory.setPath(s);
00421   s=file.readLine(); //POOLIMAGEGENERATION
00422   s=file.readLine();
00423   poolImageGeneration=s.toInt();
00424   s=file.readLine(); //PRIORITY
00425   s=file.readLine();
00426   setPriority(static_cast<priorityLevel>(s.toInt()));
00427   s=file.readLine(); //FITNESSNAME
00428   s=file.readLine();
00429   setFitnessName(s);
00430 
00431   s = file.readLine(); // TERMINATIONUSESDATE
00432   s = file.readLine();
00433   int terminationUsesDateInt = s.toInt();
00434   if (terminationUsesDateInt == 1)
00435     terminationUsesDate = true;
00436   else
00437     terminationUsesDate = false;
00438 
00439   s=file.readLine(); // PROBABILITY:ADD
00440   s=file.readLine();
00441   setProbability( SIGEL_Program::ADD, s.toInt() );
00442 
00443   s=file.readLine(); // PROBABILITY:SUB
00444   s=file.readLine();
00445   setProbability( SIGEL_Program::SUB, s.toInt() );
00446 
00447   s=file.readLine(); // PROBABILITY:MUL
00448   s=file.readLine();
00449   setProbability( SIGEL_Program::MUL, s.toInt() );
00450 
00451   s=file.readLine(); // PROBABILITY:DIV
00452   s=file.readLine();
00453   setProbability( SIGEL_Program::DIV, s.toInt() );
00454 
00455   s=file.readLine(); // PROBABILITY:LOAD
00456   s=file.readLine();
00457   setProbability( SIGEL_Program::LOAD, s.toInt() );
00458 
00459   s=file.readLine(); // PROBABILITY:COPY
00460   s=file.readLine();
00461   setProbability( SIGEL_Program::COPY, s.toInt() );
00462 
00463   s=file.readLine(); // PROBABILITY:MIN
00464   s=file.readLine();
00465   setProbability( SIGEL_Program::MIN, s.toInt() );
00466   
00467   s=file.readLine(); // PROBABILITY:MAX
00468   s=file.readLine();
00469   setProbability( SIGEL_Program::MAX, s.toInt() );
00470 
00471   s=file.readLine(); // PROBABILITY:CMP
00472   s=file.readLine();
00473   setProbability( SIGEL_Program::CMP, s.toInt() );
00474 
00475   s=file.readLine(); // PROBABILITY:JMP
00476   s=file.readLine();
00477   setProbability( SIGEL_Program::JMP, s.toInt() );
00478 
00479   s=file.readLine(); // PROBABILITY:MOVE
00480   s=file.readLine();
00481   setProbability( SIGEL_Program::MOVE, s.toInt() );
00482 
00483   s=file.readLine(); // PROBABILITY:SENSE
00484   s=file.readLine();
00485   setProbability( SIGEL_Program::SENSE, s.toInt() );
00486 
00487   s=file.readLine(); // PROBABILITY:DELAY
00488   s=file.readLine();
00489   setProbability( SIGEL_Program::DELAY, s.toInt() );
00490 
00491   s=file.readLine(); // PROBABILITY:NOP
00492   s=file.readLine();
00493   setProbability( SIGEL_Program::NOP, s.toInt() );
00494 
00495   s=file.readLine(); // PROBABILITY:MOD
00496   s=file.readLine();
00497   setProbability( SIGEL_Program::MOD, s.toInt() );
00498 
00499   s = file.readLine(); // TIMEOUTMINUTES
00500   s = file.readLine();
00501   setTimeOutMinutes( s.toInt() );
00502 
00503   s = file.readLine(); // TERMINATIONDURATIONDAYS
00504   s = file.readLine();
00505   setTerminationDurationDays( s.toInt() );
00506 
00507   s = file.readLine(); // TERMINATIONDURATIONHOURS
00508   s = file.readLine();
00509   setTerminationDurationHours( s.toInt() );
00510 
00511   s = file.readLine(); // TERMINATIONDURATIONMINUTES
00512   s = file.readLine();
00513   setTerminationDurationMinutes( s.toInt() );
00514 
00515   s = file.readLine(); // TERMINATIONDURATIONSECONDS
00516   s = file.readLine();
00517   setTerminationDurationSeconds( s.toInt() );
00518 
00519   QString buffer = file.readLine();
00520   buffer = file.readLine();
00521 
00522   hostList.clear();
00523 
00524   while (!buffer.isEmpty())
00525     {
00526       SIGEL_GP::SIG_GPPVMHost *newHost = new SIGEL_GP::SIG_GPPVMHost( buffer );
00527       hostList.append( newHost );
00528 
00529       buffer = file.readLine();
00530       buffer = file.readLine();
00531     };
00532 
00533 };
00534 
00535 void SIGEL_GP::SIG_GPParameter::writeToFile(QTextStream & file)
00536 {
00537   file << "RANDOMSEED\n";
00538   file << randomSeed << "\n";
00539   file << "MININDLENGTH\n";
00540   file << minIndLength << "\n";
00541   file << "MAXINDLENGTH\n";
00542   file << maxIndLength << "\n";
00543   file << "REPRODUCTIONPROB\n";
00544   file << reproductionProb << "\n";
00545   file << "XOVERPROB\n";
00546   file << xoverProb << "\n";
00547   file << "MUTATIONPROB\n";
00548   file << mutationProb << "\n";
00549   file << "TOURNAMENTSPERGENERATION\n";
00550   file << tournamentsPerGeneration << "\n";
00551   file << "MAXAGE\n";
00552   file << maxAge << "\n";
00553   file << "TERMINATIONTIME\n";
00554   file << terminationTime.date().year() << "\n";
00555   file << terminationTime.date().month() << "\n";
00556   file << terminationTime.date().day() << "\n";
00557   file << terminationTime.time().hour() << "\n";
00558   file << terminationTime.time().minute() << "\n";
00559   file << terminationTime.time().second() << "\n";
00560   file << "TERMINATIONGENERATIONNO\n";
00561   file << terminationGenerationNo << "\n";
00562   file << "TERMINATIONMODEL\n";
00563   file << static_cast<int>(terminationModel) << "\n";
00564   file << "SAVEEXIT\n";
00565   if (saveExit)
00566     file << 1 << "\n";
00567   else
00568     file << 0 << "\n";  
00569   file << "GRAVEYARDDIRECTORY\n";
00570   file << graveYardDirectory.path() << "\n";
00571   file << "LIVEUNDEAD\n";
00572   if (liveUndead)
00573     file << 1 << "\n";
00574   else
00575     file << 0 << "\n";  
00576   file << "POOLIMAGEDIRECTORY\n";
00577   file << poolImageDirectory.path() << "\n";
00578   file << "POOLIMAGEGENERATION\n";
00579   file << poolImageGeneration << "\n";
00580   file << "PRIORITY\n";
00581   file << static_cast<int>(priority) << "\n";
00582   file << "FITNESSNAME\n";
00583   file << fitnessName << "\n";
00584   file << "TERMINATIONUSESDATE\n";
00585   if (terminationUsesDate)
00586     file << "1\n";
00587   else
00588     file << "0\n";
00589 
00590   file << "PROBABILITY_ADD\n";
00591   file << getProbability(SIGEL_Program::ADD) << "\n";  
00592   file << "PROBABILITY_SUB\n";
00593   file << getProbability(SIGEL_Program::SUB) << "\n";
00594   file << "PROBABILITY_MUL\n";
00595   file << getProbability(SIGEL_Program::MUL) << "\n";
00596   file << "PROBABILITY_DIV\n";
00597   file << getProbability(SIGEL_Program::DIV) << "\n";
00598   file << "PROBABILITY_LOAD\n";
00599   file << getProbability(SIGEL_Program::LOAD) << "\n";
00600   file << "PROBABILITY_COPY\n";
00601   file << getProbability(SIGEL_Program::COPY) << "\n";
00602   file << "PROBABILITY_MIN\n";
00603   file << getProbability(SIGEL_Program::MIN) << "\n";
00604   file << "PROBABILITY_MAX\n";
00605   file << getProbability(SIGEL_Program::MAX) << "\n";
00606   file << "PROBABILITY_CMP\n";
00607   file << getProbability(SIGEL_Program::CMP) << "\n";
00608   file << "PROBABILITY_JMP\n";
00609   file << getProbability(SIGEL_Program::JMP) << "\n";
00610   file << "PROBABILITY_MOVE\n";
00611   file << getProbability(SIGEL_Program::MOVE) << "\n";
00612   file << "PROBABILITY_SENSE\n";
00613   file << getProbability(SIGEL_Program::SENSE) << "\n";
00614   file << "PROBABILITY_DELAY\n";
00615   file << getProbability(SIGEL_Program::DELAY) << "\n";
00616   file << "PROBABILITY_NOP\n";
00617   file << getProbability(SIGEL_Program::NOP) << "\n";  
00618   file << "PROBABILITY_MOD\n";
00619   file << getProbability(SIGEL_Program::MOD) << "\n";
00620   file << "TIMEOUTMINUTES\n";
00621   file << getTimeOutMinutes() << "\n";
00622   file << "TERMINATIONDURATIONDAYS\n";
00623   file << getTerminationDurationDays() << "\n";
00624   file << "TERMINATIONDURATIONHOURS\n";
00625   file << getTerminationDurationHours() << "\n";
00626   file << "TERMINATIONDURATIONMINUTES\n";
00627   file << getTerminationDurationMinutes() << "\n";
00628   file << "TERMINATIONDURATIONSECONDS\n";
00629   file << getTerminationDurationSeconds() << "\n";
00630 
00631   SIGEL_GP::SIG_GPPVMHost *actHost = hostList.first();
00632 
00633   while (actHost)
00634     {
00635       file << "PVMHOST\n";
00636       file << actHost->print();
00637 
00638       actHost = hostList.next();
00639     };
00640 
00641 };
00642 
00643 QList< SIGEL_GP::SIG_GPPVMHost > const &SIGEL_GP::SIG_GPParameter::getHostList() const
00644 {
00645   return hostList;
00646 };
00647 
00648 QList< SIGEL_GP::SIG_GPPVMHost > &SIGEL_GP::SIG_GPParameter::getHostList()
00649 {
00650   return hostList;
00651 };
00652 
00653   
00654 void SIGEL_GP::SIG_GPParameter::setProbability( SIGEL_Program::Robotinstruction instruction, int prob )
00655 {
00656   /*
00657 
00658   switch( instruction )
00659     {
00660 
00661     case SIGEL_Program::ADD:
00662       instructionProb[0] = prob;
00663       break;
00664 
00665     case SIGEL_Program::SUB:
00666       instructionProb[1] = prob;
00667       break;
00668 
00669     case SIGEL_Program::MUL:
00670       instructionProb[2] = prob;
00671       break;
00672 
00673     case SIGEL_Program::DIV:
00674       instructionProb[3] = prob;
00675       break;
00676 
00677     case SIGEL_Program::LOAD:
00678       instructionProb[4] = prob;
00679       break;
00680 
00681     case SIGEL_Program::MIN:
00682       instructionProb[5] = prob;
00683       break;
00684 
00685     case SIGEL_Program::MAX:
00686       instructionProb[6] = prob;
00687       break;
00688 
00689     case SIGEL_Program::CMP:
00690       instructionProb[7] = prob;
00691       break;
00692 
00693     case SIGEL_Program::JMP:
00694       instructionProb[8] = prob;
00695       break;
00696 
00697     case SIGEL_Program::NOP:
00698       instructionProb[9] = prob;
00699       break;
00700 
00701     case SIGEL_Program::MOD:
00702       instructionProb[10] = prob;
00703       break;
00704 
00705     case SIGEL_Program::COPY:
00706       instructionProb[11] = prob;
00707       break;
00708 
00709     case SIGEL_Program::MOVE:
00710       instructionProb[12] = prob;
00711       break;
00712 
00713     case SIGEL_Program::SENSE:
00714       instructionProb[13] = prob;
00715       break;
00716 
00717     case SIGEL_Program::DELAY:
00718       instructionProb[14]= prob;
00719       break;
00720     }
00721   
00722   */
00723     int instructionID = static_cast< int >( instruction ); 
00724     instructionProb[instructionID] = prob;
00725 
00726 }
00727 
00728   
00729 int  SIGEL_GP::SIG_GPParameter::getProbability( SIGEL_Program::Robotinstruction instruction )
00730 {
00731 
00732   int instructionID = static_cast< int >( instruction );
00733   int prob          = instructionProb[instructionID];
00734   
00735   /*
00736   switch( instruction )
00737     {
00738 
00739     case SIGEL_Program::ADD:
00740       prob = instructionProb[0];
00741       break;
00742 
00743     case SIGEL_Program::SUB:
00744       prob = instructionProb[1];
00745       break;
00746 
00747     case SIGEL_Program::MUL:
00748       prob = instructionProb[2];
00749       break;
00750 
00751     case SIGEL_Program::DIV:
00752       prob = instructionProb[3];
00753       break;
00754 
00755     case SIGEL_Program::LOAD:
00756       prob = instructionProb[4];
00757       break;
00758 
00759     case SIGEL_Program::MIN:
00760       prob = instructionProb[5];
00761       break;
00762 
00763     case SIGEL_Program::MAX:
00764       prob = instructionProb[6];
00765       break;
00766 
00767     case SIGEL_Program::CMP:
00768       prob = instructionProb[7];
00769       break;
00770 
00771     case SIGEL_Program::JMP:
00772       prob = instructionProb[8];
00773       break;
00774 
00775     case SIGEL_Program::NOP:
00776       prob = instructionProb[9];
00777       break;
00778 
00779     case SIGEL_Program::MOD:
00780       prob = instructionProb[10];
00781       break;
00782 
00783     case SIGEL_Program::COPY:
00784       prob = instructionProb[11];
00785       break;
00786 
00787     case SIGEL_Program::MOVE:
00788       prob = instructionProb[12];
00789       break;
00790 
00791     case SIGEL_Program::SENSE:
00792       prob = instructionProb[13];
00793       break;
00794 
00795     case SIGEL_Program::DELAY:
00796       prob = instructionProb[14];
00797       break;
00798 
00799     }
00800    
00801    */
00802 
00803     return prob;
00804 
00805 }
00806 
00807 QArray< int >& SIGEL_GP::SIG_GPParameter::getInstructionProbabilities()
00808 {
00809   return instructionProb;
00810 }
00811 
00812 bool SIGEL_GP::SIG_GPParameter::getTerminationUsesDate() const
00813 {
00814   return terminationUsesDate;
00815 };
00816 
00817 void SIGEL_GP::SIG_GPParameter::setTerminationUsesDate( bool newValue )
00818 {
00819   terminationUsesDate = newValue;
00820 };
00821 
00822 int SIGEL_GP::SIG_GPParameter::getTimeOutMinutes()
00823 {
00824   return timeOutMinutes;
00825 };
00826 
00827 void SIGEL_GP::SIG_GPParameter::setTimeOutMinutes( int newValue )
00828 {
00829   timeOutMinutes = newValue;
00830 };
00831 

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