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

/magnus/back_end/Genetic/include/PMWord.h

Go to the documentation of this file.
00001 /*
00002  *   $Id$
00003  */
00004  
00005 // Copyright (C) 1999 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 //
00008 // Contents: Definition of PMWord class
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Description:
00015 //
00016 // Revision History:
00017 //
00018 
00019 #ifndef _PMWord_H_
00020 #define _PMWord_H_
00021 
00022 
00023 #include "Word.h"
00024 #include "PM.h"
00025 #include "RandomNumbers.h"
00026 
00027 
00028 // ----------------------------- PMWordConfig ------------------------------ //
00029 
00030 
00031 class PMWordConfig 
00032 {
00033 
00034 public:
00035 
00036   /////////////////////////////////////////////////////////////////////////
00037   //                                                                     //
00038   // Constructors:                                                       //
00039   //                                                                     //
00040   /////////////////////////////////////////////////////////////////////////
00041   
00042   PMWordConfig( UniformRandom& R,  
00043                 int NumOfGens, 
00044                 int WordMaxLen,
00045                 bool allowTrivialWords = true
00046                 ) 
00047     : r( R ), 
00048       numOfGens( NumOfGens ), 
00049       wordMaxLen( WordMaxLen ),
00050       bAllowTrivialWords( allowTrivialWords )
00051     { }
00052 
00053   // copy constructor, destructor and operators =, == supplied by compiler.
00054 
00055 
00056   /////////////////////////////////////////////////////////////////////////
00057   //                                                                     //
00058   // Accessors:                                                          //
00059   //                                                                     //
00060   /////////////////////////////////////////////////////////////////////////
00061 
00062   UniformRandom& rng( ) const { return r; }
00063 
00064   int getNumOfGens( ) const { return numOfGens; }
00065  
00066   int getWordMaxLen( ) const { return wordMaxLen; }
00067 
00068   bool allowTrivialWords( ) const { return bAllowTrivialWords; }
00069 
00070  
00071 private:
00072 
00073   /////////////////////////////////////////////////////////////////////////
00074   //                                                                     //
00075   // Private functions:                                                  //
00076   //                                                                     //
00077   /////////////////////////////////////////////////////////////////////////
00078 
00079 
00080   /////////////////////////////////////////////////////////////////////////
00081   //                                                                     //
00082   // Data members:                                                       //
00083   //                                                                     //
00084   /////////////////////////////////////////////////////////////////////////
00085 
00086   UniformRandom& r;
00087   int numOfGens, wordMaxLen;
00088   bool bAllowTrivialWords;
00089 };
00090 
00091 
00092 // ------------------------------- PMWord ---------------------------------- //
00093 
00094 
00095 class PMWord : public PM 
00096 {
00097 
00098 public:
00099 
00100   /////////////////////////////////////////////////////////////////////////
00101   //                                                                     //
00102   // Constructors:                                                       //
00103   //                                                                     //
00104   /////////////////////////////////////////////////////////////////////////
00105   
00106   PMWord( const PMWordConfig& CFG, Word w = Word() ) 
00107     : cfg( CFG ), theWord( w ) { }
00108 
00109   // copy constructor, destructor and operator = supplied by compiler.
00110 
00111 
00112   /////////////////////////////////////////////////////////////////////////
00113   //                                                                     //
00114   // Overriden abstract functions:                                       //
00115   //                                                                     //
00116   /////////////////////////////////////////////////////////////////////////
00117 
00118   PM* clone( ) const { return new PMWord(*this); }
00119 
00120 
00121   /////////////////////////////////////////////////////////////////////////
00122   //                                                                     //
00123   // Overriden hook functions:                                           //
00124   //                                                                     //
00125   /////////////////////////////////////////////////////////////////////////
00126 
00127   PM* crossover( const PM* );
00128 
00129   PM* mutate( );
00130 
00131   PM* randomPM( ); 
00132 
00133   void printOn( ostream& ostr ) const { ostr << theWord; }
00134 
00135 
00136   /////////////////////////////////////////////////////////////////////////
00137   //                                                                     //
00138   // Accessors:                                                          //
00139   //                                                                     //
00140   /////////////////////////////////////////////////////////////////////////
00141 
00142   Word getWord( ) const { return theWord; }
00143   
00144   const PMWordConfig& getCfg( ) { return cfg; }
00145 
00146   bool operator == ( const PM& pm ) const 
00147   { return theWord == ((PMWord&)pm).theWord; }
00148 
00149 
00150 private:
00151 
00152   /////////////////////////////////////////////////////////////////////////
00153   //                                                                     //
00154   // Private functions:                                                  //
00155   //                                                                     //
00156   /////////////////////////////////////////////////////////////////////////
00157 
00158   int randomGen( );
00159 
00160 
00161   /////////////////////////////////////////////////////////////////////////
00162   //                                                                     //
00163   // Data members:                                                       //
00164   //                                                                     //
00165   /////////////////////////////////////////////////////////////////////////
00166 
00167   const PMWordConfig& cfg;
00168   Word theWord;
00169 };
00170 
00171 #endif

Generated at Tue Jun 19 09:49:36 2001 for Magnus Classes by doxygen1.2.6 written by Dimitri van Heesch, © 1997-2001