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

/magnus/back_end/Polynomial/include/Polynomial.h

Go to the documentation of this file.
00001 /*
00002  *   $Id: Polynomial.h,v 1.2 2000/02/10 00:00:16 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: Definitions of classes Monomial, Polynomial.
00009 //
00010 // Principal Author: Dmitry Bormotov
00011 //
00012 // Status: In development
00013 //
00014 // Usage:
00015 //
00016 // Revision History:
00017 //
00018 
00019 
00020 #ifndef _Polynomial_H_
00021 #define _Polynomial_H_
00022 
00023 #include "Integer.h"
00024 #include "Rational.h"
00025 #include "RingParser.h"
00026 #include "IStreamPoll.h"
00027 #include "PBTree.h"
00028 
00029 
00030 template <class R> class Polynomial;
00031 template <class R> class MonomialParser;
00032 template <class R> class PolynomialParser;
00033 
00034 
00035 //--------------------------------- Monomial --------------------------------//
00036 
00037 
00038 //@db 2.91
00039 
00040 template <class R> class Monomial;
00041 
00042 template <class R>
00043 ostream& operator << ( ostream& ostr, const Monomial<R>& M )
00044 {
00045   M.printOn(ostr);
00046   return ostr;
00047 }
00048 
00049 template <class R>
00050 IStreamPoll operator >> ( istream& istr, Monomial<R>& M )
00051 {
00052   Chars errMesg;
00053   M = M.readFrom(istr, errMesg);
00054   return IStreamPoll( istr, errMesg );
00055 }
00056 
00057 // 2.91 temporary hacks
00058 
00059 template <class R>
00060 ostream& operator < ( ostream& ostr, const Monomial<R>& M )
00061 {
00062   //o.write(ostr);
00063   return ostr;
00064 }
00065 
00066 template <class R>
00067 istream& operator > ( istream& istr, Monomial<R>& M )
00068 {
00069   //o.read(istr);
00070   return istr;
00071 }
00072 
00073 //@db end 
00074 
00075 
00076 template <class R> class Monomial
00077 {
00078 
00079   friend class Polynomial<R>;
00080 
00081 public:
00082 
00083 
00084   /////////////////////////////////////////////////////////////////////////
00085   //                                                                     //
00086   // Constructors:                                                       //
00087   //                                                                     //
00088   /////////////////////////////////////////////////////////////////////////
00089 
00090   Monomial( const char * );
00091 
00092   Monomial( R coef = 0, int numOfVars = 0, const int *powersOfVars = NULL );
00093 
00094   Monomial( const Monomial& );
00095 
00096   ~Monomial( ) 
00097   {     
00098     if( numberOfVariables > 0 )
00099       delete [] powersOfVariables; 
00100   }
00101 
00102 
00103   /////////////////////////////////////////////////////////////////////////
00104   //                                                                     //
00105   // Operators:                                                          //
00106   //                                                                     //
00107   /////////////////////////////////////////////////////////////////////////
00108 
00109   bool operator == ( const Monomial& ) const;
00110   
00111   Monomial& operator = ( const Monomial& );
00112 
00113   Monomial operator - () const;
00114 
00115   Monomial operator * ( const Monomial& ) const;
00116 
00117   Monomial operator + ( const Monomial& ) const;
00118 
00119   Monomial& operator += ( const Monomial& );
00120 
00121   //bool operator < ( const Monomial& M ) const { return compare(M) < 0; }
00122 
00123   /////////////////////////////////////////////////////////////////////////
00124   //                                                                     //
00125   // Accessors:                                                          //
00126   //                                                                     //
00127   /////////////////////////////////////////////////////////////////////////
00128 
00129   int compare( const Monomial& ) const;
00130   
00131   R getCoefficient( ) const { return theCoefficient; }
00132 
00133   void setCoefficient( const R& c ) { theCoefficient = c; }
00134 
00135   int getNumberOfVariables() const { return numberOfVariables; }
00136 
00137   int getPowerOfVariable( int i ) const;
00138 
00139   void setPowerOfVariable( int i, int v);
00140 
00141 
00142   /////////////////////////////////////////////////////////////////////////
00143   //                                                                     //
00144   // I/O:                                                                //
00145   //                                                                     //
00146   /////////////////////////////////////////////////////////////////////////
00147 
00148   friend ostream& operator << <R> ( ostream& ostr, const Monomial<R>& M );
00149 
00150   friend IStreamPoll operator >> <R> ( istream& istr, Monomial<R>& M );
00151 
00152 
00153   //@db 2.91 temporary hacks:
00154   
00155   friend ostream& operator < <R> ( ostream& ostr, const Monomial<R>& M );
00156   
00157   friend istream& operator > <R> ( istream& istr, Monomial<R>& M );
00158 
00159 
00160 private:
00161 
00162   /////////////////////////////////////////////////////////////////////////
00163   //                                                                     //
00164   // Data Members:                                                       //
00165   //                                                                     //
00166   /////////////////////////////////////////////////////////////////////////
00167 
00168   R theCoefficient;
00169   int numberOfVariables;
00170   int *powersOfVariables;
00171 
00172 
00173   //////////////////////////////////////////////////////////////
00174   //                                                          //
00175   // Private functions:                                       //
00176   //                                                          //
00177   //////////////////////////////////////////////////////////////
00178 
00179   void printOn( ostream& ) const;
00180 
00181   Monomial readFrom( istream& istr, Chars& errMesg )
00182   {
00183     MonomialParser<R> P(istr);
00184     return P.parseMonomial(errMesg);
00185   }
00186 
00187 
00188   /////////////////////////////////////////////////////////////////////////
00189   //                                                                     //
00190   //  Debugging stuff:                                                   //
00191   //                                                                     //
00192   /////////////////////////////////////////////////////////////////////////
00193 
00194 #ifdef DEBUG
00195 
00196   //friend int main(...);
00197 
00198 #endif
00199 
00200 };
00201 
00202 
00203 //-------------------------------- Polynomial -------------------------------//
00204 
00205 
00206 //@db 2.91
00207 
00208 template <class R> class Polynomial;
00209 
00210 template <class R>
00211 IStreamPoll operator >> ( istream& istr, Polynomial<R>& P )
00212 {
00213   Chars errMesg;
00214   P = P.readFrom(istr, errMesg);
00215   return IStreamPoll( istr, errMesg );
00216 }
00217 
00218 //@db
00219 
00220 
00221 template <class R> 
00222 class Polynomial : public PBTree< Monomial<R>, Monomial<R> >
00223 {
00224 
00225 public:
00226 
00227 
00228   /////////////////////////////////////////////////////////////////////////
00229   //                                                                     //
00230   // Constructors:                                                       //
00231   //                                                                     //
00232   /////////////////////////////////////////////////////////////////////////
00233 
00234   Polynomial( ) : PBTree< Monomial<R>, Monomial<R> >( ) { }  
00235 
00236   Polynomial( const char*);
00237 
00238   Polynomial( const Monomial<R>& );
00239 
00240   Polynomial( const Polynomial& );
00241 
00242   Polynomial( const R& );
00243 
00244 
00245   /////////////////////////////////////////////////////////////////////////
00246   //                                                                     //
00247   // Operators:                                                          //
00248   //                                                                     //
00249   /////////////////////////////////////////////////////////////////////////
00250 
00251   bool operator == ( const Polynomial& ) const;
00252 
00253   bool operator != ( const Polynomial& ) const;
00254 
00255   Polynomial& operator = ( const Polynomial& );
00256 
00257   Polynomial& operator += ( const Polynomial& );
00258 
00259   Polynomial& operator -= ( const Polynomial& );
00260 
00261   Polynomial& operator *= ( const Polynomial& );
00262 
00263   Polynomial operator + ( const Polynomial& ) const; 
00264 
00265   Polynomial operator - ( const Polynomial& ) const; 
00266 
00267   Polynomial operator * ( const Polynomial& ) const; 
00268 
00269   Polynomial operator - ( ) const;
00270 
00271 
00272   /////////////////////////////////////////////////////////////////////////
00273   //                                                                     //
00274   // Accessors:                                                          //
00275   //                                                                     //
00276   /////////////////////////////////////////////////////////////////////////
00277 
00278   bool isIdentity( ) const;
00279 
00280   int degree( ) const;
00281 
00282   int numberOfMonomials( ) const;
00283 
00284 
00285   /////////////////////////////////////////////////////////////////////////
00286   //                                                                     //
00287   // I/O:                                                                //
00288   //                                                                     //
00289   /////////////////////////////////////////////////////////////////////////
00290 
00291   friend ostream& operator << ( ostream& ostr, const Polynomial& P )
00292   {
00293     P.printOn(ostr);
00294     return ostr;
00295   }
00296 
00297   friend IStreamPoll operator >> <R> ( istream& istr, Polynomial<R>& P );
00298 
00299 private:
00300 
00301 
00302   /////////////////////////////////////////////////////////////////////////
00303   //                                                                     //
00304   // Data Members:                                                       //
00305   //                                                                     //
00306   /////////////////////////////////////////////////////////////////////////
00307 
00308 
00309   /////////////////////////////////////////////////////////////////////////
00310   //                                                                     //
00311   // Private functions:                                                  //
00312   //                                                                     //
00313   /////////////////////////////////////////////////////////////////////////
00314 
00315   void printOn( ostream& ) const;
00316 
00317   Polynomial readFrom( istream& istr, Chars& errMesg )
00318   {
00319     PolynomialParser<R> P(istr);
00320     return P.parsePolynomial(errMesg);
00321   }
00322 
00323   virtual void theKeyIsFound( const Monomial<R>& key, Monomial<R>& value )
00324   {
00325     value += key;
00326     if( value.getCoefficient() == R(0) )
00327       remove(value);
00328     //R c = value.getCoefficient();
00329     //value.setCoefficient( c + key.getCoefficient() ); 
00330   } 
00331 
00332   /////////////////////////////////////////////////////////////////////////
00333   //                                                                     //
00334   //  Debugging stuff:                                                   //
00335   //                                                                     //
00336   /////////////////////////////////////////////////////////////////////////
00337 
00338 #ifdef DEBUG
00339 
00340   //friend int main( );
00341 
00342 #endif
00343 
00344 };
00345 
00346 template <class R> 
00347 struct PolynomialIterator : public PBTreeIterator< Monomial<R>, Monomial<R> >
00348 { 
00349   PolynomialIterator( const Polynomial<R>& P )
00350     : PBTreeIterator< Monomial<R>, Monomial<R> > ( P ) { }
00351 };
00352 
00353 #endif
00354 
00355 
00356 

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