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

/magnus/back_end/SMApps/include/ConjugacyProblem.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: ConjugacyProblem.h,v 1.4 2000/10/07 18:38:01 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: Declaration of class ConjugacyProblem, helpers FPConjugacyWrapper,
00009 //           MSCConjugacyWrapper
00010 //
00011 // Principal Author: Roger Needham
00012 //
00013 // Status: in progress
00014 //
00015 // Revision History: 
00016 //
00017 // @db & @au: 00/10/07 Added GA for solving conjugacy problem for OR groups  
00018 //
00019 
00020 #ifndef _CONJUGACYPROBLEM_H_
00021 #define _CONJUGACYPROBLEM_H_
00022 
00023 
00024 #include "Word.h"
00025 #include "FPGroup.h"
00026 #include "Supervisor.h"
00027 #include "GAConjProblemForORGroup.h"
00028 
00029 
00030 //---------------------------------------------------------------------------//
00031 //------------------------ FPConjugacyWrapper -------------------------------//
00032 //---------------------------------------------------------------------------//
00033 
00034 class FPConjugacyARCer : public ARCer
00035 {
00036 public:
00037 
00038   /////////////////////////////////////////////////////////////////////////
00039   //                                                                     //
00040   // Constructors:                                                       //
00041   //                                                                     //
00042   /////////////////////////////////////////////////////////////////////////
00043 
00044   FPConjugacyARCer( ComputationManager& boss );
00045 
00046 
00047   /////////////////////////////////////////////////////////////////////////
00048   //                                                                     //
00049   // Accessors:                                                          //
00050   //                                                                     //
00051   /////////////////////////////////////////////////////////////////////////
00052 
00053   void setArguments( 
00054                     const class SMFPGroup& G, 
00055                     const class Word& u, 
00056                     const class Word& w 
00057                     );
00058 
00059   Trichotomy answer( ) const { return theAnswer; }
00060 
00061   Word conjugator( ) const { return theConjugator; } 
00062   // Returns a valid result when answer() returns yes.
00063 
00064   // Inherited from ARCer:
00065   // bool takeControl( );
00066 
00067 
00068   /////////////////////////////////////////////////////////////////////////
00069   //                                                                     //
00070   // IPC interaction members:                                            //
00071   //                                                                     //
00072   /////////////////////////////////////////////////////////////////////////
00073 
00074   void runComputation( );
00075 
00076   void writeResults( ostream& );
00077 
00078   void readResults( istream& );
00079 
00080   
00081 private:
00082 
00083   /////////////////////////////////////////////////////////////////////////
00084   //                                                                     //
00085   // Data Members:                                                       //
00086   //                                                                     //
00087   /////////////////////////////////////////////////////////////////////////
00088 
00089   const SMFPGroup *theGroup;
00090   Word firstWord, secondWord;
00091 
00092   Trichotomy theAnswer;
00093   Word theConjugator;
00094 };
00095 
00096 class FPConjugacyWrapper : public ComputationManager
00097 {
00098 public:
00099 
00100   /////////////////////////////////////////////////////////////////////////
00101   //                                                                     //
00102   // Constructors:                                                       //
00103   //                                                                     //
00104   /////////////////////////////////////////////////////////////////////////
00105 
00106   FPConjugacyWrapper(class ConjugacyProblem& CP);
00107 
00108   /////////////////////////////////////////////////////////////////////////
00109   //                                                                     //
00110   // Accessors:                                                          //
00111   //                                                                     //
00112   /////////////////////////////////////////////////////////////////////////
00113 
00114   Trichotomy answer( ) const { return theAnswer; }
00115   // This not report the result to the FE, but just sits and waits to
00116   // be polled through this member. yes => conjugate, no => not conjugate,
00117   // dontknow => not done yet.
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   /////////////////////////////////////////////////////////////////////////
00141   //                                                                     //
00142   // Data Members:                                                       //
00143   //                                                                     //
00144   /////////////////////////////////////////////////////////////////////////
00145 
00146   const class ConjugacyProblem& problem;
00147   FPConjugacyARCer arcer;
00148   Trichotomy theAnswer;
00149 };
00150 
00151 
00152 
00153 //---------------------------------------------------------------------------//
00154 //------------------------ MSCConjugacyWrapper ------------------------------//
00155 //---------------------------------------------------------------------------//
00156 
00157 
00158 class MSCConjugacyARCer : public ARCer
00159 {
00160 public:
00161 
00162   /////////////////////////////////////////////////////////////////////////
00163   //                                                                     //
00164   // Constructors:                                                       //
00165   //                                                                     //
00166   /////////////////////////////////////////////////////////////////////////
00167 
00168   MSCConjugacyARCer( ComputationManager& );
00169 
00170 
00171   /////////////////////////////////////////////////////////////////////////
00172   //                                                                     //
00173   // Accessors:                                                          //
00174   //                                                                     //
00175   /////////////////////////////////////////////////////////////////////////
00176 
00177   void setArguments( const FPGroup& G, const Word& u, const Word& v );
00178 
00179   Trichotomy answer( ) const { return theAnswer; }
00180 
00181   Word conjugator( ) const { return theConjugator; } 
00182   // Returns a valid result when answer() returns yes.
00183 
00184   // Inherited from ARCer:
00185   // bool takeControl( );
00186 
00187 
00188   /////////////////////////////////////////////////////////////////////////
00189   //                                                                     //
00190   // IPC interaction members:                                            //
00191   //                                                                     //
00192   /////////////////////////////////////////////////////////////////////////
00193 
00194   void runComputation( );
00195 
00196   void writeResults( ostream& );
00197 
00198   void readResults( istream& );
00199 
00200   
00201 private:
00202 
00203   /////////////////////////////////////////////////////////////////////////
00204   //                                                                     //
00205   // Data Members:                                                       //
00206   //                                                                     //
00207   /////////////////////////////////////////////////////////////////////////
00208 
00209   FPGroup theGroup;
00210   Word firstWord, secondWord;
00211 
00212   Trichotomy theAnswer;
00213   Word theConjugator;
00214 
00215 };
00216 
00217 
00218 class MSCConjugacyWrapper : public ComputationManager
00219 {
00220 public:
00221 
00222   /////////////////////////////////////////////////////////////////////////
00223   //                                                                     //
00224   // Constructors:                                                       //
00225   //                                                                     //
00226   /////////////////////////////////////////////////////////////////////////
00227 
00228   MSCConjugacyWrapper(class ConjugacyProblem& CP);
00229 
00230   /////////////////////////////////////////////////////////////////////////
00231   //                                                                     //
00232   // Accessors:                                                          //
00233   //                                                                     //
00234   /////////////////////////////////////////////////////////////////////////
00235 
00236   Trichotomy answer( ) const { return theAnswer; }
00237   // This not report the result to the FE, but just sits and waits to
00238   // be polled through this member. yes => conjugate, no => not conjugate,
00239   // dontknow => not done yet.
00240 
00241   /////////////////////////////////////////////////////////////////////////
00242   //                                                                     //
00243   // Control:                                                            //
00244   //                                                                     //
00245   /////////////////////////////////////////////////////////////////////////
00246 
00247   void takeControl( );         // overrides ComputationManager
00248 
00249   /////////////////////////////////////////////////////////////////////////
00250   //                                                                     //
00251   // State Transitions:                                                  //
00252   //                                                                     //
00253   /////////////////////////////////////////////////////////////////////////
00254 
00255   void start( ) { }              // overrides ComputationManager
00256 
00257   void terminate( ) { }          // overrides ComputationManager
00258 
00259 
00260 private:
00261 
00262   /////////////////////////////////////////////////////////////////////////
00263   //                                                                     //
00264   // Data Members:                                                       //
00265   //                                                                     //
00266   /////////////////////////////////////////////////////////////////////////
00267 
00268   const class ConjugacyProblem& problem;
00269   MSCConjugacyARCer arcer;
00270   Trichotomy theAnswer;
00271 };
00272 
00273 
00274 
00275 //---------------------------------------------------------------------------//
00276 //------------------------- ConjugacyProblem --------------------------------//
00277 //---------------------------------------------------------------------------//
00278 
00279 
00280 class ConjugacyProblem : public Supervisor
00281 {
00282 public:
00283 
00284   /////////////////////////////////////////////////////////////////////////
00285   //                                                                     //
00286   // Constructors:                                                       //
00287   //                                                                     //
00288   /////////////////////////////////////////////////////////////////////////
00289 
00290   ConjugacyProblem(const class SMWord& w1, const class SMWord& w2);
00291 
00292   /////////////////////////////////////////////////////////////////////////
00293   //                                                                     //
00294   // Accessors:                                                          //
00295   //                                                                     //
00296   /////////////////////////////////////////////////////////////////////////
00297 
00298   const class SMWord& firstWord( ) const { return u; }
00299   const class SMWord& secondWord( ) const { return v; }
00300 
00301   /////////////////////////////////////////////////////////////////////////
00302   //                                                                     //
00303   // Front End Interfacing:                                              //
00304   //                                                                     //
00305   /////////////////////////////////////////////////////////////////////////
00306 
00307   void viewStructure(ostream& ostr) const;  // overrides SMObject
00308 
00309   /////////////////////////////////////////////////////////////////////////
00310   //                                                                     //
00311   // Control:                                                            //
00312   //                                                                     //
00313   /////////////////////////////////////////////////////////////////////////
00314 
00315   void takeControl( );         // overrides ComputationManager
00316 
00317   /////////////////////////////////////////////////////////////////////////
00318   //                                                                     //
00319   // State Transitions:                                                  //
00320   //                                                                     //
00321   /////////////////////////////////////////////////////////////////////////
00322 
00323   void start( ) { }              // overrides ComputationManager
00324 
00325   void terminate( ) { }          // overrides ComputationManager
00326 
00327 
00328 private:
00329 
00330   /////////////////////////////////////////////////////////////////////////
00331   //                                                                     //
00332   // Data Members:                                                       //
00333   //                                                                     //
00334   /////////////////////////////////////////////////////////////////////////
00335 
00336   const class SMWord& u;
00337   const class SMWord& v;
00338 
00339   bool scMethodFailed;
00340 
00341   bool geneticLinkHasBeenSent;
00342 
00343   /////////////////////////////////////////////////////////////////////////
00344   //                                                                     //
00345   // Subordinate Computation Managers:                                   //
00346   //                                                                     //
00347   /////////////////////////////////////////////////////////////////////////
00348 
00349   Subordinate<ConjugacyProblem,FPConjugacyWrapper> fpConjugacyWrapper;
00350   Subordinate<ConjugacyProblem,MSCConjugacyWrapper> mscConjugacyWrapper;
00351   Subordinate<ConjugacyProblem,GAConjugacyForORGroup> GAConjugacy;
00352 
00353 };
00354 
00355 #endif

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