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

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

Go to the documentation of this file.
00001 /*
00002  *   $Id: RingParser.h,v 1.2 2000/02/10 00:00:17 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 RingEltParser, MatrixParser,
00009 //           MonomialParser, PolynomialParser.
00010 //
00011 // Principal Author: Dmitry Bormotov
00012 //
00013 // Status: In development
00014 //
00015 // Usage:
00016 //
00017 // Revision History:
00018 //
00019 
00020 
00021 #ifndef _RING_PARSER_H_
00022 #define _RING_PARSER_H_
00023 
00024 #include "WordParser.h"
00025 #include "Polynomial.h"
00026 
00027 
00028 template <class R> class PolynomialParser;
00029 template <class R> class Monomial;
00030 template <class R> class Polynomial;
00031 
00032 
00033 //------------------------------ RingEltParser ------------------------------//
00034 
00035 
00036 template <class R> class RingEltParser : public WordParser 
00037 {
00038 
00039 public:
00040 
00041 
00042   //////////////////////////////////////////////////////////////
00043   //                                                          //
00044   // Constructors:                                            //
00045   //                                                          //
00046   //////////////////////////////////////////////////////////////
00047 
00048   RingEltParser(istream &istr) : WordParser(istr) { }
00049   // Initialize the parser with the istream from which to read.
00050 
00051   // Destructor supplied by compiler.
00052 
00053 
00054   //////////////////////////////////////////////////////////////
00055   //                                                          //
00056   // Accessors:                                               //
00057   //                                                          //
00058   //////////////////////////////////////////////////////////////
00059 
00060   void parseWhiteSpace( );
00061     
00062   R parseRingElt( Chars& errMesg );
00063 
00064 
00065 //private:
00066 
00067 
00068   //////////////////////////////////////////////////////////////
00069   //                                                          //
00070   // Data members:                                            //
00071   //                                                          //
00072   //////////////////////////////////////////////////////////////
00073 
00074 
00075 
00076   //////////////////////////////////////////////////////////////
00077   //                                                          //
00078   // Private functions:                                       //
00079   //                                                          //
00080   //////////////////////////////////////////////////////////////
00081 
00082 
00083 
00084   /////////////////////////////////////////////////////////////////////////
00085   //                                                                     //
00086   //  Debugging stuff:                                                   //
00087   //                                                                     //
00088   /////////////////////////////////////////////////////////////////////////
00089 
00090 #ifdef DEBUG
00091 
00092   //friend int main(...);
00093 
00094 #endif
00095 
00096 };
00097 
00098 
00099 //----------------------------- MatrixParser --------------------------------//
00100 
00101 
00102 // The matrices must have the form like 
00103 // [
00104 //   [ x11, x12, x13 ],
00105 //   [ x21, x22, x23 ],
00106 //   [ x31, x32, x33 ]
00107 // ]
00108 
00109 
00110 template <class R> class MatrixParser : public RingEltParser<R> {
00111 
00112 public:
00113 
00114   //////////////////////////////////////////////////////////////
00115   //                                                          //
00116   // Constructors:                                            //
00117   //                                                          //
00118   //////////////////////////////////////////////////////////////
00119 
00120   MatrixParser(istream &istr) : RingEltParser<R>(istr) { }
00121   // Initialize the parser with the istream from which to read.
00122 
00123   // Destructor supplied by compiler.
00124 
00125   //////////////////////////////////////////////////////////////
00126   //                                                          //
00127   // Parser function:                                         //
00128   //                                                          //
00129   //////////////////////////////////////////////////////////////
00130     
00131   bool parseMatrix( Chars& errMesg, R ***M, int& MSize );
00132 
00133 
00134 private:
00135 
00136   //////////////////////////////////////////////////////////////
00137   //                                                          //
00138   // Private functions:                                       //
00139   //                                                          //
00140   //////////////////////////////////////////////////////////////
00141 
00142   VectorOf<R> parseMatrixRow( Chars& errMesg );
00143   
00144   void deleteMatrix( R ***M, int MSize );
00145 
00146 
00147   /////////////////////////////////////////////////////////////////////////
00148   //                                                                     //
00149   //  Debugging stuff:                                                   //
00150   //                                                                     //
00151   /////////////////////////////////////////////////////////////////////////
00152 
00153 #ifdef DEBUG
00154 
00155   //friend int main( );
00156 
00157 #endif
00158 
00159 };
00160 
00161 
00162 //---------------------------- MonomialParser -------------------------------//
00163 
00164 
00165 template <class R> class MonomialParser : public RingEltParser<R> 
00166 {
00167   
00168   friend class PolynomialParser<R>;
00169 
00170 public:
00171 
00172 
00173   //////////////////////////////////////////////////////////////
00174   //                                                          //
00175   // Constructors:                                            //
00176   //                                                          //
00177   //////////////////////////////////////////////////////////////
00178 
00179   MonomialParser(istream &istr) : RingEltParser<R>(istr) { }
00180   // Initialize the parser with the istream from which to read.
00181 
00182   // Destructor supplied by compiler.
00183 
00184   //////////////////////////////////////////////////////////////
00185   //                                                          //
00186   // Parser function:                                         //
00187   //                                                          //
00188   //////////////////////////////////////////////////////////////
00189     
00190   Monomial<R> parseMonomial( Chars& errMesg )
00191   {
00192     bool isLastMonomial;
00193     return getMonomial(errMesg, isLastMonomial);
00194   }
00195 
00196 private:
00197 
00198 
00199   //////////////////////////////////////////////////////////////
00200   //                                                          //
00201   // Data members:                                            //
00202   //                                                          //
00203   //////////////////////////////////////////////////////////////
00204 
00205   static const int maxNumberOfVariables = 100;
00206 
00207 
00208   //////////////////////////////////////////////////////////////
00209   //                                                          //
00210   // Private functions:                                       //
00211   //                                                          //
00212   //////////////////////////////////////////////////////////////
00213 
00214   Monomial<R> getMonomial( Chars& errMesg, bool& isLastMonomial );
00215 
00216 
00217   /////////////////////////////////////////////////////////////////////////
00218   //                                                                     //
00219   //  Debugging stuff:                                                   //
00220   //                                                                     //
00221   /////////////////////////////////////////////////////////////////////////
00222 
00223 #ifdef DEBUG
00224 
00225   //friend int main( );
00226 
00227 #endif
00228 
00229 };
00230 
00231 
00232 //--------------------------- PolynomialParser ------------------------------//
00233 
00234 
00235 template <class R> class PolynomialParser : public MonomialParser<R> 
00236 {
00237   
00238 public:
00239   
00240   
00241   //////////////////////////////////////////////////////////////
00242   //                                                          //
00243   // Constructors:                                            //
00244   //                                                          //
00245   //////////////////////////////////////////////////////////////
00246 
00247   PolynomialParser(istream &istr) : MonomialParser<R>(istr) { }
00248   // Initialize the parser with the istream from which to read.
00249 
00250   // Destructor supplied by compiler.
00251 
00252 
00253   //////////////////////////////////////////////////////////////
00254   //                                                          //
00255   // Parser function:                                         //
00256   //                                                          //
00257   //////////////////////////////////////////////////////////////
00258     
00259   Polynomial<R> parsePolynomial( Chars& errMesg );
00260 
00261 
00262 private:
00263 
00264 
00265   //////////////////////////////////////////////////////////////
00266   //                                                          //
00267   // Data members:                                            //
00268   //                                                          //
00269   //////////////////////////////////////////////////////////////
00270 
00271 
00272   //////////////////////////////////////////////////////////////
00273   //                                                          //
00274   // Private functions:                                       //
00275   //                                                          //
00276   //////////////////////////////////////////////////////////////
00277 
00278 
00279   /////////////////////////////////////////////////////////////////////////
00280   //                                                                     //
00281   //  Debugging stuff:                                                   //
00282   //                                                                     //
00283   /////////////////////////////////////////////////////////////////////////
00284 
00285 #ifdef DEBUG
00286 
00287   //friend int main( );
00288 
00289 #endif
00290 
00291 };
00292 
00293 #endif
00294 
00295 
00296 

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