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

/magnus/back_end/SMApps/include/NGSubgroupProblems.h

Go to the documentation of this file.
00001 
00002 // Copyright (C) 1995 The New York Group Theory Cooperative
00003 // See magnus/doc/COPYRIGHT for the full notice.
00004 
00005 // Contents: Declarations of classes 
00006 //
00007 // Principal Author: Dmitry Bormotov, Eugene Paderin, Alexei Myasnikov
00008 //
00009 // Status: in progress
00010 //
00011 // Revision History:
00012 //
00013 
00014 
00015 #ifndef _NSubroupProblems_h_
00016 #define _NSubroupProblems_h_
00017 
00018 
00019 #include "Supervisor.h"
00020 #include "File.h"
00021 #include "ARCer.h"
00022 #include "SMFPGroup.h"
00023 #include "SMWord.h"
00024 #include "SGOfNilpotentGroup.h"
00025 
00026 // ----------------- SGOfNGinitPreimageARCer ---------------------- //
00027 
00028 class SGOfNGinitPreimageARCer : public ARCer
00029 {
00030 public:
00031 
00032   /////////////////////////////////////////////////////////////////////////
00033   //                                                                     //
00034   // Constructors:                                                       //
00035   //                                                                     //
00036   /////////////////////////////////////////////////////////////////////////
00037 
00038   SGOfNGinitPreimageARCer( ComputationManager& boss ) 
00039     : ARCer( boss ),theSNG( 0 ) { } 
00040   
00041   ~SGOfNGinitPreimageARCer( ) { delete theSNG; }
00042 
00043   /////////////////////////////////////////////////////////////////////////
00044   //                                                                     //
00045   // Accessors:                                                          //
00046   //                                                                     //
00047   /////////////////////////////////////////////////////////////////////////
00048 
00049   void setArguments(const NilpotentGroup& NG , 
00050                     const VectorOf<Word>& gens);
00051   const SGOfNilpotentGroup& getSubgroup() const;
00052 
00053   // Inherited from ARCer:
00054   // bool takeControl( );
00055 
00056 
00057   /////////////////////////////////////////////////////////////////////////
00058   //                                                                     //
00059   // IPC interaction members:                                            //
00060   //                                                                     //
00061   /////////////////////////////////////////////////////////////////////////
00062 
00063   void runComputation( );
00064  
00065   void writeResults( ostream& );
00066 
00067   void readResults( istream& );
00068 
00069   
00070 private:
00071 
00072   /////////////////////////////////////////////////////////////////////////
00073   //                                                                     //
00074   // Data Members:                                                       //
00075   //                                                                     //
00076   /////////////////////////////////////////////////////////////////////////
00077 
00078   SGOfNilpotentGroup* theSNG;
00079 };
00080 
00081 // ---------------------- SGOfNGinitPreimageProblem --------------------- //
00082 
00083 
00084 class SGOfNGinitPreimageProblem : public ComputationManager
00085 {
00086 public:
00087 
00088   /////////////////////////////////////////////////////////////////////////
00089   //                                                                     //
00090   // Constructors:                                                       //
00091   //                                                                     //
00092   /////////////////////////////////////////////////////////////////////////
00093 
00094   SGOfNGinitPreimageProblem(class SCM& scm);
00095 
00096   /////////////////////////////////////////////////////////////////////////
00097   //                                                                     //
00098   // Accessors:                                                          //
00099   //                                                                     //
00100   /////////////////////////////////////////////////////////////////////////
00101 
00102   /////////////////////////////////////////////////////////////////////////
00103   //                                                                     //
00104   // Control:                                                            //
00105   //                                                                     //
00106   /////////////////////////////////////////////////////////////////////////
00107 
00108   void takeControl( );         // overrides ComputationManager
00109 
00110 
00111   /////////////////////////////////////////////////////////////////////////
00112   //                                                                     //
00113   // State Transitions:                                                  //
00114   //                                                                     //
00115   /////////////////////////////////////////////////////////////////////////
00116 
00117   void start( ) { };          // overrides ComputationManager
00118 
00119   void terminate( ) { };      // overrides ComputationManager
00120 
00121 
00122 private:
00123 
00124   /////////////////////////////////////////////////////////////////////////
00125   //                                                                     //
00126   // Data Members:                                                       //
00127   //                                                                     //
00128   /////////////////////////////////////////////////////////////////////////
00129 
00130   class SCM& theSCM;
00131   class GIC& theGIC;
00132   SGOfNGinitPreimageARCer arcer;
00133 };
00134 
00135 // ----------------- SGOfNGinitializeARCer ---------------------- //
00136 
00137 class SGOfNGinitializeARCer : public ARCer
00138 {
00139 public:
00140 
00141   /////////////////////////////////////////////////////////////////////////
00142   //                                                                     //
00143   // Constructors:                                                       //
00144   //                                                                     //
00145   /////////////////////////////////////////////////////////////////////////
00146 
00147   SGOfNGinitializeARCer( ComputationManager& boss ) 
00148     : ARCer( boss ),theSNG( 0 ) { } 
00149   
00150   ~SGOfNGinitializeARCer( ) { delete theSNG; }
00151 
00152   /////////////////////////////////////////////////////////////////////////
00153   //                                                                     //
00154   // Accessors:                                                          //
00155   //                                                                     //
00156   /////////////////////////////////////////////////////////////////////////
00157 
00158   void setArguments(const NilpotentGroup& FNG , 
00159                     const VectorOf<Word>& gens);
00160   const SGOfNilpotentGroup& getSubgroup() const;
00161 
00162   // Inherited from ARCer:
00163   // bool takeControl( );
00164 
00165 
00166   /////////////////////////////////////////////////////////////////////////
00167   //                                                                     //
00168   // IPC interaction members:                                            //
00169   //                                                                     //
00170   /////////////////////////////////////////////////////////////////////////
00171 
00172   void runComputation( );
00173  
00174   void writeResults( ostream& );
00175 
00176   void readResults( istream& );
00177 
00178   
00179 private:
00180 
00181   /////////////////////////////////////////////////////////////////////////
00182   //                                                                     //
00183   // Data Members:                                                       //
00184   //                                                                     //
00185   /////////////////////////////////////////////////////////////////////////
00186 
00187   SGOfNilpotentGroup* theSNG;
00188 };
00189 
00190 // ---------------------- SGOfNGinitializeProblem --------------------- //
00191 
00192 
00193 class SGOfNGinitializeProblem : public ComputationManager
00194 {
00195 public:
00196 
00197   /////////////////////////////////////////////////////////////////////////
00198   //                                                                     //
00199   // Constructors:                                                       //
00200   //                                                                     //
00201   /////////////////////////////////////////////////////////////////////////
00202 
00203   SGOfNGinitializeProblem(class SCM& scm);
00204 
00205   /////////////////////////////////////////////////////////////////////////
00206   //                                                                     //
00207   // Accessors:                                                          //
00208   //                                                                     //
00209   /////////////////////////////////////////////////////////////////////////
00210 
00211   /////////////////////////////////////////////////////////////////////////
00212   //                                                                     //
00213   // Control:                                                            //
00214   //                                                                     //
00215   /////////////////////////////////////////////////////////////////////////
00216 
00217   void takeControl( );         // overrides ComputationManager
00218 
00219 
00220   /////////////////////////////////////////////////////////////////////////
00221   //                                                                     //
00222   // State Transitions:                                                  //
00223   //                                                                     //
00224   /////////////////////////////////////////////////////////////////////////
00225 
00226   void start( ) { };          // overrides ComputationManager
00227 
00228   void terminate( ) { };      // overrides ComputationManager
00229 
00230 
00231 private:
00232 
00233   /////////////////////////////////////////////////////////////////////////
00234   //                                                                     //
00235   // Data Members:                                                       //
00236   //                                                                     //
00237   /////////////////////////////////////////////////////////////////////////
00238 
00239   class SCM& theSCM;
00240   class GIC& theGIC;
00241   SGOfNGinitializeARCer arcer;
00242   bool haveParentInited;
00243 };
00244 
00245 
00246 class SGOfNGcomputeBasisProblem : public Supervisor
00247 {
00248 public:
00249 
00250   /////////////////////////////////////////////////////////////////////////
00251   //                                                                     //
00252   // Constructors:                                                       //
00253   //                                                                     //
00254   /////////////////////////////////////////////////////////////////////////
00255 
00256   SGOfNGcomputeBasisProblem(class SMSubgroup& sg);
00257 
00258   /////////////////////////////////////////////////////////////////////////
00259   //                                                                     //
00260   // Accessors:                                                          //
00261   //                                                                     //
00262   /////////////////////////////////////////////////////////////////////////
00263 
00264 
00265   /////////////////////////////////////////////////////////////////////////
00266   //                                                                     //
00267   // Front End Interfacing:                                              //
00268   //                                                                     //
00269   /////////////////////////////////////////////////////////////////////////
00270 
00271   void viewStructure(ostream& ostr) const;  // overrides SMObject
00272 
00273   /////////////////////////////////////////////////////////////////////////
00274   //                                                                     //
00275   // Control:                                                            //
00276   //                                                                     //
00277   /////////////////////////////////////////////////////////////////////////
00278 
00279   void takeControl( );         // overrides ComputationManager
00280 
00281   /////////////////////////////////////////////////////////////////////////
00282   //                                                                     //
00283   // State Transitions:                                                  //
00284   //                                                                     //
00285   /////////////////////////////////////////////////////////////////////////
00286 
00287   void start( );              // overrides ComputationManager
00288 
00289   void terminate( );          // overrides ComputationManager
00290 
00291 
00292 private:
00293 
00294   /////////////////////////////////////////////////////////////////////////
00295   //                                                                     //
00296   // Data Members:                                                       //
00297   //                                                                     //
00298   /////////////////////////////////////////////////////////////////////////
00299   MirrorSubordinate initializeSGOfNG;
00300   MirrorSubordinate computeBasis;
00301   class SMSubgroup& theSubgroup;
00302 };
00303 
00304 // ------------------SGOfNGDecomposeWordARCer ---------------------- //
00305 
00306 
00307 class SGOfNGDecomposeWordARCer : public ARCer
00308 {
00309 public:
00310 
00311   /////////////////////////////////////////////////////////////////////////
00312   //                                                                     //
00313   // Constructors:                                                       //
00314   //                                                                     //
00315   /////////////////////////////////////////////////////////////////////////
00316 
00317   SGOfNGDecomposeWordARCer( ComputationManager& boss ) 
00318     : ARCer( boss ),theSNG(NULL) { } 
00319   
00320   ~SGOfNGDecomposeWordARCer() { delete theSNG; }
00321 
00322   /////////////////////////////////////////////////////////////////////////
00323   //                                                                     //
00324   // Accessors:                                                          //
00325   //                                                                     //
00326   /////////////////////////////////////////////////////////////////////////
00327 
00328   void setArguments( const SGOfNilpotentGroup&, const PolyWord& );
00329 
00330   const PolyWord& decomposition() { return theDecomposition; }
00331   bool contains() { return isContain; }
00332 
00333   // Inherited from ARCer:
00334   // bool takeControl( );
00335 
00336 
00337   /////////////////////////////////////////////////////////////////////////
00338   //                                                                     //
00339   // IPC interaction members:                                            //
00340   //                                                                     //
00341   /////////////////////////////////////////////////////////////////////////
00342 
00343   void runComputation( );
00344  
00345   void writeResults( ostream& );
00346 
00347   void readResults( istream& );
00348 
00349   
00350 private:
00351 
00352   /////////////////////////////////////////////////////////////////////////
00353   //                                                                     //
00354   // Data Members:                                                       //
00355   //                                                                     //
00356   /////////////////////////////////////////////////////////////////////////
00357 
00358   SGOfNilpotentGroup* theSNG;
00359   
00360   bool isContain;
00361 
00362   PolyWord theDecomposition;
00363  
00364   PolyWord theWord;
00365 };
00366 
00367 // --------------------- SGOfNGDecomposeWordProblem ------------------------ //
00368 
00369 
00370 class SGOfNGDecomposeWordProblem : public Supervisor
00371 {
00372 public:
00373 
00374   /////////////////////////////////////////////////////////////////////////
00375   //                                                                     //
00376   // Constructors:                                                       //
00377   //                                                                     //
00378   /////////////////////////////////////////////////////////////////////////
00379 
00380  SGOfNGDecomposeWordProblem( class SMSubgroup&, const class SMWord& );
00381 
00382 
00383   /////////////////////////////////////////////////////////////////////////
00384   //                                                                     //
00385   // Front End Interfacing:                                              //
00386   //                                                                     //
00387   /////////////////////////////////////////////////////////////////////////
00388 
00389   void viewStructure(ostream& ostr) const;  // overrides SMObject
00390 
00391 
00392   /////////////////////////////////////////////////////////////////////////
00393   //                                                                     //
00394   // Control:                                                            //
00395   //                                                                     //
00396   /////////////////////////////////////////////////////////////////////////
00397 
00398   void takeControl( );         // overrides ComputationManager
00399 
00400 
00401   /////////////////////////////////////////////////////////////////////////
00402   //                                                                     //
00403   // State Transitions:                                                  //
00404   //                                                                     //
00405   /////////////////////////////////////////////////////////////////////////
00406 
00407   void start( ) { }            // overrides ComputationManager
00408 
00409   void terminate( ) { }        // overrides ComputationManager
00410 
00411 
00412 private:
00413 
00414   /////////////////////////////////////////////////////////////////////////
00415   //                                                                     //
00416   // Data Members:                                                       //
00417   //                                                                     //
00418   /////////////////////////////////////////////////////////////////////////
00419 
00420   const class SMWord& theWord;
00421   class SMSubgroup& theSubgroup;
00422   class SIC& theSIC;
00423 
00424   SGOfNGDecomposeWordARCer arcer;
00425   MirrorSubordinate  initializeSGOfNG;
00426   MirrorSubordinate  computeBasis;
00427   MirrorSubordinate  ngDecomposeWord;
00428   bool started;
00429 };
00430 
00431 // ------------------SGOfNGWordContainARCer ---------------------- //
00432 
00433 
00434 class SGOfNGWordContainARCer : public ARCer
00435 {
00436 public:
00437 
00438   /////////////////////////////////////////////////////////////////////////
00439   //                                                                     //
00440   // Constructors:                                                       //
00441   //                                                                     //
00442   /////////////////////////////////////////////////////////////////////////
00443 
00444   SGOfNGWordContainARCer( ComputationManager& boss ) 
00445     : ARCer( boss ),theSubgroup(0) { } 
00446   
00447   ~SGOfNGWordContainARCer() { delete theSubgroup; }
00448 
00449   /////////////////////////////////////////////////////////////////////////
00450   //                                                                     //
00451   // Accessors:                                                          //
00452   //                                                                     //
00453   /////////////////////////////////////////////////////////////////////////
00454 
00455   void setArguments( const SGOfNilpotentGroup&, const SetOf<Word>& );
00456 
00457   bool answer() { return theAnswer; }
00458 
00459   // Inherited from ARCer:
00460   // bool takeControl( );
00461 
00462 
00463   /////////////////////////////////////////////////////////////////////////
00464   //                                                                     //
00465   // IPC interaction members:                                            //
00466   //                                                                     //
00467   /////////////////////////////////////////////////////////////////////////
00468 
00469   void runComputation( );
00470  
00471   void writeResults( ostream& );
00472 
00473   void readResults( istream& );
00474 
00475   
00476 private:
00477 
00478   /////////////////////////////////////////////////////////////////////////
00479   //                                                                     //
00480   // Data Members:                                                       //
00481   //                                                                     //
00482   /////////////////////////////////////////////////////////////////////////
00483 
00484   SGOfNilpotentGroup* theSubgroup;
00485   
00486   bool theAnswer;
00487 
00488   SetOf<Word> theTestWords;
00489 };
00490 
00491 // --------------------- SGOfNGWordContainProblem ------------------------ //
00492 
00493 class SGOfNGWordContain : public ComputationManager
00494 {
00495 public:
00496 
00497   /////////////////////////////////////////////////////////////////////////
00498   //                                                                     //
00499   // Constructors:                                                       //
00500   //                                                                     //
00501   /////////////////////////////////////////////////////////////////////////
00502 
00503   SGOfNGWordContain( class SGOfNGWordContainProblem& );
00504 
00505   // SGOfNGWordContain( const class SubgroupContainProblem& );
00506 
00507   /////////////////////////////////////////////////////////////////////////
00508   //                                                                     //
00509   // Accessors:                                                          //
00510   //                                                                     //
00511   /////////////////////////////////////////////////////////////////////////
00512 
00513   Trichotomy answer( ) const;
00514 
00515   /////////////////////////////////////////////////////////////////////////
00516   //                                                                     //
00517   // Front End Interfacing:                                              //
00518   //                                                                     //
00519   /////////////////////////////////////////////////////////////////////////
00520 
00521   void viewStructure(ostream& ostr) const { }  // overrides SMObject
00522 
00523   /////////////////////////////////////////////////////////////////////////
00524   //                                                                     //
00525   // Control:                                                            //
00526   //                                                                     //
00527   /////////////////////////////////////////////////////////////////////////
00528 
00529   void takeControl( );         // overrides ComputationManager
00530 
00531 
00532   /////////////////////////////////////////////////////////////////////////
00533   //                                                                     //
00534   // State Transitions:                                                  //
00535   //                                                                     //
00536   /////////////////////////////////////////////////////////////////////////
00537 
00538   void start( ) { }            // overrides ComputationManager
00539 
00540   void terminate( ) { }        // overrides ComputationManager
00541 
00542 
00543 private:
00544 
00545   /////////////////////////////////////////////////////////////////////////
00546   //                                                                     //
00547   // Data Members:                                                       //
00548   //                                                                     //
00549   /////////////////////////////////////////////////////////////////////////
00550 
00551   const class SMSubgroup& theSubgroup;
00552   SetOf<Word> theTestWords;
00553 
00554   SGOfNGWordContainARCer arcer;
00555   bool arcerStarted;
00556 
00557   Trichotomy theAnswer;
00558 };
00559 
00560 
00561 class SGOfNGWordContainProblem : public Supervisor
00562 {
00563 public:
00564 
00565   /////////////////////////////////////////////////////////////////////////
00566   //                                                                     //
00567   // Constructors:                                                       //
00568   //                                                                     //
00569   /////////////////////////////////////////////////////////////////////////
00570 
00571  SGOfNGWordContainProblem( class SMSubgroup&, const class SMWord& );
00572 
00573 
00574   /////////////////////////////////////////////////////////////////////////
00575   //                                                                     //
00576   // Accessors:                                                          //
00577   //                                                                     //
00578   /////////////////////////////////////////////////////////////////////////
00579 
00580   const SMSubgroup& getSubgroup( ) const { return theSubgroup; }
00581 
00582   const SMWord& getTestWord( ) const { return theTestWord; }
00583 
00584   /////////////////////////////////////////////////////////////////////////
00585   //                                                                     //
00586   // Front End Interfacing:                                              //
00587   //                                                                     //
00588   /////////////////////////////////////////////////////////////////////////
00589 
00590   void viewStructure(ostream& ostr) const;  // overrides SMObject
00591 
00592 
00593   /////////////////////////////////////////////////////////////////////////
00594   //                                                                     //
00595   // Control:                                                            //
00596   //                                                                     //
00597   /////////////////////////////////////////////////////////////////////////
00598 
00599   void takeControl( );         // overrides ComputationManager
00600 
00601 
00602   /////////////////////////////////////////////////////////////////////////
00603   //                                                                     //
00604   // State Transitions:                                                  //
00605   //                                                                     //
00606   /////////////////////////////////////////////////////////////////////////
00607 
00608   void start( ) { }            // overrides ComputationManager
00609 
00610   void terminate( ) { }        // overrides ComputationManager
00611 
00612 
00613 private:
00614 
00615   /////////////////////////////////////////////////////////////////////////
00616   //                                                                     //
00617   // Data Members:                                                       //
00618   //                                                                     //
00619   /////////////////////////////////////////////////////////////////////////
00620 
00621   class SMSubgroup& theSubgroup;
00622   const class SMWord& theTestWord;
00623 
00624   MirrorSubordinate initPreimageSGOfNG;
00625   Subordinate<SGOfNGWordContainProblem, SGOfNGWordContain> sgContain;
00626 };
00627 
00628 // ----------------- SGOfNGcontainSubgroupARCer ---------------------- //
00629 
00630 class SGOfNGcontainSubgroupARCer : public ARCer
00631 {
00632 public:
00633 
00634   /////////////////////////////////////////////////////////////////////////
00635   //                                                                     //
00636   // Constructors:                                                       //
00637   //                                                                     //
00638   /////////////////////////////////////////////////////////////////////////
00639 
00640   SGOfNGcontainSubgroupARCer( ComputationManager& boss ) 
00641     : ARCer( boss ),theSubgroup1( 0 ) { } 
00642   
00643   ~SGOfNGcontainSubgroupARCer( ) { delete theSubgroup1;}
00644 
00645   /////////////////////////////////////////////////////////////////////////
00646   //                                                                     //
00647   // Accessors:                                                          //
00648   //                                                                     //
00649   /////////////////////////////////////////////////////////////////////////
00650 
00651   void setArguments(const SGOfNilpotentGroup& SNG1 , 
00652                     const VectorOf<Word>& SNG2);
00653   bool getAnswer() const;
00654 
00655   // Inherited from ARCer:
00656   // bool takeControl( );
00657 
00658 
00659   /////////////////////////////////////////////////////////////////////////
00660   //                                                                     //
00661   // IPC interaction members:                                            //
00662   //                                                                     //
00663   /////////////////////////////////////////////////////////////////////////
00664 
00665   void runComputation( );
00666  
00667   void writeResults( ostream& );
00668 
00669   void readResults( istream& );
00670 
00671   
00672 private:
00673 
00674   /////////////////////////////////////////////////////////////////////////
00675   //                                                                     //
00676   // Data Members:                                                       //
00677   //                                                                     //
00678   /////////////////////////////////////////////////////////////////////////
00679   SGOfNilpotentGroup* theSubgroup1;
00680   VectorOf<Word> theSubgroup2;
00681   bool answer;
00682 };
00683 
00684 // ----------------- SGOfNGcontainSubgroupProblem ---------------------- //
00685 
00686 class SGOfNGcontainSubgroupProblem : public Supervisor
00687 {
00688 public:
00689 
00690   /////////////////////////////////////////////////////////////////////////
00691   //                                                                     //
00692   // Constructors:                                                       //
00693   //                                                                     //
00694   /////////////////////////////////////////////////////////////////////////
00695 
00696   SGOfNGcontainSubgroupProblem(class SMSubgroup& sg1,const class SMSubgroup& sg2);
00697 
00698   /////////////////////////////////////////////////////////////////////////
00699   //                                                                     //
00700   // Accessors:                                                          //
00701   //                                                                     //
00702   /////////////////////////////////////////////////////////////////////////
00703 
00704 
00705   /////////////////////////////////////////////////////////////////////////
00706   //                                                                     //
00707   // Front End Interfacing:                                              //
00708   //                                                                     //
00709   /////////////////////////////////////////////////////////////////////////
00710 
00711   void viewStructure(ostream& ostr) const;  // overrides SMObject
00712 
00713   /////////////////////////////////////////////////////////////////////////
00714   //                                                                     //
00715   // Control:                                                            //
00716   //                                                                     //
00717   /////////////////////////////////////////////////////////////////////////
00718 
00719   void takeControl( );         // overrides ComputationManager
00720 
00721   /////////////////////////////////////////////////////////////////////////
00722   //                                                                     //
00723   // State Transitions:                                                  //
00724   //                                                                     //
00725   /////////////////////////////////////////////////////////////////////////
00726 
00727   void start( );              // overrides ComputationManager
00728 
00729   void terminate( );          // overrides ComputationManager
00730 
00731 
00732 private:
00733 
00734   /////////////////////////////////////////////////////////////////////////
00735   //                                                                     //
00736   // Data Members:                                                       //
00737   //                                                                     //
00738   /////////////////////////////////////////////////////////////////////////
00739   MirrorSubordinate initPreimageSGOfNG;
00740   class SMSubgroup& theSubgroup1;
00741   const class SMSubgroup& theSubgroup2;
00742   SGOfNGcontainSubgroupARCer arcer;
00743   bool started;
00744 };
00745 
00746 // ----------------- SGOfNGequalSubgroupProblem ---------------------- //
00747 
00748 class SGOfNGequalSubgroupProblem : public Supervisor
00749 {
00750 public:
00751 
00752   /////////////////////////////////////////////////////////////////////////
00753   //                                                                     //
00754   // Constructors:                                                       //
00755   //                                                                     //
00756   /////////////////////////////////////////////////////////////////////////
00757 
00758   SGOfNGequalSubgroupProblem(class SMSubgroup& sg1, class SMSubgroup& sg2);
00759 
00760   /////////////////////////////////////////////////////////////////////////
00761   //                                                                     //
00762   // Accessors:                                                          //
00763   //                                                                     //
00764   /////////////////////////////////////////////////////////////////////////
00765 
00766 
00767   /////////////////////////////////////////////////////////////////////////
00768   //                                                                     //
00769   // Front End Interfacing:                                              //
00770   //                                                                     //
00771   /////////////////////////////////////////////////////////////////////////
00772 
00773   void viewStructure(ostream& ostr) const;  // overrides SMObject
00774 
00775   /////////////////////////////////////////////////////////////////////////
00776   //                                                                     //
00777   // Control:                                                            //
00778   //                                                                     //
00779   /////////////////////////////////////////////////////////////////////////
00780 
00781   void takeControl( );         // overrides ComputationManager
00782 
00783   /////////////////////////////////////////////////////////////////////////
00784   //                                                                     //
00785   // State Transitions:                                                  //
00786   //                                                                     //
00787   /////////////////////////////////////////////////////////////////////////
00788 
00789   void start( );              // overrides ComputationManager
00790 
00791   void terminate( );          // overrides ComputationManager
00792 
00793 
00794 private:
00795 
00796   /////////////////////////////////////////////////////////////////////////
00797   //                                                                     //
00798   // Data Members:                                                       //
00799   //                                                                     //
00800   /////////////////////////////////////////////////////////////////////////
00801   MirrorSubordinate initPreimageSGOfNG1;
00802   MirrorSubordinate initPreimageSGOfNG2;
00803   class SMSubgroup& theSubgroup1;
00804   class SMSubgroup& theSubgroup2;
00805   SGOfNGcontainSubgroupARCer arcer1;
00806   SGOfNGcontainSubgroupARCer arcer2;
00807   bool started1;
00808   bool started2;
00809 };
00810 
00811 // ----------------- SGOfNGindexARCer ---------------------- //
00812 
00813 class SGOfNGindexARCer : public ARCer
00814 {
00815 public:
00816 
00817   /////////////////////////////////////////////////////////////////////////
00818   //                                                                     //
00819   // Constructors:                                                       //
00820   //                                                                     //
00821   /////////////////////////////////////////////////////////////////////////
00822 
00823   SGOfNGindexARCer( ComputationManager& boss ) 
00824     : ARCer( boss ),theSNG( 0 ) { } 
00825   
00826   ~SGOfNGindexARCer( ) { delete theSNG; }
00827 
00828   /////////////////////////////////////////////////////////////////////////
00829   //                                                                     //
00830   // Accessors:                                                          //
00831   //                                                                     //
00832   /////////////////////////////////////////////////////////////////////////
00833 
00834   void setArguments(const SGOfNilpotentGroup& );
00835   int getIndex() const;
00836 
00837   // Inherited from ARCer:
00838   // bool takeControl( );
00839 
00840 
00841   /////////////////////////////////////////////////////////////////////////
00842   //                                                                     //
00843   // IPC interaction members:                                            //
00844   //                                                                     //
00845   /////////////////////////////////////////////////////////////////////////
00846 
00847   void runComputation( );
00848  
00849   void writeResults( ostream& );
00850 
00851   void readResults( istream& );
00852 
00853   
00854 private:
00855 
00856   /////////////////////////////////////////////////////////////////////////
00857   //                                                                     //
00858   // Data Members:                                                       //
00859   //                                                                     //
00860   /////////////////////////////////////////////////////////////////////////
00861 
00862   SGOfNilpotentGroup* theSNG;
00863   int index;
00864 };
00865 
00866 class SGOfNGindexProblem : public Supervisor
00867 {
00868 public:
00869 
00870   /////////////////////////////////////////////////////////////////////////
00871   //                                                                     //
00872   // Constructors:                                                       //
00873   //                                                                     //
00874   /////////////////////////////////////////////////////////////////////////
00875 
00876   SGOfNGindexProblem(class SMSubgroup& sg);
00877 
00878   /////////////////////////////////////////////////////////////////////////
00879   //                                                                     //
00880   // Accessors:                                                          //
00881   //                                                                     //
00882   /////////////////////////////////////////////////////////////////////////
00883 
00884 
00885   /////////////////////////////////////////////////////////////////////////
00886   //                                                                     //
00887   // Front End Interfacing:                                              //
00888   //                                                                     //
00889   /////////////////////////////////////////////////////////////////////////
00890 
00891   void viewStructure(ostream& ostr) const;  // overrides SMObject
00892 
00893   /////////////////////////////////////////////////////////////////////////
00894   //                                                                     //
00895   // Control:                                                            //
00896   //                                                                     //
00897   /////////////////////////////////////////////////////////////////////////
00898 
00899   void takeControl( );         // overrides ComputationManager
00900 
00901   /////////////////////////////////////////////////////////////////////////
00902   //                                                                     //
00903   // State Transitions:                                                  //
00904   //                                                                     //
00905   /////////////////////////////////////////////////////////////////////////
00906 
00907   void start( );              // overrides ComputationManager
00908 
00909   void terminate( );          // overrides ComputationManager
00910 
00911 
00912 private:
00913 
00914   /////////////////////////////////////////////////////////////////////////
00915   //                                                                     //
00916   // Data Members:                                                       //
00917   //                                                                     //
00918   /////////////////////////////////////////////////////////////////////////
00919   SGOfNGindexARCer arcer;
00920   MirrorSubordinate initPreimageSGOfNG;
00921   class SMSubgroup& theSubgroup;
00922   bool started;
00923 };
00924 //----------------------------------------------------------------------//
00925 //------------------------  SGOfNGhirschNumberProblem ------------------//
00926 //----------------------------------------------------------------------//
00927 
00928 class SGOfNGhirschNumberProblem : public Supervisor
00929 {
00930 public:
00931 
00932   /////////////////////////////////////////////////////////////////////////
00933   //                                                                     //
00934   // Constructors:                                                       //
00935   //                                                                     //
00936   /////////////////////////////////////////////////////////////////////////
00937 
00938   SGOfNGhirschNumberProblem(class SMSubgroup& sg);
00939 
00940   /////////////////////////////////////////////////////////////////////////
00941   //                                                                     //
00942   // Accessors:                                                          //
00943   //                                                                     //
00944   /////////////////////////////////////////////////////////////////////////
00945 
00946 
00947   /////////////////////////////////////////////////////////////////////////
00948   //                                                                     //
00949   // Front End Interfacing:                                              //
00950   //                                                                     //
00951   /////////////////////////////////////////////////////////////////////////
00952 
00953   void viewStructure(ostream& ostr) const;  // overrides SMObject
00954 
00955   /////////////////////////////////////////////////////////////////////////
00956   //                                                                     //
00957   // Control:                                                            //
00958   //                                                                     //
00959   /////////////////////////////////////////////////////////////////////////
00960 
00961   void takeControl( );         // overrides ComputationManager
00962 
00963   /////////////////////////////////////////////////////////////////////////
00964   //                                                                     //
00965   // State Transitions:                                                  //
00966   //                                                                     //
00967   /////////////////////////////////////////////////////////////////////////
00968 
00969   void start( );              // overrides ComputationManager
00970 
00971   void terminate( );          // overrides ComputationManager
00972 
00973 
00974 private:
00975 
00976   /////////////////////////////////////////////////////////////////////////
00977   //                                                                     //
00978   // Data Members:                                                       //
00979   //                                                                     //
00980   /////////////////////////////////////////////////////////////////////////
00981 
00982   MirrorSubordinate initializeSGOfNG;
00983   class SMSubgroup& theSubgroup;
00984   bool started;
00985 };
00986 
00987 // ----------------- SGOfNGisNormalARCer ---------------------- //
00988 
00989 class SGOfNGisNormalARCer : public ARCer
00990 {
00991 public:
00992 
00993   /////////////////////////////////////////////////////////////////////////
00994   //                                                                     //
00995   // Constructors:                                                       //
00996   //                                                                     //
00997   /////////////////////////////////////////////////////////////////////////
00998 
00999   SGOfNGisNormalARCer( ComputationManager& boss ) 
01000     : ARCer( boss ),theSNG( 0 ) { } 
01001   
01002   ~SGOfNGisNormalARCer( ) { delete theSNG; }
01003 
01004   /////////////////////////////////////////////////////////////////////////
01005   //                                                                     //
01006   // Accessors:                                                          //
01007   //                                                                     //
01008   /////////////////////////////////////////////////////////////////////////
01009 
01010   void setArguments(const SGOfNilpotentGroup& );
01011   bool answer() const;
01012 
01013   // Inherited from ARCer:
01014   // bool takeControl( );
01015 
01016 
01017   /////////////////////////////////////////////////////////////////////////
01018   //                                                                     //
01019   // IPC interaction members:                                            //
01020   //                                                                     //
01021   /////////////////////////////////////////////////////////////////////////
01022 
01023   void runComputation( );
01024  
01025   void writeResults( ostream& );
01026 
01027   void readResults( istream& );
01028 
01029   
01030 private:
01031 
01032   /////////////////////////////////////////////////////////////////////////
01033   //                                                                     //
01034   // Data Members:                                                       //
01035   //                                                                     //
01036   /////////////////////////////////////////////////////////////////////////
01037 
01038   SGOfNilpotentGroup* theSNG;
01039   bool theAnswer;
01040 };
01041 
01042 class SGOfNGisNormalProblem : public Supervisor
01043 {
01044 public:
01045 
01046   /////////////////////////////////////////////////////////////////////////
01047   //                                                                     //
01048   // Constructors:                                                       //
01049   //                                                                     //
01050   /////////////////////////////////////////////////////////////////////////
01051 
01052   SGOfNGisNormalProblem(class SMSubgroup& sg);
01053 
01054   /////////////////////////////////////////////////////////////////////////
01055   //                                                                     //
01056   // Accessors:                                                          //
01057   //                                                                     //
01058   /////////////////////////////////////////////////////////////////////////
01059 
01060 
01061   /////////////////////////////////////////////////////////////////////////
01062   //                                                                     //
01063   // Front End Interfacing:                                              //
01064   //                                                                     //
01065   /////////////////////////////////////////////////////////////////////////
01066 
01067   void viewStructure(ostream& ostr) const;  // overrides SMObject
01068 
01069   /////////////////////////////////////////////////////////////////////////
01070   //                                                                     //
01071   // Control:                                                            //
01072   //                                                                     //
01073   /////////////////////////////////////////////////////////////////////////
01074 
01075   void takeControl( );         // overrides ComputationManager
01076 
01077   /////////////////////////////////////////////////////////////////////////
01078   //                                                                     //
01079   // State Transitions:                                                  //
01080   //                                                                     //
01081   /////////////////////////////////////////////////////////////////////////
01082 
01083   void start( );              // overrides ComputationManager
01084 
01085   void terminate( );          // overrides ComputationManager
01086 
01087 
01088 private:
01089 
01090   /////////////////////////////////////////////////////////////////////////
01091   //                                                                     //
01092   // Data Members:                                                       //
01093   //                                                                     //
01094   /////////////////////////////////////////////////////////////////////////
01095   SGOfNGisNormalARCer arcer;
01096   MirrorSubordinate initPreimageSGOfNG;
01097   class SMSubgroup& theSubgroup;
01098   bool started;
01099 };
01100 // ----------------- SGOfNGcomputeNClassARCer ---------------------- //
01101 
01102 class SGOfNGcomputeNClassARCer : public ARCer
01103 {
01104 public:
01105 
01106   /////////////////////////////////////////////////////////////////////////
01107   //                                                                     //
01108   // Constructors:                                                       //
01109   //                                                                     //
01110   /////////////////////////////////////////////////////////////////////////
01111 
01112   SGOfNGcomputeNClassARCer( ComputationManager& boss ) 
01113     : ARCer( boss ),theSNG( 0 ) { } 
01114   
01115   ~SGOfNGcomputeNClassARCer( ) { delete theSNG; }
01116 
01117   /////////////////////////////////////////////////////////////////////////
01118   //                                                                     //
01119   // Accessors:                                                          //
01120   //                                                                     //
01121   /////////////////////////////////////////////////////////////////////////
01122 
01123   void setArguments(const NilpotentGroup&,const VectorOf<Word>& );
01124   int getClass() const;
01125 
01126   // Inherited from ARCer:
01127   // bool takeControl( );
01128 
01129 
01130   /////////////////////////////////////////////////////////////////////////
01131   //                                                                     //
01132   // IPC interaction members:                                            //
01133   //                                                                     //
01134   /////////////////////////////////////////////////////////////////////////
01135 
01136   void runComputation( );
01137  
01138   void writeResults( ostream& );
01139 
01140   void readResults( istream& );
01141 
01142   
01143 private:
01144 
01145   /////////////////////////////////////////////////////////////////////////
01146   //                                                                     //
01147   // Data Members:                                                       //
01148   //                                                                     //
01149   /////////////////////////////////////////////////////////////////////////
01150 
01151   SGOfNilpotentGroup* theSNG;
01152   int theClass;
01153 };
01154 
01155 // --------------------- SGOfNGcomputeNClassProblem ------------------------ //
01156 
01157 
01158 class SGOfNGcomputeNClassProblem : public Supervisor
01159 {
01160 public:
01161 
01162   /////////////////////////////////////////////////////////////////////////
01163   //                                                                     //
01164   // Constructors:                                                       //
01165   //                                                                     //
01166   /////////////////////////////////////////////////////////////////////////
01167 
01168  SGOfNGcomputeNClassProblem( class SMSubgroup& );
01169 
01170 
01171   /////////////////////////////////////////////////////////////////////////
01172   //                                                                     //
01173   // Front End Interfacing:                                              //
01174   //                                                                     //
01175   /////////////////////////////////////////////////////////////////////////
01176 
01177   void viewStructure(ostream& ostr) const;  // overrides SMObject
01178 
01179 
01180   /////////////////////////////////////////////////////////////////////////
01181   //                                                                     //
01182   // Control:                                                            //
01183   //                                                                     //
01184   /////////////////////////////////////////////////////////////////////////
01185 
01186   void takeControl( );         // overrides ComputationManager
01187 
01188 
01189   /////////////////////////////////////////////////////////////////////////
01190   //                                                                     //
01191   // State Transitions:                                                  //
01192   //                                                                     //
01193   /////////////////////////////////////////////////////////////////////////
01194 
01195   void start( ) { }            // overrides ComputationManager
01196 
01197   void terminate( ) { }        // overrides ComputationManager
01198 
01199 
01200 private:
01201 
01202   /////////////////////////////////////////////////////////////////////////
01203   //                                                                     //
01204   // Data Members:                                                       //
01205   //                                                                     //
01206   /////////////////////////////////////////////////////////////////////////
01207 
01208   class SMSubgroup& theSubgroup;
01209 
01210   class GIC& theGIC;
01211   SGOfNGcomputeNClassARCer arcer;
01212   MirrorSubordinate computeBasis;
01213   bool started;
01214 };
01215 
01216 // ----------------- SGOfNGPresentationARCer ---------------------- //
01217 
01218 class SGOfNGPresentationARCer : public ARCer
01219 {
01220 public:
01221 
01222   /////////////////////////////////////////////////////////////////////////
01223   //                                                                     //
01224   // Constructors:                                                       //
01225   //                                                                     //
01226   /////////////////////////////////////////////////////////////////////////
01227 
01228   SGOfNGPresentationARCer( ComputationManager& boss ) 
01229     : ARCer( boss ),theSubgroup( 0 ), thePresentation( 0 ){ } 
01230   
01231   ~SGOfNGPresentationARCer() { delete theSubgroup; delete thePresentation; }
01232 
01233   /////////////////////////////////////////////////////////////////////////
01234   //                                                                     //
01235   // Accessors:                                                          //
01236   //                                                                     //
01237   /////////////////////////////////////////////////////////////////////////
01238 
01239   void setArguments(const SGOfNilpotentGroup& presentation);
01240   const PresentationForSNG& getPresentation() const;
01241 
01242   // Inherited from ARCer:
01243   // bool takeControl( );
01244 
01245 
01246   /////////////////////////////////////////////////////////////////////////
01247   //                                                                     //
01248   // IPC interaction members:                                            //
01249   //                                                                     //
01250   /////////////////////////////////////////////////////////////////////////
01251 
01252   void runComputation( );
01253  
01254   void writeResults( ostream& );
01255 
01256   void readResults( istream& );
01257 
01258   
01259 private:
01260 
01261   /////////////////////////////////////////////////////////////////////////
01262   //                                                                     //
01263   // Data Members:                                                       //
01264   //                                                                     //
01265   /////////////////////////////////////////////////////////////////////////
01266 
01267   PresentationForSNG* thePresentation;
01268   SGOfNilpotentGroup* theSubgroup;
01269 };
01270 
01271 
01272 //-----------------------------------------------------------------//
01273 //-------------------- SGOfNGbuildPresentationProblem ----------------//
01274 //-----------------------------------------------------------------//
01275 
01276 
01277 class SGOfNGbuildPresentationProblem : public Supervisor
01278 {
01279 public:
01280 
01281   /////////////////////////////////////////////////////////////////////////
01282   //                                                                     //
01283   // Constructors:                                                       //
01284   //                                                                     //
01285   /////////////////////////////////////////////////////////////////////////
01286 
01287    SGOfNGbuildPresentationProblem(class SMSubgroup& subgroup);
01288 
01289   /////////////////////////////////////////////////////////////////////////
01290   //                                                                     //
01291   // Accessors:                                                          //
01292   //                                                                     //
01293   /////////////////////////////////////////////////////////////////////////
01294 
01295 
01296   /////////////////////////////////////////////////////////////////////////
01297   //                                                                     //
01298   // Front End Interfacing:                                              //
01299   //                                                                     //
01300   /////////////////////////////////////////////////////////////////////////
01301 
01302   void viewStructure(ostream& ostr) const;  // overrides SMObject
01303 
01304   /////////////////////////////////////////////////////////////////////////
01305   //                                                                     //
01306   // Control:                                                            //
01307   //                                                                     //
01308   /////////////////////////////////////////////////////////////////////////
01309 
01310   void takeControl( );         // overrides ComputationManager
01311 
01312   /////////////////////////////////////////////////////////////////////////
01313   //                                                                     //
01314   // State Transitions:                                                  //
01315   //                                                                     //
01316   /////////////////////////////////////////////////////////////////////////
01317 
01318   void start( );              // overrides ComputationManager
01319 
01320   void terminate( );          // overrides ComputationManager
01321 
01322 
01323 private:
01324 
01325   /////////////////////////////////////////////////////////////////////////
01326   //                                                                     //
01327   // Data Members:                                                       //
01328   //                                                                     //
01329   /////////////////////////////////////////////////////////////////////////
01330   SGOfNGPresentationARCer arcer;
01331   class SMSubgroup& theSubgroup;
01332   MirrorSubordinate initPreimageSGOfNG;
01333   bool started;
01334 };
01335 
01336 // ----------------- SGOfNGnormalClosureARCer ---------------------- //
01337 
01338 class SGOfNGnormalClosureARCer : public ARCer
01339 {
01340 public:
01341 
01342   /////////////////////////////////////////////////////////////////////////
01343   //                                                                     //
01344   // Constructors:                                                       //
01345   //                                                                     //
01346   /////////////////////////////////////////////////////////////////////////
01347 
01348   SGOfNGnormalClosureARCer( ComputationManager& boss ) 
01349     : ARCer( boss ),theSubgroup( 0 ){ } 
01350   
01351   ~SGOfNGnormalClosureARCer( ) { delete theSubgroup;  }
01352 
01353   /////////////////////////////////////////////////////////////////////////
01354   //                                                                     //
01355   // Accessors:                                                          //
01356   //                                                                     //
01357   /////////////////////////////////////////////////////////////////////////
01358 
01359   void setArguments(const SGOfNilpotentGroup& presentation);
01360   const VectorOf<Word>& normalClosure() const;
01361 
01362   // Inherited from ARCer:
01363   // bool takeControl( );
01364 
01365 
01366   /////////////////////////////////////////////////////////////////////////
01367   //                                                                     //
01368   // IPC interaction members:                                            //
01369   //                                                                     //
01370   /////////////////////////////////////////////////////////////////////////
01371 
01372   void runComputation( );
01373  
01374   void writeResults( ostream& );
01375 
01376   void readResults( istream& );
01377 
01378   
01379 private:
01380 
01381   /////////////////////////////////////////////////////////////////////////
01382   //                                                                     //
01383   // Data Members:                                                       //
01384   //                                                                     //
01385   /////////////////////////////////////////////////////////////////////////
01386 
01387   SGOfNilpotentGroup* theSubgroup;
01388   VectorOf<Word> nClosure;
01389 };
01390 
01391 
01392 //-----------------------------------------------------------------//
01393 //-------------------- SGOfNGnormalClosureProblem -----------------//
01394 //-----------------------------------------------------------------//
01395 
01396 
01397 class SGOfNGnormalClosureProblem : public Supervisor
01398 {
01399 public:
01400 
01401   /////////////////////////////////////////////////////////////////////////
01402   //                                                                     //
01403   // Constructors:                                                       //
01404   //                                                                     //
01405   /////////////////////////////////////////////////////////////////////////
01406 
01407    SGOfNGnormalClosureProblem(class SMSubgroup& subgroup);
01408 
01409   /////////////////////////////////////////////////////////////////////////
01410   //                                                                     //
01411   // Accessors:                                                          //
01412   //                                                                     //
01413   /////////////////////////////////////////////////////////////////////////
01414 
01415 
01416   /////////////////////////////////////////////////////////////////////////
01417   //                                                                     //
01418   // Front End Interfacing:                                              //
01419   //                                                                     //
01420   /////////////////////////////////////////////////////////////////////////
01421 
01422   void viewStructure(ostream& ostr) const;  // overrides SMObject
01423 
01424   /////////////////////////////////////////////////////////////////////////
01425   //                                                                     //
01426   // Control:                                                            //
01427   //                                                                     //
01428   /////////////////////////////////////////////////////////////////////////
01429 
01430   void takeControl( );         // overrides ComputationManager
01431 
01432   /////////////////////////////////////////////////////////////////////////
01433   //                                                                     //
01434   // State Transitions:                                                  //
01435   //                                                                     //
01436   /////////////////////////////////////////////////////////////////////////
01437 
01438   void start( );              // overrides ComputationManager
01439 
01440   void terminate( );          // overrides ComputationManager
01441 
01442 
01443 private:
01444 
01445   /////////////////////////////////////////////////////////////////////////
01446   //                                                                     //
01447   // Data Members:                                                       //
01448   //                                                                     //
01449   /////////////////////////////////////////////////////////////////////////
01450   SGOfNGnormalClosureARCer arcer;
01451   MirrorSubordinate initializeSGOfNG;
01452   bool started;
01453   class SMSubgroup& theSubgroup;
01454 };
01455 
01456 // ----------------- SGOfNGnormalClosureGensARCer ---------------------- //
01457 
01458 class SGOfNGnormalClosureGensARCer : public ARCer
01459 {
01460 public:
01461 
01462   /////////////////////////////////////////////////////////////////////////
01463   //                                                                     //
01464   // Constructors:                                                       //
01465   //                                                                     //
01466   /////////////////////////////////////////////////////////////////////////
01467 
01468   SGOfNGnormalClosureGensARCer( ComputationManager& boss ) 
01469     : ARCer( boss ),theSubgroup( 0 ){ } 
01470   
01471   ~SGOfNGnormalClosureGensARCer( ) { delete theSubgroup;  }
01472 
01473   /////////////////////////////////////////////////////////////////////////
01474   //                                                                     //
01475   // Accessors:                                                          //
01476   //                                                                     //
01477   /////////////////////////////////////////////////////////////////////////
01478 
01479   void setArguments(const SGOfNilpotentGroup& presentation);
01480   const VectorOf<Word>& normalClosure() const;
01481 
01482   // Inherited from ARCer:
01483   // bool takeControl( );
01484 
01485 
01486   /////////////////////////////////////////////////////////////////////////
01487   //                                                                     //
01488   // IPC interaction members:                                            //
01489   //                                                                     //
01490   /////////////////////////////////////////////////////////////////////////
01491 
01492   void runComputation( );
01493  
01494   void writeResults( ostream& );
01495 
01496   void readResults( istream& );
01497 
01498   
01499 private:
01500 
01501   /////////////////////////////////////////////////////////////////////////
01502   //                                                                     //
01503   // Data Members:                                                       //
01504   //                                                                     //
01505   /////////////////////////////////////////////////////////////////////////
01506 
01507   SGOfNilpotentGroup* theSubgroup;
01508   VectorOf<Word> nClosure;
01509 };
01510 
01511 
01512 //-----------------------------------------------------------------//
01513 //--------------------SGOfNGnormalClosureGensProblem --------------//
01514 //-----------------------------------------------------------------//
01515 
01516 
01517 class SGOfNGnormalClosureGensProblem : public Supervisor
01518 {
01519 public:
01520 
01521   /////////////////////////////////////////////////////////////////////////
01522   //                                                                     //
01523   // Constructors:                                                       //
01524   //                                                                     //
01525   /////////////////////////////////////////////////////////////////////////
01526 
01527    SGOfNGnormalClosureGensProblem(class SMSubgroup& subgroup);
01528 
01529   /////////////////////////////////////////////////////////////////////////
01530   //                                                                     //
01531   // Accessors:                                                          //
01532   //                                                                     //
01533   /////////////////////////////////////////////////////////////////////////
01534 
01535 
01536   /////////////////////////////////////////////////////////////////////////
01537   //                                                                     //
01538   // Front End Interfacing:                                              //
01539   //                                                                     //
01540   /////////////////////////////////////////////////////////////////////////
01541 
01542   void viewStructure(ostream& ostr) const;  // overrides SMObject
01543 
01544   /////////////////////////////////////////////////////////////////////////
01545   //                                                                     //
01546   // Control:                                                            //
01547   //                                                                     //
01548   /////////////////////////////////////////////////////////////////////////
01549 
01550   void takeControl( );         // overrides ComputationManager
01551 
01552   /////////////////////////////////////////////////////////////////////////
01553   //                                                                     //
01554   // State Transitions:                                                  //
01555   //                                                                     //
01556   /////////////////////////////////////////////////////////////////////////
01557 
01558   void start( );              // overrides ComputationManager
01559 
01560   void terminate( );          // overrides ComputationManager
01561 
01562 
01563 private:
01564 
01565   /////////////////////////////////////////////////////////////////////////
01566   //                                                                     //
01567   // Data Members:                                                       //
01568   //                                                                     //
01569   /////////////////////////////////////////////////////////////////////////
01570   SGOfNGnormalClosureGensARCer arcer;
01571   class SMSubgroup& theSubgroup;
01572 };
01573 
01574 #endif
01575 

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