SurfInvGaConfParser Class Reference

#include <SurfInvGaConfParser.hpp>

Inheritance diagram for SurfInvGaConfParser:

Inheritance graph
[legend]
Collaboration diagram for SurfInvGaConfParser:

Collaboration graph
[legend]
List of all members.

Public Member Functions

void initializeASTFactory (antlr::ASTFactory &factory)
 SurfInvGaConfParser (antlr::TokenBuffer &tokenBuf)
 SurfInvGaConfParser (antlr::TokenStream &lexer)
 SurfInvGaConfParser (const antlr::ParserSharedInputState &state)
int getNumTokens () const
const char * getTokenName (int type) const
const char *const * getTokenNames () const
void configentry ()
bool boolvalue ()
std::string stringvalue ()
double numvalue ()
void configfile ()
antlr::RefAST getAST ()

Public Attributes

bool verbose
bool usevrefmodel
std::string vrefmodel
int fitexponent
int popsize
double inittemp
double coolingratio
int generations
double mutationprob
double crossoverprob
double poisson
int threads
double errorlevel
std::string gatype
std::string outputbase
std::string inputdata
int annealinggeneration
bool elitist
std::vector< double > thickbase
std::vector< double > thickstep
std::vector< int > thicksizes
std::vector< double > svelbase
std::vector< double > svelstep
std::vector< int > svelsizes
std::vector< double > weights

Protected Member Functions

 SurfInvGaConfParser (antlr::TokenBuffer &tokenBuf, int k)
 SurfInvGaConfParser (antlr::TokenStream &lexer, int k)

Protected Attributes

antlr::RefAST returnAST

Detailed Description

Definition at line 18 of file SurfInvGaConfParser.hpp.

Constructor & Destructor Documentation

SurfInvGaConfParser::SurfInvGaConfParser ( antlr::TokenBuffer &  tokenBuf,
int  k 
) [protected]

Definition at line 8 of file SurfInvGaConfParser.cpp.

00009 : antlr::LLkParser(tokenBuf,k)
00010 {
00011 }

SurfInvGaConfParser::SurfInvGaConfParser ( antlr::TokenBuffer &  tokenBuf  ) 

Definition at line 13 of file SurfInvGaConfParser.cpp.

00014 : antlr::LLkParser(tokenBuf,10)
00015 {
00016 }

SurfInvGaConfParser::SurfInvGaConfParser ( antlr::TokenStream &  lexer,
int  k 
) [protected]

Definition at line 18 of file SurfInvGaConfParser.cpp.

00019 : antlr::LLkParser(lexer,k)
00020 {
00021 }

SurfInvGaConfParser::SurfInvGaConfParser ( antlr::TokenStream &  lexer  ) 

Definition at line 23 of file SurfInvGaConfParser.cpp.

00024 : antlr::LLkParser(lexer,10)
00025 {
00026 }

SurfInvGaConfParser::SurfInvGaConfParser ( const antlr::ParserSharedInputState &  state  ) 

Definition at line 28 of file SurfInvGaConfParser.cpp.

00029 : antlr::LLkParser(state,10)
00030 {
00031 }

Member Function Documentation

void SurfInvGaConfParser::initializeASTFactory ( antlr::ASTFactory &  factory  ) 

Definition at line 548 of file SurfInvGaConfParser.cpp.

00549 {
00550 }

int SurfInvGaConfParser::getNumTokens (  )  const [inline]

Definition at line 62 of file SurfInvGaConfParser.hpp.

00063         {
00064                 return SurfInvGaConfParser::NUM_TOKENS;
00065         }

const char* SurfInvGaConfParser::getTokenName ( int  type  )  const [inline]

Definition at line 66 of file SurfInvGaConfParser.hpp.

00067         {
00068                 if( type > getNumTokens() ) return 0;
00069                 return SurfInvGaConfParser::tokenNames[type];
00070         }

const char* const* SurfInvGaConfParser::getTokenNames (  )  const [inline]

Definition at line 71 of file SurfInvGaConfParser.hpp.

00072         {
00073                 return SurfInvGaConfParser::tokenNames;
00074         }

void SurfInvGaConfParser::configentry (  ) 

Definition at line 33 of file SurfInvGaConfParser.cpp.

References annealinggeneration, ANNEALINGGENERATIONT, boolvalue(), coolingratio, COOLINGRATIOT, crossoverprob, CROSSOVERPROBT, elitist, ELITISTT, EQUAL, errorlevel, ERRORLEVELT, fitexponent, FITEXPONENTT, gatype, GATYPET, generations, GENERATIONST, inittemp, INITTEMPT, inputdata, INPUTDATAT, mutationprob, MUTATIONPROBT, NUMBER, numvalue(), outputbase, OUTPUTBASET, poisson, POISSONT, popsize, POPSIZET, stringvalue(), svelbase, SVELBASET, thickbase, THICKBASET, thicksizes, THICKSIZEST, thickstep, THICKSTEPT, threads, THREADST, usevrefmodel, USEVREFMODELT, verbose, VERBOSET, vrefmodel, and VREFMODELT.

Referenced by configfile().

00033                                       {
00034         
00035         try {      // for error handling
00036                 {
00037                 switch ( LA(1)) {
00038                 case VERBOSET:
00039                 {
00040                         match(VERBOSET);
00041                         match(EQUAL);
00042                         verbose=boolvalue();
00043                         break;
00044                 }
00045                 case USEVREFMODELT:
00046                 {
00047                         match(USEVREFMODELT);
00048                         match(EQUAL);
00049                         usevrefmodel=boolvalue();
00050                         break;
00051                 }
00052                 case VREFMODELT:
00053                 {
00054                         match(VREFMODELT);
00055                         match(EQUAL);
00056                         vrefmodel=stringvalue();
00057                         break;
00058                 }
00059                 case FITEXPONENTT:
00060                 {
00061                         match(FITEXPONENTT);
00062                         match(EQUAL);
00063                         fitexponent=numvalue();
00064                         break;
00065                 }
00066                 case POPSIZET:
00067                 {
00068                         match(POPSIZET);
00069                         match(EQUAL);
00070                         popsize=numvalue();
00071                         break;
00072                 }
00073                 case INITTEMPT:
00074                 {
00075                         match(INITTEMPT);
00076                         match(EQUAL);
00077                         inittemp=numvalue();
00078                         break;
00079                 }
00080                 case COOLINGRATIOT:
00081                 {
00082                         match(COOLINGRATIOT);
00083                         match(EQUAL);
00084                         coolingratio=numvalue();
00085                         break;
00086                 }
00087                 case GENERATIONST:
00088                 {
00089                         match(GENERATIONST);
00090                         match(EQUAL);
00091                         generations=numvalue();
00092                         break;
00093                 }
00094                 case MUTATIONPROBT:
00095                 {
00096                         match(MUTATIONPROBT);
00097                         match(EQUAL);
00098                         mutationprob=numvalue();
00099                         break;
00100                 }
00101                 case CROSSOVERPROBT:
00102                 {
00103                         match(CROSSOVERPROBT);
00104                         match(EQUAL);
00105                         crossoverprob=numvalue();
00106                         break;
00107                 }
00108                 case POISSONT:
00109                 {
00110                         match(POISSONT);
00111                         match(EQUAL);
00112                         poisson=numvalue();
00113                         break;
00114                 }
00115                 case THREADST:
00116                 {
00117                         match(THREADST);
00118                         match(EQUAL);
00119                         threads=numvalue();
00120                         break;
00121                 }
00122                 case ERRORLEVELT:
00123                 {
00124                         match(ERRORLEVELT);
00125                         match(EQUAL);
00126                         errorlevel=numvalue();
00127                         break;
00128                 }
00129                 case GATYPET:
00130                 {
00131                         match(GATYPET);
00132                         match(EQUAL);
00133                         gatype=stringvalue();
00134                         break;
00135                 }
00136                 case OUTPUTBASET:
00137                 {
00138                         match(OUTPUTBASET);
00139                         match(EQUAL);
00140                         outputbase=stringvalue();
00141                         break;
00142                 }
00143                 case INPUTDATAT:
00144                 {
00145                         match(INPUTDATAT);
00146                         match(EQUAL);
00147                         inputdata=stringvalue();
00148                         break;
00149                 }
00150                 case ANNEALINGGENERATIONT:
00151                 {
00152                         match(ANNEALINGGENERATIONT);
00153                         match(EQUAL);
00154                         annealinggeneration=numvalue();
00155                         break;
00156                 }
00157                 case ELITISTT:
00158                 {
00159                         match(ELITISTT);
00160                         match(EQUAL);
00161                         elitist=boolvalue();
00162                         break;
00163                 }
00164                 case THICKBASET:
00165                 {
00166                         match(THICKBASET);
00167                         match(EQUAL);
00168                         if ( inputState->guessing==0 ) {
00169 #line 70 "SurfInvGaConf.g"
00170                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00171 #line 172 "SurfInvGaConfParser.cpp"
00172                         }
00173                         { // ( ... )+
00174                         int _cnt74=0;
00175                         for (;;) {
00176                                 if ((LA(1) == NUMBER)) {
00177                                         dtemp=numvalue();
00178                                         if ( inputState->guessing==0 ) {
00179 #line 71 "SurfInvGaConf.g"
00180                                                 if (i < thickbase.size()) {thickbase.at(i) = dtemp;} else{thickbase.push_back(dtemp);}++i;
00181 #line 182 "SurfInvGaConfParser.cpp"
00182                                         }
00183                                 }
00184                                 else {
00185                                         if ( _cnt74>=1 ) { goto _loop74; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00186                                 }
00187                                 
00188                                 _cnt74++;
00189                         }
00190                         _loop74:;
00191                         }  // ( ... )+
00192                         break;
00193                 }
00194                 case THICKSTEPT:
00195                 {
00196                         match(THICKSTEPT);
00197                         match(EQUAL);
00198                         if ( inputState->guessing==0 ) {
00199 #line 72 "SurfInvGaConf.g"
00200                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00201 #line 202 "SurfInvGaConfParser.cpp"
00202                         }
00203                         { // ( ... )+
00204                         int _cnt80=0;
00205                         for (;;) {
00206                                 if ((LA(1) == NUMBER)) {
00207                                         dtemp=numvalue();
00208                                         if ( inputState->guessing==0 ) {
00209 #line 73 "SurfInvGaConf.g"
00210                                                 if (i < thickstep.size()) {thickstep.at(i) = dtemp;} else{thickstep.push_back(dtemp);}++i;
00211 #line 212 "SurfInvGaConfParser.cpp"
00212                                         }
00213                                 }
00214                                 else {
00215                                         if ( _cnt80>=1 ) { goto _loop80; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00216                                 }
00217                                 
00218                                 _cnt80++;
00219                         }
00220                         _loop80:;
00221                         }  // ( ... )+
00222                         break;
00223                 }
00224                 case THICKSIZEST:
00225                 {
00226                         match(THICKSIZEST);
00227                         match(EQUAL);
00228                         if ( inputState->guessing==0 ) {
00229 #line 74 "SurfInvGaConf.g"
00230                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00231 #line 232 "SurfInvGaConfParser.cpp"
00232                         }
00233                         { // ( ... )+
00234                         int _cnt86=0;
00235                         for (;;) {
00236                                 if ((LA(1) == NUMBER)) {
00237                                         itemp=numvalue();
00238                                         if ( inputState->guessing==0 ) {
00239 #line 75 "SurfInvGaConf.g"
00240                                                 if (i < thicksizes.size()) {thicksizes.at(i) = itemp;} else{thicksizes.push_back(itemp);}++i;
00241 #line 242 "SurfInvGaConfParser.cpp"
00242                                         }
00243                                 }
00244                                 else {
00245                                         if ( _cnt86>=1 ) { goto _loop86; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00246                                 }
00247                                 
00248                                 _cnt86++;
00249                         }
00250                         _loop86:;
00251                         }  // ( ... )+
00252                         break;
00253                 }
00254                 case SVELBASET:
00255                 {
00256                         match(SVELBASET);
00257                         match(EQUAL);
00258                         if ( inputState->guessing==0 ) {
00259 #line 76 "SurfInvGaConf.g"
00260                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00261 #line 262 "SurfInvGaConfParser.cpp"
00262                         }
00263                         { // ( ... )+
00264                         int _cnt92=0;
00265                         for (;;) {
00266                                 if ((LA(1) == NUMBER)) {
00267                                         dtemp=numvalue();
00268                                         if ( inputState->guessing==0 ) {
00269 #line 77 "SurfInvGaConf.g"
00270                                                 if (i < svelbase.size()) {svelbase.at(i) = dtemp;} else{svelbase.push_back(dtemp);}++i;
00271 #line 272 "SurfInvGaConfParser.cpp"
00272                                         }
00273                                 }
00274                                 else {
00275                                         if ( _cnt92>=1 ) { goto _loop92; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00276                                 }
00277                                 
00278                                 _cnt92++;
00279                         }
00280                         _loop92:;
00281                         }  // ( ... )+
00282                         break;
00283                 }
00284                 case SVELSTEPT:
00285                 {
00286                         match(SVELSTEPT);
00287                         match(EQUAL);
00288                         if ( inputState->guessing==0 ) {
00289 #line 78 "SurfInvGaConf.g"
00290                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00291 #line 292 "SurfInvGaConfParser.cpp"
00292                         }
00293                         { // ( ... )+
00294                         int _cnt98=0;
00295                         for (;;) {
00296                                 if ((LA(1) == NUMBER)) {
00297                                         dtemp=numvalue();
00298                                         if ( inputState->guessing==0 ) {
00299 #line 79 "SurfInvGaConf.g"
00300                                                 if (i < svelstep.size()) {svelstep.at(i) = dtemp;} else{svelstep.push_back(dtemp);}++i;
00301 #line 302 "SurfInvGaConfParser.cpp"
00302                                         }
00303                                 }
00304                                 else {
00305                                         if ( _cnt98>=1 ) { goto _loop98; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00306                                 }
00307                                 
00308                                 _cnt98++;
00309                         }
00310                         _loop98:;
00311                         }  // ( ... )+
00312                         break;
00313                 }
00314                 case SVELSIZEST:
00315                 {
00316                         match(SVELSIZEST);
00317                         match(EQUAL);
00318                         if ( inputState->guessing==0 ) {
00319 #line 80 "SurfInvGaConf.g"
00320                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00321 #line 322 "SurfInvGaConfParser.cpp"
00322                         }
00323                         { // ( ... )+
00324                         int _cnt104=0;
00325                         for (;;) {
00326                                 if ((LA(1) == NUMBER)) {
00327                                         itemp=numvalue();
00328                                         if ( inputState->guessing==0 ) {
00329 #line 81 "SurfInvGaConf.g"
00330                                                 if (i < svelsizes.size()) {svelsizes.at(i) = itemp;} else{svelsizes.push_back(itemp);}++i;
00331 #line 332 "SurfInvGaConfParser.cpp"
00332                                         }
00333                                 }
00334                                 else {
00335                                         if ( _cnt104>=1 ) { goto _loop104; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00336                                 }
00337                                 
00338                                 _cnt104++;
00339                         }
00340                         _loop104:;
00341                         }  // ( ... )+
00342                         break;
00343                 }
00344                 case WEIGHTST:
00345                 {
00346                         match(WEIGHTST);
00347                         match(EQUAL);
00348                         if ( inputState->guessing==0 ) {
00349 #line 82 "SurfInvGaConf.g"
00350                                 i = 0; dtemp = 0; stemp = ""; btemp = false;
00351 #line 352 "SurfInvGaConfParser.cpp"
00352                         }
00353                         { // ( ... )+
00354                         int _cnt110=0;
00355                         for (;;) {
00356                                 if ((LA(1) == NUMBER)) {
00357                                         dtemp=numvalue();
00358                                         if ( inputState->guessing==0 ) {
00359 #line 83 "SurfInvGaConf.g"
00360                                                 if (i < weights.size()) {weights.at(i) = dtemp;} else{weights.push_back(dtemp);}++i;
00361 #line 362 "SurfInvGaConfParser.cpp"
00362                                         }
00363                                 }
00364                                 else {
00365                                         if ( _cnt110>=1 ) { goto _loop110; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00366                                 }
00367                                 
00368                                 _cnt110++;
00369                         }
00370                         _loop110:;
00371                         }  // ( ... )+
00372                         break;
00373                 }
00374                 default:
00375                 {
00376                         throw antlr::NoViableAltException(LT(1), getFilename());
00377                 }
00378                 }
00379                 }
00380         }
00381         catch (antlr::RecognitionException& ex) {
00382                 if( inputState->guessing == 0 ) {
00383                         reportError(ex);
00384                         recover(ex,_tokenSet_0);
00385                 } else {
00386                         throw;
00387                 }
00388         }
00389 }

Here is the call graph for this function:

bool SurfInvGaConfParser::boolvalue (  ) 

Definition at line 391 of file SurfInvGaConfParser.cpp.

References FALSE, and TRUE.

Referenced by configentry().

00391                                      {
00392 #line 97 "SurfInvGaConf.g"
00393         bool r;
00394 #line 395 "SurfInvGaConfParser.cpp"
00395         
00396         try {      // for error handling
00397                 {
00398                 switch ( LA(1)) {
00399                 case TRUE:
00400                 {
00401                         match(TRUE);
00402                         if ( inputState->guessing==0 ) {
00403 #line 98 "SurfInvGaConf.g"
00404                                 r = true;
00405 #line 406 "SurfInvGaConfParser.cpp"
00406                         }
00407                         break;
00408                 }
00409                 case FALSE:
00410                 {
00411                         match(FALSE);
00412                         if ( inputState->guessing==0 ) {
00413 #line 98 "SurfInvGaConf.g"
00414                                 r = false;
00415 #line 416 "SurfInvGaConfParser.cpp"
00416                         }
00417                         break;
00418                 }
00419                 default:
00420                 {
00421                         throw antlr::NoViableAltException(LT(1), getFilename());
00422                 }
00423                 }
00424                 }
00425         }
00426         catch (antlr::RecognitionException& ex) {
00427                 if( inputState->guessing == 0 ) {
00428                         reportError(ex);
00429                         recover(ex,_tokenSet_0);
00430                 } else {
00431                         throw;
00432                 }
00433         }
00434         return r;
00435 }

std::string SurfInvGaConfParser::stringvalue (  ) 

Definition at line 437 of file SurfInvGaConfParser.cpp.

References STRING.

Referenced by configentry().

00437                                             {
00438 #line 101 "SurfInvGaConf.g"
00439         std::string r;
00440 #line 441 "SurfInvGaConfParser.cpp"
00441         antlr::RefToken  currvalue = antlr::nullToken;
00442         
00443         try {      // for error handling
00444                 currvalue = LT(1);
00445                 match(STRING);
00446                 if ( inputState->guessing==0 ) {
00447 #line 102 "SurfInvGaConf.g"
00448                         r = currvalue->getText();
00449 #line 450 "SurfInvGaConfParser.cpp"
00450                 }
00451         }
00452         catch (antlr::RecognitionException& ex) {
00453                 if( inputState->guessing == 0 ) {
00454                         reportError(ex);
00455                         recover(ex,_tokenSet_0);
00456                 } else {
00457                         throw;
00458                 }
00459         }
00460         return r;
00461 }

double SurfInvGaConfParser::numvalue (  ) 

Definition at line 463 of file SurfInvGaConfParser.cpp.

References NUMBER.

Referenced by configentry().

00463                                       {
00464 #line 93 "SurfInvGaConf.g"
00465         double r;
00466 #line 467 "SurfInvGaConfParser.cpp"
00467         antlr::RefToken  currvalue = antlr::nullToken;
00468         
00469         try {      // for error handling
00470                 currvalue = LT(1);
00471                 match(NUMBER);
00472                 if ( inputState->guessing==0 ) {
00473 #line 94 "SurfInvGaConf.g"
00474                         r = atof(currvalue->getText().c_str());
00475 #line 476 "SurfInvGaConfParser.cpp"
00476                 }
00477         }
00478         catch (antlr::RecognitionException& ex) {
00479                 if( inputState->guessing == 0 ) {
00480                         reportError(ex);
00481                         recover(ex,_tokenSet_1);
00482                 } else {
00483                         throw;
00484                 }
00485         }
00486         return r;
00487 }

void SurfInvGaConfParser::configfile (  ) 

Definition at line 489 of file SurfInvGaConfParser.cpp.

References COMMENT, configentry(), EQUAL, fitexponent, usevrefmodel, and verbose.

Referenced by SurfInvGaConf::GetData().

00489                                      {
00490 #line 85 "SurfInvGaConf.g"
00491         
00492         verbose = false;
00493         usevrefmodel = false;
00494         fitexponent = 2;
00495         
00496 #line 497 "SurfInvGaConfParser.cpp"
00497         
00498         try {      // for error handling
00499                 { // ( ... )+
00500                 int _cnt114=0;
00501                 for (;;) {
00502                         if ((_tokenSet_2.member(LA(1)))) {
00503                                 configentry();
00504                                 {
00505                                 if ((LA(1) == COMMENT) && (_tokenSet_0.member(LA(2))) && (LA(3) == antlr::Token::EOF_TYPE || LA(3) == EQUAL || LA(3) == COMMENT) && (_tokenSet_3.member(LA(4))) && (_tokenSet_1.member(LA(5))) && (_tokenSet_4.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
00506                                         match(COMMENT);
00507                                 }
00508                                 else if ((_tokenSet_0.member(LA(1))) && (LA(2) == antlr::Token::EOF_TYPE || LA(2) == EQUAL || LA(2) == COMMENT) && (_tokenSet_3.member(LA(3))) && (_tokenSet_1.member(LA(4))) && (_tokenSet_4.member(LA(5))) && (_tokenSet_5.member(LA(6))) && (_tokenSet_5.member(LA(7))) && (_tokenSet_5.member(LA(8))) && (_tokenSet_5.member(LA(9))) && (_tokenSet_5.member(LA(10)))) {
00509                                 }
00510                                 else {
00511                                         throw antlr::NoViableAltException(LT(1), getFilename());
00512                                 }
00513                                 
00514                                 }
00515                         }
00516                         else {
00517                                 if ( _cnt114>=1 ) { goto _loop114; } else {throw antlr::NoViableAltException(LT(1), getFilename());}
00518                         }
00519                         
00520                         _cnt114++;
00521                 }
00522                 _loop114:;
00523                 }  // ( ... )+
00524                 { // ( ... )*
00525                 for (;;) {
00526                         if ((LA(1) == COMMENT)) {
00527                                 match(COMMENT);
00528                         }
00529                         else {
00530                                 goto _loop116;
00531                         }
00532                         
00533                 }
00534                 _loop116:;
00535                 } // ( ... )*
00536                 match(antlr::Token::EOF_TYPE);
00537         }
00538         catch (antlr::RecognitionException& ex) {
00539                 if( inputState->guessing == 0 ) {
00540                         reportError(ex);
00541                         recover(ex,_tokenSet_6);
00542                 } else {
00543                         throw;
00544                 }
00545         }
00546 }

Here is the call graph for this function:

antlr::RefAST SurfInvGaConfParser::getAST (  )  [inline]

Definition at line 81 of file SurfInvGaConfParser.hpp.

00082         {
00083                 return returnAST;
00084         }

Member Data Documentation

bool SurfInvGaConfParser::verbose

Definition at line 25 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), configfile(), and SurfInvGaConf::GetData().

bool SurfInvGaConfParser::usevrefmodel

Definition at line 26 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), configfile(), and SurfInvGaConf::GetData().

std::string SurfInvGaConfParser::vrefmodel

Definition at line 27 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

int SurfInvGaConfParser::fitexponent

Definition at line 28 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), configfile(), and SurfInvGaConf::GetData().

int SurfInvGaConfParser::popsize

Definition at line 29 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::inittemp

Definition at line 30 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::coolingratio

Definition at line 31 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

int SurfInvGaConfParser::generations

Definition at line 32 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::mutationprob

Definition at line 33 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::crossoverprob

Definition at line 34 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::poisson

Definition at line 35 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

int SurfInvGaConfParser::threads

Definition at line 36 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

double SurfInvGaConfParser::errorlevel

Definition at line 37 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::string SurfInvGaConfParser::gatype

Definition at line 38 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::string SurfInvGaConfParser::outputbase

Definition at line 39 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::string SurfInvGaConfParser::inputdata

Definition at line 40 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

int SurfInvGaConfParser::annealinggeneration

Definition at line 41 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

bool SurfInvGaConfParser::elitist

Definition at line 42 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::vector< double > SurfInvGaConfParser::thickbase

Definition at line 43 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::vector< double > SurfInvGaConfParser::thickstep

Definition at line 44 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::vector< int > SurfInvGaConfParser::thicksizes

Definition at line 45 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::vector< double > SurfInvGaConfParser::svelbase

Definition at line 46 of file SurfInvGaConfParser.hpp.

Referenced by configentry(), and SurfInvGaConf::GetData().

std::vector< double > SurfInvGaConfParser::svelstep

Definition at line 47 of file SurfInvGaConfParser.hpp.

Referenced by SurfInvGaConf::GetData().

std::vector< int > SurfInvGaConfParser::svelsizes

Definition at line 48 of file SurfInvGaConfParser.hpp.

Referenced by SurfInvGaConf::GetData().

std::vector< double > SurfInvGaConfParser::weights

Definition at line 49 of file SurfInvGaConfParser.hpp.

Referenced by SurfInvGaConf::GetData().

antlr::RefAST SurfInvGaConfParser::returnAST [protected]

Definition at line 87 of file SurfInvGaConfParser.hpp.

The documentation for this class was generated from the following files:
Generated on Thu Nov 22 14:10:56 2007 for GPLIB++ by  doxygen 1.5.1