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

/magnus/back_end/SMApps/include/OneRelatorProblems.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: OneRelatorProblems.h,v 1.4 1998/03/07 23:06:57 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
00009 //
00010 // Author: 
00011 //
00012 // Status: in progress
00013 //
00014 // Revision History:
00015 //
00016 
00017 #ifndef __ONE_RELATOR_PROBLEMS__
00018 #define __ONE_RELATOR_PROBLEMS__
00019 
00020 #include "fastProblems.h"
00021 
00022 class ORFindHNNPresentation : public FastComputation
00023 {
00024 public:
00025 
00026   ORFindHNNPresentation(const SMFPGroup& G) 
00027     : theGroup( G ), numOfGens(0), stableGen(1), accompGen(1) { }
00028 
00029   ORFindHNNPresentation(const SMFPGroup& G, const Generator& stable) 
00030     : theGroup( G ), numOfGens(1), stableGen(stable), accompGen(1) { }
00031 
00032   ORFindHNNPresentation(const SMFPGroup& G, const Generator& stable, 
00033                         const Generator& accomp) 
00034     : theGroup( G ), numOfGens(2), stableGen(stable), accompGen(accomp) { }
00035 
00036   void takeControl( );              // overrides ComputationManager
00037 
00038 private:
00039 
00040   const SMFPGroup& theGroup;
00041   int numOfGens;
00042   Generator stableGen;
00043   Generator accompGen;
00044 };
00045 
00046 class ORGroup_IsMagnusSubgroup : public FastComputation 
00047 {
00048 public:
00049 
00050   ORGroup_IsMagnusSubgroup( const SMSubgroup& S )
00051     : subgroup( S )
00052   { }
00053 
00054   void takeControl( );
00055 
00056 private:
00057 
00058   const SMSubgroup& subgroup;
00059 };
00060 
00061 
00062 //================================================================
00063 
00064 
00065 
00066 class ORExtendedWordProblemARCer : public ARCer
00067 {
00068 public:
00069 
00070   /////////////////////////////////////////////////////////////////////////
00071   //                                                                     //
00072   // Constructors:                                                       //
00073   //                                                                     //
00074   /////////////////////////////////////////////////////////////////////////
00075 
00076   ORExtendedWordProblemARCer( ComputationManager& );
00077 
00078 
00079   /////////////////////////////////////////////////////////////////////////
00080   //                                                                     //
00081   // Accessors:                                                          //
00082   //                                                                     //
00083   /////////////////////////////////////////////////////////////////////////
00084 
00085   void setArguments( const Word& relator, const Word& testWord, 
00086                      const VectorOf<Word>& target );
00087 
00088   bool getRetValue() const { return retValue; }
00089 
00090   Word wordInBasis( ) const { return theWordInBasis; } 
00091 
00092   // Inherited from ARCer:
00093   // bool takeControl( );
00094 
00095 
00096   /////////////////////////////////////////////////////////////////////////
00097   //                                                                     //
00098   // IPC interaction members:                                            //
00099   //                                                                     //
00100   /////////////////////////////////////////////////////////////////////////
00101 
00102   void runComputation( );
00103 
00104   void writeResults( ostream& );
00105 
00106   void readResults( istream& );
00107 
00108   
00109 private:
00110 
00111   /////////////////////////////////////////////////////////////////////////
00112   //                                                                     //
00113   // Private functions:                                                  //
00114   //                                                                     //
00115   /////////////////////////////////////////////////////////////////////////
00116 
00117   void printWord(const Word& w, ostream& ostr);
00118 
00119 
00120   /////////////////////////////////////////////////////////////////////////
00121   //                                                                     //
00122   // Data Members:                                                       //
00123   //                                                                     //
00124   /////////////////////////////////////////////////////////////////////////
00125 
00126   Word theRelator;
00127   Word theTestWord;
00128   VectorOf<Word> theTarget;
00129 
00130   Trichotomy answer;
00131   Word theWordInBasis;
00132   bool retValue;
00133 };
00134 
00135 
00136 
00137 // -------------------------- ORWordProblemCM ------------------------------ //
00138 
00139 
00140 class ORExtendedWordProblemCM : public ComputationManager
00141 {
00142 public:
00143 
00144   /////////////////////////////////////////////////////////////////////////
00145   //                                                                     //
00146   // Constructors:                                                       //
00147   //                                                                     //
00148   /////////////////////////////////////////////////////////////////////////
00149 
00150   ORExtendedWordProblemCM( class ORExtendedWordProblem& PO );
00151 
00152   /////////////////////////////////////////////////////////////////////////
00153   //                                                                     //
00154   // Accessors:                                                          //
00155   //                                                                     //
00156   /////////////////////////////////////////////////////////////////////////
00157 
00158   Trichotomy isExpressed( ) const { return itIsExpressed; }
00159 
00160   Word wordInBasis( ) const { return theWordInBasis; }
00161     
00162   /////////////////////////////////////////////////////////////////////////
00163   //                                                                     //
00164   // Control:                                                            //
00165   //                                                                     //
00166   /////////////////////////////////////////////////////////////////////////
00167 
00168   void takeControl( );         // overrides ComputationManager
00169 
00170   /////////////////////////////////////////////////////////////////////////
00171   //                                                                     //
00172   // State Transitions:                                                  //
00173   //                                                                     //
00174   /////////////////////////////////////////////////////////////////////////
00175 
00176   void start( ) { };              // overrides ComputationManager
00177 
00178   void terminate( );          // overrides ComputationManager
00179 
00180 
00181 private:
00182 
00183   /////////////////////////////////////////////////////////////////////////
00184   //                                                                     //
00185   // Data Members:                                                       //
00186   //                                                                     //
00187   /////////////////////////////////////////////////////////////////////////
00188 
00189   const Word theRelator;
00190   const Word theTestWord;
00191   const VectorOf<Word> theTarget;
00192   
00193   Trichotomy itIsExpressed;
00194   Word theWordInBasis;
00195   bool bStarted;
00196   
00197   ORExtendedWordProblemARCer arcer;
00198 };
00199 
00200 
00201 // --------------------------- ORExtendedWordProblem ---------------------- //
00202 
00203 
00204 class ORExtendedWordProblem : public Supervisor
00205 {
00206 
00207 public:
00208 
00209   /////////////////////////////////////////////////////////////////////////
00210   //                                                                     //
00211   // Constructors:                                                       //
00212   //                                                                     //
00213   /////////////////////////////////////////////////////////////////////////
00214 
00215   ORExtendedWordProblem( class SMSubgroup& target, class SMWord& w );
00216 
00217   /////////////////////////////////////////////////////////////////////////
00218   //                                                                     //
00219   // Accessors:                                                          //
00220   //                                                                     //
00221   /////////////////////////////////////////////////////////////////////////
00222 
00223   Trichotomy answer( ) const { return theAnswer; }
00224   // When a WordProblem is used internally, it does not report the result
00225   // to the FE, but just sits and waits to be polled through this member.
00226   // yes => trivial, no => not trivial, dontknow => not done yet.
00227 
00228   Word wordInBasis( ) const { return theWordInBasis; }
00229 
00230   const SMWord& getTestWord( ) const { return theWord; }
00231 
00232   const SMSubgroup& getTarget( ) const { return theTarget; }
00233 
00234   /////////////////////////////////////////////////////////////////////////
00235   //                                                                     //
00236   // Front End Interfacing:                                              //
00237   //                                                                     //
00238   /////////////////////////////////////////////////////////////////////////
00239 
00240   void viewStructure(ostream& ostr) const;  // overrides SMObject
00241 
00242   /////////////////////////////////////////////////////////////////////////
00243   //                                                                     //
00244   // Control:                                                            //
00245   //                                                                     //
00246   /////////////////////////////////////////////////////////////////////////
00247 
00248   void takeControl( );         // overrides ComputationManager
00249 
00250   /////////////////////////////////////////////////////////////////////////
00251   //                                                                     //
00252   // State Transitions:                                                  //
00253   //                                                                     //
00254   /////////////////////////////////////////////////////////////////////////
00255 
00256   void start( ) { }           // overrides ComputationManager
00257 
00258   void terminate( ) { }       // overrides ComputationManager
00259 
00260 
00261 private:
00262 
00263   /////////////////////////////////////////////////////////////////////////
00264   //                                                                     //
00265   // Data Members:                                                       //
00266   //                                                                     //
00267   /////////////////////////////////////////////////////////////////////////
00268 
00269   SMWord& theWord;
00270 
00271   SMSubgroup& theTarget;
00272 
00273   // Housekeeping members:
00274 
00275   Trichotomy theAnswer;
00276   Word theWordInBasis;
00277 
00278   // GCM components this uses; only for automatic ARC passing:
00279 
00280   Subordinate<ORExtendedWordProblem, ORExtendedWordProblemCM> orwp;
00281 };
00282 
00283 
00284 // --------------------- ORIsMagnusSubgroup --------------------------------- //
00285 
00286 class ORIsMagnusSubgroup : public FastComputation 
00287 {
00288 public:
00289 
00290   ORIsMagnusSubgroup( const SMSubgroup& subgroup )
00291     : theSubgroup( subgroup )
00292   { }
00293 
00294   void takeControl( );
00295 
00296 private:
00297 
00298   const SMSubgroup& theSubgroup;
00299 };
00300 
00301 
00302 /*
00303 // --------------------- ORConsequencesEnumerator ------------------------ //
00304 
00305 class ORConsequencesEnumeratorARCer : public ARCer
00306 {
00307 public:
00308 
00309   /////////////////////////////////////////////////////////////////////////
00310   //                                                                     //
00311   // Constructors:                                                       //
00312   //                                                                     //
00313   /////////////////////////////////////////////////////////////////////////
00314 
00315   ORConsequencesEnumeratorARCer( ComputationManager& );
00316 
00317 
00318   /////////////////////////////////////////////////////////////////////////
00319   //                                                                     //
00320   // Accessors:                                                          //
00321   //                                                                     //
00322   /////////////////////////////////////////////////////////////////////////
00323 
00324   void setArguments( const VectorOf<Chars>& namesOfGenerators, 
00325                      const Word& relator, const Chars& fileName );
00326 
00327   // Inherited from ARCer:
00328   // bool takeControl( );
00329 
00330 
00331   /////////////////////////////////////////////////////////////////////////
00332   //                                                                     //
00333   // IPC interaction members:                                            //
00334   //                                                                     //
00335   /////////////////////////////////////////////////////////////////////////
00336 
00337   void runComputation( );
00338 
00339   void writeResults( ostream& );
00340 
00341   void readResults( istream& );
00342 
00343   
00344 private:
00345 
00346   /////////////////////////////////////////////////////////////////////////
00347   //                                                                     //
00348   // Private functions:                                                  //
00349   //                                                                     //
00350   /////////////////////////////////////////////////////////////////////////
00351 
00352   void printWord(const Word& w, ostream& ostr);
00353 
00354 
00355   /////////////////////////////////////////////////////////////////////////
00356   //                                                                     //
00357   // Data Members:                                                       //
00358   //                                                                     //
00359   /////////////////////////////////////////////////////////////////////////
00360 
00361   VectorOf<Chars> theNamesOfGenerators;
00362   Word theRelator;
00363   Chars theFileName;
00364 };
00365 
00366 
00367 
00368 // -------------------------- ORWordProblemCM ------------------------------ //
00369 
00370 
00371 class ORConsequencesEnumeratorCM : public ComputationManager
00372 {
00373 public:
00374 
00375   /////////////////////////////////////////////////////////////////////////
00376   //                                                                     //
00377   // Constructors:                                                       //
00378   //                                                                     //
00379   /////////////////////////////////////////////////////////////////////////
00380 
00381   ORConsequencesEnumeratorCM( class ORConsequencesEnumerator& CE );
00382 
00383   /////////////////////////////////////////////////////////////////////////
00384   //                                                                     //
00385   // Accessors:                                                          //
00386   //                                                                     //
00387   /////////////////////////////////////////////////////////////////////////
00388 
00389   /////////////////////////////////////////////////////////////////////////
00390   //                                                                     //
00391   // Control:                                                            //
00392   //                                                                     //
00393   /////////////////////////////////////////////////////////////////////////
00394 
00395   void takeControl( );         // overrides ComputationManager
00396 
00397   /////////////////////////////////////////////////////////////////////////
00398   //                                                                     //
00399   // State Transitions:                                                  //
00400   //                                                                     //
00401   /////////////////////////////////////////////////////////////////////////
00402 
00403   void start( ) { };              // overrides ComputationManager
00404 
00405   void terminate( );          // overrides ComputationManager
00406 
00407 
00408 private:
00409 
00410   /////////////////////////////////////////////////////////////////////////
00411   //                                                                     //
00412   // Data Members:                                                       //
00413   //                                                                     //
00414   /////////////////////////////////////////////////////////////////////////
00415 
00416   const class SMFPGroup& theGroup;
00417   Chars theFileName;
00418 
00419   bool arcerStarted;
00420   ORConsequencesEnumeratorARCer arcer;
00421 };
00422 
00423 
00424 // --------------------------- ORConsequencesEnumerator ---------------------- //
00425 
00426 
00427 class ORConsequencesEnumerator : public Supervisor
00428 {
00429 
00430 public:
00431 
00432   /////////////////////////////////////////////////////////////////////////
00433   //                                                                     //
00434   // Constructors:                                                       //
00435   //                                                                     //
00436   /////////////////////////////////////////////////////////////////////////
00437 
00438   ORConsequencesEnumerator( class SMFPGroup& group );
00439 
00440   /////////////////////////////////////////////////////////////////////////
00441   //                                                                     //
00442   // Accessors:                                                          //
00443   //                                                                     //
00444   /////////////////////////////////////////////////////////////////////////
00445 
00446   const SMFPGroup& getGroup( ) const { return theGroup; }
00447 
00448   Chars getFileName( ) const { return theFileName; }
00449 
00450   /////////////////////////////////////////////////////////////////////////
00451   //                                                                     //
00452   // Front End Interfacing:                                              //
00453   //                                                                     //
00454   /////////////////////////////////////////////////////////////////////////
00455 
00456   void viewStructure(ostream& ostr) const;  // overrides SMObject
00457 
00458   /////////////////////////////////////////////////////////////////////////
00459   //                                                                     //
00460   // Control:                                                            //
00461   //                                                                     //
00462   /////////////////////////////////////////////////////////////////////////
00463 
00464   void takeControl( );         // overrides ComputationManager
00465 
00466   /////////////////////////////////////////////////////////////////////////
00467   //                                                                     //
00468   // State Transitions:                                                  //
00469   //                                                                     //
00470   /////////////////////////////////////////////////////////////////////////
00471 
00472   void start( ) { }           // overrides ComputationManager
00473 
00474   void terminate( ) { }       // overrides ComputationManager
00475 
00476 
00477 private:
00478 
00479   /////////////////////////////////////////////////////////////////////////
00480   //                                                                     //
00481   // Data Members:                                                       //
00482   //                                                                     //
00483   /////////////////////////////////////////////////////////////////////////
00484 
00485   const SMFPGroup& theGroup;
00486   Chars theFileName;
00487   bool linked;
00488 
00489   // GCM components this uses; only for automatic ARC passing:
00490 
00491   Subordinate<ORConsequencesEnumerator, ORConsequencesEnumeratorCM> enumerator;
00492 };
00493 */
00494 
00495 #endif

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