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

/magnus/back_end/SMApps/include/QuadEquationSolver.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: QuadEquationSolver.h,v 1.2 1997/06/30 20:09:40 bormotov Exp $
00003  */
00004 
00005 // Copyright (C) 1995 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 
00008 // Contents: Declarations of classes 
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Revision History:
00015 //
00016 
00017 
00018 #ifndef _QuadEquationSolver_h_
00019 #define _QuadEquationSolver_h_
00020 
00021 
00022 #include "Supervisor.h"
00023 #include "SMEquation.h"
00024 #include "File.h"
00025 #include "LogWatcher.h"
00026 #include "fastProblems.h"
00027 
00028 class EquationSolverARCer : public ARCer
00029 {
00030 public:
00031 
00032   /////////////////////////////////////////////////////////////////////////
00033   //                                                                     //
00034   // Constructors:                                                       //
00035   //                                                                     //
00036   /////////////////////////////////////////////////////////////////////////
00037 
00038   EquationSolverARCer( ComputationManager& boss ) : ARCer( boss ) { } 
00039 
00040 
00041   /////////////////////////////////////////////////////////////////////////
00042   //                                                                     //
00043   // Accessors:                                                          //
00044   //                                                                     //
00045   /////////////////////////////////////////////////////////////////////////
00046 
00047   void setArguments( class SMEquation& eq, 
00048                      const Chars& aBasicFileName, const Chars& aStabFileName,
00049                      bool workOnBasicSolutions, bool workOnStabilizer);
00050 
00051 
00052   int numberOfBasicSolutions( ) const;
00053 
00054   int numberOfRegStabGenerators( ) const;
00055 
00056   // Inherited from ARCer:
00057   // bool takeControl( );
00058 
00059   
00060   /////////////////////////////////////////////////////////////////////////
00061   //                                                                     //
00062   // IPC interaction members:                                            //
00063   //                                                                     //
00064   /////////////////////////////////////////////////////////////////////////
00065 
00066   void runComputation( );
00067   // Overrides ARCer::runComputation().
00068 
00069   void writeResults( ostream& ostr );
00070   void readResults( istream& istr );
00071 
00072 private:
00073 
00074   /////////////////////////////////////////////////////////////////////////
00075   //                                                                     //
00076   // Data Members:                                                       //
00077   //                                                                     //
00078   /////////////////////////////////////////////////////////////////////////
00079 
00080   // class QEqnSolutionsInFreeGroup *solver;
00081   FreeGroup F;
00082   Word word;
00083   int numberOfVariables;
00084   bool workOnBasicSolutions;
00085   bool workOnStabilizer;
00086 
00087   Chars basicFileName;
00088   Chars stabFileName;
00089   int numOfBasicSolutions;
00090   int numOfRegStabGenerators;
00091 };
00092 
00093 
00094 //--------------------------- EquationSolver ------------------------//
00095 
00096 
00097 class EquationSolver : public ComputationManager
00098 {
00099 public:
00100 
00101   /////////////////////////////////////////////////////////////////////////
00102   //                                                                     //
00103   // Constructors:                                                       //
00104   //                                                                     //
00105   /////////////////////////////////////////////////////////////////////////
00106 
00107   EquationSolver( class EquationProblem& equationProblem );
00108 
00109   EquationSolver( class QuickEquationProblem& equationProblem );
00110 
00111   /////////////////////////////////////////////////////////////////////////
00112   //                                                                     //
00113   // Accessors:                                                          //
00114   //                                                                     //
00115   /////////////////////////////////////////////////////////////////////////
00116 
00117   //  SMEquation& equation( ) { return theEquation; }
00118 
00119   /////////////////////////////////////////////////////////////////////////
00120   //                                                                     //
00121   // Control:                                                            //
00122   //                                                                     //
00123   /////////////////////////////////////////////////////////////////////////
00124 
00125   void takeControl( );         // overrides ComputationManager
00126 
00127   /////////////////////////////////////////////////////////////////////////
00128   //                                                                     //
00129   // State Transitions:                                                  //
00130   //                                                                     //
00131   /////////////////////////////////////////////////////////////////////////
00132 
00133   void start( ) { }              // overrides ComputationManager
00134 
00135   void terminate( );          // overrides ComputationManager
00136 
00137   
00138 private:
00139 
00140   void updateBasicSolutions( );
00141   void updateRegStabGenerators( );
00142 
00143   /////////////////////////////////////////////////////////////////////////
00144   //                                                                     //
00145   // Data Members:                                                       //
00146   //                                                                     //
00147   /////////////////////////////////////////////////////////////////////////
00148 
00149   SMEquation& equation;
00150 
00151   Chars basicFileName;
00152   Chars stabFileName;
00153 
00154   LogFileWatcher watchBasicSolutions;
00155   LogFileWatcher watchRegStabGenerators;
00156 
00157   bool workOnBasicSolutions;
00158   bool workOnStabilizer;
00159 
00160   ListOf<Endomorphism> foundBasicSolutions;
00161   ListOf<Automorphism> foundRegStabGenerators;
00162 
00163   EquationSolverARCer arcer;
00164 };
00165 
00166 
00167 // ------------------------------ ------------------------------
00168 
00169 class EquationRandomSolutionARCer : public ARCer
00170 {
00171 public:
00172 
00173   /////////////////////////////////////////////////////////////////////////
00174   //                                                                     //
00175   // Constructors:                                                       //
00176   //                                                                     //
00177   /////////////////////////////////////////////////////////////////////////
00178 
00179   EquationRandomSolutionARCer( ComputationManager& boss ) : ARCer( boss ), equation(0) { } 
00180 
00181 
00182   /////////////////////////////////////////////////////////////////////////
00183   //                                                                     //
00184   // Accessors:                                                          //
00185   //                                                                     //
00186   /////////////////////////////////////////////////////////////////////////
00187 
00188   void setArguments( class SMEquation& eq, const Chars& aRandomFileName,
00189                      const Chars& aBasicFileName, const Chars& aStabFileName );
00190 
00191   // Inherited from ARCer:
00192   // bool takeControl( );
00193 
00194   
00195   /////////////////////////////////////////////////////////////////////////
00196   //                                                                     //
00197   // IPC interaction members:                                            //
00198   //                                                                     //
00199   /////////////////////////////////////////////////////////////////////////
00200 
00201   void runComputation( );
00202   // Overrides ARCer::runComputation().
00203 
00204   void writeResults( ostream& ostr ) { ostr < ' '; }
00205   void readResults( istream& istr ) { }
00206 
00207 private:
00208 
00209   /////////////////////////////////////////////////////////////////////////
00210   //                                                                     //
00211   // Data Members:                                                       //
00212   //                                                                     //
00213   /////////////////////////////////////////////////////////////////////////
00214 
00215   class SMEquation *equation;
00216   Chars randomFileName; // output file.
00217   Chars basicFileName;  // input file from another process.
00218   Chars stabFileName;   // input file from another process.
00219 };
00220 
00221 
00222 //--------------------------- EquationRandomSolutions ------------------------//
00223 
00224 
00225 class EquationRandomSolutions : public ComputationManager
00226 {
00227 public:
00228 
00229   /////////////////////////////////////////////////////////////////////////
00230   //                                                                     //
00231   // Constructors:                                                       //
00232   //                                                                     //
00233   /////////////////////////////////////////////////////////////////////////
00234 
00235   EquationRandomSolutions( class EquationProblem& ep );
00236 
00237   /////////////////////////////////////////////////////////////////////////
00238   //                                                                     //
00239   // Accessors:                                                          //
00240   //                                                                     //
00241   /////////////////////////////////////////////////////////////////////////
00242 
00243   // SMEquation& equation( ) { return theEquation; }
00244 
00245 
00246   /////////////////////////////////////////////////////////////////////////
00247   //                                                                     //
00248   // Control:                                                            //
00249   //                                                                     //
00250   /////////////////////////////////////////////////////////////////////////
00251 
00252   void takeControl( );         // overrides ComputationManager
00253 
00254   /////////////////////////////////////////////////////////////////////////
00255   //                                                                     //
00256   // State Transitions:                                                  //
00257   //                                                                     //
00258   /////////////////////////////////////////////////////////////////////////
00259 
00260   void start( ) { }              // overrides ComputationManager
00261 
00262   void terminate( ) { }          // overrides ComputationManager
00263 
00264   
00265 private:
00266 
00267   /////////////////////////////////////////////////////////////////////////
00268   //                                                                     //
00269   // Data Members:                                                       //
00270   //                                                                     //
00271   /////////////////////////////////////////////////////////////////////////
00272 
00273   EquationRandomSolutionARCer arcer;
00274 };
00275 
00276 
00277 
00278 
00279 
00280 
00281 class EquationProblem : public Supervisor
00282 {
00283 public:
00284 
00285   /////////////////////////////////////////////////////////////////////////
00286   //                                                                     //
00287   // Constructors:                                                       //
00288   //                                                                     //
00289   /////////////////////////////////////////////////////////////////////////
00290 
00291   EquationProblem( class SMEquation& w );
00292 
00293 
00294   /////////////////////////////////////////////////////////////////////////
00295   //                                                                     //
00296   // Accessors:                                                          //
00297   //                                                                     //
00298   /////////////////////////////////////////////////////////////////////////
00299 
00300   SMEquation& getEquation() const { return equation; }
00301 
00302   Chars getBasicSolutionsFileName( ) const { return basicSolutionsFileName; }
00303   
00304   Chars getRegStabGeneratorsFileName( ) const { return regStabGeneratorsFileName; }
00305 
00306   Chars getRandomSolutionsFileName( ) const { return randomSolutionsFileName; }
00307 
00308   /////////////////////////////////////////////////////////////////////////
00309   //                                                                     //
00310   // Front End Interfacing:                                              //
00311   //                                                                     //
00312   /////////////////////////////////////////////////////////////////////////
00313 
00314   void viewStructure(ostream& ostr) const;  // overrides SMObject
00315 
00316 
00317   /////////////////////////////////////////////////////////////////////////
00318   //                                                                     //
00319   // Control:                                                            //
00320   //                                                                     //
00321   /////////////////////////////////////////////////////////////////////////
00322 
00323   void takeControl( );         // overrides ComputationManager
00324 
00325 
00326   /////////////////////////////////////////////////////////////////////////
00327   //                                                                     //
00328   // State Transitions:                                                  //
00329   //                                                                     //
00330   /////////////////////////////////////////////////////////////////////////
00331 
00332   void start( ) { };          // overrides ComputationManager
00333 
00334   void terminate( ) { };      // overrides ComputationManager
00335 
00336 
00337 private:
00338 
00339   /////////////////////////////////////////////////////////////////////////
00340   //                                                                     //
00341   // Data Members:                                                       //
00342   //                                                                     //
00343   /////////////////////////////////////////////////////////////////////////
00344 
00345   SMEquation& equation;
00346  
00347   bool linksSent;
00348   Chars basicSolutionsFileName;
00349   Chars regStabGeneratorsFileName;
00350   Chars randomSolutionsFileName;
00351   
00352   /////////////////////////////////////////////////////////////////////////
00353   //                                                                     //
00354   // Subordinate Computation Managers:                                   //
00355   //                                                                     //
00356   /////////////////////////////////////////////////////////////////////////
00357 
00358   Subordinate<EquationProblem, EquationSolver> basicSubordinate;
00359   Subordinate<EquationProblem, EquationRandomSolutions> randomSubordinate;
00360 
00361 };
00362 
00363 
00364 
00365 class QuickEquationProblem : public Supervisor
00366 {
00367 public:
00368 
00369   /////////////////////////////////////////////////////////////////////////
00370   //                                                                     //
00371   // Constructors:                                                       //
00372   //                                                                     //
00373   /////////////////////////////////////////////////////////////////////////
00374 
00375   QuickEquationProblem( class SMEquation& w );
00376 
00377 
00378   /////////////////////////////////////////////////////////////////////////
00379   //                                                                     //
00380   // Accessors:                                                          //
00381   //                                                                     //
00382   /////////////////////////////////////////////////////////////////////////
00383 
00384   SMEquation& getEquation() const { return equation; }
00385 
00386   Chars getBasicSolutionsFileName( ) const { return basicSolutionsFileName; }
00387   
00388   /////////////////////////////////////////////////////////////////////////
00389   //                                                                     //
00390   // Front End Interfacing:                                              //
00391   //                                                                     //
00392   /////////////////////////////////////////////////////////////////////////
00393 
00394   void viewStructure(ostream& ostr) const;  // overrides SMObject
00395 
00396 
00397   /////////////////////////////////////////////////////////////////////////
00398   //                                                                     //
00399   // Control:                                                            //
00400   //                                                                     //
00401   /////////////////////////////////////////////////////////////////////////
00402 
00403   void takeControl( );         // overrides ComputationManager
00404 
00405 
00406   /////////////////////////////////////////////////////////////////////////
00407   //                                                                     //
00408   // State Transitions:                                                  //
00409   //                                                                     //
00410   /////////////////////////////////////////////////////////////////////////
00411 
00412   void start( ) { };          // overrides ComputationManager
00413 
00414   void terminate( ) { };      // overrides ComputationManager
00415 
00416 
00417 private:
00418 
00419   /////////////////////////////////////////////////////////////////////////
00420   //                                                                     //
00421   // Data Members:                                                       //
00422   //                                                                     //
00423   /////////////////////////////////////////////////////////////////////////
00424 
00425   SMEquation& equation;
00426  
00427   bool linkSent;
00428   Chars basicSolutionsFileName;
00429   
00430   /////////////////////////////////////////////////////////////////////////
00431   //                                                                     //
00432   // Subordinate Computation Managers:                                   //
00433   //                                                                     //
00434   /////////////////////////////////////////////////////////////////////////
00435 
00436   Subordinate<QuickEquationProblem, EquationSolver> basicSubordinate;
00437 
00438 };
00439 
00440 
00441 
00442 ///////////////////// fast problems /////////////////////////////
00443 
00444 class QEquationInFreeBasicSolutions : public FastComputation
00445 {
00446 public:
00447 
00448   QEquationInFreeBasicSolutions(const class SMEquation& e) : equation( e ) { }
00449 
00450   void takeControl( );              // overrides ComputationManager
00451 
00452 private:
00453 
00454   const class SMEquation& equation;
00455 };
00456 
00457 class QEquationInFreeRegStabGenerators : public FastComputation
00458 {
00459 public:
00460 
00461   QEquationInFreeRegStabGenerators(const class SMEquation& e) : equation( e ) { }
00462 
00463   void takeControl( );              // overrides ComputationManager
00464 
00465 private:
00466 
00467   const class SMEquation& equation;
00468 };
00469 
00470 
00471 
00472 #endif

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