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

/magnus/back_end/SMApps/include/AbelianInvariants.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: AbelianInvariants.h,v 1.1.1.1 1996/12/05 19:45:08 bormotov 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 _ABELIANINVARIANTS_H_
00020 #define _ABELIANINVARIANTS_H_
00021 
00022 
00023 #include "Supervisor.h"
00024 #include "AbelianGroup.h"
00025 #include "ARCer.h"
00026 
00027 
00028 // ---------------------- AbelianInvariantsARCer --------------------------- //
00029 
00030 
00031 class AbelianInvariantsARCer : public ARCer
00032 {
00033 public:
00034 
00035   /////////////////////////////////////////////////////////////////////////
00036   //                                                                     //
00037   // Constructors:                                                       //
00038   //                                                                     //
00039   /////////////////////////////////////////////////////////////////////////
00040 
00041   AbelianInvariantsARCer( ComputationManager& boss ) 
00042     : ARCer( boss ), AG( 0 ) { } 
00043 
00044   ~AbelianInvariantsARCer( ) { delete AG; } 
00045 
00046 
00047   /////////////////////////////////////////////////////////////////////////
00048   //                                                                     //
00049   // Accessors:                                                          //
00050   //                                                                     //
00051   /////////////////////////////////////////////////////////////////////////
00052 
00053   void setArguments( const FPGroup&, bool );
00054 
00055   // Inherited from ARCer:
00056   // bool takeControl( );
00057 
00058   AbelianGroup getCyclicDecomposition();
00059   
00060   
00061   /////////////////////////////////////////////////////////////////////////
00062   //                                                                     //
00063   // IPC interaction members:                                            //
00064   //                                                                     //
00065   /////////////////////////////////////////////////////////////////////////
00066 
00067   void runComputation( );
00068  
00069   void writeResults( ostream& );
00070 
00071   void readResults( istream& );
00072 
00073 
00074 private:
00075 
00076   /////////////////////////////////////////////////////////////////////////
00077   //                                                                     //
00078   // Data Members:                                                       //
00079   //                                                                     //
00080   /////////////////////////////////////////////////////////////////////////
00081 
00082   FPGroup G;
00083 
00084   bool bMakeFile;
00085 
00086   AbelianGroup* AG;
00087 };
00088 
00089 
00090 // -------------------------- AbelianInvariants ---------------------------- //
00091 
00092 
00093 class AbelianInvariants : public ComputationManager
00094 {
00095 public:
00096 
00097   /////////////////////////////////////////////////////////////////////////
00098   //                                                                     //
00099   // Constructors:                                                       //
00100   //                                                                     //
00101   /////////////////////////////////////////////////////////////////////////
00102 
00103   AbelianInvariants(class GCM& gcm);
00104 
00105 
00106   /////////////////////////////////////////////////////////////////////////
00107   //                                                                     //
00108   // Accessors:                                                          //
00109   //                                                                     //
00110   /////////////////////////////////////////////////////////////////////////
00111 
00112   /////////////////////////////////////////////////////////////////////////
00113   //                                                                     //
00114   // Control:                                                            //
00115   //                                                                     //
00116   /////////////////////////////////////////////////////////////////////////
00117 
00118   void takeControl( );         // overrides ComputationManager
00119 
00120 
00121   /////////////////////////////////////////////////////////////////////////
00122   //                                                                     //
00123   // State Transitions:                                                  //
00124   //                                                                     //
00125   /////////////////////////////////////////////////////////////////////////
00126 
00127   void start( ) { };          // overrides ComputationManager
00128 
00129   void terminate( ) { };      // overrides ComputationManager
00130 
00131 
00132 private:
00133 
00134   /////////////////////////////////////////////////////////////////////////
00135   //                                                                     //
00136   // Data Members:                                                       //
00137   //                                                                     //
00138   /////////////////////////////////////////////////////////////////////////
00139 
00140   class GCM& theGCM;
00141   
00142   AbelianInvariantsARCer arcer;
00143 };
00144 
00145 
00146 // ---------------------- AbelianInvariantsOfFactor ------------------------ //
00147 
00148 
00149 class AbelianInvariantsOfFactor : public ComputationManager
00150 {
00151 public:
00152 
00153   /////////////////////////////////////////////////////////////////////////
00154   //                                                                     //
00155   // Constructors:                                                       //
00156   //                                                                     //
00157   /////////////////////////////////////////////////////////////////////////
00158 
00159   AbelianInvariantsOfFactor(class SCM& scm);
00160 
00161 
00162   /////////////////////////////////////////////////////////////////////////
00163   //                                                                     //
00164   // Accessors:                                                          //
00165   //                                                                     //
00166   /////////////////////////////////////////////////////////////////////////
00167 
00168   /////////////////////////////////////////////////////////////////////////
00169   //                                                                     //
00170   // Control:                                                            //
00171   //                                                                     //
00172   /////////////////////////////////////////////////////////////////////////
00173 
00174   void takeControl( );         // overrides ComputationManager
00175 
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   class SCM& theSCM;
00197 
00198   AbelianInvariantsARCer arcer;
00199 };
00200 
00201 
00202 // ------------------------- AbelInvariantsProb ---------------------------- //
00203 
00204 
00205 class AbelInvariantsProb : public Supervisor
00206 {
00207 public:
00208 
00209   /////////////////////////////////////////////////////////////////////////
00210   //                                                                     //
00211   // Constructors:                                                       //
00212   //                                                                     //
00213   /////////////////////////////////////////////////////////////////////////
00214 
00215   AbelInvariantsProb(class SMFPGroup& G);
00216 
00217   /////////////////////////////////////////////////////////////////////////
00218   //                                                                     //
00219   // Front End Interfacing:                                              //
00220   //                                                                     //
00221   /////////////////////////////////////////////////////////////////////////
00222 
00223   void viewStructure(ostream& ostr) const;  // overrides SMObject
00224 
00225   /////////////////////////////////////////////////////////////////////////
00226   //                                                                     //
00227   // Control:                                                            //
00228   //                                                                     //
00229   /////////////////////////////////////////////////////////////////////////
00230 
00231   void takeControl( );         // overrides ComputationManager
00232 
00233   /////////////////////////////////////////////////////////////////////////
00234   //                                                                     //
00235   // State Transitions:                                                  //
00236   //                                                                     //
00237   /////////////////////////////////////////////////////////////////////////
00238 
00239   void start( ) { };          // overrides ComputationManager
00240 
00241   void terminate( ) { };      // overrides ComputationManager
00242 
00243 
00244 private:
00245 
00246   /////////////////////////////////////////////////////////////////////////
00247   //                                                                     //
00248   // Data Members:                                                       //
00249   //                                                                     //
00250   /////////////////////////////////////////////////////////////////////////
00251 
00252   SMFPGroup& theGroup;
00253 
00254   MirrorSubordinate abelianInvariants;
00255 
00256 };
00257 
00258 
00259 // -------------------------- AbelianRank ---------------------------------- //
00260 
00261 
00262 class AbelianRank : public ComputationManager
00263 {
00264 public:
00265 
00266   /////////////////////////////////////////////////////////////////////////
00267   //                                                                     //
00268   // Constructors:                                                       //
00269   //                                                                     //
00270   /////////////////////////////////////////////////////////////////////////
00271 
00272   AbelianRank(class GCM& gcm);
00273 
00274   ~AbelianRank( );
00275 
00276   /////////////////////////////////////////////////////////////////////////
00277   //                                                                     //
00278   // Control:                                                            //
00279   //                                                                     //
00280   /////////////////////////////////////////////////////////////////////////
00281 
00282   void takeControl( );         // overrides ComputationManager
00283 
00284   /////////////////////////////////////////////////////////////////////////
00285   //                                                                     //
00286   // State Transitions:                                                  //
00287   //                                                                     //
00288   /////////////////////////////////////////////////////////////////////////
00289 
00290   void start( );              // overrides ComputationManager
00291 
00292   void terminate( ) { };      // overrides ComputationManager
00293 
00294 
00295 private:
00296 
00297   /////////////////////////////////////////////////////////////////////////
00298   //                                                                     //
00299   // Data Members:                                                       //
00300   //                                                                     //
00301   /////////////////////////////////////////////////////////////////////////
00302 
00303   SMFPGroup& theGroup;
00304 
00305   class AbelianInfinitenessProblem* theProb;
00306 
00307 };
00308 
00309 // ------------------ Abelian Primary Decomposition -------------------------//
00310 
00311 // ---------------------- AbelianPrimesARCer --------------------------- //
00312 
00313 
00314 class AbelianPrimesARCer : public ARCer
00315 {
00316 public:
00317 
00318   /////////////////////////////////////////////////////////////////////////
00319   //                                                                     //
00320   // Constructors:                                                       //
00321   //                                                                     //
00322   /////////////////////////////////////////////////////////////////////////
00323 
00324   AbelianPrimesARCer( ComputationManager& boss ) 
00325     : ARCer( boss ), AG( 0 ) { } 
00326 
00327   ~AbelianPrimesARCer( ) { delete AG; } 
00328 
00329 
00330   /////////////////////////////////////////////////////////////////////////
00331   //                                                                     //
00332   // Accessors:                                                          //
00333   //                                                                     //
00334   /////////////////////////////////////////////////////////////////////////
00335 
00336   void setArguments( const AbelianGroup& );
00337 
00338   // Inherited from ARCer:
00339   // bool takeControl( );
00340 
00341   AbelianGroup getPrimaryDecomposition();
00342   
00343   
00344   /////////////////////////////////////////////////////////////////////////
00345   //                                                                     //
00346   // IPC interaction members:                                            //
00347   //                                                                     //
00348   /////////////////////////////////////////////////////////////////////////
00349 
00350   void runComputation( );
00351  
00352   void writeResults( ostream& );
00353 
00354   void readResults( istream& );
00355 
00356 
00357 private:
00358 
00359   /////////////////////////////////////////////////////////////////////////
00360   //                                                                     //
00361   // Data Members:                                                       //
00362   //                                                                     //
00363   /////////////////////////////////////////////////////////////////////////
00364 
00365   FPGroup G;
00366 
00367   bool bMakeFile;
00368 
00369   AbelianGroup* AG;
00370 };
00371 
00372 class AbelianPrimes : public ComputationManager
00373 {
00374 public:
00375 
00376   /////////////////////////////////////////////////////////////////////////
00377   //                                                                     //
00378   // Constructors:                                                       //
00379   //                                                                     //
00380   /////////////////////////////////////////////////////////////////////////
00381 
00382    AbelianPrimes(class GCM& gcm);
00383 
00384   /////////////////////////////////////////////////////////////////////////
00385   //                                                                     //
00386   // Accessors:                                                          //
00387   //                                                                     //
00388   /////////////////////////////////////////////////////////////////////////
00389 
00390   /////////////////////////////////////////////////////////////////////////
00391   //                                                                     //
00392   // Control:                                                            //
00393   //                                                                     //
00394   /////////////////////////////////////////////////////////////////////////
00395 
00396   void takeControl( );         // overrides ComputationManager
00397 
00398 
00399   /////////////////////////////////////////////////////////////////////////
00400   //                                                                     //
00401   // State Transitions:                                                  //
00402   //                                                                     //
00403   /////////////////////////////////////////////////////////////////////////
00404 
00405   void start( ) { };          // overrides ComputationManager
00406 
00407   void terminate( ) { };      // overrides ComputationManager
00408 
00409 
00410 private:
00411 
00412   /////////////////////////////////////////////////////////////////////////
00413   //                                                                     //
00414   // Data Members:                                                       //
00415   //                                                                     //
00416   /////////////////////////////////////////////////////////////////////////
00417 
00418    class GCM& theGCM;
00419    AbelianPrimesARCer A;
00420    bool primesStarted;
00421 
00422 };
00423 
00424 class AbelianPrimeDecomp : public Supervisor
00425 {
00426 public:
00427 
00428   /////////////////////////////////////////////////////////////////////////
00429   //                                                                     //
00430   // Constructors:                                                       //
00431   //                                                                     //
00432   /////////////////////////////////////////////////////////////////////////
00433 
00434   AbelianPrimeDecomp(class SMFPGroup& smg);
00435 
00436   /////////////////////////////////////////////////////////////////////////
00437   //                                                                     //
00438   // Front End Interfacing:                                              //
00439   //                                                                     //
00440   /////////////////////////////////////////////////////////////////////////
00441 
00442   void viewStructure(ostream& ostr) const;  // overrides SMObject
00443 
00444   /////////////////////////////////////////////////////////////////////////
00445   //                                                                     //
00446   // Control:                                                            //
00447   //                                                                     //
00448   /////////////////////////////////////////////////////////////////////////
00449 
00450   void takeControl( );         // overrides ComputationManager
00451 
00452   /////////////////////////////////////////////////////////////////////////
00453   //                                                                     //
00454   // State Transitions:                                                  //
00455   //                                                                     //
00456   /////////////////////////////////////////////////////////////////////////
00457 
00458   void start( ) { };          // overrides ComputationManager
00459 
00460   void terminate( ) { };      // overrides ComputationManager
00461 
00462 
00463 private:
00464 
00465   /////////////////////////////////////////////////////////////////////////
00466   //                                                                     //
00467   // Data Members:                                                       //
00468   //                                                                     //
00469   /////////////////////////////////////////////////////////////////////////
00470 
00471   SMFPGroup& theGroup;
00472 
00473   MirrorSubordinate abelianPrimes;
00474   MirrorSubordinate abelianInvariants;
00475   bool abDone;
00476 
00477 };
00478 
00479 #endif
00480 
00481 

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