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

/magnus/back_end/Elt/include/AbelianWord.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: AbelianWord.h,v 1.2 1996/11/15 22:07:15 alex 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 classes AbelianWord, AbelianWordRep
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: in progress
00013 //
00014 // Usage:
00015 //
00016 // Special Notes:
00017 //
00018 // Revision History:
00019 //
00020 
00021 #ifndef _AbelianWord_h_
00022 #define _AbelianWord_h_
00023 
00024 #include "Integer.h"
00025 #include "Vector.h"
00026 #include "PureRep.h"
00027 #include "Word.h"
00028 
00029 
00030 // --------------------------- AbelianWordRep ------------------------------ //
00031 
00032 
00033 class AbelianWordRep : public PureRep
00034 {
00035 
00036 public:
00037   
00038   /////////////////////////////////////////////////////////////////////////
00039   //                                                                     //
00040   //  Constructors:                                                      //
00041   //                                                                     //
00042   /////////////////////////////////////////////////////////////////////////
00043 
00044   // No default constructor
00045   // Copy constructor provided by compiler (does logical deep copy).
00046 
00047   AbelianWordRep( ) { }
00048 
00049   AbelianWordRep( int numOfGens, const Word& w );
00050 
00051   AbelianWordRep( const VectorOf<Integer>& v ) : thePowers( v ) { }
00052   
00053 
00054   /////////////////////////////////////////////////////////////////////////
00055   //                                                                     //
00056   //  Operators:                                                         //
00057   //                                                                     //
00058   /////////////////////////////////////////////////////////////////////////
00059 
00060   bool operator == ( const AbelianWordRep& w ) const;
00061  
00062   Integer operator [] ( int i ) const;
00063 
00064   Integer& operator [] ( int i );
00065 
00066   AbelianWordRep* operator * ( const AbelianWordRep& aw ) const;
00067 
00068   /////////////////////////////////////////////////////////////////////////
00069   //                                                                     //
00070   //  Accessors:                                                         //
00071   //                                                                     //
00072   /////////////////////////////////////////////////////////////////////////
00073 
00074   int numberOfGenerators( ) const { return thePowers.length(); }
00075 
00076   VectorOf<Integer> getPowers( ) const { return thePowers; }
00077 
00078   Word getWord( ) const;
00079 
00080   Integer fullLength( ) const;
00081 
00082   AbelianWordRep inverse( ) const;
00083 
00084   bool isTrivial( ) const;
00085 
00086 
00087   /////////////////////////////////////////////////////////////////////////
00088   //                                                                     //
00089   //  I/O                                                                //
00090   //                                                                     //
00091   /////////////////////////////////////////////////////////////////////////
00092     
00093   void printOn( ostream& ) const;
00094   
00095   // Input operator is not yet implemented.
00096 
00097 
00098   /////////////////////////////////////////////////////////////////////////
00099   //                                                                     //
00100   //  IPC tools:                                                         //
00101   //                                                                     //
00102   /////////////////////////////////////////////////////////////////////////
00103 
00104   void write( ostream& ostr ) const;
00105 
00106   void read( istream& istr );
00107 
00108 
00109   /////////////////////////////////////////////////////////////////////////
00110   //                                                                     //
00111   //  Representation methods:                                            //
00112   //                                                                     //
00113   /////////////////////////////////////////////////////////////////////////
00114   
00115   AbelianWordRep* clone( ) const { return new AbelianWordRep(*this); }
00116   // overrides PureRep::clone()
00117   
00118 
00119 private:
00120 
00121   /////////////////////////////////////////////////////////////////////////
00122   //                                                                     //
00123   //  Data members:                                                      //
00124   //                                                                     //
00125   /////////////////////////////////////////////////////////////////////////
00126 
00127   VectorOf<Integer> thePowers;
00128 };
00129 
00130 
00131 // ---------------------------- AbelianWord -------------------------------- //
00132 
00133 
00134 class AbelianWord : public ObjectOf<AbelianWordRep>
00135 {
00136 
00137 public:
00138   
00139   /////////////////////////////////////////////////////////////////////////
00140   //                                                                     //
00141   //  Constructors:                                                      //
00142   //                                                                     //
00143   /////////////////////////////////////////////////////////////////////////
00144 
00145   // Copy constructor provided by compiler (does logical deep copy).
00146 
00147   AbelianWord( )
00148     : ObjectOf<AbelianWordRep>( new AbelianWordRep( ) ) { }
00149 
00150   AbelianWord( int numOfGens, const Word& w )
00151     : ObjectOf<AbelianWordRep>( new AbelianWordRep(numOfGens,w) ) { }
00152 
00153   AbelianWord( const VectorOf<Integer>& v )
00154     : ObjectOf<AbelianWordRep>( new AbelianWordRep(v) ) { }
00155   
00156 
00157   /////////////////////////////////////////////////////////////////////////
00158   //                                                                     //
00159   //  Operators:                                                         //
00160   //                                                                     //
00161   /////////////////////////////////////////////////////////////////////////
00162 
00163   // Operator = provided by compiler.
00164 
00165   bool operator == ( const AbelianWord& w ) const {
00166     return ( (look() == w.look()) || (*look() == *w.look()) );
00167   }
00168   // Returns true if the word is equal to w.
00169 
00170   int operator != ( const AbelianWord& w ) const { return !( *this == w ); }
00171   // Returns true if the word is not equal to w.
00172 
00173   Integer operator [] ( int i ) const {
00174     return look() -> operator [](i);
00175   }
00176   // Returns the power of i-th generator in abelian form of the word.
00177 
00178   Integer& operator [] ( int i ) {
00179     return change() -> operator [](i);
00180   }
00181   // Returns the power of i-th generator in abelian form of the word.
00182 
00183   AbelianWord operator * ( const AbelianWord& w ) const {
00184          return AbelianWord( *look() * *w.look() );
00185   }
00186   /////////////////////////////////////////////////////////////////////////
00187   //                                                                     //
00188   //  Accessors:                                                         //
00189   //                                                                     //
00190   /////////////////////////////////////////////////////////////////////////
00191 
00192   int numberOfGenerators( ) const {
00193     return look()->numberOfGenerators();
00194   }
00195   // Returns the number of different generators in the word presentation.
00196 
00197   VectorOf<Integer> getPowers( ) const {
00198     return look()->getPowers();
00199   }
00200   // Transforms an abelian word to a vector of generators powers
00201 
00202   Word getWord( ) const {
00203     return look()->getWord();
00204   }
00205   // Transforms an abelian word to an usual word. 
00206 
00207   Integer fullLength( ) const {
00208     return look()->fullLength();
00209   }
00210   // I.e. the sum of all powers.
00211 
00212   AbelianWord inverse( ) const {
00213     return new AbelianWordRep( look()->inverse() );
00214   }
00215   // Computes the inverse word.
00216 
00217   bool isTrivial( ) const {
00218     return look()->isTrivial();
00219   }
00220   // True if word is equal to 1.
00221 
00222 
00223   /////////////////////////////////////////////////////////////////////////
00224   //                                                                     //
00225   //  I/O                                                                //
00226   //                                                                     //
00227   /////////////////////////////////////////////////////////////////////////
00228 
00229   friend ostream& operator << ( ostream& ostr, const AbelianWord& w )
00230   {
00231     w.look()->printOn(ostr);
00232     return ostr;
00233   }
00234   
00235   // Input operator is not yet implemented.
00236 
00237 
00238   /////////////////////////////////////////////////////////////////////////
00239   //                                                                     //
00240   // IPC tools:                                                          //
00241   //                                                                     //
00242   /////////////////////////////////////////////////////////////////////////
00243 
00244   friend ostream& operator < ( ostream& ostr, const AbelianWord& w )
00245   {
00246     w.look()->write(ostr);
00247     return ostr;
00248   }
00249   
00250   friend istream& operator > ( istream& istr, AbelianWord& w )
00251   {
00252     w.change()->read(istr);
00253     return istr;
00254   }
00255 
00256 
00257 protected:
00258 
00259   /////////////////////////////////////////////////////////////////////////
00260   //                                                                     //
00261   // Protected functions:                                                //
00262   //                                                                     //
00263   /////////////////////////////////////////////////////////////////////////
00264 
00265   AbelianWord( AbelianWordRep* newrep ) 
00266     : ObjectOf<AbelianWordRep>(newrep) { }
00267 
00268 };
00269 
00270 #endif

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