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

/magnus/back_end/SMApps/include/IsWordAPE.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: IsWordAPE.h,v 1.1 2000/10/07 18:42:32 bormotov Exp $
00003  */
00004  
00005 // Contents: Declaration of classes IsWordAPE, IsWordAPEProblem, IsWordAPEARCer
00006 //
00007 // Principal Author: Alexander Ushakov
00008 //
00009 // Status: in progress
00010 //
00011 // Revision History:
00012 //
00013 
00014 
00015 #ifndef _IS_WORD_APE_H_
00016 #define _IS_WORD_APE_H_
00017 
00018 
00019 #include "TurnerProperSubgroupEnumerator.h"
00020 #include "FreeGroup.h"
00021 #include "Supervisor.h"
00022 #include "RankOfSubgroup.h"
00023 
00024 
00025 // ------------------------  IsWordAPEARCer ------------------------------ //
00026 
00027 
00028 class IsWordAPEARCer : public ARCer
00029 {
00030 public:
00031 
00032   /////////////////////////////////////////////////////////////////////////
00033   //                                                                     //
00034   // Constructors:                                                       //
00035   //                                                                     //
00036   /////////////////////////////////////////////////////////////////////////
00037 
00038   IsWordAPEARCer( ComputationManager& boss, 
00039                   const class FreeGroup& group, 
00040                   const Word& word );
00041 
00042   ~IsWordAPEARCer();
00043 
00044   /////////////////////////////////////////////////////////////////////////
00045   //                                                                     //
00046   // Accessors:                                                          //
00047   //                                                                     //
00048   /////////////////////////////////////////////////////////////////////////
00049 
00050 
00051   /////////////////////////////////////////////////////////////////////////
00052   //                                                                     //
00053   // IPC interaction members:                                            //
00054   //                                                                     //
00055   /////////////////////////////////////////////////////////////////////////
00056 
00057   void runComputation( );
00058  
00059   void writeResults( ostream& );
00060 
00061   void readResults( istream& );
00062   
00063   Chars getFileName( ) const { return PSE->getFileName(); }
00064 
00065   Trichotomy getAnswer() const { return answer;}
00066   bool HaveSG() const { return haveSG; } 
00067 
00068   bool getSG(SGofFreeGroup& sg) {
00069     if (answer!=no) return true;
00070     sg = *theSG;
00071     return true;
00072   }
00073 
00074 private:
00075 
00076   /////////////////////////////////////////////////////////////////////////
00077   //                                                                     //
00078   // Data Members:                                                       //
00079   //                                                                     //
00080   /////////////////////////////////////////////////////////////////////////
00081 
00082   const class FreeGroup theGroup;
00083   // given free group
00084   const Word theWord;
00085   // given word
00086 
00087   const static int period = 1000;
00088 
00089   Trichotomy answer;
00090   SGofFreeGroup* theSG;
00091   bool haveSG;
00092   // answer
00093 
00094   ProperSubgroupEnumerator* PSE;
00095   // Subgroup enumerator 
00096 
00097   void lookingup();
00098   // enumerate subgroup
00099   bool checkForPrimitive(SGofFreeGroup sg);
00100   // check word for primitive in subgroup sg
00101   void printSG( ostream& file, const SGofFreeGroup& subgroup );
00102 
00103 
00104   // ------------------------  pairSG_bool ------------------------------ //
00105   
00106   class pairSG_bool
00107     {
00108     public:
00109       
00110       pairSG_bool(const SGofFreeGroup& sg) : theSG(sg) , checked(false) { }
00111       pairSG_bool(const SGofFreeGroup& sg, bool b) : theSG(sg), checked(b) { }
00112       
00113       inline bool operator == (const pairSG_bool& sg) const { 
00114         return (theSG==sg.theSG);
00115       }
00116       
00117       inline int hash() const {
00118         return theSG.hash();
00119       }
00120       
00121       void setChecked( ) { checked=true; }
00122       bool getChecked( ) const { return checked; }
00123       
00124       SGofFreeGroup getSG() const { return theSG; }
00125       
00126     private:
00127       SGofFreeGroup theSG;
00128       bool checked;
00129       
00130     };
00131   
00132 
00133 };
00134 
00135 
00136 // ------------------------  IsWordAPE ------------------------------ //
00137 
00138 
00139 class IsWordAPE : public ComputationManager
00140 {
00141 public:
00142 
00143   /////////////////////////////////////////////////////////////////////////
00144   //                                                                     //
00145   // Constructors:                                                       //
00146   //                                                                     //
00147   /////////////////////////////////////////////////////////////////////////
00148 
00149   IsWordAPE(class IsWordAPEProblem& problemObject );
00150 
00151   ~IsWordAPE( );
00152 
00153   /////////////////////////////////////////////////////////////////////////
00154   //                                                                     //
00155   // Accessors:                                                          //
00156   //                                                                     //
00157   /////////////////////////////////////////////////////////////////////////
00158 
00159   Trichotomy getAnswer() const { 
00160        return theARCer.getAnswer();
00161   }
00162 
00163   bool haveSG() const { 
00164        return theARCer.HaveSG();
00165   }
00166 
00167   bool getSG(SGofFreeGroup& sg) {
00168        return theARCer.getSG(sg);
00169   }
00170 
00171   Chars getFileName( ) { return theARCer.getFileName(); }
00172   // Returns name of the file with computation details
00173 
00174 
00175   /////////////////////////////////////////////////////////////////////////
00176   //                                                                     //
00177   // Control:                                                            //
00178   //                                                                     //
00179   /////////////////////////////////////////////////////////////////////////
00180 
00181   void takeControl( );         // overrides ComputationManager
00182 
00183   /////////////////////////////////////////////////////////////////////////
00184   //                                                                     //
00185   // State Transitions:                                                  //
00186   //                                                                     //
00187   /////////////////////////////////////////////////////////////////////////
00188 
00189   void start( ) { };              // overrides ComputationManager
00190 
00191   void terminate( ) { };          // overrides ComputationManager
00192 
00193 
00194 private:
00195 
00196   /////////////////////////////////////////////////////////////////////////
00197   //                                                                     //
00198   // Data Members:                                                       //
00199   //                                                                     //
00200   /////////////////////////////////////////////////////////////////////////
00201 
00202   const class SMWord& theWord;
00203 
00204   FreeGroup theGroup;
00205 
00206   IsWordAPEARCer theARCer;
00207 
00208 };
00209 
00210 
00211 // -------------------- IsWordAPEProblem --------------------------- //
00212 
00213 
00214 class IsWordAPEProblem : public Supervisor
00215 {
00216 public:
00217 
00218   /////////////////////////////////////////////////////////////////////////
00219   //                                                                     //
00220   // Constructors:                                                       //
00221   //                                                                     //
00222   /////////////////////////////////////////////////////////////////////////
00223 
00224   IsWordAPEProblem(const class SMWord& w);
00225 
00226 
00227   /////////////////////////////////////////////////////////////////////////
00228   //                                                                     //
00229   // Accessors:                                                          //
00230   //                                                                     //
00231   /////////////////////////////////////////////////////////////////////////
00232 
00233   const class SMWord& getWord( ) const { return theWord; }
00234 
00235 
00236   /////////////////////////////////////////////////////////////////////////
00237   //                                                                     //
00238   // Front End Interfacing:                                              //
00239   //                                                                     //
00240   /////////////////////////////////////////////////////////////////////////
00241 
00242   void viewStructure(ostream& ostr) const;  // overrides SMObject
00243 
00244 
00245   /////////////////////////////////////////////////////////////////////////
00246   //                                                                     //
00247   // Control:                                                            //
00248   //                                                                     //
00249   /////////////////////////////////////////////////////////////////////////
00250 
00251   void takeControl( );         // overrides ComputationManager
00252 
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   const SMWord& theWord;
00274  
00275   bool linkHasBeenSent;
00276   
00277 
00278   /////////////////////////////////////////////////////////////////////////
00279   //                                                                     //
00280   // Subordinate Computation Managers:                                   //
00281   //                                                                     //
00282   /////////////////////////////////////////////////////////////////////////
00283 
00284   Subordinate<IsWordAPEProblem, IsWordAPE> isWordAPE;
00285  
00286 };
00287 
00288 #endif

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