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

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

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