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

/magnus/back_end/Group/include/AbelianInfinitenessProblem.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: AbelianInfinitenessProblem.h,v 1.6 2000/02/09 23:58:01 bormotov Exp $
00003  */
00004 
00005 // Copyright (C) 1994 The New York Group Theory Cooperative
00006 // See magnus/doc/COPYRIGHT for the full notice.
00007 
00008 // Contents: Definition of the AbelianInfinitenessProblem class.
00009 //
00010 // Principal Authors: Dmitry Bormotov
00011 //
00012 // Status: 
00013 //
00014 // Revision History:
00015 //
00016 // Special Remarks:
00017 //
00018 
00019 
00020 #ifndef _ABELIANINFINITENESSPROBLEM_H_
00021 #define _ABELIANINFINITENESSPROBLEM_H_
00022 
00023 
00024 #include "FPGroup.h"
00025 #include "GaussTransformation.h"
00026 
00027 
00028 // ---------------------  AbelianInfinitenessProblem ------------------------//
00029 
00030 
00031 class AbelianInfinitenessProblem 
00032 {
00033 
00034 public:
00035 
00036   
00037   /////////////////////////////////////////////////////////////////////////
00038   //                                                                     //
00039   // Constructors:                                                       //
00040   //                                                                     //
00041   /////////////////////////////////////////////////////////////////////////
00042 
00043   AbelianInfinitenessProblem( const FPGroup& G) : theGroup( G ),
00044     bStart( false ), bDone( false ) { }
00045 
00046   ~AbelianInfinitenessProblem( ) 
00047   {
00048     if( !bDone ) // clear a memory
00049       finishComputation();
00050   }
00051       
00052 
00053   /////////////////////////////////////////////////////////////////////////
00054   //                                                                     //
00055   // Activation members:                                                 //
00056   //                                                                     //
00057   /////////////////////////////////////////////////////////////////////////
00058 
00059   void startComputation( );
00060   // Start the computation. 
00061   // You shouldn't call this more than one time.
00062              
00063   bool continueComputation( ) 
00064   {
00065   #if SAFETY > 0
00066     if ( !bStart )
00067       error("void AbelianInfinitenessProblem::continueComputation( ) : "
00068             "tried to continue computation before it's started");
00069   #endif
00070  
00071     if( bDone )
00072       return bDone;
00073 
00074     GT->run();
00075 
00076     if( GT->done() ) {
00077       itIsInfinite = ( GT->isSingular() == YES );
00078       finishComputation();
00079     }
00080 
00081     return bDone;
00082   }
00083   // Advance the computation. 
00084   // You have to call startComputation() before.
00085   // This function returns true if the computation is done.
00086 
00087 
00088   /////////////////////////////////////////////////////////////////////////
00089   //                                                                     //
00090   // Status Queries:                                                     //
00091   //                                                                     //
00092   /////////////////////////////////////////////////////////////////////////
00093 
00094   bool done( ) const { return bDone; }
00095   // true only when the computation is finished.
00096 
00097 
00098   /////////////////////////////////////////////////////////////////////////
00099   //                                                                     //
00100   // Accessors:                                                          //
00101   //                                                                     //
00102   /////////////////////////////////////////////////////////////////////////
00103 
00104   // You can call all these functions iff the computation is finished
00105   // ( when the done() functions returns true ).
00106 
00107   bool isInfinite( ) 
00108   {
00109   #if SAFETY > 0
00110     if ( !bDone )
00111       error("bool AbelianInfinitenessProblem::isInfinite( ) : "
00112             "tried to get result before the computation is finished.");
00113   #endif
00114 
00115     return itIsInfinite;
00116   }
00117 
00118   
00119 private:
00120 
00121 
00122   /////////////////////////////////////////////////////////////////////////
00123   //                                                                     //
00124   // Data Members:                                                       //
00125   //                                                                     //
00126   /////////////////////////////////////////////////////////////////////////
00127 
00128   bool bDone;
00129   bool bStart;
00130   bool itIsInfinite;
00131   Matrix<Rational> *matrix;
00132   int width;
00133   int height;
00134   const FPGroup theGroup;
00135   GaussTransformation<Rational> *GT;
00136 
00137 
00138   /////////////////////////////////////////////////////////////////////////
00139   //                                                                     //
00140   // Private methods:                                                    //
00141   //                                                                     //
00142   /////////////////////////////////////////////////////////////////////////
00143 
00144   AbelianInfinitenessProblem( const AbelianInfinitenessProblem& );
00145   // It is hidden, not implemented.
00146 
00147   AbelianInfinitenessProblem& operator = ( const AbelianInfinitenessProblem& );
00148   // It is hidden, not implemented.
00149 
00150   void finishComputation( );
00151 
00152 
00153   /////////////////////////////////////////////////////////////////////////
00154   //                                                                     //
00155   // Debugging stuff:                                                    //
00156   //                                                                     //
00157   /////////////////////////////////////////////////////////////////////////
00158 
00159 #ifdef DEBUG
00160   //friend int main( );
00161 #endif
00162 
00163 };
00164 
00165 #endif

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