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

/magnus/back_end/SMApps/include/NilpotentQuotients.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: NilpotentQuotients.h,v 1.10 1998/08/03 20:24:15 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 NilpotentWPARCer, NilpotentWPInQuotients,
00009 //            NilpotentWP, NGcomputeBasisARCer, NGcomputeBasis,
00010 //            NilpotentQuotients, NGcomputeBasisProblem, NGPresentationARCer,
00011 //            NGdecomposeWordARCer, NGdecomposeWord 
00012 
00013 //
00014 // Principal Author: Roger Needham, Alexei Myasnikov
00015 //
00016 // Status: in progress
00017 //
00018 // Revision History:
00019 //
00020 
00021 
00022 #ifndef _NILPOTENTQUOTIENTS_H_
00023 #define _NILPOTENTQUOTIENTS_H_
00024 
00025 
00026 //@rn  This is specialized for the moment to work only on the specific class of
00027 //@rn  a group which was checked in as nilpotent. It can, in principle, work
00028 //@rn  on any nilpotent quotient of any FP group.
00029 
00030 
00031 #include "Supervisor.h"
00032 #include "NilpotentGroup.h"
00033 #include "ComputationManager.h"
00034 #include "List.h"
00035 #include "File.h"
00036 #include "Presentation.h"
00037 
00038 // ---------------------- NilpotentWPARCer --------------------------- //
00039 
00040 
00041 class NilpotentWPARCer : public ARCer
00042 {
00043 public:
00044 
00045   /////////////////////////////////////////////////////////////////////////
00046   //                                                                     //
00047   // Constructors:                                                       //
00048   //                                                                     //
00049   /////////////////////////////////////////////////////////////////////////
00050 
00051   NilpotentWPARCer( ComputationManager& boss ) 
00052     : ARCer( boss ),theGroup(0) { } 
00053 
00054   ~NilpotentWPARCer( ) { delete theGroup;} 
00055 
00056 
00057   /////////////////////////////////////////////////////////////////////////
00058   //                                                                     //
00059   // Accessors:                                                          //
00060   //                                                                     //
00061   /////////////////////////////////////////////////////////////////////////
00062 
00063   void setArguments(const SetOf<Word>& setW, const NilpotentGroup& NG);
00064   void setArguments(const VectorOf<Word>& vecW, const NilpotentGroup& NG);
00065   void setArguments(const int& length, const NilpotentGroup& NG);
00066   void setArguments(const int& length, const NilpotentGroup& NG,
00067                     const VectorOf<Word>& gen);
00068  // Inherited from ARCer:
00069   // bool takeControl( );
00070 
00071   bool getResult() const;
00072   Word getWord() const;
00073   VectorOf<int> getCommutator() const;
00074   
00075   
00076   /////////////////////////////////////////////////////////////////////////
00077   //                                                                     //
00078   // IPC interaction members:                                            //
00079   //                                                                     //
00080   /////////////////////////////////////////////////////////////////////////
00081 
00082   void runComputation( );
00083  
00084   void writeResults( ostream& );
00085 
00086   void readResults( istream& );
00087 
00088 
00089 private:
00090 
00091   void commutatorsCheck();
00092   // Enumerates all commutators of length = theCommutatorsLength,
00093   // and checks them for triviality.
00094   void wordsCheck();
00095   // Checks theWords for triviality.
00096   void setGroup(const NilpotentGroup& NG);
00097 
00098   /////////////////////////////////////////////////////////////////////////
00099   //                                                                     //
00100   // Data Members:                                                       //
00101   //                                                                     //
00102   /////////////////////////////////////////////////////////////////////////
00103 
00104   VectorOf<Word> theWords;
00105   int theCommutatorsLength;
00106 
00107   VectorOf<Word> generators;
00108   // Vector of generators, to commutate.
00109   NilpotentGroup* theGroup;
00110   bool result;
00111   bool isCommutatorsChecks;
00112   Word retWord;
00113   VectorOf<int> commutator;
00114 };
00115 
00116 //---------------------------------------------------------------------------//
00117 //---------------------------- NilpotentWPInQuotients------------------------//
00118 //---------------------------------------------------------------------------//
00119 
00120 
00121 class NilpotentWPInQuotients : public ComputationManager
00122 {
00123 public:
00124   
00125   /////////////////////////////////////////////////////////////////////////
00126   //                                                                     //
00127   // Constructors:                                                       //
00128   //                                                                     //
00129   /////////////////////////////////////////////////////////////////////////
00130 
00131   NilpotentWPInQuotients(Supervisor& sup);
00132   // Constructor gets abstract supervisor, so you can call this
00133   // computation manager from any supervisor.
00134 
00135   void initialize(const VectorOf<Word>& vecW,const class SMFPGroup* group,
00136                   int startClass = 2);
00137   void initialize(const SetOf<Word>& w,const class SMFPGroup* group,
00138                   int startClass = 2);
00139   // Initializing for checking of words set.
00140   // You have to call initialize, before running start, because we
00141   // need to initialize words and group for running problem.
00142   
00143   void initialize(const int& length,const class SMFPGroup* group,
00144                   int startClass = 2);
00145   // Initializing for checking  commutators.
00146   // You have to call initialize, before running start, becouse we
00147   // need to initialize words and group for running problem.
00148 
00149   void initialize(const int& length,const class SMFPGroup* group,
00150                   const VectorOf<Word>& gen,int startClass = 2);
00151   // Initializing for checking  commutators of generators in 'gen'.
00152   // You have to call initialize, before running start, becouse we
00153   // need to initialize words and group for running problem.
00154 
00155   /////////////////////////////////////////////////////////////////////////
00156   //                                                                     //
00157   // Accessors:                                                          //
00158   //                                                                     //
00159   /////////////////////////////////////////////////////////////////////////
00160 
00161   Trichotomy isTrivial() const { return is_trivial; }
00162   // Returns no if there are non trivial words in set.
00163   Trichotomy isTrivial( int& nClass ) const;
00164   // Returns no if there are non trivial words in set and nClass =
00165   // class of nilpotent quotient, in which word is not trivial.
00166 
00167   Word getWord() const;
00168   // Returns non trivial word if it was found, and empty if was not.
00169   VectorOf<int> getCommutator() const;
00170   // Returns vector of generators in commutator if isCommutatorsCheck==true
00171   // If commutator [a,b,c], returns {1,2,3}                                   
00172 
00173   /////////////////////////////////////////////////////////////////////////
00174   //                                                                     //
00175   // Control:                                                            //
00176   //                                                                     //
00177   /////////////////////////////////////////////////////////////////////////
00178 
00179   void takeControl( );         // overrides ComputationManager
00180 
00181   /////////////////////////////////////////////////////////////////////////
00182   //                                                                     //
00183   // State Transitions:                                                  //
00184   //                                                                     //
00185   /////////////////////////////////////////////////////////////////////////
00186 
00187   void start( );              // overrides ComputationManager
00188 
00189   void terminate( ) { };          // overrides ComputationManager
00190 
00191 
00192 private:
00193 
00194   /////////////////////////////////////////////////////////////////////////
00195   //                                                                     //
00196   // Data Members:                                                       //
00197   //                                                                     //
00198   /////////////////////////////////////////////////////////////////////////
00199 
00200   SetOf<Word> theWords;
00201   // Set of words to be checked.
00202   VectorOf<Word> generators;
00203   // Vector of generators, to commutate.
00204   // If generators.length == 0, then commutates generators of the group
00205   int theCommutatorsLength;
00206   // The length of commutators to be checked.
00207   bool isCommutatorsCheck;
00208   const SMFPGroup* theGroup;
00209 
00210   int currentClass;
00211   // Class of quotient in which the word problem is solving.
00212 
00213   int upperBound;
00214   // Upper class for quotients. For nilpotent groups - nilpotency class-1,
00215   // for others - 10.
00216 
00217   NilpotentWPARCer arcer;
00218   Trichotomy is_trivial;
00219   bool isStarted;
00220   Word retWord;
00221   VectorOf<int> commutator;
00222 };
00223 
00224 //---------------------------------------------------------------------------//
00225 //---------------------------- NilpotentWP ----------------------------------//
00226 //---------------------------------------------------------------------------//
00227 
00228 
00229 class NilpotentWP : public ComputationManager
00230 {
00231 public:
00232 
00233   /////////////////////////////////////////////////////////////////////////
00234   //                                                                     //
00235   // Constructors:                                                       //
00236   //                                                                     //
00237   /////////////////////////////////////////////////////////////////////////
00238 
00239   NilpotentWP( Supervisor& sup);
00240   // Constructor gets abstract supervisor, so you can call this
00241   // computation manager from any supervisor.
00242 
00243   void initialize(const VectorOf<Word>& vecW,const class  SMFPGroup* group);
00244   void initialize(const SetOf<Word>& w,const class  SMFPGroup* group);
00245   // You have to call initialize, before running start, because we
00246   // need to initialize words and group for running problem.
00247 
00248   void initialize(const int& length,const class  SMFPGroup* group);
00249   // Initializing for checking  commutators.
00250   // You have to call initialize, before running start, because we
00251   // need to initialize words and group for running problem.
00252 
00253   void initialize(const int& length,const class  SMFPGroup* group,
00254                   const VectorOf<Word>& gen);
00255   // Initializing for checking  commutators of generators in 'gen'..
00256   // You have to call initialize, before running start, because we
00257   // need to initialize words and group for running problem.
00258 
00259   /////////////////////////////////////////////////////////////////////////
00260   //                                                                     //
00261   // Accessors:                                                          //
00262   //                                                                     //
00263   /////////////////////////////////////////////////////////////////////////
00264 
00265   Trichotomy isTrivial() const;
00266   // Returns yes if all words in set are trivial.
00267 
00268   Word getWord() const;
00269   // Returns non trivial word if it was found, and empty if was not.
00270   VectorOf<int> getCommutator() const;
00271   // Returns vector of generators in commutator if isCommutatorsCheck==true
00272   // If commutator [a,b,c], returns {1,2,3}                                   
00273 
00274   /////////////////////////////////////////////////////////////////////////
00275   //                                                                     //
00276   // Control:                                                            //
00277   //                                                                     //
00278   /////////////////////////////////////////////////////////////////////////
00279 
00280   void takeControl( );         // overrides ComputationManager
00281 
00282   /////////////////////////////////////////////////////////////////////////
00283   //                                                                     //
00284   // State Transitions:                                                  //
00285   //                                                                     //
00286   /////////////////////////////////////////////////////////////////////////
00287 
00288   void start( );              // overrides ComputationManager
00289 
00290   void terminate( ) { };          // overrides ComputationManager
00291 
00292 
00293 private:
00294 
00295   /////////////////////////////////////////////////////////////////////////
00296   //                                                                     //
00297   // Data Members:                                                       //
00298   //                                                                     //
00299   /////////////////////////////////////////////////////////////////////////
00300 
00301   SetOf<Word> theWords;
00302   const SMFPGroup* theGroup;
00303   
00304   int theCommutatorsLength;
00305   // The length of commutators to be checked.
00306   bool isCommutatorsCheck;
00307   VectorOf<Word> generators;
00308   // Vector of generators, to commutate.
00309   // If generators.length == 0, then commutates generators of the group.
00310   int theClass;
00311   // Class of nilpotency
00312 
00313   NilpotentWPARCer arcer;
00314 
00315   bool isStarted;
00316   Trichotomy is_trivial;
00317   Word retWord;
00318   VectorOf<int> commutator;
00319 };
00320 
00321 // ---------------------- NGcomputeBasisARCer --------------------------- //
00322 
00323 
00324 class NGcomputeBasisARCer : public ARCer
00325 {
00326 public:
00327 
00328   /////////////////////////////////////////////////////////////////////////
00329   //                                                                     //
00330   // Constructors:                                                       //
00331   //                                                                     //
00332   /////////////////////////////////////////////////////////////////////////
00333 
00334   NGcomputeBasisARCer( ComputationManager& boss, bool put_in_file = false) 
00335     : ARCer( boss ), init( 0 ),putInFile(put_in_file) { } 
00336 
00337   ~NGcomputeBasisARCer( ) { if (init) delete init; } 
00338 
00339 
00340   /////////////////////////////////////////////////////////////////////////
00341   //                                                                     //
00342   // Accessors:                                                          //
00343   //                                                                     //
00344   /////////////////////////////////////////////////////////////////////////
00345 
00346   void setArguments(const FPGroup& group,const int& nilpClass);
00347   // Inherited from ARCer:
00348   // bool takeControl( );
00349 
00350   const NilpotentGroup& getGroup() const;
00351   Chars getFileName() const {return structFile.getFileName();}
00352 
00353   /////////////////////////////////////////////////////////////////////////
00354   //                                                                     //
00355   // IPC interaction members:                                            //
00356   //                                                                     //
00357   /////////////////////////////////////////////////////////////////////////
00358 
00359   void runComputation( );
00360  
00361   void writeResults( ostream& );
00362 
00363   void readResults( istream& );
00364 
00365 
00366 private:
00367 
00368   /////////////////////////////////////////////////////////////////////////
00369   //                                                                     //
00370   // Data Members:                                                       //
00371   //                                                                     //
00372   /////////////////////////////////////////////////////////////////////////
00373 
00374   NilpotentGroup* init;
00375   File structFile;
00376   bool putInFile;
00377 };
00378 
00379 //---------------------------------------------------------------------------//
00380 //------------------------- NGcomputeBasis ----------------------------------//
00381 //---------------------------------------------------------------------------//
00382 
00383 
00384 class NGcomputeBasis : public ComputationManager
00385 {
00386 public:
00387 
00388   /////////////////////////////////////////////////////////////////////////
00389   //                                                                     //
00390   // Constructors:                                                       //
00391   //                                                                     //
00392   /////////////////////////////////////////////////////////////////////////
00393 
00394   NGcomputeBasis(class GCM& gcm, bool internal = true);
00395 
00396   ~NGcomputeBasis( );
00397 
00398   /////////////////////////////////////////////////////////////////////////
00399   //                                                                     //
00400   // Accessors:                                                          //
00401   //                                                                     //
00402   /////////////////////////////////////////////////////////////////////////
00403 
00404 
00405   /////////////////////////////////////////////////////////////////////////
00406   //                                                                     //
00407   // Front End Interfacing:                                              //
00408   //                                                                     //
00409   /////////////////////////////////////////////////////////////////////////
00410 
00411   void viewStructure(ostream& ostr) const { }  // overrides SMObject
00412 
00413   /////////////////////////////////////////////////////////////////////////
00414   //                                                                     //
00415   // Control:                                                            //
00416   //                                                                     //
00417   /////////////////////////////////////////////////////////////////////////
00418 
00419   void takeControl( );         // overrides ComputationManager
00420 
00421   /////////////////////////////////////////////////////////////////////////
00422   //                                                                     //
00423   // State Transitions:                                                  //
00424   //                                                                     //
00425   /////////////////////////////////////////////////////////////////////////
00426 
00427   void start( );              // overrides ComputationManager
00428 
00429   void terminate( );          // overrides ComputationManager
00430 
00431 
00432 private:
00433 
00434   /////////////////////////////////////////////////////////////////////////
00435   //                                                                     //
00436   // Data Members:                                                       //
00437   //                                                                     //
00438   /////////////////////////////////////////////////////////////////////////
00439   GCM& theGCM;                     
00440                                    
00441   NGcomputeBasisARCer arcer;
00442   int arcsNumber;
00443   bool haveCD;
00444 };
00445 
00446 
00447 //---------------------------------------------------------------------------//
00448 //------------------------ NilpotentQuotients -------------------------------//
00449 //---------------------------------------------------------------------------//
00450 
00451 
00452 class NilpotentQuotients : public ComputationManager
00453 {
00454 public:
00455 
00456   /////////////////////////////////////////////////////////////////////////
00457   //                                                                     //
00458   // Constructors:                                                       //
00459   //                                                                     //
00460   /////////////////////////////////////////////////////////////////////////
00461 
00462   NilpotentQuotients(class GCM& gcm, bool internal = true);
00463   
00464   ~NilpotentQuotients( );
00465 
00466   /////////////////////////////////////////////////////////////////////////
00467   //                                                                     //
00468   // Accessors:                                                          //
00469   //                                                                     //
00470   /////////////////////////////////////////////////////////////////////////
00471 
00472 
00473   /////////////////////////////////////////////////////////////////////////
00474   //                                                                     //
00475   // Front End Interfacing:                                              //
00476   //                                                                     //
00477   /////////////////////////////////////////////////////////////////////////
00478 
00479   void viewStructure(ostream& ostr) const { }  // overrides SMObject
00480 
00481   /////////////////////////////////////////////////////////////////////////
00482   //                                                                     //
00483   // Control:                                                            //
00484   //                                                                     //
00485   /////////////////////////////////////////////////////////////////////////
00486 
00487   void takeControl( );         // overrides ComputationManager
00488 
00489   /////////////////////////////////////////////////////////////////////////
00490   //                                                                     //
00491   // State Transitions:                                                  //
00492   //                                                                     //
00493   /////////////////////////////////////////////////////////////////////////
00494 
00495   void start( );              // overrides ComputationManager
00496 
00497   void terminate( );          // overrides ComputationManager
00498 
00499 
00500 private:
00501   bool increaseCurrentClass();
00502   /////////////////////////////////////////////////////////////////////////
00503   //                                                                     //
00504   // Data Members:                                                       //
00505   //                                                                     //
00506   /////////////////////////////////////////////////////////////////////////
00507 
00508   GCM& theGCM;
00509 
00510   SMFPGroup& theGroup;
00511 
00512   NGcomputeBasisARCer arcer;
00513 
00514   int currentClass;
00515   // This is the class of currently computing quotient.
00516 
00517   int upperBound; 
00518   // The hard-wired upper bound on the classes we'll compute.
00519   // For Nilpotent groups it Nilpotency class - 1, for others 10.
00520   
00521 };
00522 
00523 
00524 
00525 //---------------------------------------------------------------------------//
00526 //--------------------- NGcomputeBasisProblem -------------------------------//
00527 //---------------------------------------------------------------------------//
00528 
00529 
00530 class NGcomputeBasisProblem : public Supervisor
00531 {
00532 public:
00533 
00534   /////////////////////////////////////////////////////////////////////////
00535   //                                                                     //
00536   // Constructors:                                                       //
00537   //                                                                     //
00538   /////////////////////////////////////////////////////////////////////////
00539 
00540   NGcomputeBasisProblem(class SMFPGroup& G);
00541 
00542   /////////////////////////////////////////////////////////////////////////
00543   //                                                                     //
00544   // Front End Interfacing:                                              //
00545   //                                                                     //
00546   /////////////////////////////////////////////////////////////////////////
00547 
00548   void viewStructure(ostream& ostr) const;  // overrides SMObject
00549 
00550   /////////////////////////////////////////////////////////////////////////
00551   //                                                                     //
00552   // Control:                                                            //
00553   //                                                                     //
00554   /////////////////////////////////////////////////////////////////////////
00555 
00556   void takeControl( );         // overrides ComputationManager
00557 
00558   /////////////////////////////////////////////////////////////////////////
00559   //                                                                     //
00560   // State Transitions:                                                  //
00561   //                                                                     //
00562   /////////////////////////////////////////////////////////////////////////
00563 
00564   void start( );              // overrides ComputationManager
00565 
00566   void terminate( ) { };      // overrides ComputationManager
00567 
00568 
00569 private:
00570 
00571   /////////////////////////////////////////////////////////////////////////
00572   //                                                                     //
00573   // Data Members:                                                       //
00574   //                                                                     //
00575   /////////////////////////////////////////////////////////////////////////
00576 
00577   SMFPGroup& theGroup;
00578 
00579   MirrorSubordinate computeBasis;
00580 
00581 };
00582 
00583 
00584 // ----------------- NGPresentationARCer ---------------------- //
00585 
00586 class NGPresentationARCer : public ARCer
00587 {
00588 public:
00589 
00590   /////////////////////////////////////////////////////////////////////////
00591   //                                                                     //
00592   // Constructors:                                                       //
00593   //                                                                     //
00594   /////////////////////////////////////////////////////////////////////////
00595 
00596   NGPresentationARCer( ComputationManager& boss ) 
00597     : ARCer( boss ),theGroup( 0 ), thePresentation( 0 ){ } 
00598   
00599   ~NGPresentationARCer( ) {  }
00600 
00601   /////////////////////////////////////////////////////////////////////////
00602   //                                                                     //
00603   // Accessors:                                                          //
00604   //                                                                     //
00605   /////////////////////////////////////////////////////////////////////////
00606 
00607   void setArguments(const NilpotentGroup& presentation);
00608   const PresentationForNG& getPresentation() const;
00609 
00610   // Inherited from ARCer:
00611   // bool takeControl( );
00612 
00613 
00614   /////////////////////////////////////////////////////////////////////////
00615   //                                                                     //
00616   // IPC interaction members:                                            //
00617   //                                                                     //
00618   /////////////////////////////////////////////////////////////////////////
00619 
00620   void runComputation( );
00621  
00622   void writeResults( ostream& );
00623 
00624   void readResults( istream& );
00625 
00626   
00627 private:
00628 
00629   /////////////////////////////////////////////////////////////////////////
00630   //                                                                     //
00631   // Data Members:                                                       //
00632   //                                                                     //
00633   /////////////////////////////////////////////////////////////////////////
00634 
00635   PresentationForNG* thePresentation;
00636   NilpotentGroup* theGroup;
00637 };
00638 
00639 // ------------------ NGdecomposeWordARCer ---------------------- //
00640 
00641 
00642 class NGdecomposeWordARCer : public ARCer
00643 {
00644 public:
00645 
00646   /////////////////////////////////////////////////////////////////////////
00647   //                                                                     //
00648   // Constructors:                                                       //
00649   //                                                                     //
00650   /////////////////////////////////////////////////////////////////////////
00651 
00652   NGdecomposeWordARCer( ComputationManager& boss ) 
00653     : ARCer( boss ),theNG(NULL) { } 
00654   
00655   ~NGdecomposeWordARCer() { delete theNG; }
00656 
00657   /////////////////////////////////////////////////////////////////////////
00658   //                                                                     //
00659   // Accessors:                                                          //
00660   //                                                                     //
00661   /////////////////////////////////////////////////////////////////////////
00662 
00663   void setArguments( const NilpotentGroup&, const Word& );
00664 
00665   PolyWord decomposition() { return retWord; }
00666 
00667   // Inherited from ARCer:
00668   // bool takeControl( );
00669 
00670 
00671   /////////////////////////////////////////////////////////////////////////
00672   //                                                                     //
00673   // IPC interaction members:                                            //
00674   //                                                                     //
00675   /////////////////////////////////////////////////////////////////////////
00676 
00677   void runComputation( );
00678  
00679   void writeResults( ostream& );
00680 
00681   void readResults( istream& );
00682 
00683   
00684 private:
00685 
00686   /////////////////////////////////////////////////////////////////////////
00687   //                                                                     //
00688   // Data Members:                                                       //
00689   //                                                                     //
00690   /////////////////////////////////////////////////////////////////////////
00691 
00692   NilpotentGroup* theNG;
00693   
00694   PolyWord retWord;
00695 
00696   Word theWord;
00697 };
00698 
00699 //---------------------------------------------------------------------------//
00700 //------------------------ NGdecomposeWord    -------------------------------//
00701 //---------------------------------------------------------------------------//
00702 
00703 
00704 class NGdecomposeWord : public ComputationManager
00705 {
00706 public:
00707 
00708   /////////////////////////////////////////////////////////////////////////
00709   //                                                                     //
00710   // Constructors:                                                       //
00711   //                                                                     //
00712   /////////////////////////////////////////////////////////////////////////
00713 
00714   NGdecomposeWord(class WCM& wcm);
00715   
00716   ~NGdecomposeWord( );
00717 
00718   /////////////////////////////////////////////////////////////////////////
00719   //                                                                     //
00720   // Accessors:                                                          //
00721   //                                                                     //
00722   /////////////////////////////////////////////////////////////////////////
00723 
00724 
00725   /////////////////////////////////////////////////////////////////////////
00726   //                                                                     //
00727   // Front End Interfacing:                                              //
00728   //                                                                     //
00729   /////////////////////////////////////////////////////////////////////////
00730 
00731   void viewStructure(ostream& ostr) const { }  // overrides SMObject
00732 
00733   /////////////////////////////////////////////////////////////////////////
00734   //                                                                     //
00735   // Control:                                                            //
00736   //                                                                     //
00737   /////////////////////////////////////////////////////////////////////////
00738 
00739   void takeControl( );         // overrides ComputationManager
00740 
00741   /////////////////////////////////////////////////////////////////////////
00742   //                                                                     //
00743   // State Transitions:                                                  //
00744   //                                                                     //
00745   /////////////////////////////////////////////////////////////////////////
00746 
00747   void start( );              // overrides ComputationManager
00748 
00749   void terminate( );          // overrides ComputationManager
00750 
00751 
00752 private:
00753 
00754   /////////////////////////////////////////////////////////////////////////
00755   //                                                                     //
00756   // Data Members:                                                       //
00757   //                                                                     //
00758   /////////////////////////////////////////////////////////////////////////
00759 
00760   class WCM& theWCM;
00761 
00762   class SMWord& theWord;
00763 
00764   NGdecomposeWordARCer arcer;
00765 
00766   bool  started;;
00767  
00768   
00769 };
00770 
00771 
00772 #endif

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