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

/magnus/back_end/SMApps/include/AbelianProblems.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: AbelianProblems.h,v 1.6 2000/02/09 06:30:47 alex Exp $
00003  */
00004 
00005 // Copyright (C) 1996 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 
00008 // Contents: Declarations of classes AbelianInvariants, AbelInvariantsProb,
00009 //           AbelianRank, AbelianWordProblem
00010 //
00011 // Principal Author: Dmitry Bormotov
00012 //
00013 // Status: in progress
00014 //
00015 // Revision History:
00016 //
00017 
00018 
00019 #ifndef _AbelianProblems_h_
00020 #define _AbelianProblems_h_
00021 
00022 
00023 #include "Supervisor.h"
00024 #include "AbelianInvariants.h"
00025 #include "AbelianSGPresentation.h"
00026 
00027 
00028 // ----------------------- AbelianWordProblem ------------------------------ //
00029 
00030 
00031 class AbelianWordProblem : public Supervisor
00032 {
00033 public:
00034 
00035   /////////////////////////////////////////////////////////////////////////
00036   //                                                                     //
00037   // Constructors:                                                       //
00038   //                                                                     //
00039   /////////////////////////////////////////////////////////////////////////
00040 
00041   AbelianWordProblem(class SMWord& w);
00042 
00043   /////////////////////////////////////////////////////////////////////////
00044   //                                                                     //
00045   // Front End Interfacing:                                              //
00046   //                                                                     //
00047   /////////////////////////////////////////////////////////////////////////
00048 
00049   void viewStructure(ostream& ostr) const;  // overrides SMObject
00050 
00051   /////////////////////////////////////////////////////////////////////////
00052   //                                                                     //
00053   // Control:                                                            //
00054   //                                                                     //
00055   /////////////////////////////////////////////////////////////////////////
00056 
00057   void takeControl( );         // overrides ComputationManager
00058 
00059   /////////////////////////////////////////////////////////////////////////
00060   //                                                                     //
00061   // State Transitions:                                                  //
00062   //                                                                     //
00063   /////////////////////////////////////////////////////////////////////////
00064 
00065   void start( ) { };          // overrides ComputationManager
00066 
00067   void terminate( ) { };      // overrides ComputationManager
00068 
00069 
00070 private:
00071 
00072   /////////////////////////////////////////////////////////////////////////
00073   //                                                                     //
00074   // Data Members:                                                       //
00075   //                                                                     //
00076   /////////////////////////////////////////////////////////////////////////
00077 
00078   SMWord& theWord;
00079 
00080   MirrorSubordinate abelianInvariants;
00081 
00082 };
00083 
00084 
00085 //---------------------------------------------------------------------------//
00086 //------------------------ AbelianIsomProblem -------------------------------//
00087 //---------------------------------------------------------------------------//
00088 
00089 
00090 class AbelianIsomProblem : public Supervisor
00091 {
00092 public:
00093 
00094   /////////////////////////////////////////////////////////////////////////
00095   //                                                                     //
00096   // Constructors:                                                       //
00097   //                                                                     //
00098   /////////////////////////////////////////////////////////////////////////
00099 
00100   AbelianIsomProblem(class SMFPGroup& g1, class SMFPGroup& g2);
00101 
00102   /////////////////////////////////////////////////////////////////////////
00103   //                                                                     //
00104   // Front End Interfacing:                                              //
00105   //                                                                     //
00106   /////////////////////////////////////////////////////////////////////////
00107 
00108   void viewStructure(ostream& ostr) const;  // overrides SMObject
00109 
00110   /////////////////////////////////////////////////////////////////////////
00111   //                                                                     //
00112   // Control:                                                            //
00113   //                                                                     //
00114   /////////////////////////////////////////////////////////////////////////
00115 
00116   void takeControl( );         // overrides ComputationManager
00117 
00118   /////////////////////////////////////////////////////////////////////////
00119   //                                                                     //
00120   // State Transitions:                                                  //
00121   //                                                                     //
00122   /////////////////////////////////////////////////////////////////////////
00123 
00124   void start( ) { };          // overrides ComputationManager
00125 
00126   void terminate( ) { };      // overrides ComputationManager
00127 
00128 
00129 private:
00130 
00131   /////////////////////////////////////////////////////////////////////////
00132   //                                                                     //
00133   // Data Members:                                                       //
00134   //                                                                     //
00135   /////////////////////////////////////////////////////////////////////////
00136 
00137   SMFPGroup& G1;
00138   SMFPGroup& G2;
00139 
00140   MirrorSubordinate abelianInvariants1;
00141   MirrorSubordinate abelianInvariants2;
00142 
00143 };
00144 
00145 
00146 //------------------- AbelianTorsionFreeRankProblem -------------------------//
00147 
00148 
00149 class AbelianTorsionFreeRankProblem : public Supervisor
00150 {
00151 public:
00152 
00153   /////////////////////////////////////////////////////////////////////////
00154   //                                                                     //
00155   // Constructors:                                                       //
00156   //                                                                     //
00157   /////////////////////////////////////////////////////////////////////////
00158 
00159   AbelianTorsionFreeRankProblem(class SMFPGroup& G);
00160 
00161   /////////////////////////////////////////////////////////////////////////
00162   //                                                                     //
00163   // Front End Interfacing:                                              //
00164   //                                                                     //
00165   /////////////////////////////////////////////////////////////////////////
00166 
00167   void viewStructure(ostream& ostr) const;  // overrides SMObject
00168 
00169   /////////////////////////////////////////////////////////////////////////
00170   //                                                                     //
00171   // Control:                                                            //
00172   //                                                                     //
00173   /////////////////////////////////////////////////////////////////////////
00174 
00175   void takeControl( );         // overrides ComputationManager
00176 
00177   /////////////////////////////////////////////////////////////////////////
00178   //                                                                     //
00179   // State Transitions:                                                  //
00180   //                                                                     //
00181   /////////////////////////////////////////////////////////////////////////
00182 
00183   void start( ) { };          // overrides ComputationManager
00184 
00185   void terminate( ) { };      // overrides ComputationManager
00186 
00187 
00188 private:
00189 
00190   /////////////////////////////////////////////////////////////////////////
00191   //                                                                     //
00192   // Data Members:                                                       //
00193   //                                                                     //
00194   /////////////////////////////////////////////////////////////////////////
00195 
00196   SMFPGroup& theGroup;
00197 
00198   MirrorSubordinate abelianInvariants;
00199 
00200 };
00201 
00202 
00203 //-------------- AbelianOrderOfTheTorsionSubgroupProblem --------------------//
00204 
00205 
00206 class AbelianOrderOfTheTorsionSubgroupProblem : public Supervisor
00207 {
00208 public:
00209 
00210   /////////////////////////////////////////////////////////////////////////
00211   //                                                                     //
00212   // Constructors:                                                       //
00213   //                                                                     //
00214   /////////////////////////////////////////////////////////////////////////
00215 
00216   AbelianOrderOfTheTorsionSubgroupProblem(class SMFPGroup& G);
00217 
00218   /////////////////////////////////////////////////////////////////////////
00219   //                                                                     //
00220   // Front End Interfacing:                                              //
00221   //                                                                     //
00222   /////////////////////////////////////////////////////////////////////////
00223 
00224   void viewStructure(ostream& ostr) const;  // overrides SMObject
00225 
00226   /////////////////////////////////////////////////////////////////////////
00227   //                                                                     //
00228   // Control:                                                            //
00229   //                                                                     //
00230   /////////////////////////////////////////////////////////////////////////
00231 
00232   void takeControl( );         // overrides ComputationManager
00233 
00234   /////////////////////////////////////////////////////////////////////////
00235   //                                                                     //
00236   // State Transitions:                                                  //
00237   //                                                                     //
00238   /////////////////////////////////////////////////////////////////////////
00239 
00240   void start( ) { };          // overrides ComputationManager
00241 
00242   void terminate( ) { };      // overrides ComputationManager
00243 
00244 
00245 private:
00246 
00247   /////////////////////////////////////////////////////////////////////////
00248   //                                                                     //
00249   // Data Members:                                                       //
00250   //                                                                     //
00251   /////////////////////////////////////////////////////////////////////////
00252 
00253   SMFPGroup& theGroup;
00254 
00255   MirrorSubordinate abelianInvariants;
00256 
00257 };
00258 
00259 
00260 //------------------------- AbelianOrderProblem -----------------------------//
00261 
00262 
00263 class AbelianOrderProblem : public Supervisor
00264 {
00265 public:
00266 
00267   /////////////////////////////////////////////////////////////////////////
00268   //                                                                     //
00269   // Constructors:                                                       //
00270   //                                                                     //
00271   /////////////////////////////////////////////////////////////////////////
00272 
00273   AbelianOrderProblem(class SMFPGroup& G);
00274 
00275   /////////////////////////////////////////////////////////////////////////
00276   //                                                                     //
00277   // Front End Interfacing:                                              //
00278   //                                                                     //
00279   /////////////////////////////////////////////////////////////////////////
00280 
00281   void viewStructure(ostream& ostr) const;  // overrides SMObject
00282 
00283   /////////////////////////////////////////////////////////////////////////
00284   //                                                                     //
00285   // Control:                                                            //
00286   //                                                                     //
00287   /////////////////////////////////////////////////////////////////////////
00288 
00289   void takeControl( );         // overrides ComputationManager
00290 
00291   /////////////////////////////////////////////////////////////////////////
00292   //                                                                     //
00293   // State Transitions:                                                  //
00294   //                                                                     //
00295   /////////////////////////////////////////////////////////////////////////
00296 
00297   void start( ) { };          // overrides ComputationManager
00298 
00299   void terminate( ) { };      // overrides ComputationManager
00300 
00301 
00302 private:
00303 
00304   /////////////////////////////////////////////////////////////////////////
00305   //                                                                     //
00306   // Data Members:                                                       //
00307   //                                                                     //
00308   /////////////////////////////////////////////////////////////////////////
00309 
00310   SMFPGroup& theGroup;
00311 
00312   MirrorSubordinate abelianInvariants;
00313 
00314 };
00315 
00316 
00317 // -------------------- AbelianOrderOfEltProblem --------------------------- //
00318 
00319 
00320 class AbelianOrderOfEltProblem : public Supervisor
00321 {
00322 public:
00323 
00324   /////////////////////////////////////////////////////////////////////////
00325   //                                                                     //
00326   // Constructors:                                                       //
00327   //                                                                     //
00328   /////////////////////////////////////////////////////////////////////////
00329 
00330   AbelianOrderOfEltProblem(class SMWord& w);
00331 
00332   /////////////////////////////////////////////////////////////////////////
00333   //                                                                     //
00334   // Front End Interfacing:                                              //
00335   //                                                                     //
00336   /////////////////////////////////////////////////////////////////////////
00337 
00338   void viewStructure(ostream& ostr) const;  // overrides SMObject
00339 
00340   /////////////////////////////////////////////////////////////////////////
00341   //                                                                     //
00342   // Control:                                                            //
00343   //                                                                     //
00344   /////////////////////////////////////////////////////////////////////////
00345 
00346   void takeControl( );         // overrides ComputationManager
00347 
00348   /////////////////////////////////////////////////////////////////////////
00349   //                                                                     //
00350   // State Transitions:                                                  //
00351   //                                                                     //
00352   /////////////////////////////////////////////////////////////////////////
00353 
00354   void start( ) { };          // overrides ComputationManager
00355 
00356   void terminate( ) { };      // overrides ComputationManager
00357 
00358 
00359 private:
00360 
00361   /////////////////////////////////////////////////////////////////////////
00362   //                                                                     //
00363   // Data Members:                                                       //
00364   //                                                                     //
00365   /////////////////////////////////////////////////////////////////////////
00366 
00367   SMWord& theWord;
00368 
00369   MirrorSubordinate abelianInvariants;
00370 
00371 };
00372 
00373 
00374 // --------------------- AbelianEqualityProblem ---------------------------- //
00375 
00376 
00377 class AbelianEqualityProblem : public Supervisor
00378 {
00379 public:
00380 
00381   /////////////////////////////////////////////////////////////////////////
00382   //                                                                     //
00383   // Constructors:                                                       //
00384   //                                                                     //
00385   /////////////////////////////////////////////////////////////////////////
00386 
00387   AbelianEqualityProblem(class SMWord& w1, class SMWord& w2);
00388 
00389   /////////////////////////////////////////////////////////////////////////
00390   //                                                                     //
00391   // Front End Interfacing:                                              //
00392   //                                                                     //
00393   /////////////////////////////////////////////////////////////////////////
00394 
00395   void viewStructure(ostream& ostr) const;  // overrides SMObject
00396 
00397   /////////////////////////////////////////////////////////////////////////
00398   //                                                                     //
00399   // Control:                                                            //
00400   //                                                                     //
00401   /////////////////////////////////////////////////////////////////////////
00402 
00403   void takeControl( );         // overrides ComputationManager
00404 
00405   /////////////////////////////////////////////////////////////////////////
00406   //                                                                     //
00407   // State Transitions:                                                  //
00408   //                                                                     //
00409   /////////////////////////////////////////////////////////////////////////
00410 
00411   void start( ) { };          // overrides ComputationManager
00412 
00413   void terminate( ) { };      // overrides ComputationManager
00414 
00415 
00416 private:
00417 
00418   /////////////////////////////////////////////////////////////////////////
00419   //                                                                     //
00420   // Data Members:                                                       //
00421   //                                                                     //
00422   /////////////////////////////////////////////////////////////////////////
00423 
00424   SMWord& word1;
00425   SMWord& word2;
00426 
00427   MirrorSubordinate abelianInvariants;
00428 
00429 };
00430 
00431 
00432 // ------------------------ WordInSGOfAbelian ------------------------------ //
00433 
00434 
00435 class WordInSGOfAbelian : public Supervisor
00436 {
00437 
00438 public:
00439 
00440   /////////////////////////////////////////////////////////////////////////
00441   //                                                                     //
00442   // Constructors:                                                       //
00443   //                                                                     //
00444   /////////////////////////////////////////////////////////////////////////
00445 
00446   WordInSGOfAbelian(class SMSubgroup& S, class SMWord& w);
00447 
00448   /////////////////////////////////////////////////////////////////////////
00449   //                                                                     //
00450   // Accessors:                                                          //
00451   //                                                                     //
00452   /////////////////////////////////////////////////////////////////////////
00453 
00454   /////////////////////////////////////////////////////////////////////////
00455   //                                                                     //
00456   // Front End Interfacing:                                              //
00457   //                                                                     //
00458   /////////////////////////////////////////////////////////////////////////
00459 
00460   void viewStructure(ostream& ostr) const;  // overrides SMObject
00461 
00462   /////////////////////////////////////////////////////////////////////////
00463   //                                                                     //
00464   // Control:                                                            //
00465   //                                                                     //
00466   /////////////////////////////////////////////////////////////////////////
00467 
00468   void takeControl( );         // overrides ComputationManager
00469 
00470   /////////////////////////////////////////////////////////////////////////
00471   //                                                                     //
00472   // State Transitions:                                                  //
00473   //                                                                     //
00474   /////////////////////////////////////////////////////////////////////////
00475 
00476   void start( ) { };          // overrides ComputationManager
00477 
00478   void terminate( ) { };      // overrides ComputationManager
00479 
00480 
00481 private:
00482 
00483   /////////////////////////////////////////////////////////////////////////
00484   //                                                                     //
00485   // Data Members:                                                       //
00486   //                                                                     //
00487   /////////////////////////////////////////////////////////////////////////
00488 
00489   SMSubgroup& theSubgroup;
00490 
00491   SMWord& theWord;
00492   
00493   MirrorSubordinate abelianInvariants;
00494 };
00495 
00496 
00497 // ------------------- AbelianIsSGEqualToTheGroup -------------------------- //
00498 
00499 
00500 class AbelianIsSGEqualToTheGroup : public Supervisor
00501 {
00502 
00503 public:
00504 
00505   /////////////////////////////////////////////////////////////////////////
00506   //                                                                     //
00507   // Constructors:                                                       //
00508   //                                                                     //
00509   /////////////////////////////////////////////////////////////////////////
00510 
00511   AbelianIsSGEqualToTheGroup(class SMSubgroup& S);
00512 
00513   /////////////////////////////////////////////////////////////////////////
00514   //                                                                     //
00515   // Accessors:                                                          //
00516   //                                                                     //
00517   /////////////////////////////////////////////////////////////////////////
00518 
00519   /////////////////////////////////////////////////////////////////////////
00520   //                                                                     //
00521   // Front End Interfacing:                                              //
00522   //                                                                     //
00523   /////////////////////////////////////////////////////////////////////////
00524 
00525   void viewStructure(ostream& ostr) const;  // overrides SMObject
00526 
00527   /////////////////////////////////////////////////////////////////////////
00528   //                                                                     //
00529   // Control:                                                            //
00530   //                                                                     //
00531   /////////////////////////////////////////////////////////////////////////
00532 
00533   void takeControl( );         // overrides ComputationManager
00534 
00535   /////////////////////////////////////////////////////////////////////////
00536   //                                                                     //
00537   // State Transitions:                                                  //
00538   //                                                                     //
00539   /////////////////////////////////////////////////////////////////////////
00540 
00541   void start( ) { };          // overrides ComputationManager
00542 
00543   void terminate( ) { };      // overrides ComputationManager
00544 
00545 
00546 private:
00547 
00548   /////////////////////////////////////////////////////////////////////////
00549   //                                                                     //
00550   // Data Members:                                                       //
00551   //                                                                     //
00552   /////////////////////////////////////////////////////////////////////////
00553 
00554   SMSubgroup& theSubgroup;
00555   
00556   MirrorSubordinate abelianInvariants;
00557 };
00558 
00559 
00560 // ---------------------- AbelianSGIndexProblem ---------------------------- //
00561 
00562 
00563 class AbelianSGIndexProblem : public Supervisor
00564 {
00565 
00566 public:
00567 
00568   /////////////////////////////////////////////////////////////////////////
00569   //                                                                     //
00570   // Constructors:                                                       //
00571   //                                                                     //
00572   /////////////////////////////////////////////////////////////////////////
00573 
00574   AbelianSGIndexProblem(class SMSubgroup& S);
00575 
00576   /////////////////////////////////////////////////////////////////////////
00577   //                                                                     //
00578   // Accessors:                                                          //
00579   //                                                                     //
00580   /////////////////////////////////////////////////////////////////////////
00581 
00582   /////////////////////////////////////////////////////////////////////////
00583   //                                                                     //
00584   // Front End Interfacing:                                              //
00585   //                                                                     //
00586   /////////////////////////////////////////////////////////////////////////
00587 
00588   void viewStructure(ostream& ostr) const;  // overrides SMObject
00589 
00590   /////////////////////////////////////////////////////////////////////////
00591   //                                                                     //
00592   // Control:                                                            //
00593   //                                                                     //
00594   /////////////////////////////////////////////////////////////////////////
00595 
00596   void takeControl( );         // overrides ComputationManager
00597 
00598   /////////////////////////////////////////////////////////////////////////
00599   //                                                                     //
00600   // State Transitions:                                                  //
00601   //                                                                     //
00602   /////////////////////////////////////////////////////////////////////////
00603 
00604   void start( ) { };          // overrides ComputationManager
00605 
00606   void terminate( ) { };      // overrides ComputationManager
00607 
00608 
00609 private:
00610 
00611   /////////////////////////////////////////////////////////////////////////
00612   //                                                                     //
00613   // Data Members:                                                       //
00614   //                                                                     //
00615   /////////////////////////////////////////////////////////////////////////
00616 
00617   SMSubgroup& theSubgroup;
00618   
00619   MirrorSubordinate abelianInvariants;
00620 };
00621 
00622 
00623 // -------------------- AbelianIsSGIsolatedProblem ------------------------- //
00624 
00625 
00626 class AbelianIsSGIsolatedProblem : public Supervisor
00627 {
00628 
00629 public:
00630 
00631   /////////////////////////////////////////////////////////////////////////
00632   //                                                                     //
00633   // Constructors:                                                       //
00634   //                                                                     //
00635   /////////////////////////////////////////////////////////////////////////
00636 
00637   AbelianIsSGIsolatedProblem(class SMSubgroup& S);
00638 
00639   /////////////////////////////////////////////////////////////////////////
00640   //                                                                     //
00641   // Accessors:                                                          //
00642   //                                                                     //
00643   /////////////////////////////////////////////////////////////////////////
00644 
00645   /////////////////////////////////////////////////////////////////////////
00646   //                                                                     //
00647   // Front End Interfacing:                                              //
00648   //                                                                     //
00649   /////////////////////////////////////////////////////////////////////////
00650 
00651   void viewStructure(ostream& ostr) const;  // overrides SMObject
00652 
00653   /////////////////////////////////////////////////////////////////////////
00654   //                                                                     //
00655   // Control:                                                            //
00656   //                                                                     //
00657   /////////////////////////////////////////////////////////////////////////
00658 
00659   void takeControl( );         // overrides ComputationManager
00660 
00661   /////////////////////////////////////////////////////////////////////////
00662   //                                                                     //
00663   // State Transitions:                                                  //
00664   //                                                                     //
00665   /////////////////////////////////////////////////////////////////////////
00666 
00667   void start( ) { };          // overrides ComputationManager
00668 
00669   void terminate( ) { };      // overrides ComputationManager
00670 
00671 
00672 private:
00673 
00674   /////////////////////////////////////////////////////////////////////////
00675   //                                                                     //
00676   // Data Members:                                                       //
00677   //                                                                     //
00678   /////////////////////////////////////////////////////////////////////////
00679 
00680   SMSubgroup& theSubgroup;
00681   
00682   MirrorSubordinate abelianInvariants;
00683 };
00684 
00685 
00686 // ------------------- AbelianSGContainmentProblem ------------------------- //
00687 
00688 
00689 class AbelianSGContainmentProblem : public Supervisor
00690 {
00691 
00692 public:
00693 
00694   /////////////////////////////////////////////////////////////////////////
00695   //                                                                     //
00696   // Constructors:                                                       //
00697   //                                                                     //
00698   /////////////////////////////////////////////////////////////////////////
00699 
00700   AbelianSGContainmentProblem(class SMSubgroup& S1, class SMSubgroup& S2);
00701 
00702   
00703   /////////////////////////////////////////////////////////////////////////
00704   //                                                                     //
00705   // Accessors:                                                          //
00706   //                                                                     //
00707   /////////////////////////////////////////////////////////////////////////
00708 
00709   /////////////////////////////////////////////////////////////////////////
00710   //                                                                     //
00711   // Front End Interfacing:                                              //
00712   //                                                                     //
00713   /////////////////////////////////////////////////////////////////////////
00714 
00715   void viewStructure(ostream& ostr) const;  // overrides SMObject
00716 
00717   /////////////////////////////////////////////////////////////////////////
00718   //                                                                     //
00719   // Control:                                                            //
00720   //                                                                     //
00721   /////////////////////////////////////////////////////////////////////////
00722 
00723   void takeControl( );         // overrides ComputationManager
00724 
00725   /////////////////////////////////////////////////////////////////////////
00726   //                                                                     //
00727   // State Transitions:                                                  //
00728   //                                                                     //
00729   /////////////////////////////////////////////////////////////////////////
00730 
00731   void start( ) { };          // overrides ComputationManager
00732 
00733   void terminate( ) { };      // overrides ComputationManager
00734 
00735 
00736 private:
00737 
00738   /////////////////////////////////////////////////////////////////////////
00739   //                                                                     //
00740   // Data Members:                                                       //
00741   //                                                                     //
00742   /////////////////////////////////////////////////////////////////////////
00743 
00744   SMSubgroup& subgroup1;
00745 
00746   SMSubgroup& subgroup2;
00747   
00748   MirrorSubordinate abelianInvariants;
00749 };
00750 
00751 
00752 // -------------------- FindCanonicalSmithPresentation --------------------- //
00753 
00754 
00755 class FindCanonicalSmithPresentation : public Supervisor
00756 {
00757 
00758 public:
00759 
00760   /////////////////////////////////////////////////////////////////////////
00761   //                                                                     //
00762   // Constructors:                                                       //
00763   //                                                                     //
00764   /////////////////////////////////////////////////////////////////////////
00765 
00766   FindCanonicalSmithPresentation(class SMFPGroup& G);
00767 
00768 
00769   /////////////////////////////////////////////////////////////////////////
00770   //                                                                     //
00771   // Front End Interfacing:                                              //
00772   //                                                                     //
00773   /////////////////////////////////////////////////////////////////////////
00774 
00775   void viewStructure(ostream& ostr) const;  // overrides SMObject
00776 
00777 
00778   /////////////////////////////////////////////////////////////////////////
00779   //                                                                     //
00780   // Control:                                                            //
00781   //                                                                     //
00782   /////////////////////////////////////////////////////////////////////////
00783 
00784   void takeControl( );         // overrides ComputationManager
00785 
00786 
00787   /////////////////////////////////////////////////////////////////////////
00788   //                                                                     //
00789   // State Transitions:                                                  //
00790   //                                                                     //
00791   /////////////////////////////////////////////////////////////////////////
00792 
00793   void start( ) { };          // overrides ComputationManager
00794 
00795   void terminate( ) { };      // overrides ComputationManager
00796 
00797 
00798 private:
00799 
00800   /////////////////////////////////////////////////////////////////////////
00801   //                                                                     //
00802   // Data Members:                                                       //
00803   //                                                                     //
00804   /////////////////////////////////////////////////////////////////////////
00805 
00806   SMFPGroup& theGroup;
00807 
00808   MirrorSubordinate abelianInvariants;
00809 
00810 
00811   /////////////////////////////////////////////////////////////////////////
00812   //                                                                     //
00813   // Private functions:                                                  //
00814   //                                                                     //
00815   /////////////////////////////////////////////////////////////////////////
00816 
00817   void makePresentation();
00818 
00819 };
00820 
00821 // -------------------- AbelianPHeightOfEltProblem --------------------------- //
00822 
00823 
00824 class AbelianPHeightOfEltProblem : public Supervisor
00825 {
00826 public:
00827 
00828   /////////////////////////////////////////////////////////////////////////
00829   //                                                                     //
00830   // Constructors:                                                       //
00831   //                                                                     //
00832   /////////////////////////////////////////////////////////////////////////
00833 
00834   AbelianPHeightOfEltProblem(class SMWord& w, int p = 1);
00835 
00836   /////////////////////////////////////////////////////////////////////////
00837   //                                                                     //
00838   // Front End Interfacing:                                              //
00839   //                                                                     //
00840   /////////////////////////////////////////////////////////////////////////
00841 
00842   void viewStructure(ostream& ostr) const;  // overrides SMObject
00843 
00844   /////////////////////////////////////////////////////////////////////////
00845   //                                                                     //
00846   // Control:                                                            //
00847   //                                                                     //
00848   /////////////////////////////////////////////////////////////////////////
00849 
00850   void takeControl( );         // overrides ComputationManager
00851 
00852   /////////////////////////////////////////////////////////////////////////
00853   //                                                                     //
00854   // State Transitions:                                                  //
00855   //                                                                     //
00856   /////////////////////////////////////////////////////////////////////////
00857 
00858   void start( ) { };          // overrides ComputationManager
00859 
00860   void terminate( ) { };      // overrides ComputationManager
00861 
00862 
00863 private:
00864 
00865   /////////////////////////////////////////////////////////////////////////
00866   //                                                                     //
00867   // Data Members:                                                       //
00868   //                                                                     //
00869   /////////////////////////////////////////////////////////////////////////
00870 
00871   SMWord& theWord;
00872   bool notPrime;
00873   bool abDone;    // This flag used to know was abelianization done before
00874   Integer P;      // The p, entered by user
00875 
00876   MirrorSubordinate abelianInvariants;
00877   MirrorSubordinate abelianPrimes;
00878 };
00879 //-------------- AbelianOrderOfTheTorsionSubgroupProblem --------------------//
00880 
00881 
00882 class AbelianComputeTorsionSubgroup : public Supervisor
00883 {
00884 public:
00885 
00886   /////////////////////////////////////////////////////////////////////////
00887   //                                                                     //
00888   // Constructors:                                                       //
00889   //                                                                     //
00890   /////////////////////////////////////////////////////////////////////////
00891 
00892   AbelianComputeTorsionSubgroup(class SMFPGroup& G);
00893 
00894   /////////////////////////////////////////////////////////////////////////
00895   //                                                                     //
00896   // Front End Interfacing:                                              //
00897   //                                                                     //
00898   /////////////////////////////////////////////////////////////////////////
00899 
00900   void viewStructure(ostream& ostr) const;  // overrides SMObject
00901 
00902   /////////////////////////////////////////////////////////////////////////
00903   //                                                                     //
00904   // Control:                                                            //
00905   //                                                                     //
00906   /////////////////////////////////////////////////////////////////////////
00907 
00908   void takeControl( );         // overrides ComputationManager
00909 
00910   /////////////////////////////////////////////////////////////////////////
00911   //                                                                     //
00912   // State Transitions:                                                  //
00913   //                                                                     //
00914   /////////////////////////////////////////////////////////////////////////
00915 
00916   void start( ) { };          // overrides ComputationManager
00917 
00918   void terminate( ) { };      // overrides ComputationManager
00919 
00920 
00921 private:
00922 
00923   /////////////////////////////////////////////////////////////////////////
00924   //                                                                     //
00925   // Data Members:                                                       //
00926   //                                                                     //
00927   /////////////////////////////////////////////////////////////////////////
00928 
00929   SMFPGroup& theGroup;
00930 
00931   MirrorSubordinate abelianInvariants;
00932 
00933 };
00934 // ---------------------- AbelianEltPowerSubgrARCer --------------------------- //
00935 
00936 
00937 class AbelianEltPowerSubgrARCer : public ARCer
00938 {
00939 public:
00940 
00941   /////////////////////////////////////////////////////////////////////////
00942   //                                                                     //
00943   // Constructors:                                                       //
00944   //                                                                     //
00945   /////////////////////////////////////////////////////////////////////////
00946 
00947   AbelianEltPowerSubgrARCer( ComputationManager& boss ) 
00948     : ARCer( boss ), AG( 0 ), result(0) { } 
00949 
00950   ~AbelianEltPowerSubgrARCer( ) { delete AG; } 
00951 
00952 
00953   /////////////////////////////////////////////////////////////////////////
00954   //                                                                     //
00955   // Accessors:                                                          //
00956   //                                                                     //
00957   /////////////////////////////////////////////////////////////////////////
00958 
00959   void setArguments( const AbelianGroup& group, const Word& w, const VectorOf<Word>& sG);
00960 
00961   // Inherited from ARCer:
00962   // bool takeControl( );
00963 
00964   Integer getPowerOfEltSubgrup();
00965   
00966   
00967   /////////////////////////////////////////////////////////////////////////
00968   //                                                                     //
00969   // IPC interaction members:                                            //
00970   //                                                                     //
00971   /////////////////////////////////////////////////////////////////////////
00972 
00973   void runComputation( );
00974  
00975   void writeResults( ostream& );
00976 
00977   void readResults( istream& );
00978 
00979 
00980 private:
00981 
00982   /////////////////////////////////////////////////////////////////////////
00983   //                                                                     //
00984   // Data Members:                                                       //
00985   //                                                                     //
00986   /////////////////////////////////////////////////////////////////////////
00987 
00988   AbelianGroup* AG;
00989   Word theWord;
00990   VectorOf<Word> theSubgroup;
00991   Integer result;
00992 };
00993 
00994 class AbelianEltPowerSubgrComp : public ComputationManager
00995 {
00996 public:
00997 
00998   /////////////////////////////////////////////////////////////////////////
00999   //                                                                     //
01000   // Constructors:                                                       //
01001   //                                                                     //
01002   /////////////////////////////////////////////////////////////////////////
01003 
01004    AbelianEltPowerSubgrComp(class AbelianEltPowerSubgr& gcm);
01005 
01006  
01007   /////////////////////////////////////////////////////////////////////////
01008   //                                                                     //
01009   // Accessors:                                                          //
01010   //                                                                     //
01011   /////////////////////////////////////////////////////////////////////////
01012 
01013   /////////////////////////////////////////////////////////////////////////
01014   //                                                                     //
01015   // Control:                                                            //
01016   //                                                                     //
01017   /////////////////////////////////////////////////////////////////////////
01018 
01019   void takeControl( );         // overrides ComputationManager
01020 
01021    bool isDone() const { return finished;}
01022   /////////////////////////////////////////////////////////////////////////
01023   //                                                                     //
01024   // State Transitions:                                                  //
01025   //                                                                     //
01026   /////////////////////////////////////////////////////////////////////////
01027 
01028   void start( ) { };          // overrides ComputationManager
01029 
01030   void terminate( ) { };      // overrides ComputationManager
01031 
01032 
01033 private:
01034 
01035   /////////////////////////////////////////////////////////////////////////
01036   //                                                                     //
01037   // Data Members:                                                       //
01038   //                                                                     //
01039   /////////////////////////////////////////////////////////////////////////
01040 
01041    class AbelianEltPowerSubgr& theSupervisor;
01042    AbelianEltPowerSubgrARCer A;
01043    bool finished;
01044 };
01045 
01046 class AbelianEltPowerSubgr : public Supervisor
01047 {
01048 public:
01049 
01050   /////////////////////////////////////////////////////////////////////////
01051   //                                                                     //
01052   // Constructors:                                                       //
01053   //                                                                     //
01054   /////////////////////////////////////////////////////////////////////////
01055 
01056   AbelianEltPowerSubgr(const class SMSubgroup& smg,const class SMWord& smw);
01057 
01058   /////////////////////////////////////////////////////////////////////////
01059   //                                                                     //
01060   // Front End Interfacing:                                              //
01061   //                                                                     //
01062   /////////////////////////////////////////////////////////////////////////
01063 
01064   void viewStructure(ostream& ostr) const;  // overrides SMObject
01065 
01066   /////////////////////////////////////////////////////////////////////////
01067   //                                                                     //
01068   // Control:                                                            //
01069   //                                                                     //
01070   /////////////////////////////////////////////////////////////////////////
01071 
01072   void takeControl( );         // overrides ComputationManager
01073 
01074   /////////////////////////////////////////////////////////////////////////
01075   //                                                                     //
01076   // State Transitions:                                                  //
01077   //                                                                     //
01078   /////////////////////////////////////////////////////////////////////////
01079 
01080   void start( ) { };          // overrides ComputationManager
01081 
01082   void terminate( ) { };      // overrides ComputationManager
01083 
01084   const SMWord& getWord() const {return theWord;}
01085   const SMSubgroup& getSubgroup() const {return theSubgroup;}
01086 
01087 private:
01088 
01089   /////////////////////////////////////////////////////////////////////////
01090   //                                                                     //
01091   // Data Members:                                                       //
01092   //                                                                     //
01093   /////////////////////////////////////////////////////////////////////////
01094 
01095   const SMWord& theWord;
01096   const SMSubgroup& theSubgroup;
01097 
01098   Subordinate<AbelianEltPowerSubgr,AbelianEltPowerSubgrComp> abelianEltPowerSubgr;
01099 };
01100 
01101 // -------------------- AbelianPowerProblem --------------------------- //
01102 
01103 
01104 class AbelianPowerProblem : public Supervisor
01105 {
01106 public:
01107 
01108   /////////////////////////////////////////////////////////////////////////
01109   //                                                                     //
01110   // Constructors:                                                       //
01111   //                                                                     //
01112   /////////////////////////////////////////////////////////////////////////
01113 
01114   AbelianPowerProblem(class SMWord& w);
01115 
01116   /////////////////////////////////////////////////////////////////////////
01117   //                                                                     //
01118   // Front End Interfacing:                                              //
01119   //                                                                     //
01120   /////////////////////////////////////////////////////////////////////////
01121 
01122   void viewStructure(ostream& ostr) const;  // overrides SMObject
01123 
01124   /////////////////////////////////////////////////////////////////////////
01125   //                                                                     //
01126   // Control:                                                            //
01127   //                                                                     //
01128   /////////////////////////////////////////////////////////////////////////
01129 
01130   void takeControl( );         // overrides ComputationManager
01131 
01132   /////////////////////////////////////////////////////////////////////////
01133   //                                                                     //
01134   // State Transitions:                                                  //
01135   //                                                                     //
01136   /////////////////////////////////////////////////////////////////////////
01137 
01138   void start( ) { };          // overrides ComputationManager
01139 
01140   void terminate( ) { };      // overrides ComputationManager
01141 
01142 
01143 private:
01144 
01145   /////////////////////////////////////////////////////////////////////////
01146   //                                                                     //
01147   // Data Members:                                                       //
01148   //                                                                     //
01149   /////////////////////////////////////////////////////////////////////////
01150 
01151   SMWord& theWord;
01152   bool abDone;
01153 
01154   MirrorSubordinate abelianInvariants;
01155   MirrorSubordinate abelianPrimes;
01156 };
01157 // ---------------------- AbelianInvariantsOfSGARCer --------------------------- //
01158 
01159 
01160 class AbelianInvariantsOfSGARCer : public ARCer
01161 {
01162 public:
01163 
01164   /////////////////////////////////////////////////////////////////////////
01165   //                                                                     //
01166   // Constructors:                                                       //
01167   //                                                                     //
01168   /////////////////////////////////////////////////////////////////////////
01169 
01170   AbelianInvariantsOfSGARCer( ComputationManager& boss ) 
01171     : ARCer( boss ), AG( NULL ), ASG( NULL ), presentationFound( false ) { } 
01172 
01173   ~AbelianInvariantsOfSGARCer( ) { delete AG; delete ASG; } 
01174 
01175 
01176   /////////////////////////////////////////////////////////////////////////
01177   //                                                                     //
01178   // Accessors:                                                          //
01179   //                                                                     //
01180   /////////////////////////////////////////////////////////////////////////
01181 
01182   void setArguments( const AbelianGroup&, const VectorOf<Word>&);
01183 
01184   // Inherited from ARCer:
01185   // bool takeControl( );
01186 
01187   AbelianSGPresentation getSGCyclicDecomposition();
01188   
01189   
01190   /////////////////////////////////////////////////////////////////////////
01191   //                                                                     //
01192   // IPC interaction members:                                            //
01193   //                                                                     //
01194   /////////////////////////////////////////////////////////////////////////
01195 
01196   void runComputation( );
01197  
01198   void writeResults( ostream& );
01199 
01200   void readResults( istream& );
01201 
01202 
01203 private:
01204 
01205   /////////////////////////////////////////////////////////////////////////
01206   //                                                                     //
01207   // Data Members:                                                       //
01208   //                                                                     //
01209   /////////////////////////////////////////////////////////////////////////
01210 
01211   VectorOf<Word> theSGGens;
01212   
01213   bool presentationFound;  
01214 
01215   AbelianGroup* AG;
01216 
01217   AbelianSGPresentation* ASG;
01218 };
01219 
01220 
01221 // -------------------------- AbelianSGInvariants ---------------------------- //
01222 
01223 
01224 class AbelianSGInvariants : public ComputationManager
01225 {
01226 public:
01227 
01228   /////////////////////////////////////////////////////////////////////////
01229   //                                                                     //
01230   // Constructors:                                                       //
01231   //                                                                     //
01232   /////////////////////////////////////////////////////////////////////////
01233 
01234   AbelianSGInvariants(class SCM& scm);
01235 
01236   /////////////////////////////////////////////////////////////////////////
01237   //                                                                     //
01238   // Accessors:                                                          //
01239   //                                                                     //
01240   /////////////////////////////////////////////////////////////////////////
01241 
01242   /////////////////////////////////////////////////////////////////////////
01243   //                                                                     //
01244   // Control:                                                            //
01245   //                                                                     //
01246   /////////////////////////////////////////////////////////////////////////
01247 
01248   void takeControl( );         // overrides ComputationManager
01249 
01250 
01251   /////////////////////////////////////////////////////////////////////////
01252   //                                                                     //
01253   // State Transitions:                                                  //
01254   //                                                                     //
01255   /////////////////////////////////////////////////////////////////////////
01256 
01257   void start( ) { };          // overrides ComputationManager
01258 
01259   void terminate( ) { };      // overrides ComputationManager
01260 
01261 
01262 private:
01263 
01264   /////////////////////////////////////////////////////////////////////////
01265   //                                                                     //
01266   // Data Members:                                                       //
01267   //                                                                     //
01268   /////////////////////////////////////////////////////////////////////////
01269 
01270   class SCM& theSCM;
01271   bool presentationStarted;
01272   AbelianInvariantsOfSGARCer arcer;
01273 };
01274 
01275 
01276 class AbelianSGCyclicDecomposition : public Supervisor
01277 {
01278 public:
01279 
01280   /////////////////////////////////////////////////////////////////////////
01281   //                                                                     //
01282   // Constructors:                                                       //
01283   //                                                                     //
01284   /////////////////////////////////////////////////////////////////////////
01285 
01286   AbelianSGCyclicDecomposition(class SMSubgroup& smg);
01287 
01288   /////////////////////////////////////////////////////////////////////////
01289   //                                                                     //
01290   // Front End Interfacing:                                              //
01291   //                                                                     //
01292   /////////////////////////////////////////////////////////////////////////
01293 
01294   void viewStructure(ostream& ostr) const;  // overrides SMObject
01295 
01296   /////////////////////////////////////////////////////////////////////////
01297   //                                                                     //
01298   // Control:                                                            //
01299   //                                                                     //
01300   /////////////////////////////////////////////////////////////////////////
01301 
01302   void takeControl( );         // overrides ComputationManager
01303 
01304   /////////////////////////////////////////////////////////////////////////
01305   //                                                                     //
01306   // State Transitions:                                                  //
01307   //                                                                     //
01308   /////////////////////////////////////////////////////////////////////////
01309 
01310   void start( ) { };          // overrides ComputationManager
01311 
01312   void terminate( ) { };      // overrides ComputationManager
01313 
01314 
01315 private:
01316 
01317   /////////////////////////////////////////////////////////////////////////
01318   //                                                                     //
01319   // Data Members:                                                       //
01320   //                                                                     //
01321   /////////////////////////////////////////////////////////////////////////
01322 
01323   SMSubgroup& theSubgroup;
01324 
01325   MirrorSubordinate abelianSGInvariants;
01326   MirrorSubordinate abelianInvariants;
01327   bool abDone;
01328 
01329 };
01330 // ---------------------- AbelianPrimesOfSGARCer --------------------------- //
01331 
01332 
01333 class AbelianPrimesOfSGARCer : public ARCer
01334 {
01335 public:
01336 
01337   /////////////////////////////////////////////////////////////////////////
01338   //                                                                     //
01339   // Constructors:                                                       //
01340   //                                                                     //
01341   /////////////////////////////////////////////////////////////////////////
01342 
01343   AbelianPrimesOfSGARCer( ComputationManager& boss ) 
01344     : ARCer( boss ), ASG( NULL ) { } 
01345 
01346   ~AbelianPrimesOfSGARCer( ) { delete ASG; } 
01347 
01348 
01349   /////////////////////////////////////////////////////////////////////////
01350   //                                                                     //
01351   // Accessors:                                                          //
01352   //                                                                     //
01353   /////////////////////////////////////////////////////////////////////////
01354 
01355   void setArguments( const AbelianSGPresentation&);
01356 
01357   // Inherited from ARCer:
01358   // bool takeControl( );
01359 
01360   AbelianSGPresentation getSGPrimaryDecomposition();
01361   
01362   /////////////////////////////////////////////////////////////////////////
01363   //                                                                     //
01364   // IPC interaction members:                                            //
01365   //                                                                     //
01366   /////////////////////////////////////////////////////////////////////////
01367 
01368   void runComputation( );
01369  
01370   void writeResults( ostream& );
01371 
01372   void readResults( istream& );
01373 
01374 
01375 private:
01376 
01377   /////////////////////////////////////////////////////////////////////////
01378   //                                                                     //
01379   // Data Members:                                                       //
01380   //                                                                     //
01381   /////////////////////////////////////////////////////////////////////////
01382 
01383   AbelianSGPresentation* ASG;
01384 };
01385 
01386 
01387 // -------------------------- AbelianSGPrimes ---------------------------- //
01388 
01389 
01390 class AbelianSGPrimes : public ComputationManager
01391 {
01392 public:
01393 
01394   /////////////////////////////////////////////////////////////////////////
01395   //                                                                     //
01396   // Constructors:                                                       //
01397   //                                                                     //
01398   /////////////////////////////////////////////////////////////////////////
01399 
01400   AbelianSGPrimes(class AbelianSGPrimesDecomposition& sup);
01401 
01402   /////////////////////////////////////////////////////////////////////////
01403   //                                                                     //
01404   // Accessors:                                                          //
01405   //                                                                     //
01406   /////////////////////////////////////////////////////////////////////////
01407 
01408   /////////////////////////////////////////////////////////////////////////
01409   //                                                                     //
01410   // Control:                                                            //
01411   //                                                                     //
01412   /////////////////////////////////////////////////////////////////////////
01413 
01414   void takeControl( );         // overrides ComputationManager
01415 
01416 
01417   /////////////////////////////////////////////////////////////////////////
01418   //                                                                     //
01419   // State Transitions:                                                  //
01420   //                                                                     //
01421   /////////////////////////////////////////////////////////////////////////
01422 
01423   void start( ) { };          // overrides ComputationManager
01424 
01425   void terminate( ) { };      // overrides ComputationManager
01426 
01427 
01428 private:
01429 
01430   /////////////////////////////////////////////////////////////////////////
01431   //                                                                     //
01432   // Data Members:                                                       //
01433   //                                                                     //
01434   /////////////////////////////////////////////////////////////////////////
01435 
01436   class AbelianSGPrimesDecomposition& theSupervisor;
01437   bool primesStarted;
01438   AbelianPrimesOfSGARCer arcer;
01439 };
01440 
01441 
01442 class AbelianSGPrimesDecomposition : public Supervisor
01443 {
01444 public:
01445 
01446   /////////////////////////////////////////////////////////////////////////
01447   //                                                                     //
01448   // Constructors:                                                       //
01449   //                                                                     //
01450   /////////////////////////////////////////////////////////////////////////
01451 
01452   AbelianSGPrimesDecomposition(class SMSubgroup& smg);
01453 
01454   /////////////////////////////////////////////////////////////////////////
01455   //                                                                     //
01456   // Front End Interfacing:                                              //
01457   //                                                                     //
01458   /////////////////////////////////////////////////////////////////////////
01459 
01460   void viewStructure(ostream& ostr) const;  // overrides SMObject
01461 
01462   /////////////////////////////////////////////////////////////////////////
01463   //                                                                     //
01464   // Control:                                                            //
01465   //                                                                     //
01466   /////////////////////////////////////////////////////////////////////////
01467   SMSubgroup& getSubgroup() const { return theSubgroup;}
01468 
01469   void takeControl( );         // overrides ComputationManager
01470 
01471   /////////////////////////////////////////////////////////////////////////
01472   //                                                                     //
01473   // State Transitions:                                                  //
01474   //                                                                     //
01475   /////////////////////////////////////////////////////////////////////////
01476 
01477   void start( ) { };          // overrides ComputationManager
01478 
01479   void terminate( ) { };      // overrides ComputationManager
01480 
01481 
01482 private:
01483 
01484   /////////////////////////////////////////////////////////////////////////
01485   //                                                                     //
01486   // Data Members:                                                       //
01487   //                                                                     //
01488   /////////////////////////////////////////////////////////////////////////
01489 
01490   SMSubgroup& theSubgroup;
01491 
01492   MirrorSubordinate abelianSGInvariants;
01493   MirrorSubordinate abelianInvariants;
01494   Subordinate<AbelianSGPrimesDecomposition,AbelianSGPrimes> abelianSGPrimes;
01495   bool abDone;
01496   bool abSGDone;
01497 
01498 };
01499 
01500 class AbelianSGOrder : public Supervisor
01501 {
01502 public:
01503 
01504   /////////////////////////////////////////////////////////////////////////
01505   //                                                                     //
01506   // Constructors:                                                       //
01507   //                                                                     //
01508   /////////////////////////////////////////////////////////////////////////
01509 
01510   AbelianSGOrder(class SMSubgroup& smg);
01511 
01512   /////////////////////////////////////////////////////////////////////////
01513   //                                                                     //
01514   // Front End Interfacing:                                              //
01515   //                                                                     //
01516   /////////////////////////////////////////////////////////////////////////
01517 
01518   void viewStructure(ostream& ostr) const;  // overrides SMObject
01519 
01520   /////////////////////////////////////////////////////////////////////////
01521   //                                                                     //
01522   // Control:                                                            //
01523   //                                                                     //
01524   /////////////////////////////////////////////////////////////////////////
01525 
01526   void takeControl( );         // overrides ComputationManager
01527 
01528   /////////////////////////////////////////////////////////////////////////
01529   //                                                                     //
01530   // State Transitions:                                                  //
01531   //                                                                     //
01532   /////////////////////////////////////////////////////////////////////////
01533 
01534   void start( ) { };          // overrides ComputationManager
01535 
01536   void terminate( ) { };      // overrides ComputationManager
01537 
01538 
01539 private:
01540 
01541   /////////////////////////////////////////////////////////////////////////
01542   //                                                                     //
01543   // Data Members:                                                       //
01544   //                                                                     //
01545   /////////////////////////////////////////////////////////////////////////
01546 
01547   SMSubgroup& theSubgroup;
01548 
01549   MirrorSubordinate abelianSGInvariants;
01550   MirrorSubordinate abelianInvariants;
01551   bool abDone;
01552 
01553 };
01554 
01555 // ---------------------- AbelianMaximalRootARCer --------------------------- //
01556 
01557 
01558 class AbelianMaximalRootARCer : public ARCer
01559 {
01560 public:
01561 
01562   /////////////////////////////////////////////////////////////////////////
01563   //                                                                     //
01564   // Constructors:                                                       //
01565   //                                                                     //
01566   /////////////////////////////////////////////////////////////////////////
01567 
01568   AbelianMaximalRootARCer( ComputationManager& boss ) 
01569     : ARCer( boss ), AG( 0 ), thePower(0) { } 
01570 
01571   ~AbelianMaximalRootARCer( ) { delete AG; } 
01572 
01573 
01574   /////////////////////////////////////////////////////////////////////////
01575   //                                                                     //
01576   // Accessors:                                                          //
01577   //                                                                     //
01578   /////////////////////////////////////////////////////////////////////////
01579 
01580   void setArguments( const AbelianGroup& group, const Word& w);
01581 
01582   // Inherited from ARCer:
01583   // bool takeControl( );
01584 
01585   Integer getPower() const;
01586   Word getRoot() const;
01587   
01588   
01589   /////////////////////////////////////////////////////////////////////////
01590   //                                                                     //
01591   // IPC interaction members:                                            //
01592   //                                                                     //
01593   /////////////////////////////////////////////////////////////////////////
01594 
01595   void runComputation( );
01596  
01597   void writeResults( ostream& );
01598 
01599   void readResults( istream& );
01600 
01601 
01602 private:
01603 
01604   /////////////////////////////////////////////////////////////////////////
01605   //                                                                     //
01606   // Data Members:                                                       //
01607   //                                                                     //
01608   /////////////////////////////////////////////////////////////////////////
01609 
01610   AbelianGroup* AG;
01611   Integer thePower;
01612   Word theRoot;
01613   Word theWord;
01614 };
01615 
01616 class AbelianMaximalRootComp : public ComputationManager
01617 {
01618 public:
01619 
01620   /////////////////////////////////////////////////////////////////////////
01621   //                                                                     //
01622   // Constructors:                                                       //
01623   //                                                                     //
01624   /////////////////////////////////////////////////////////////////////////
01625 
01626    AbelianMaximalRootComp(class AbelianMaximalRoot& sup);
01627 
01628  
01629   /////////////////////////////////////////////////////////////////////////
01630   //                                                                     //
01631   // Accessors:                                                          //
01632   //                                                                     //
01633   /////////////////////////////////////////////////////////////////////////
01634 
01635   /////////////////////////////////////////////////////////////////////////
01636   //                                                                     //
01637   // Control:                                                            //
01638   //                                                                     //
01639   /////////////////////////////////////////////////////////////////////////
01640 
01641   void takeControl( );         // overrides ComputationManager
01642 
01643   /////////////////////////////////////////////////////////////////////////
01644   //                                                                     //
01645   // State Transitions:                                                  //
01646   //                                                                     //
01647   /////////////////////////////////////////////////////////////////////////
01648 
01649   void start( ) { };          // overrides ComputationManager
01650 
01651   void terminate( ) { };      // overrides ComputationManager
01652 
01653 
01654 private:
01655 
01656   /////////////////////////////////////////////////////////////////////////
01657   //                                                                     //
01658   // Data Members:                                                       //
01659   //                                                                     //
01660   /////////////////////////////////////////////////////////////////////////
01661 
01662    class AbelianMaximalRoot& theSupervisor;
01663    AbelianMaximalRootARCer A;
01664    bool rootStarted;
01665 };
01666 
01667 class AbelianMaximalRoot : public Supervisor
01668 {
01669 public:
01670 
01671   /////////////////////////////////////////////////////////////////////////
01672   //                                                                     //
01673   // Constructors:                                                       //
01674   //                                                                     //
01675   /////////////////////////////////////////////////////////////////////////
01676 
01677   AbelianMaximalRoot(class SMWord& smw);
01678 
01679   /////////////////////////////////////////////////////////////////////////
01680   //                                                                     //
01681   // Front End Interfacing:                                              //
01682   //                                                                     //
01683   /////////////////////////////////////////////////////////////////////////
01684 
01685   void viewStructure(ostream& ostr) const;  // overrides SMObject
01686 
01687   /////////////////////////////////////////////////////////////////////////
01688   //                                                                     //
01689   // Control:                                                            //
01690   //                                                                     //
01691   /////////////////////////////////////////////////////////////////////////
01692 
01693   void takeControl( );         // overrides ComputationManager
01694 
01695   /////////////////////////////////////////////////////////////////////////
01696   //                                                                     //
01697   // State Transitions:                                                  //
01698   //                                                                     //
01699   /////////////////////////////////////////////////////////////////////////
01700 
01701   void start( ) { };          // overrides ComputationManager
01702 
01703   void terminate( ) { };      // overrides ComputationManager
01704 
01705   SMWord& getWord() const {return theWord;}
01706 
01707 private:
01708 
01709   /////////////////////////////////////////////////////////////////////////
01710   //                                                                     //
01711   // Data Members:                                                       //
01712   //                                                                     //
01713   /////////////////////////////////////////////////////////////////////////
01714 
01715   SMWord& theWord;
01716 
01717   MirrorSubordinate abelianInvariants;
01718   MirrorSubordinate abelianPrimes;
01719   bool abDone;
01720   bool abPDone;
01721   Subordinate<AbelianMaximalRoot,AbelianMaximalRootComp> abelianMaximalRoot;
01722 };
01723 
01724 class AbelianIsIsomorphicSG : public Supervisor
01725 {
01726 public:
01727 
01728   /////////////////////////////////////////////////////////////////////////
01729   //                                                                     //
01730   // Constructors:                                                       //
01731   //                                                                     //
01732   /////////////////////////////////////////////////////////////////////////
01733 
01734   AbelianIsIsomorphicSG(class SMSubgroup& smg1, class SMSubgroup& smg2);
01735 
01736   /////////////////////////////////////////////////////////////////////////
01737   //                                                                     //
01738   // Front End Interfacing:                                              //
01739   //                                                                     //
01740   /////////////////////////////////////////////////////////////////////////
01741 
01742   void viewStructure(ostream& ostr) const;  // overrides SMObject
01743 
01744   /////////////////////////////////////////////////////////////////////////
01745   //                                                                     //
01746   // Control:                                                            //
01747   //                                                                     //
01748   /////////////////////////////////////////////////////////////////////////
01749 
01750   void takeControl( );         // overrides ComputationManager
01751 
01752   /////////////////////////////////////////////////////////////////////////
01753   //                                                                     //
01754   // State Transitions:                                                  //
01755   //                                                                     //
01756   /////////////////////////////////////////////////////////////////////////
01757 
01758   void start( ) { };          // overrides ComputationManager
01759 
01760   void terminate( ) { };      // overrides ComputationManager
01761 
01762 
01763 private:
01764 
01765   /////////////////////////////////////////////////////////////////////////
01766   //                                                                     //
01767   // Data Members:                                                       //
01768   //                                                                     //
01769   /////////////////////////////////////////////////////////////////////////
01770 
01771   SMSubgroup& theSubgroup1;
01772   SMSubgroup& theSubgroup2;
01773 
01774   MirrorSubordinate abelianSG1Invariants;
01775   MirrorSubordinate abelianSG2Invariants;
01776   MirrorSubordinate abelianInvariants;
01777   bool abDone;
01778   bool sg1abDone;
01779   bool sg2abDone;
01780 
01781 };
01782 class AbelianTorsionFreeRankOfSG : public Supervisor
01783 {
01784 public:
01785 
01786   /////////////////////////////////////////////////////////////////////////
01787   //                                                                     //
01788   // Constructors:                                                       //
01789   //                                                                     //
01790   /////////////////////////////////////////////////////////////////////////
01791 
01792   AbelianTorsionFreeRankOfSG(class SMSubgroup& SG);
01793 
01794   /////////////////////////////////////////////////////////////////////////
01795   //                                                                     //
01796   // Front End Interfacing:                                              //
01797   //                                                                     //
01798   /////////////////////////////////////////////////////////////////////////
01799 
01800   void viewStructure(ostream& ostr) const;  // overrides SMObject
01801 
01802   /////////////////////////////////////////////////////////////////////////
01803   //                                                                     //
01804   // Control:                                                            //
01805   //                                                                     //
01806   /////////////////////////////////////////////////////////////////////////
01807 
01808   void takeControl( );         // overrides ComputationManager
01809 
01810   /////////////////////////////////////////////////////////////////////////
01811   //                                                                     //
01812   // State Transitions:                                                  //
01813   //                                                                     //
01814   /////////////////////////////////////////////////////////////////////////
01815 
01816   void start( ) { };          // overrides ComputationManager
01817 
01818   void terminate( ) { };      // overrides ComputationManager
01819 
01820 
01821 private:
01822 
01823   /////////////////////////////////////////////////////////////////////////
01824   //                                                                     //
01825   // Data Members:                                                       //
01826   //                                                                     //
01827   /////////////////////////////////////////////////////////////////////////
01828 
01829   SMSubgroup& theSubgroup;
01830 
01831   bool abDone;
01832   MirrorSubordinate abelianInvariants;
01833   MirrorSubordinate abelianSGInvariants;
01834 
01835 };
01836 //-------------- AbelianOrderOfTheTorsionSubgroupOfSG --------------------//
01837 
01838 
01839 class AbelianOrderOfTheTorsionSubgroupOfSG : public Supervisor
01840 {
01841 public:
01842 
01843   /////////////////////////////////////////////////////////////////////////
01844   //                                                                     //
01845   // Constructors:                                                       //
01846   //                                                                     //
01847   /////////////////////////////////////////////////////////////////////////
01848 
01849   AbelianOrderOfTheTorsionSubgroupOfSG(class SMSubgroup& SG);
01850 
01851   /////////////////////////////////////////////////////////////////////////
01852   //                                                                     //
01853   // Front End Interfacing:                                              //
01854   //                                                                     //
01855   /////////////////////////////////////////////////////////////////////////
01856 
01857   void viewStructure(ostream& ostr) const;  // overrides SMObject
01858 
01859   /////////////////////////////////////////////////////////////////////////
01860   //                                                                     //
01861   // Control:                                                            //
01862   //                                                                     //
01863   /////////////////////////////////////////////////////////////////////////
01864 
01865   void takeControl( );         // overrides ComputationManager
01866 
01867   /////////////////////////////////////////////////////////////////////////
01868   //                                                                     //
01869   // State Transitions:                                                  //
01870   //                                                                     //
01871   /////////////////////////////////////////////////////////////////////////
01872 
01873   void start( ) { };          // overrides ComputationManager
01874 
01875   void terminate( ) { };      // overrides ComputationManager
01876 
01877 
01878 private:
01879 
01880   /////////////////////////////////////////////////////////////////////////
01881   //                                                                     //
01882   // Data Members:                                                       //
01883   //                                                                     //
01884   /////////////////////////////////////////////////////////////////////////
01885 
01886   SMSubgroup& theSubgroup;
01887   bool abDone;  
01888 
01889   MirrorSubordinate abelianInvariants;
01890   MirrorSubordinate abelianSGInvariants;
01891 
01892 };
01893 class EltPrimeForm : public Supervisor
01894 {
01895 public:
01896 
01897   /////////////////////////////////////////////////////////////////////////
01898   //                                                                     //
01899   // Constructors:                                                       //
01900   //                                                                     //
01901   /////////////////////////////////////////////////////////////////////////
01902 
01903   EltPrimeForm(class SMWord& smw);
01904 
01905   /////////////////////////////////////////////////////////////////////////
01906   //                                                                     //
01907   // Front End Interfacing:                                              //
01908   //                                                                     //
01909   /////////////////////////////////////////////////////////////////////////
01910 
01911   void viewStructure(ostream& ostr) const;  // overrides SMObject
01912 
01913   /////////////////////////////////////////////////////////////////////////
01914   //                                                                     //
01915   // Control:                                                            //
01916   //                                                                     //
01917   /////////////////////////////////////////////////////////////////////////
01918 
01919   void takeControl( );         // overrides ComputationManager
01920 
01921   /////////////////////////////////////////////////////////////////////////
01922   //                                                                     //
01923   // State Transitions:                                                  //
01924   //                                                                     //
01925   /////////////////////////////////////////////////////////////////////////
01926 
01927   void start( ) { };          // overrides ComputationManager
01928 
01929   void terminate( ) { };      // overrides ComputationManager
01930 
01931 
01932 private:
01933 
01934   /////////////////////////////////////////////////////////////////////////
01935   //                                                                     //
01936   // Data Members:                                                       //
01937   //                                                                     //
01938   /////////////////////////////////////////////////////////////////////////
01939 
01940   SMWord& theWord;
01941 
01942   MirrorSubordinate abelianPrimes;
01943   MirrorSubordinate abelianInvariants;
01944   bool abDone;
01945 
01946 };
01947 
01948 
01949 // ---------------------- virtualFreeCompARCer --------------------------- //
01950 
01951 
01952 class virtualFreeCompARCer : public ARCer
01953 {
01954 public:
01955 
01956   /////////////////////////////////////////////////////////////////////////
01957   //                                                                     //
01958   // Constructors:                                                       //
01959   //                                                                     //
01960   /////////////////////////////////////////////////////////////////////////
01961 
01962   virtualFreeCompARCer( ComputationManager& boss ) 
01963     : ARCer( boss ), AG( 0 ) { } 
01964 
01965   ~virtualFreeCompARCer( ) { 
01966   
01967     if ( AG )
01968       delete AG; 
01969   
01970   } 
01971 
01972 
01973   /////////////////////////////////////////////////////////////////////////
01974   //                                                                     //
01975   // Accessors:                                                          //
01976   //                                                                     //
01977   /////////////////////////////////////////////////////////////////////////
01978 
01979   void setArguments( const AbelianGroup& group, const VectorOf<Word>& sG);
01980   
01981   // Inherited from ARCer:
01982   // bool takeControl( );
01983   
01984   VectorOf<Word> getVFComplement()const { return result;}
01985   
01986   
01987   /////////////////////////////////////////////////////////////////////////
01988   //                                                                     //
01989   // IPC interaction members:                                            //
01990   //                                                                     //
01991   /////////////////////////////////////////////////////////////////////////
01992   
01993   void runComputation( );
01994   
01995   void writeResults( ostream& );
01996   
01997   void readResults( istream& );
01998   
01999   
02000 private:
02001   
02002   /////////////////////////////////////////////////////////////////////////
02003   //                                                                     //
02004   // Data Members:                                                       //
02005   //                                                                     //
02006   /////////////////////////////////////////////////////////////////////////
02007   
02008   AbelianGroup* AG;
02009   VectorOf<Word> theSubgroup;
02010   VectorOf<Word> result;
02011 };
02012 
02013 
02014 class virtualFreeComp  : public Supervisor
02015 {
02016 public:
02017 
02018   /////////////////////////////////////////////////////////////////////////
02019   //                                                                     //
02020   // Constructors:                                                       //
02021   //                                                                     //
02022   /////////////////////////////////////////////////////////////////////////
02023 
02024   virtualFreeComp(class SMSubgroup& sms);
02025 
02026   /////////////////////////////////////////////////////////////////////////
02027   //                                                                     //
02028   // Front End Interfacing:                                              //
02029   //                                                                     //
02030   /////////////////////////////////////////////////////////////////////////
02031 
02032   void viewStructure(ostream& ostr) const;  // overrides SMObject
02033 
02034   /////////////////////////////////////////////////////////////////////////
02035   //                                                                     //
02036   // Control:                                                            //
02037   //                                                                     //
02038   /////////////////////////////////////////////////////////////////////////
02039 
02040   void takeControl( );         // overrides ComputationManager
02041 
02042   /////////////////////////////////////////////////////////////////////////
02043   //                                                                     //
02044   // State Transitions:                                                  //
02045   //                                                                     //
02046   /////////////////////////////////////////////////////////////////////////
02047 
02048   void start( ) { };          // overrides ComputationManager
02049 
02050   void terminate( ) { };      // overrides ComputationManager
02051 
02052 
02053 private:
02054 
02055   /////////////////////////////////////////////////////////////////////////
02056   //                                                                     //
02057   // Data Members:                                                       //
02058   //                                                                     //
02059   /////////////////////////////////////////////////////////////////////////
02060 
02061   SMSubgroup& theSubgroup;
02062 
02063   virtualFreeCompARCer arcer;
02064   MirrorSubordinate abelianInvariants;
02065   bool abDone;
02066   bool started;
02067 
02068 };
02069 
02070 // ---------------------- SubgroupIsolatorARCer --------------------------- //
02071 
02072 
02073 class SubgroupIsolatorARCer : public ARCer
02074 {
02075 public:
02076 
02077   /////////////////////////////////////////////////////////////////////////
02078   //                                                                     //
02079   // Constructors:                                                       //
02080   //                                                                     //
02081   /////////////////////////////////////////////////////////////////////////
02082 
02083   SubgroupIsolatorARCer( ComputationManager& boss ) 
02084     : ARCer( boss ), AG( 0 ) { } 
02085 
02086   ~SubgroupIsolatorARCer( ) { 
02087   
02088     if ( AG )
02089       delete AG; 
02090   
02091   } 
02092 
02093 
02094   /////////////////////////////////////////////////////////////////////////
02095   //                                                                     //
02096   // Accessors:                                                          //
02097   //                                                                     //
02098   /////////////////////////////////////////////////////////////////////////
02099 
02100   void setArguments( const AbelianGroup& group, const VectorOf<Word>& sG);
02101   
02102   // Inherited from ARCer:
02103   // bool takeControl( );
02104   
02105   VectorOf<Word> getIsolator()const { return result;}
02106   
02107   
02108   /////////////////////////////////////////////////////////////////////////
02109   //                                                                     //
02110   // IPC interaction members:                                            //
02111   //                                                                     //
02112   /////////////////////////////////////////////////////////////////////////
02113   
02114   void runComputation( );
02115   
02116   void writeResults( ostream& );
02117   
02118   void readResults( istream& );
02119   
02120   
02121 private:
02122   
02123   /////////////////////////////////////////////////////////////////////////
02124   //                                                                     //
02125   // Data Members:                                                       //
02126   //                                                                     //
02127   /////////////////////////////////////////////////////////////////////////
02128   
02129   AbelianGroup* AG;
02130   VectorOf<Word> theSubgroup;
02131   VectorOf<Word> result;
02132 };
02133 
02134 
02135 class SubgroupIsolator  : public Supervisor
02136 {
02137 public:
02138 
02139   /////////////////////////////////////////////////////////////////////////
02140   //                                                                     //
02141   // Constructors:                                                       //
02142   //                                                                     //
02143   /////////////////////////////////////////////////////////////////////////
02144 
02145   SubgroupIsolator(class SMSubgroup& sms);
02146 
02147   /////////////////////////////////////////////////////////////////////////
02148   //                                                                     //
02149   // Front End Interfacing:                                              //
02150   //                                                                     //
02151   /////////////////////////////////////////////////////////////////////////
02152 
02153   void viewStructure(ostream& ostr) const;  // overrides SMObject
02154 
02155   /////////////////////////////////////////////////////////////////////////
02156   //                                                                     //
02157   // Control:                                                            //
02158   //                                                                     //
02159   /////////////////////////////////////////////////////////////////////////
02160 
02161   void takeControl( );         // overrides ComputationManager
02162 
02163   /////////////////////////////////////////////////////////////////////////
02164   //                                                                     //
02165   // State Transitions:                                                  //
02166   //                                                                     //
02167   /////////////////////////////////////////////////////////////////////////
02168 
02169   void start( ) { };          // overrides ComputationManager
02170 
02171   void terminate( ) { };      // overrides ComputationManager
02172 
02173 
02174 private:
02175 
02176   /////////////////////////////////////////////////////////////////////////
02177   //                                                                     //
02178   // Data Members:                                                       //
02179   //                                                                     //
02180   /////////////////////////////////////////////////////////////////////////
02181 
02182   SMSubgroup& theSubgroup;
02183 
02184   SubgroupIsolatorARCer arcer;
02185   MirrorSubordinate abelianInvariants;
02186   bool abDone;
02187   bool started;
02188 
02189 };
02190 
02191 // ---------------------- AbelianSGPurityARCer --------------------------- //
02192 
02193 class AbelianSGPurityARCer : public ARCer
02194 {
02195 public:
02196 
02197   /////////////////////////////////////////////////////////////////////////
02198   //                                                                     //
02199   // Constructors:                                                       //
02200   //                                                                     //
02201   /////////////////////////////////////////////////////////////////////////
02202 
02203   AbelianSGPurityARCer( ComputationManager& boss, class SMSubgroup& subgroup) 
02204     : ARCer( boss ), isPure( false ), theSubgroup( subgroup ) { } 
02205 
02206   /////////////////////////////////////////////////////////////////////////
02207   //                                                                     //
02208   // Accessors:                                                          //
02209   //                                                                     //
02210   /////////////////////////////////////////////////////////////////////////
02211 
02212 //  void setArguments( const AbelianGroup& group, const Word& w);
02213 
02214   // Inherited from ARCer:
02215   // bool takeControl( );
02216  
02217   bool isPureSubgroup() const;
02218   bool computePurity() const;
02219 
02220   /////////////////////////////////////////////////////////////////////////
02221   //                                                                     //
02222   // IPC interaction members:                                            //
02223   //                                                                     //
02224   /////////////////////////////////////////////////////////////////////////
02225 
02226   void runComputation( );
02227  
02228   void writeResults( ostream& );
02229 
02230   void readResults( istream& );
02231 
02232 
02233 private:
02234 
02235   /////////////////////////////////////////////////////////////////////////
02236   //                                                                     //
02237   // Data Members:                                                       //
02238   //                                                                     //
02239   /////////////////////////////////////////////////////////////////////////
02240 
02241   bool isPure; 
02242   const SMSubgroup& theSubgroup;
02243 };
02244 
02245 
02246 class AbelianSGPurityProblem  : public Supervisor
02247 {
02248 public:
02249 
02250   /////////////////////////////////////////////////////////////////////////
02251   //                                                                     //
02252   // Constructors:                                                       //
02253   //                                                                     //
02254   /////////////////////////////////////////////////////////////////////////
02255 
02256   AbelianSGPurityProblem(class SMSubgroup& sms);
02257 
02258   /////////////////////////////////////////////////////////////////////////
02259   //                                                                     //
02260   // Front End Interfacing:                                              //
02261   //                                                                     //
02262   /////////////////////////////////////////////////////////////////////////
02263 
02264   void viewStructure(ostream& ostr) const;  // overrides SMObject
02265 
02266   /////////////////////////////////////////////////////////////////////////
02267   //                                                                     //
02268   // Control:                                                            //
02269   //                                                                     //
02270   /////////////////////////////////////////////////////////////////////////
02271 
02272   void takeControl( );         // overrides ComputationManager
02273 
02274   /////////////////////////////////////////////////////////////////////////
02275   //                                                                     //
02276   // State Transitions:                                                  //
02277   //                                                                     //
02278   /////////////////////////////////////////////////////////////////////////
02279 
02280   void start( ) { };          // overrides ComputationManager
02281 
02282   void terminate( ) { };      // overrides ComputationManager
02283 
02284 
02285 private:
02286 
02287   /////////////////////////////////////////////////////////////////////////
02288   //                                                                     //
02289   // Data Members:                                                       //
02290   //                                                                     //
02291   /////////////////////////////////////////////////////////////////////////
02292 
02293   SMSubgroup& theSubgroup;
02294 
02295   MirrorSubordinate abelianPrimes;
02296   MirrorSubordinate abelianInvariants;
02297   MirrorSubordinate abelianSGInvariants;
02298   bool abDone;
02299   bool PDDone;
02300   bool sgAbDone;
02301    AbelianSGPurityARCer arcer;
02302 };
02303 
02304 class AbelianSGGenedByWordPurityProblem  : public Supervisor
02305 {
02306 public:
02307 
02308   /////////////////////////////////////////////////////////////////////////
02309   //                                                                     //
02310   // Constructors:                                                       //
02311   //                                                                     //
02312   /////////////////////////////////////////////////////////////////////////
02313 
02314   AbelianSGGenedByWordPurityProblem(class SMWord& smw);
02315 
02316   /////////////////////////////////////////////////////////////////////////
02317   //                                                                     //
02318   // Front End Interfacing:                                              //
02319   //                                                                     //
02320   /////////////////////////////////////////////////////////////////////////
02321 
02322   void viewStructure(ostream& ostr) const;  // overrides SMObject
02323 
02324   /////////////////////////////////////////////////////////////////////////
02325   //                                                                     //
02326   // Control:                                                            //
02327   //                                                                     //
02328   /////////////////////////////////////////////////////////////////////////
02329 
02330   void takeControl( );         // overrides ComputationManager
02331 
02332   /////////////////////////////////////////////////////////////////////////
02333   //                                                                     //
02334   // State Transitions:                                                  //
02335   //                                                                     //
02336   /////////////////////////////////////////////////////////////////////////
02337 
02338   void start( ) { };          // overrides ComputationManager
02339 
02340   void terminate( ) { };      // overrides ComputationManager
02341 
02342 
02343 private:
02344 
02345   /////////////////////////////////////////////////////////////////////////
02346   //                                                                     //
02347   // Data Members:                                                       //
02348   //                                                                     //
02349   /////////////////////////////////////////////////////////////////////////
02350 
02351   SMWord& theWord;
02352 
02353   MirrorSubordinate abelianPrimes;
02354   MirrorSubordinate abelianInvariants;
02355   bool abDone;
02356 };
02357 
02358 //----------------------- AbelianDoesGensSummand --------------------//
02359 
02360 class AbelianDoesGensSummand  : public Supervisor
02361 {
02362 public:
02363 
02364   /////////////////////////////////////////////////////////////////////////
02365   //                                                                     //
02366   // Constructors:                                                       //
02367   //                                                                     //
02368   /////////////////////////////////////////////////////////////////////////
02369 
02370   AbelianDoesGensSummand(class SMWord& smw);
02371 
02372   /////////////////////////////////////////////////////////////////////////
02373   //                                                                     //
02374   // Front End Interfacing:                                              //
02375   //                                                                     //
02376   /////////////////////////////////////////////////////////////////////////
02377 
02378   void viewStructure(ostream& ostr) const;  // overrides SMObject
02379 
02380   /////////////////////////////////////////////////////////////////////////
02381   //                                                                     //
02382   // Control:                                                            //
02383   //                                                                     //
02384   /////////////////////////////////////////////////////////////////////////
02385 
02386   void takeControl( );         // overrides ComputationManager
02387 
02388   /////////////////////////////////////////////////////////////////////////
02389   //                                                                     //
02390   // State Transitions:                                                  //
02391   //                                                                     //
02392   /////////////////////////////////////////////////////////////////////////
02393 
02394   void start( ) { };          // overrides ComputationManager
02395 
02396   void terminate( ) { };      // overrides ComputationManager
02397 
02398 
02399 private:
02400 
02401   /////////////////////////////////////////////////////////////////////////
02402   //                                                                     //
02403   // Data Members:                                                       //
02404   //                                                                     //
02405   /////////////////////////////////////////////////////////////////////////
02406 
02407   SMWord& theWord;
02408 
02409   MirrorSubordinate abelianPrimes;
02410   MirrorSubordinate abelianInvariants;
02411   bool abDone;
02412 };
02413 
02414 // ------------------- AbelianSGEqualityProblem ------------------------- //
02415 
02416 
02417 class AbelianSGEqualityProblem : public Supervisor
02418 {
02419 
02420 public:
02421 
02422   /////////////////////////////////////////////////////////////////////////
02423   //                                                                     //
02424   // Constructors:                                                       //
02425   //                                                                     //
02426   /////////////////////////////////////////////////////////////////////////
02427 
02428   AbelianSGEqualityProblem(class SMSubgroup& S1, class SMSubgroup& S2);
02429 
02430   
02431   /////////////////////////////////////////////////////////////////////////
02432   //                                                                     //
02433   // Accessors:                                                          //
02434   //                                                                     //
02435   /////////////////////////////////////////////////////////////////////////
02436 
02437   /////////////////////////////////////////////////////////////////////////
02438   //                                                                     //
02439   // Front End Interfacing:                                              //
02440   //                                                                     //
02441   /////////////////////////////////////////////////////////////////////////
02442 
02443   void viewStructure(ostream& ostr) const;  // overrides SMObject
02444 
02445   /////////////////////////////////////////////////////////////////////////
02446   //                                                                     //
02447   // Control:                                                            //
02448   //                                                                     //
02449   /////////////////////////////////////////////////////////////////////////
02450 
02451   void takeControl( );         // overrides ComputationManager
02452 
02453   /////////////////////////////////////////////////////////////////////////
02454   //                                                                     //
02455   // State Transitions:                                                  //
02456   //                                                                     //
02457   /////////////////////////////////////////////////////////////////////////
02458 
02459   void start( ) { };          // overrides ComputationManager
02460 
02461   void terminate( ) { };      // overrides ComputationManager
02462 
02463 
02464 private:
02465 
02466   /////////////////////////////////////////////////////////////////////////
02467   //                                                                     //
02468   // Data Members:                                                       //
02469   //                                                                     //
02470   /////////////////////////////////////////////////////////////////////////
02471 
02472   SMSubgroup& subgroup1;
02473   SMSubgroup& subgroup2;
02474   
02475   bool s1AbDone;
02476   bool s2AbDone;
02477 
02478   MirrorSubordinate s1AbelianInvariantsOfFactor;
02479   MirrorSubordinate s2AbelianInvariantsOfFactor;
02480 };
02481 
02482 // ---------------------- IsAbelianWordPowerOfSecondArcer --------------------------- //
02483 
02484 class IsAbelianWordPowerOfSecondArcer : public ARCer
02485 {
02486 public:
02487 
02488   /////////////////////////////////////////////////////////////////////////
02489   //                                                                     //
02490   // Constructors:                                                       //
02491   //                                                                     //
02492   /////////////////////////////////////////////////////////////////////////
02493 
02494   IsAbelianWordPowerOfSecondArcer( ComputationManager& boss) 
02495     : ARCer( boss ), power( 0 ), AG(NULL) { } 
02496 
02497    ~IsAbelianWordPowerOfSecondArcer( ) { delete AG; } 
02498 
02499 
02500   /////////////////////////////////////////////////////////////////////////
02501   //                                                                     //
02502   // Accessors:                                                          //
02503   //                                                                     //
02504   /////////////////////////////////////////////////////////////////////////
02505 
02506 void IsAbelianWordPowerOfSecondArcer::setArguments(const AbelianGroup& abGroup,
02507                                 const SMWord& w1,const SMWord& w2);
02508   // Inherited from ARCer:
02509   // bool takeControl( );
02510  
02511   int getPower() const;
02512 
02513   /////////////////////////////////////////////////////////////////////////
02514   //                                                                     //
02515   // IPC interaction members:                                            //
02516   //                                                                     //
02517   /////////////////////////////////////////////////////////////////////////
02518 
02519   void runComputation( );
02520  
02521   void writeResults( ostream& );
02522 
02523   void readResults( istream& );
02524 
02525 
02526 private:
02527 
02528   /////////////////////////////////////////////////////////////////////////
02529   //                                                                     //
02530   // Data Members:                                                       //
02531   //                                                                     //
02532   /////////////////////////////////////////////////////////////////////////
02533 
02534   int power; 
02535   AbelianGroup* AG;
02536   Word theWord1;
02537   Word theWord2;
02538 };
02539 
02540 
02541 class IsAbelianWordPowerOfSecond  : public Supervisor
02542 {
02543 public:
02544 
02545   /////////////////////////////////////////////////////////////////////////
02546   //                                                                     //
02547   // Constructors:                                                       //
02548   //                                                                     //
02549   /////////////////////////////////////////////////////////////////////////
02550 
02551   IsAbelianWordPowerOfSecond(class SMWord& w1,class SMWord& w2);
02552 
02553   /////////////////////////////////////////////////////////////////////////
02554   //                                                                     //
02555   // Front End Interfacing:                                              //
02556   //                                                                     //
02557   /////////////////////////////////////////////////////////////////////////
02558 
02559   void viewStructure(ostream& ostr) const;  // overrides SMObject
02560 
02561   /////////////////////////////////////////////////////////////////////////
02562   //                                                                     //
02563   // Control:                                                            //
02564   //                                                                     //
02565   /////////////////////////////////////////////////////////////////////////
02566 
02567   void takeControl( );         // overrides ComputationManager
02568 
02569   /////////////////////////////////////////////////////////////////////////
02570   //                                                                     //
02571   // State Transitions:                                                  //
02572   //                                                                     //
02573   /////////////////////////////////////////////////////////////////////////
02574 
02575   void start( ) { };          // overrides ComputationManager
02576 
02577   void terminate( ) { };      // overrides ComputationManager
02578 
02579 
02580 private:
02581 
02582   /////////////////////////////////////////////////////////////////////////
02583   //                                                                     //
02584   // Data Members:                                                       //
02585   //                                                                     //
02586   /////////////////////////////////////////////////////////////////////////
02587 
02588   SMWord& theWord1;
02589   SMWord& theWord2;
02590   bool arcerSet;
02591 
02592   MirrorSubordinate abelianInvariants;
02593   bool abDone;
02594   IsAbelianWordPowerOfSecondArcer arcer;
02595 };
02596 
02597 
02598 class AbelianHomIsEpiComp : public ComputationManager
02599 {
02600 public:
02601 
02602   /////////////////////////////////////////////////////////////////////////
02603   //                                                                     //
02604   // Constructors:                                                       //
02605   //                                                                     //
02606   /////////////////////////////////////////////////////////////////////////
02607 
02608    AbelianHomIsEpiComp(class MCM& mcm);
02609 
02610   /////////////////////////////////////////////////////////////////////////
02611   //                                                                     //
02612   // Accessors:                                                          //
02613   //                                                                     //
02614   /////////////////////////////////////////////////////////////////////////
02615 
02616   /////////////////////////////////////////////////////////////////////////
02617   //                                                                     //
02618   // Control:                                                            //
02619   //                                                                     //
02620   /////////////////////////////////////////////////////////////////////////
02621 
02622   void takeControl( );         // overrides ComputationManager
02623 
02624   /////////////////////////////////////////////////////////////////////////
02625   //                                                                     //
02626   // State Transitions:                                                  //
02627   //                                                                     //
02628   /////////////////////////////////////////////////////////////////////////
02629 
02630   void start( ) { };          // overrides ComputationManager
02631 
02632   void terminate( ) { };      // overrides ComputationManager
02633 
02634 
02635 private:
02636 
02637   /////////////////////////////////////////////////////////////////////////
02638   //                                                                     //
02639   // Data Members:                                                       //
02640   //                                                                     //
02641   /////////////////////////////////////////////////////////////////////////
02642 
02643    class MCM& theMCM;
02644    AbelianInvariantsARCer arcer;
02645 };
02646 
02647 class AbelianHomIsEpi  : public Supervisor
02648 {
02649 public:
02650 
02651   /////////////////////////////////////////////////////////////////////////
02652   //                                                                     //
02653   // Constructors:                                                       //
02654   //                                                                     //
02655   /////////////////////////////////////////////////////////////////////////
02656 
02657   AbelianHomIsEpi(class SMMap& map);
02658 
02659   /////////////////////////////////////////////////////////////////////////
02660   //                                                                     //
02661   // Front End Interfacing:                                              //
02662   //                                                                     //
02663   /////////////////////////////////////////////////////////////////////////
02664 
02665   void viewStructure(ostream& ostr) const;  // overrides SMObject
02666 
02667   /////////////////////////////////////////////////////////////////////////
02668   //                                                                     //
02669   // Control:                                                            //
02670   //                                                                     //
02671   /////////////////////////////////////////////////////////////////////////
02672 
02673   void takeControl( );         // overrides ComputationManager
02674 
02675   /////////////////////////////////////////////////////////////////////////
02676   //                                                                     //
02677   // State Transitions:                                                  //
02678   //                                                                     //
02679   /////////////////////////////////////////////////////////////////////////
02680 
02681   void start( ) { };          // overrides ComputationManager
02682 
02683   void terminate( ) { };      // overrides ComputationManager
02684 
02685 
02686 private:
02687 
02688   /////////////////////////////////////////////////////////////////////////
02689   //                                                                     //
02690   // Data Members:                                                       //
02691   //                                                                     //
02692   /////////////////////////////////////////////////////////////////////////
02693 
02694   SMMap& theMap;
02695 
02696   MirrorSubordinate abelianHomIsEpi;
02697 };
02698 class AbelianHomIsMonoComp : public ComputationManager
02699 {
02700 public:
02701 
02702   /////////////////////////////////////////////////////////////////////////
02703   //                                                                     //
02704   // Constructors:                                                       //
02705   //                                                                     //
02706   /////////////////////////////////////////////////////////////////////////
02707 
02708    AbelianHomIsMonoComp(class MCM& mcm);
02709 
02710    ~AbelianHomIsMonoComp(){delete abSG;}
02711   /////////////////////////////////////////////////////////////////////////
02712   //                                                                     //
02713   // Accessors:                                                          //
02714   //                                                                     //
02715   /////////////////////////////////////////////////////////////////////////
02716 
02717   /////////////////////////////////////////////////////////////////////////
02718   //                                                                     //
02719   // Control:                                                            //
02720   //                                                                     //
02721   /////////////////////////////////////////////////////////////////////////
02722 
02723   void takeControl( );         // overrides ComputationManager
02724 
02725   /////////////////////////////////////////////////////////////////////////
02726   //                                                                     //
02727   // State Transitions:                                                  //
02728   //                                                                     //
02729   /////////////////////////////////////////////////////////////////////////
02730 
02731   void start( ) { };          // overrides ComputationManager
02732 
02733   void terminate( ) { };      // overrides ComputationManager
02734 
02735 
02736 private:
02737 
02738   /////////////////////////////////////////////////////////////////////////
02739   //                                                                     //
02740   // Data Members:                                                       //
02741   //                                                                     //
02742   /////////////////////////////////////////////////////////////////////////
02743 
02744    class MCM& theMCM;
02745    AbelianInvariantsOfSGARCer arcer;
02746    AbelianSGPresentation* abSG;
02747    bool sgInvStarted;
02748    bool sgInvFinished;
02749 };
02750 
02751 class AbelianHomIsMono  : public Supervisor
02752 {
02753 public:
02754 
02755   /////////////////////////////////////////////////////////////////////////
02756   //                                                                     //
02757   // Constructors:                                                       //
02758   //                                                                     //
02759   /////////////////////////////////////////////////////////////////////////
02760 
02761   AbelianHomIsMono(class SMMap& map);
02762 
02763   /////////////////////////////////////////////////////////////////////////
02764   //                                                                     //
02765   // Front End Interfacing:                                              //
02766   //                                                                     //
02767   /////////////////////////////////////////////////////////////////////////
02768 
02769   void viewStructure(ostream& ostr) const;  // overrides SMObject
02770 
02771   /////////////////////////////////////////////////////////////////////////
02772   //                                                                     //
02773   // Control:                                                            //
02774   //                                                                     //
02775   /////////////////////////////////////////////////////////////////////////
02776 
02777   void takeControl( );         // overrides ComputationManager
02778 
02779   /////////////////////////////////////////////////////////////////////////
02780   //                                                                     //
02781   // State Transitions:                                                  //
02782   //                                                                     //
02783   /////////////////////////////////////////////////////////////////////////
02784 
02785   void start( ) { };          // overrides ComputationManager
02786 
02787   void terminate( ) { };      // overrides ComputationManager
02788 
02789 
02790 private:
02791 
02792   /////////////////////////////////////////////////////////////////////////
02793   //                                                                     //
02794   // Data Members:                                                       //
02795   //                                                                     //
02796   /////////////////////////////////////////////////////////////////////////
02797 
02798   SMMap& theMap;
02799 
02800   MirrorSubordinate abelianInvariants1;
02801   MirrorSubordinate abelianInvariants2;
02802   MirrorSubordinate abelianHomIsMono;
02803   MirrorSubordinate abelianHomIsEpi;
02804   bool  abRangeDone; 
02805   bool  abDomainDone; 
02806 };
02807 
02808 class AbelianHomIsAuto  : public Supervisor
02809 {
02810 public:
02811 
02812   /////////////////////////////////////////////////////////////////////////
02813   //                                                                     //
02814   // Constructors:                                                       //
02815   //                                                                     //
02816   /////////////////////////////////////////////////////////////////////////
02817 
02818   AbelianHomIsAuto(class SMHomomorphism& homo);
02819 
02820   /////////////////////////////////////////////////////////////////////////
02821   //                                                                     //
02822   // Front End Interfacing:                                              //
02823   //                                                                     //
02824   /////////////////////////////////////////////////////////////////////////
02825 
02826   void viewStructure(ostream& ostr) const;  // overrides SMObject
02827 
02828   /////////////////////////////////////////////////////////////////////////
02829   //                                                                     //
02830   // Control:                                                            //
02831   //                                                                     //
02832   /////////////////////////////////////////////////////////////////////////
02833 
02834   void takeControl( );         // overrides ComputationManager
02835 
02836   /////////////////////////////////////////////////////////////////////////
02837   //                                                                     //
02838   // State Transitions:                                                  //
02839   //                                                                     //
02840   /////////////////////////////////////////////////////////////////////////
02841 
02842   void start( ) { };          // overrides ComputationManager
02843 
02844   void terminate( ) { };      // overrides ComputationManager
02845 
02846 
02847 private:
02848 
02849   /////////////////////////////////////////////////////////////////////////
02850   //                                                                     //
02851   // Data Members:                                                       //
02852   //                                                                     //
02853   /////////////////////////////////////////////////////////////////////////
02854 
02855   SMHomomorphism& theHomo;
02856 
02857   MirrorSubordinate abelianHomIsEpi;
02858 };
02859 
02860 class AbelianHomIsIso  : public Supervisor
02861 {
02862 public:
02863 
02864   /////////////////////////////////////////////////////////////////////////
02865   //                                                                     //
02866   // Constructors:                                                       //
02867   //                                                                     //
02868   /////////////////////////////////////////////////////////////////////////
02869 
02870   AbelianHomIsIso(class SMHomomorphism2& homo);
02871 
02872   /////////////////////////////////////////////////////////////////////////
02873   //                                                                     //
02874   // Front End Interfacing:                                              //
02875   //                                                                     //
02876   /////////////////////////////////////////////////////////////////////////
02877 
02878   void viewStructure(ostream& ostr) const;  // overrides SMObject
02879 
02880   /////////////////////////////////////////////////////////////////////////
02881   //                                                                     //
02882   // Control:                                                            //
02883   //                                                                     //
02884   /////////////////////////////////////////////////////////////////////////
02885 
02886   void takeControl( );         // overrides ComputationManager
02887 
02888   /////////////////////////////////////////////////////////////////////////
02889   //                                                                     //
02890   // State Transitions:                                                  //
02891   //                                                                     //
02892   /////////////////////////////////////////////////////////////////////////
02893 
02894   void start( ) { };          // overrides ComputationManager
02895 
02896   void terminate( ) { };      // overrides ComputationManager
02897 
02898 
02899 private:
02900 
02901   /////////////////////////////////////////////////////////////////////////
02902   //                                                                     //
02903   // Data Members:                                                       //
02904   //                                                                     //
02905   /////////////////////////////////////////////////////////////////////////
02906 
02907   SMHomomorphism2& theHomo;
02908   bool abRangeDone;
02909   bool abDomainDone;
02910 
02911   MirrorSubordinate abelianHomIsMono;
02912   MirrorSubordinate abelianHomIsEpi;
02913   MirrorSubordinate abelianInvariants1;
02914   MirrorSubordinate abelianInvariants2;
02915 };
02916 
02917 // ---------------------- AbelianOrderOfAutoARCer --------------------------- //
02918 
02919 
02920 class AbelianOrderOfAutoARCer : public ARCer
02921 {
02922 public:
02923 
02924   /////////////////////////////////////////////////////////////////////////
02925   //                                                                     //
02926   // Constructors:                                                       //
02927   //                                                                     //
02928   /////////////////////////////////////////////////////////////////////////
02929 
02930   AbelianOrderOfAutoARCer( ComputationManager& boss ) 
02931     : ARCer( boss ), AG( 0 ), result(0) { } 
02932 
02933   ~AbelianOrderOfAutoARCer( ) { delete AG; } 
02934 
02935 
02936   /////////////////////////////////////////////////////////////////////////
02937   //                                                                     //
02938   // Accessors:                                                          //
02939   //                                                                     //
02940   /////////////////////////////////////////////////////////////////////////
02941 
02942   void setArguments( const AbelianGroup& group, const VectorOf<Word>& image);
02943 
02944   // Inherited from ARCer:
02945   // bool takeControl( );
02946 
02947   int getOrder() const {return result;}
02948   
02949   
02950   /////////////////////////////////////////////////////////////////////////
02951   //                                                                     //
02952   // IPC interaction members:                                            //
02953   //                                                                     //
02954   /////////////////////////////////////////////////////////////////////////
02955 
02956   void runComputation( );
02957  
02958   void writeResults( ostream& );
02959 
02960   void readResults( istream& );
02961 
02962 
02963 private:
02964 
02965   /////////////////////////////////////////////////////////////////////////
02966   //                                                                     //
02967   // Data Members:                                                       //
02968   //                                                                     //
02969   /////////////////////////////////////////////////////////////////////////
02970 
02971   AbelianGroup* AG;
02972   VectorOf<Word> theImages;
02973   int result;
02974 };
02975 // ---------------------- AbelianOrderOfAuto --------------------------- //
02976 
02977 class AbelianOrderOfAuto  : public Supervisor
02978 {
02979 public:
02980 
02981   /////////////////////////////////////////////////////////////////////////
02982   //                                                                     //
02983   // Constructors:                                                       //
02984   //                                                                     //
02985   /////////////////////////////////////////////////////////////////////////
02986 
02987   AbelianOrderOfAuto(const class SMHomomorphism& );
02988 
02989   /////////////////////////////////////////////////////////////////////////
02990   //                                                                     //
02991   // Front End Interfacing:                                              //
02992   //                                                                     //
02993   /////////////////////////////////////////////////////////////////////////
02994 
02995   void viewStructure(ostream& ostr) const;  // overrides SMObject
02996 
02997   /////////////////////////////////////////////////////////////////////////
02998   //                                                                     //
02999   // Control:                                                            //
03000   //                                                                     //
03001   /////////////////////////////////////////////////////////////////////////
03002 
03003   void takeControl( );         // overrides ComputationManager
03004 
03005   /////////////////////////////////////////////////////////////////////////
03006   //                                                                     //
03007   // State Transitions:                                                  //
03008   //                                                                     //
03009   /////////////////////////////////////////////////////////////////////////
03010 
03011   void start( ) { };          // overrides ComputationManager
03012 
03013   void terminate( ) { };      // overrides ComputationManager
03014 
03015 
03016 private:
03017 
03018   /////////////////////////////////////////////////////////////////////////
03019   //                                                                     //
03020   // Data Members:                                                       //
03021   //                                                                     //
03022   /////////////////////////////////////////////////////////////////////////
03023 
03024   const class SMHomomorphism& theAuto;
03025   MirrorSubordinate abelianInvariants;
03026   AbelianOrderOfAutoARCer arcer;
03027   bool started;
03028 };
03029 // ---------------------- AbelianInverseAutoARCer --------------------------- //
03030 
03031 
03032 class AbelianInverseAutoARCer : public ARCer
03033 {
03034 public:
03035 
03036   /////////////////////////////////////////////////////////////////////////
03037   //                                                                     //
03038   // Constructors:                                                       //
03039   //                                                                     //
03040   /////////////////////////////////////////////////////////////////////////
03041 
03042   AbelianInverseAutoARCer( ComputationManager& boss ) 
03043     : ARCer( boss ), AG( 0 ), result(0) { } 
03044 
03045   ~AbelianInverseAutoARCer( ) { delete AG; } 
03046 
03047 
03048   /////////////////////////////////////////////////////////////////////////
03049   //                                                                     //
03050   // Accessors:                                                          //
03051   //                                                                     //
03052   /////////////////////////////////////////////////////////////////////////
03053 
03054   void setArguments( const AbelianGroup& group, const VectorOf<Word>& image);
03055 
03056   // Inherited from ARCer:
03057   // bool takeControl( );
03058 
03059   const VectorOf<Word> getInverse() const {return result;}
03060   
03061   
03062   /////////////////////////////////////////////////////////////////////////
03063   //                                                                     //
03064   // IPC interaction members:                                            //
03065   //                                                                     //
03066   /////////////////////////////////////////////////////////////////////////
03067 
03068   void runComputation( );
03069  
03070   void writeResults( ostream& );
03071 
03072   void readResults( istream& );
03073 
03074 
03075 private:
03076 
03077   /////////////////////////////////////////////////////////////////////////
03078   //                                                                     //
03079   // Data Members:                                                       //
03080   //                                                                     //
03081   /////////////////////////////////////////////////////////////////////////
03082 
03083   AbelianGroup* AG;
03084   VectorOf<Word> theImages;
03085   VectorOf<Word> result;
03086 };
03087 // ---------------------- AbelianInverseAuto --------------------------- //
03088 
03089 class AbelianInverseAuto  : public Supervisor
03090 {
03091 public:
03092 
03093   /////////////////////////////////////////////////////////////////////////
03094   //                                                                     //
03095   // Constructors:                                                       //
03096   //                                                                     //
03097   /////////////////////////////////////////////////////////////////////////
03098 
03099   AbelianInverseAuto(const class SMHomomorphism& );
03100 
03101   /////////////////////////////////////////////////////////////////////////
03102   //                                                                     //
03103   // Front End Interfacing:                                              //
03104   //                                                                     //
03105   /////////////////////////////////////////////////////////////////////////
03106 
03107   void viewStructure(ostream& ostr) const;  // overrides SMObject
03108 
03109   /////////////////////////////////////////////////////////////////////////
03110   //                                                                     //
03111   // Control:                                                            //
03112   //                                                                     //
03113   /////////////////////////////////////////////////////////////////////////
03114 
03115   void takeControl( );         // overrides ComputationManager
03116 
03117   /////////////////////////////////////////////////////////////////////////
03118   //                                                                     //
03119   // State Transitions:                                                  //
03120   //                                                                     //
03121   /////////////////////////////////////////////////////////////////////////
03122 
03123   void start( ) { };          // overrides ComputationManager
03124 
03125   void terminate( ) { };      // overrides ComputationManager
03126 
03127 
03128 private:
03129 
03130   /////////////////////////////////////////////////////////////////////////
03131   //                                                                     //
03132   // Data Members:                                                       //
03133   //                                                                     //
03134   /////////////////////////////////////////////////////////////////////////
03135 
03136   const class SMHomomorphism& theAuto;
03137   AbelianInverseAutoARCer arcer;
03138 };
03139 
03140 
03141 // ---------------------AbelianFixedPointsOfAutoARCer----------------------- //
03142 
03143 class AbelianFixedPointsOfAutoARCer : public ARCer
03144 {
03145 public:
03146 
03147   /////////////////////////////////////////////////////////////////////////
03148   //                                                                     //
03149   // Constructors:                                                       //
03150   //                                                                     //
03151   /////////////////////////////////////////////////////////////////////////
03152 
03153   AbelianFixedPointsOfAutoARCer( ComputationManager& boss ) 
03154     : ARCer( boss ), 
03155       A( FPGroup() ),
03156       result( ) 
03157     { } 
03158 
03159   /////////////////////////////////////////////////////////////////////////
03160   //                                                                     //
03161   // Accessors:                                                          //
03162   //                                                                     //
03163   /////////////////////////////////////////////////////////////////////////
03164 
03165   void setArguments( const AbelianGroup& , const VectorOf<Word>& );
03166 
03167   // Inherited from ARCer:
03168   // bool takeControl( );
03169 
03170   const VectorOf<Word> getResult( ) const 
03171     { return result; }
03172   
03173   /////////////////////////////////////////////////////////////////////////
03174   //                                                                     //
03175   // IPC interaction members:                                            //
03176   //                                                                     //
03177   /////////////////////////////////////////////////////////////////////////
03178 
03179   void runComputation( );
03180  
03181   void writeResults( ostream& );
03182 
03183   void readResults( istream& );
03184 
03185 
03186 private:
03187 
03188   /////////////////////////////////////////////////////////////////////////
03189   //                                                                     //
03190   // Data Members:                                                       //
03191   //                                                                     //
03192   /////////////////////////////////////////////////////////////////////////
03193 
03194   AbelianGroup A;
03195   VectorOf<Word> theImages;
03196   VectorOf<Word> result;
03197 };
03198 
03199 //-----------------------AbelianFixedPointsOfAutoProblem-------------------- //
03200 
03201 class AbelianFixedPointsOfAutoProblem  : public Supervisor
03202 {
03203 public:
03204 
03205   /////////////////////////////////////////////////////////////////////////
03206   //                                                                     //
03207   // Constructors:                                                       //
03208   //                                                                     //
03209   /////////////////////////////////////////////////////////////////////////
03210 
03211   AbelianFixedPointsOfAutoProblem(const class SMHomomorphism& );
03212   
03213   /////////////////////////////////////////////////////////////////////////
03214   //                                                                     //
03215   // Front End Interfacing:                                              //
03216   //                                                                     //
03217   /////////////////////////////////////////////////////////////////////////
03218 
03219   void viewStructure(ostream& ostr) const;  // overrides SMObject
03220 
03221   /////////////////////////////////////////////////////////////////////////
03222   //                                                                     //
03223   // Control:                                                            //
03224   //                                                                     //
03225   /////////////////////////////////////////////////////////////////////////
03226 
03227   void takeControl( );         // overrides ComputationManager
03228 
03229   /////////////////////////////////////////////////////////////////////////
03230   //                                                                     //
03231   // State Transitions:                                                  //
03232   //                                                                     //
03233   /////////////////////////////////////////////////////////////////////////
03234 
03235   void start( ) { };          // overrides ComputationManager
03236 
03237   void terminate( ) { };      // overrides ComputationManager
03238 
03239 
03240 private:
03241 
03242   /////////////////////////////////////////////////////////////////////////
03243   //                                                                     //
03244   // Data Members:                                                       //
03245   //                                                                     //
03246   /////////////////////////////////////////////////////////////////////////
03247 
03248   const class SMHomomorphism& theAuto;
03249 
03250   AbelianFixedPointsOfAutoARCer arcer;
03251 };
03252 
03253 // ---------------------- AbelianSGIntersectionARCer ----------------------- //
03254 
03255 class AbelianSGIntersectionARCer : public ARCer
03256 {
03257 public:
03258 
03259   /////////////////////////////////////////////////////////////////////////
03260   //                                                                     //
03261   // Constructors:                                                       //
03262   //                                                                     //
03263   /////////////////////////////////////////////////////////////////////////
03264 
03265   AbelianSGIntersectionARCer( ComputationManager& boss ) 
03266     : ARCer( boss ), 
03267       A( FPGroup() ),
03268       s1( ),
03269       s2( ),
03270       result( ),
03271       file( )
03272     { } 
03273 
03274   /////////////////////////////////////////////////////////////////////////
03275   //                                                                     //
03276   // Accessors:                                                          //
03277   //                                                                     //
03278   /////////////////////////////////////////////////////////////////////////
03279   
03280   void setArguments( const AbelianGroup& g, 
03281                      const VectorOf<Word>& v1,
03282                      const VectorOf<Word>& v2);
03283   
03284   // Inherited from ARCer:
03285   // bool takeControl( );
03286   
03287   VectorOf<Word> getResult() const 
03288     { 
03289       return result; 
03290     }
03291   
03292   Chars getFileName() const
03293     { 
03294       return file.getFileName(); 
03295     }
03296   
03297   /////////////////////////////////////////////////////////////////////////
03298   //                                                                     //
03299   // IPC interaction members:                                            //
03300   //                                                                     //
03301   /////////////////////////////////////////////////////////////////////////
03302   
03303   void runComputation( );
03304  
03305   void writeResults( ostream& );
03306 
03307   void readResults( istream& );
03308   
03309   
03310 private:
03311 
03312   /////////////////////////////////////////////////////////////////////////
03313   //                                                                     //
03314   // Data Members:                                                       //
03315   //                                                                     //
03316   /////////////////////////////////////////////////////////////////////////
03317 
03318   AbelianGroup A;
03319   
03320   VectorOf<Word> s1;
03321   VectorOf<Word> s2;
03322   
03323   VectorOf<Word> result;
03324   File file;
03325 };
03326 // -------------------- AbelianSGIntersectionProblem ----------------------- //
03327 
03328 class AbelianSGIntersectionProblem : public Supervisor
03329 {
03330 public:
03331 
03332   /////////////////////////////////////////////////////////////////////////
03333   //                                                                     //
03334   // Constructors:                                                       //
03335   //                                                                     //
03336   /////////////////////////////////////////////////////////////////////////
03337 
03338   AbelianSGIntersectionProblem(class SMSubgroup& S1, class SMSubgroup& S2);
03339   
03340   /////////////////////////////////////////////////////////////////////////
03341   //                                                                     //
03342   // Accessors:                                                          //
03343   //                                                                     //
03344   /////////////////////////////////////////////////////////////////////////
03345 
03346   /////////////////////////////////////////////////////////////////////////
03347   //                                                                     //
03348   // Front End Interfacing:                                              //
03349   //                                                                     //
03350   /////////////////////////////////////////////////////////////////////////
03351 
03352   void viewStructure(ostream& ostr) const;  // overrides SMObject
03353 
03354   /////////////////////////////////////////////////////////////////////////
03355   //                                                                     //
03356   // Control:                                                            //
03357   //                                                                     //
03358   /////////////////////////////////////////////////////////////////////////
03359   
03360   void takeControl( );         // overrides ComputationManager
03361 
03362   /////////////////////////////////////////////////////////////////////////
03363   //                                                                     //
03364   // State Transitions:                                                  //
03365   //                                                                     //
03366   /////////////////////////////////////////////////////////////////////////
03367 
03368   void start( ) { };          // overrides ComputationManager
03369   
03370   void terminate( ) { };      // overrides ComputationManager
03371   
03372 
03373 private:
03374 
03375   /////////////////////////////////////////////////////////////////////////
03376   //                                                                     //
03377   // Data Members:                                                       //
03378   //                                                                     //
03379   /////////////////////////////////////////////////////////////////////////
03380 
03381   SMSubgroup& subgroup1;
03382   SMSubgroup& subgroup2;
03383   
03384   bool init;
03385   
03386   MirrorSubordinate abelianInvariants;
03387 
03388   AbelianSGIntersectionARCer arcer;
03389 };
03390 
03391 // ------------------------ AbelianIntegralHomologyARCer -------------------------- //
03392 
03393 class AbelianIntegralHomologyARCer : public ARCer
03394 {
03395 public:
03396 
03397   /////////////////////////////////////////////////////////////////////////
03398   //                                                                     //
03399   // Constructors:                                                       //
03400   //                                                                     //
03401   /////////////////////////////////////////////////////////////////////////
03402 
03403   AbelianIntegralHomologyARCer( ComputationManager& boss ) 
03404     : ARCer( boss ), 
03405       A( FPGroup() ),
03406       d( 0 ),
03407       result( FPGroup() )
03408     { } 
03409 
03410   /////////////////////////////////////////////////////////////////////////
03411   //                                                                     //
03412   // Accessors:                                                          //
03413   //                                                                     //
03414   /////////////////////////////////////////////////////////////////////////
03415   
03416   void setArguments( const AbelianGroup& g, int n );
03417   
03418   // Inherited from ARCer:
03419   // bool takeControl( );
03420   
03421   AbelianGroup getResult() const 
03422     { 
03423       return result; 
03424     }
03425   
03426   /////////////////////////////////////////////////////////////////////////
03427   //                                                                     //
03428   // IPC interaction members:                                            //
03429   //                                                                     //
03430   /////////////////////////////////////////////////////////////////////////
03431   
03432   void runComputation( );
03433  
03434   void writeResults( ostream& );
03435 
03436   void readResults( istream& );
03437   
03438   
03439 private:
03440 
03441   /////////////////////////////////////////////////////////////////////////
03442   //                                                                     //
03443   // Data Members:                                                       //
03444   //                                                                     //
03445   /////////////////////////////////////////////////////////////////////////
03446 
03447   AbelianGroup A;
03448   int d;
03449     
03450   AbelianGroup result;
03451 };
03452 
03453 // ----------------------- AbelianIntegralHomologyProblem -------------------------- //
03454 
03455 class AbelianIntegralHomologyProblem : public Supervisor
03456 {
03457 public:
03458 
03459   /////////////////////////////////////////////////////////////////////////
03460   //                                                                     //
03461   // Constructors:                                                       //
03462   //                                                                     //
03463   /////////////////////////////////////////////////////////////////////////
03464 
03465   AbelianIntegralHomologyProblem( class SMFPGroup& G, int n = 2 );
03466   
03467   /////////////////////////////////////////////////////////////////////////
03468   //                                                                     //
03469   // Accessors:                                                          //
03470   //                                                                     //
03471   /////////////////////////////////////////////////////////////////////////
03472 
03473   /////////////////////////////////////////////////////////////////////////
03474   //                                                                     //
03475   // Front End Interfacing:                                              //
03476   //                                                                     //
03477   /////////////////////////////////////////////////////////////////////////
03478 
03479   void viewStructure(ostream& ostr) const;  // overrides SMObject
03480 
03481   /////////////////////////////////////////////////////////////////////////
03482   //                                                                     //
03483   // Control:                                                            //
03484   //                                                                     //
03485   /////////////////////////////////////////////////////////////////////////
03486   
03487   void takeControl( );         // overrides ComputationManager
03488 
03489   /////////////////////////////////////////////////////////////////////////
03490   //                                                                     //
03491   // State Transitions:                                                  //
03492   //                                                                     //
03493   /////////////////////////////////////////////////////////////////////////
03494 
03495   void start( ) { };          // overrides ComputationManager
03496   
03497   void terminate( ) { };      // overrides ComputationManager
03498   
03499 
03500 private:
03501 
03502   /////////////////////////////////////////////////////////////////////////
03503   //                                                                     //
03504   // Data Members:                                                       //
03505   //                                                                     //
03506   /////////////////////////////////////////////////////////////////////////
03507 
03508   SMFPGroup& theGroup;
03509   bool init;
03510   int d;
03511   
03512   MirrorSubordinate abelianInvariants;
03513   
03514   AbelianIntegralHomologyARCer arcer;
03515 };
03516 
03517 
03518 #endif
03519 
03520 

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