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

/magnus/back_end/Genetic/include/PMPolynomial.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 classes PMPolyConfig, PMPolynomial
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Description:
00015 //
00016 // Revision History:
00017 //
00018 
00019 #ifndef _PMPolynomial_H_
00020 #define _PMPolynomial_H_
00021 
00022 
00023 #include "Int2.h"
00024 #include "PM.h"
00025 #include "RandomNumbers.h"
00026 #include "Polynomial.h"
00027 
00028 
00029 // ----------------------------- PMPolyConfig ------------------------------ //
00030 
00031 
00032 class PMPolyConfig
00033 {
00034 
00035 public:
00036 
00037   /////////////////////////////////////////////////////////////////////////
00038   //                                                                     //
00039   // Constructors:                                                       //
00040   //                                                                     //
00041   /////////////////////////////////////////////////////////////////////////
00042   
00043   PMPolyConfig( UniformRandom& R,  
00044                 int MaxCoef, 
00045                 int MaxPower,
00046                 int NumOfVars,
00047                 int MaxNumOfMonoms
00048                 ) 
00049     : r( R ), 
00050       maxCoef( MaxCoef ), 
00051       maxPower( MaxPower ), 
00052       numOfVars( NumOfVars ), 
00053       maxNumOfMonoms( MaxNumOfMonoms )
00054     { }
00055   
00056   // copy constructor, destructor and operators =, == supplied by compiler.
00057 
00058 
00059   /////////////////////////////////////////////////////////////////////////
00060   //                                                                     //
00061   // Accessors:                                                          //
00062   //                                                                     //
00063   /////////////////////////////////////////////////////////////////////////
00064 
00065   UniformRandom& rng( ) const { return r; }
00066 
00067   int getMaxCoef( ) const { return maxCoef; }
00068  
00069   int getMaxPower( ) const { return maxPower; }
00070 
00071   int getNumOfVars( ) const { return numOfVars; }
00072  
00073   int getMaxNumOfMonoms( ) const { return maxNumOfMonoms; }
00074 
00075 
00076 private:
00077 
00078   /////////////////////////////////////////////////////////////////////////
00079   //                                                                     //
00080   // Private functions:                                                  //
00081   //                                                                     //
00082   /////////////////////////////////////////////////////////////////////////
00083 
00084 
00085   /////////////////////////////////////////////////////////////////////////
00086   //                                                                     //
00087   // Data members:                                                       //
00088   //                                                                     //
00089   /////////////////////////////////////////////////////////////////////////
00090 
00091   UniformRandom& r;
00092   int maxCoef, maxPower, numOfVars, maxNumOfMonoms;
00093 };
00094 
00095 
00096 // ----------------------------- PMPolynomial ------------------------------ //
00097 
00098 
00099 class PMPolynomial : public PM 
00100 {
00101 
00102 public:
00103 
00104   /////////////////////////////////////////////////////////////////////////
00105   //                                                                     //
00106   // Constructors:                                                       //
00107   //                                                                     //
00108   /////////////////////////////////////////////////////////////////////////
00109   
00110   PMPolynomial( const PMPolyConfig& CFG, 
00111                 Polynomial<Int2> p = Polynomial<Int2>() ) 
00112     : cfg( CFG ), poly( p ) { }
00113 
00114   // copy constructor, destructor and operator = supplied by compiler.
00115 
00116 
00117   /////////////////////////////////////////////////////////////////////////
00118   //                                                                     //
00119   // Overriden abstract functions:                                       //
00120   //                                                                     //
00121   /////////////////////////////////////////////////////////////////////////
00122 
00123   PM* clone( ) const { return new PMPolynomial(*this); }
00124 
00125 
00126   /////////////////////////////////////////////////////////////////////////
00127   //                                                                     //
00128   // Overriden hook functions:                                           //
00129   //                                                                     //
00130   /////////////////////////////////////////////////////////////////////////
00131 
00132   PM* crossover( const PM* ) { return clone(); }
00133 
00134   PM* mutate( );
00135 
00136   PM* randomPM( ) { }
00137   // no implementation
00138 
00139   void printOn( ostream& ostr ) const { ostr << poly; }
00140 
00141 
00142   /////////////////////////////////////////////////////////////////////////
00143   //                                                                     //
00144   // Accessors:                                                          //
00145   //                                                                     //
00146   /////////////////////////////////////////////////////////////////////////
00147 
00148   Polynomial<Int2> getPolynomial( ) const { return poly; }
00149   
00150   const PMPolyConfig& getCfg( ) { return cfg; }
00151 
00152   bool operator == ( const PM& pm ) const 
00153     { return poly == ((PMPolynomial&)pm).poly; }
00154   
00155 
00156 private:
00157 
00158   /////////////////////////////////////////////////////////////////////////
00159   //                                                                     //
00160   // Private functions:                                                  //
00161   //                                                                     //
00162   /////////////////////////////////////////////////////////////////////////
00163 
00164   Monomial<Int2> randomMonomial( int maxCoef, int maxNumOfVars, 
00165                                  int maxPower, int absentVar );
00166 
00167   Polynomial<Int2> randomPolynomial( int maxNumOfMonoms, int absentVar );
00168 
00169 
00170   /////////////////////////////////////////////////////////////////////////
00171   //                                                                     //
00172   // Data members:                                                       //
00173   //                                                                     //
00174   /////////////////////////////////////////////////////////////////////////
00175 
00176   const PMPolyConfig& cfg;
00177   Polynomial<Int2> poly;
00178 };
00179 
00180 #endif

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