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

/magnus/back_end/Genetic/include/GABraid.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 class PMQESol
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Description:
00015 //
00016 // Revision History:
00017 //
00018 
00019 
00020 #ifndef _GABraid_H_
00021 #define _GABraid_H_
00022 
00023 
00024 #include "PMWord.h"
00025 #include "PMArray.h"
00026 #include "GA.h"
00027 #include "FreeGroup.h"
00028 
00029 
00030 // ------------------------------- Triple ---------------------------------- //
00031 
00032 
00033 struct Triple
00034 {
00035   Triple(int i = 0, int j = 0, int k = 0, int l = 0) 
00036     : x(i), y(j), z(k), w(l) { }
00037 
00038   bool operator == (const Triple& t) const 
00039     { return x == t.x && y == t.y && z == t.z && w == t.w; }
00040 
00041   bool operator != (const Triple& t) const 
00042     { return !(*this == t); }
00043 
00044   friend ostream& operator << ( ostream& out, const Triple& t ) {
00045     out << " (" << t.x << "," << t.y << "," << t.z << "," << t.w << ")";
00046   }
00047 
00048   int x,y,z,w;
00049 };
00050 
00051 
00052 //---------------------------- PMB2ComConfig ------------------------------- //
00053 
00054 
00055 class PMB2ComConfig
00056 {
00057 
00058 public:
00059 
00060   /////////////////////////////////////////////////////////////////////////
00061   //                                                                     //
00062   // Constructors:                                                       //
00063   //                                                                     //
00064   /////////////////////////////////////////////////////////////////////////
00065   
00066   PMB2ComConfig( UniformRandom& R,  
00067                  int MaxNumOfComms,
00068                  FreeGroup sc,
00069                  int NumOfVars,
00070                  VectorOf<Word> Gens
00071                 ) 
00072     : r( R ),
00073       maxNumOfComms( MaxNumOfComms ),
00074       SC( sc ),
00075       numOfVars( NumOfVars ),
00076       numOfConsts( sc.numberOfGenerators() - NumOfVars ),
00077       gens( Gens )
00078     { 
00079       FreeGroup F(numOfConsts);
00080       VectorOf<Word> v(SC.numberOfGenerators());
00081       for( int i = numOfVars; i < v.length(); ++i )
00082         v[i] = Word(Generator(i+1-numOfVars));
00083       for( int i = 0; i < numOfVars; ++i )
00084         v[i] = gens[i];
00085       M = Map(SC,F,v);
00086     }
00087 
00088   // copy constructor, destructor and operators =, == supplied by compiler.
00089 
00090 
00091   /////////////////////////////////////////////////////////////////////////
00092   //                                                                     //
00093   // Accessors:                                                          //
00094   //                                                                     //
00095   /////////////////////////////////////////////////////////////////////////
00096 
00097   UniformRandom& rng( ) const { return r; }
00098 
00099   int getMaxNumOfComms( ) const { return maxNumOfComms; }
00100  
00101   int getNumOfVars( ) const { return numOfVars; }
00102 
00103   int getNumOfConsts( ) const { return numOfConsts; }
00104 
00105   FreeGroup getSC( ) const { return SC; }
00106 
00107   Map getM( ) const { return M; }
00108 
00109  
00110 private:
00111 
00112   /////////////////////////////////////////////////////////////////////////
00113   //                                                                     //
00114   // Private functions:                                                  //
00115   //                                                                     //
00116   /////////////////////////////////////////////////////////////////////////
00117 
00118 
00119   /////////////////////////////////////////////////////////////////////////
00120   //                                                                     //
00121   // Data members:                                                       //
00122   //                                                                     //
00123   /////////////////////////////////////////////////////////////////////////
00124 
00125   UniformRandom& r;
00126   int maxNumOfComms, numOfVars, numOfConsts;
00127   FreeGroup SC;
00128   VectorOf<Word> gens;
00129   Map M;
00130 };
00131 
00132 
00133 // ------------------------------- PMB2Com --------------------------------- //
00134 
00135 
00136 class PMB2Com : public PM 
00137 {
00138 
00139 public:
00140 
00141   /////////////////////////////////////////////////////////////////////////
00142   //                                                                     //
00143   // Constructors:                                                       //
00144   //                                                                     //
00145   /////////////////////////////////////////////////////////////////////////
00146 
00147   PMB2Com( const PMB2ComConfig& CFG, int NumOfComms, Triple* T );
00148 
00149   PMB2Com( const PMB2ComConfig& CFG );
00150 
00151   PMB2Com( const PMB2Com& pm );
00152   
00153   ~PMB2Com( );
00154   
00155   /////////////////////////////////////////////////////////////////////////
00156   //                                                                     //
00157   // Overriden abstract functions:                                       //
00158   //                                                                     //
00159   /////////////////////////////////////////////////////////////////////////
00160 
00161   PM* clone( ) const { return new PMB2Com(*this); }
00162 
00163 
00164   /////////////////////////////////////////////////////////////////////////
00165   //                                                                     //
00166   // Overriden hook functions:                                           //
00167   //                                                                     //
00168   /////////////////////////////////////////////////////////////////////////
00169 
00170   PM* crossover( const PM* );
00171 
00172   PM* mutate( );
00173 
00174   PM* randomPM( ); 
00175 
00176   void printOn( ostream& ostr ) const;
00177 
00178   bool operator == ( const PM& p ) const;
00179 
00180 
00181   /////////////////////////////////////////////////////////////////////////
00182   //                                                                     //
00183   // Accessors:                                                          //
00184   //                                                                     //
00185   /////////////////////////////////////////////////////////////////////////
00186 
00187   PMB2Com& operator = ( const PMB2Com& pm );
00188 
00189   Word productInOriginalGroup( const PMB2Com& pm ) const;
00190 
00191 
00192 private:
00193 
00194   /////////////////////////////////////////////////////////////////////////
00195   //                                                                     //
00196   // Private functions:                                                  //
00197   //                                                                     //
00198   /////////////////////////////////////////////////////////////////////////
00199 
00200   Triple randomTriple( );
00201 
00202   Word productInOriginalGroup( int tLen, Triple* t ) const;
00203 
00204   bool productIsTrivial( int tLen, Triple* t) const;
00205 
00206 
00207   /////////////////////////////////////////////////////////////////////////
00208   //                                                                     //
00209   // Data members:                                                       //
00210   //                                                                     //
00211   /////////////////////////////////////////////////////////////////////////
00212 
00213   const PMB2ComConfig& cfg;
00214   Triple* comms;
00215   int numOfComms;
00216 };
00217 
00218 
00219 // --------------------------- GABurauSolver ------------------------------- //
00220 
00221 
00222 class GABurauSolver : public GA
00223 {
00224 
00225 public:
00226   
00227   /////////////////////////////////////////////////////////////////////////
00228   //                                                                     //
00229   // Constructors:                                                       //
00230   //                                                                     //
00231   /////////////////////////////////////////////////////////////////////////
00232   
00233   GABurauSolver( const GAConfig& GAC, const FreeGroup& G, int NumOfVars, 
00234                  const FreeGroup& B, VectorOf<Word> BGens, 
00235                  const FreeGroup& sc );
00236   
00237   // copy constructor supplied by compiler.
00238   
00239   // destructor supplied by compiler.
00240 
00241 
00242   /////////////////////////////////////////////////////////////////////////
00243   //                                                                     //
00244   // Overriden abstract functions:                                       //
00245   //                                                                     //
00246   /////////////////////////////////////////////////////////////////////////
00247 
00248   void initPopulation( );
00249 
00250   int fitness( const PM* pm );
00251   
00252 
00253   /////////////////////////////////////////////////////////////////////////
00254   //                                                                     //
00255   // Accessors:                                                          //
00256   //                                                                     //
00257   /////////////////////////////////////////////////////////////////////////
00258 
00259   Map getSolution( const Word& u, ostream* o = NULL );
00260   // returns a solution for equation u found by genetic algorithm
00261 
00262 
00263   /////////////////////////////////////////////////////////////////////////
00264   //                                                                     //
00265   // OI:                                                                 //
00266   //                                                                     //
00267   /////////////////////////////////////////////////////////////////////////
00268 
00269 
00270 private:
00271 
00272   /////////////////////////////////////////////////////////////////////////
00273   //                                                                     //
00274   // Private functions:                                                  //
00275   //                                                                     //
00276   /////////////////////////////////////////////////////////////////////////
00277   
00278   void reworkEquation( );
00279   
00280   void init( );
00281     
00282   Word PMtoG( const PM* pm, int k );
00283 
00284   bool checkForSolution( Map& res );
00285 
00286 
00287   /////////////////////////////////////////////////////////////////////////
00288   //                                                                     //
00289   // Data members:                                                       //
00290   //                                                                     //
00291   /////////////////////////////////////////////////////////////////////////
00292   
00293   FreeGroup theGroup, B, SC;
00294   int numOfVars, numOfGens, numOfConsts, g;
00295   bool keepDetails;
00296   VectorOf<Word> bGens;
00297   Map M,MB;
00298   Word w;
00299   ostream* out;
00300   PMB2ComConfig PMCC;
00301   PMArrayConfig PMAC;
00302 };
00303 
00304 
00305 #endif

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