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

/magnus/back_end/Enumerators/include/SMListWordProblem.h

Go to the documentation of this file.
00001 #include "Supervisor.h"
00002 #include "SMEnumerator.h"
00003 #include "SMList.h"
00004 #include "File.h"
00005 #include "Word.h"
00006 #include "SMFPGroup.h"
00007 #include "OutMessages.h"
00008 #include "RandomNumbers.h"
00009 #include "ListProblems.h"
00010 #include "SMListIterator.h"
00011 
00012 #ifndef _SMLIST_WORD_PROBLEM_H_
00013 #define _SMLIST_WORD_PROBLEM_H_
00014 
00015 // --------------------------- SMListGeneticWPArcer ------------------------ //
00016 
00017 
00018 class SMListGeneticWPArcer : public ARCer
00019 {
00020 public:
00021 
00022   /////////////////////////////////////////////////////////////////////////
00023   //                                                                     //
00024   // Constructors:                                                       //
00025   //                                                                     //
00026   /////////////////////////////////////////////////////////////////////////
00027 
00028   SMListGeneticWPArcer( ComputationManager& );
00029 
00030   ~SMListGeneticWPArcer( ) { }
00031 
00032 
00033   /////////////////////////////////////////////////////////////////////////
00034   //                                                                     //
00035   // Accessors:                                                          //
00036   //                                                                     //
00037   /////////////////////////////////////////////////////////////////////////
00038 
00039   void setArguments( SMList<Word>* );
00040 
00041   // Inherited from ARCer:
00042   // bool takeControl( );
00043 
00044 
00045   /////////////////////////////////////////////////////////////////////////
00046   //                                                                     //
00047   // IPC interaction members:                                            //
00048   //                                                                     //
00049   /////////////////////////////////////////////////////////////////////////
00050 
00051   void runComputation( );
00052 
00053   void writeResults( ostream& );
00054 
00055   void readResults( istream& );
00056 
00057   
00058 private:
00059 
00060   /////////////////////////////////////////////////////////////////////////
00061   //                                                                     //
00062   // Private functions:                                                  //
00063   //                                                                     //
00064   /////////////////////////////////////////////////////////////////////////
00065 
00066   /////////////////////////////////////////////////////////////////////////
00067   //                                                                     //
00068   // Data Members:                                                       //
00069   //                                                                     //
00070   /////////////////////////////////////////////////////////////////////////
00071   SMListIterator<Word>* theIterator;
00072   SMList<Word>* theList;
00073 };
00074 
00075 
00076 
00077 // ---------------------------- SMListGeneticWPCM ------------------------- //
00078 
00079 
00080 class SMListGeneticWPCM : public ComputationManager
00081 {
00082 public:
00083 
00084   /////////////////////////////////////////////////////////////////////////
00085   //                                                                     //
00086   // Constructors:                                                       //
00087   //                                                                     //
00088   /////////////////////////////////////////////////////////////////////////
00089 
00090   SMListGeneticWPCM( class SMListSupervisor& sms );
00091 
00092   //  ~GeneticWPCM( );
00093 
00094   /////////////////////////////////////////////////////////////////////////
00095   //                                                                     //
00096   // Accessors:                                                          //
00097   //                                                                     //
00098   /////////////////////////////////////////////////////////////////////////
00099    
00100   /////////////////////////////////////////////////////////////////////////
00101   //                                                                     //
00102   // Control:                                                            //
00103   //                                                                     //
00104   /////////////////////////////////////////////////////////////////////////
00105 
00106   void takeControl( );         // overrides ComputationManager
00107 
00108   /////////////////////////////////////////////////////////////////////////
00109   //                                                                     //
00110   // State Transitions:                                                  //
00111   //                                                                     //
00112   /////////////////////////////////////////////////////////////////////////
00113 
00114   void start( );              // overrides ComputationManager
00115 
00116   void terminate( );          // overrides ComputationManager
00117 
00118 
00119 private:
00120 
00121   /////////////////////////////////////////////////////////////////////////
00122   //                                                                     //
00123   // Data Members:                                                       //
00124   //                                                                     //
00125   /////////////////////////////////////////////////////////////////////////
00126 
00127   SMListGeneticWPArcer arcer;
00128 };
00129 
00130 // ----------------------- SMListWPCheckARCer ------------------ //
00131 
00132 class SMListWPCheckARCer : public ARCer
00133 {
00134 public:
00135   SMListWPCheckARCer( ComputationManager& boss ) 
00136     : ARCer( boss ),
00137       theIterator( NULL ),
00138       theGroup( NULL ) { } 
00139 
00140   /////////////////////////////////////////////////////////////////////////
00141   //                                                                     //
00142   // Accessors:                                                          //
00143   //                                                                     //
00144   /////////////////////////////////////////////////////////////////////////
00145 
00146   // Inherited from ARCer:
00147   // bool takeControl( );
00148 
00149   void setArguments( SMList<Word>*, const SMFPGroup*  );
00150 
00151   void runComputation( );
00152   void writeResults( ostream& ) { };
00153   void readResults( istream& ) { };
00154 
00155 private:
00156   SMListIterator<Word>* theIterator;
00157   const class SMFPGroup* theGroup;
00158   class SMList<Word>* theList;
00159 };
00160 
00161 
00162 // --------------------- SMListWPCheckComputation  ---------------------- //
00163 
00164 
00165 class SMListWPCheckComputation  : public ComputationManager
00166 {
00167 public:
00168 
00169   /////////////////////////////////////////////////////////////////////////
00170   //                                                                     //
00171   // Constructors:                                                       //
00172   //                                                                     //
00173   /////////////////////////////////////////////////////////////////////////
00174  
00175   SMListWPCheckComputation( SMListSupervisor& );
00176   
00177   ~SMListWPCheckComputation(); 
00178 
00179   /////////////////////////////////////////////////////////////////////////
00180   //                                                                     //
00181   // Accessors:                                                            //
00182   //                                                                     //
00183   /////////////////////////////////////////////////////////////////////////
00184 
00185 
00186   /////////////////////////////////////////////////////////////////////////
00187   //                                                                     //
00188   // Control:                                                            //
00189   //                                                                     //
00190   /////////////////////////////////////////////////////////////////////////
00191 
00192   void takeControl( );         // overrides ComputationManager
00193 
00194 
00195   /////////////////////////////////////////////////////////////////////////
00196   //                                                                     //
00197   // State Transitions:                                                  //
00198   //                                                                     //
00199   /////////////////////////////////////////////////////////////////////////
00200 
00201   void start( ) { }
00202 
00203   void terminate( ) { }        // overrides ComputationManager
00204 
00205 
00206 private:
00207 
00208   /////////////////////////////////////////////////////////////////////////
00209   //                                                                     //
00210   // Data Members:                                                       //
00211   //                                                                     //
00212   /////////////////////////////////////////////////////////////////////////
00213 
00214   SMList<Word>& theList;
00215 
00216   bool started;
00217   SMListWPCheckARCer arcer;
00218 };
00219 
00220 // --------------------------- SMListWPPrinResultArcer --------------------- //
00221 
00222 
00223 class SMListWPPrinResultArcer : public ARCer
00224 {
00225 public:
00226 
00227   /////////////////////////////////////////////////////////////////////////
00228   //                                                                     //
00229   // Constructors:                                                       //
00230   //                                                                     //
00231   /////////////////////////////////////////////////////////////////////////
00232 
00233   SMListWPPrinResultArcer( ComputationManager& b) :
00234     ARCer( b ),
00235     theList( NULL ) { }
00236 
00237   ~SMListWPPrinResultArcer( ) { }
00238 
00239 
00240   /////////////////////////////////////////////////////////////////////////
00241   //                                                                     //
00242   // Accessors:                                                          //
00243   //                                                                     //
00244   /////////////////////////////////////////////////////////////////////////
00245 
00246   void setArguments( SMList<Word>* );
00247 
00248   Chars getFileOfNonTrivial() const { return fileOfNonTrivial.getFileName(); }
00249   const SMListData& getTrivialData() const { return trivialData; }
00250 
00251 
00252 
00253   // Inherited from ARCer:
00254   // bool takeControl( );
00255 
00256 
00257   /////////////////////////////////////////////////////////////////////////
00258   //                                                                     //
00259   // IPC interaction members:                                            //
00260   //                                                                     //
00261   /////////////////////////////////////////////////////////////////////////
00262 
00263   void runComputation( );
00264   void writeResults( ostream& o ) { o < trivialData;}
00265 
00266   void readResults( istream& i ) { i > trivialData; }
00267 
00268   
00269 private:
00270 
00271   /////////////////////////////////////////////////////////////////////////
00272   //                                                                     //
00273   // Private functions:                                                  //
00274   //                                                                     //
00275   /////////////////////////////////////////////////////////////////////////
00276   /////////////////////////////////////////////////////////////////////////
00277   //                                                                     //
00278   // Data Members:                                                       //
00279   //                                                                     //
00280   /////////////////////////////////////////////////////////////////////////
00281   SMList<Word>* theList;
00282   File fileOfNonTrivial;
00283   SMListData trivialData;
00284 };
00285 
00286 // --------------------- SMListExtractTrivialWords  ---------------------- //
00287 
00288 
00289 class SMListExtractTrivialWords  : public SMListSupervisor
00290 {
00291 public:
00292 
00293   /////////////////////////////////////////////////////////////////////////
00294   //                                                                     //
00295   // Constructors:                                                       //
00296   //                                                                     //
00297   /////////////////////////////////////////////////////////////////////////
00298  
00299   SMListExtractTrivialWords( SMList<Word>& );
00300   
00301   ~SMListExtractTrivialWords() {
00302 
00303   }
00304   /////////////////////////////////////////////////////////////////////////
00305   //                                                                     //
00306   // Front End Interfacing:                                              //
00307   //                                                                     //
00308   /////////////////////////////////////////////////////////////////////////
00309 
00310   void viewStructure(ostream& ostr) const;  // overrides SMObject
00311 
00312 
00313   /////////////////////////////////////////////////////////////////////////
00314   //                                                                     //
00315   // Control:                                                            //
00316   //                                                                     //
00317   /////////////////////////////////////////////////////////////////////////
00318 
00319   void takeControl( );         // overrides ComputationManager
00320 
00321   bool finished( );
00322   /////////////////////////////////////////////////////////////////////////
00323   //                                                                     //
00324   // State Transitions:                                                  //
00325   //                                                                     //
00326   /////////////////////////////////////////////////////////////////////////
00327 
00328   void start( ); 
00329 
00330   void terminate( ) { }        // overrides ComputationManager
00331 
00332 
00333 private:
00334 
00335   /////////////////////////////////////////////////////////////////////////
00336   //                                                                     //
00337   // Data Members:                                                       //
00338   //                                                                     //
00339   /////////////////////////////////////////////////////////////////////////
00340 
00341   MirrorSubordinate abelianInvariants;
00342   MirrorSubordinate kbSupervisor;
00343   MirrorSubordinate agSupervisor;
00344   MirrorSubordinate normalClosure;
00345   Subordinate<SMListExtractTrivialWords, SMListGeneticWPCM> genetic;
00346 
00347   Subordinate<SMListExtractTrivialWords, SMListWPCheckComputation> checker;
00348 
00349   SMListWPPrinResultArcer arcer;
00350 
00351 };
00352 
00353 
00354 // ----------------------- SMListWordIsCentralARCer ------------------ //
00355 
00356 class SMListWordIsCentralARCer : public ARCer
00357 {
00358 public:
00359   SMListWordIsCentralARCer( ComputationManager& boss );
00360 
00361   /////////////////////////////////////////////////////////////////////////
00362   //                                                                     //
00363   // Accessors:                                                          //
00364   //                                                                     //
00365   /////////////////////////////////////////////////////////////////////////
00366 
00367   // Inherited from ARCer:
00368   // bool takeControl( );
00369 
00370   void setArguments( SMList<Word>*);
00371 
00372   void runComputation( );
00373   void writeResults( ostream& o ) { 
00374     o < tCounter; 
00375     o < ntCounter;
00376     o < centralData;
00377   };
00378   void readResults( istream& i ) { 
00379     i > tCounter; 
00380     i > ntCounter;
00381     i > centralData;
00382   };
00383 
00384   Chars getFileOfNonCentral() const { return fileOfNonCentral.getFileName(); }
00385   const SMListData& getCentralData() const { return centralData; }
00386  
00387 private:
00388   SMListIterator<Word>* theIterator;
00389   const class SMFPGroup* theGroup;
00390   class SMList<Word>* theList;
00391   File fileOfNonCentral;
00392   SMListData centralData;
00393   int tCounter;
00394   int ntCounter;
00395 };
00396 
00397 
00398 // --------------------- SMListWordIsCentralComputation -------------------- //
00399 
00400 
00401 class SMListWordIsCentralComputation  : public ComputationManager
00402 {
00403 public:
00404 
00405   /////////////////////////////////////////////////////////////////////////
00406   //                                                                     //
00407   // Constructors:                                                       //
00408   //                                                                     //
00409   /////////////////////////////////////////////////////////////////////////
00410  
00411   SMListWordIsCentralComputation( class SMListExtractCentralWords& );
00412   
00413   ~SMListWordIsCentralComputation(); 
00414 
00415   /////////////////////////////////////////////////////////////////////////
00416   //                                                                     //
00417   // Accessors:                                                            //
00418   //                                                                     //
00419   /////////////////////////////////////////////////////////////////////////
00420 
00421   Chars getFileOfNonCentral() const { return arcer.getFileOfNonCentral(); }
00422   const SMListData& getCentralData() const { return arcer.getCentralData(); }
00423 
00424   /////////////////////////////////////////////////////////////////////////
00425   //                                                                     //
00426   // Control:                                                            //
00427   //                                                                     //
00428   /////////////////////////////////////////////////////////////////////////
00429 
00430   void takeControl( );         // overrides ComputationManager
00431 
00432 
00433   /////////////////////////////////////////////////////////////////////////
00434   //                                                                     //
00435   // State Transitions:                                                  //
00436   //                                                                     //
00437   /////////////////////////////////////////////////////////////////////////
00438 
00439   void start( ) { }
00440 
00441   void terminate( ) { }        // overrides ComputationManager
00442 
00443 
00444 private:
00445 
00446   /////////////////////////////////////////////////////////////////////////
00447   //                                                                     //
00448   // Data Members:                                                       //
00449   //                                                                     //
00450   /////////////////////////////////////////////////////////////////////////
00451 
00452   SMList<Word>& theList;
00453 
00454   bool started;
00455   SMListWordIsCentralARCer arcer;
00456 };
00457 
00458 // --------------------- SMListExtractCentralWords -------------------- //
00459 
00460 
00461 class SMListExtractCentralWords  : public Supervisor
00462 {
00463 public:
00464 
00465   /////////////////////////////////////////////////////////////////////////
00466   //                                                                     //
00467   // Constructors:                                                       //
00468   //                                                                     //
00469   /////////////////////////////////////////////////////////////////////////
00470  
00471   SMListExtractCentralWords( SMList<Word>& );
00472   
00473   ~SMListExtractCentralWords() {
00474 
00475   }
00476   /////////////////////////////////////////////////////////////////////////
00477   //                                                                     //
00478   // Front End Interfacing:                                              //
00479   //                                                                     //
00480   /////////////////////////////////////////////////////////////////////////
00481 
00482   void viewStructure(ostream& ostr) const;  // overrides SMObject
00483 
00484 
00485   /////////////////////////////////////////////////////////////////////////
00486   //                                                                     //
00487   // Control:                                                            //
00488   //                                                                     //
00489   /////////////////////////////////////////////////////////////////////////
00490 
00491   void takeControl( );         // overrides ComputationManager
00492 
00493   SMList<Word>& getList() { return theList; }
00494 
00495   /////////////////////////////////////////////////////////////////////////
00496   //                                                                     //
00497   // State Transitions:                                                  //
00498   //                                                                     //
00499   /////////////////////////////////////////////////////////////////////////
00500 
00501   void start( ); 
00502 
00503   void terminate( ) { }        // overrides ComputationManager
00504 
00505 
00506 private:
00507 
00508   /////////////////////////////////////////////////////////////////////////
00509   //                                                                     //
00510   // Data Members:                                                       //
00511   //                                                                     //
00512   /////////////////////////////////////////////////////////////////////////
00513 
00514   SMList<Word>& theList;
00515 
00516   MirrorSubordinate abelianInvariants;
00517   MirrorSubordinate kbSupervisor;
00518   MirrorSubordinate agSupervisor;
00519   MirrorSubordinate normalClosure;
00520 
00521   Subordinate<SMListExtractCentralWords,SMListWordIsCentralComputation> checker;
00522 
00523 };
00524 
00525 #endif

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