CoCoALib-0.9905 date: 23 May 2007


TmpGPoly.H

Go to the documentation of this file.
00001 #ifndef CoCoA_GPoly_H
00002 #define CoCoA_GPoly_H
00003 
00004 //   Copyright (c)  2005  Massimo Caboara
00005 
00006 //   This file is part of the source of CoCoALib, the CoCoA Library.
00007 
00008 //   CoCoALib is free software; you can redistribute it and/or modify
00009 //   it under the terms of the GNU General Public License (version 2)
00010 //   as published by the Free Software Foundation.  A copy of the full
00011 //   licence may be found in the file COPYING in this directory.
00012 
00013 //   CoCoALib is distributed in the hope that it will be useful,
00014 //   but WITHOUT ANY WARRANTY; without even the implied warranty of
00015 //   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00016 //   GNU General Public License for more details.
00017 
00018 //   You should have received a copy of the GNU General Public License
00019 //   along with CoCoA; if not, write to the Free Software
00020 //   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
00021 
00022 
00023 #include "CoCoA/SparsePolyRing.H"
00024 #include "CoCoA/RingHom.H"
00025 #include "CoCoA/FreeModule.H"
00026 #include "CoCoA/PPWithMask.H"
00027 #include "CoCoA/TmpGTypes.H"
00028 
00029 #include<list>
00030 // using std::list; // for GPolyList; GPolyPtrList;
00031 #include<vector>
00032 // using std::vector; // for GPolyPtrVector;
00033 
00034 
00035 namespace CoCoA
00036 {
00037 
00038   class GPair;     // fwd decl
00039   class Reductors; // fwd decl
00040 
00041   namespace CoeffEncoding
00042   {
00043     enum type {Field, FrFldOfGCDDomain};
00044   }
00045 
00046 // Two utilities for GRingInfo ctors
00047 
00048   RingHom CreateNewP2OldPRingHom(const SparsePolyRing& theNewSPR,
00049                                  const SparsePolyRing& theOldSPR);
00050 
00051   RingHom CreateOldP2NewPRingHom(const SparsePolyRing& theNewSPR,
00052                                  const SparsePolyRing& theOldSPR);
00053 
00054 //-- class GRingInfo --------------------------------------------------*/
00055 
00056 
00057 // Add fields for GradingIndex,ModulevarIndex.
00058 
00059 unsigned int ModuleVarIndex(const SparsePolyRing&);
00060 
00061 enum ComputationInputAndGradingType {AllGraded,AllAffine,AffineInputWithGradedRing};
00062 
00063 
00064 class GRingInfo
00065 {
00066 
00067 public:
00068   GRingInfo(const SparsePolyRing& theNewSPR,       // when you have polynomials only ie GB
00069             const bool HomogeneousInput,
00070             const DivMaskRule&);
00071   GRingInfo(const SparsePolyRing& theNewSPR,       // when you have modules from theFM
00072             const SparsePolyRing& theOldSPR,
00073             const FreeModule& theFM,
00074             const FreeModule& theOutputFM,
00075             const bool HomogeneousInput,
00076             const DivMaskRule&);
00077   GRingInfo(const SparsePolyRing& theNewSPR,      // when you have module op on polynomials result vectorlist
00078             const SparsePolyRing& theOldSPR,
00079             const FreeModule& theOutputFM,
00080             const bool HomogeneousInput,
00081             const DivMaskRule&);
00082   GRingInfo(const SparsePolyRing& theNewSPR,      // when you have module op on polynomials result polylist
00083             const SparsePolyRing& theOldSPR,
00084             const bool HomogeneousInput,
00085             const DivMaskRule&);
00086   ~GRingInfo(){};
00087   const SparsePolyRing& myNewSPR()const{return myNewSPRValue;};
00088   const SparsePolyRing& myOldSPR()const{return myOldSPRValue;};
00089   const FreeModule myFreeModule()const{return myFreeModuleValue;};
00090   const FreeModule myOutputFreeModule()const{return myOutputFreeModuleValue;};
00091   const RingHom& myNewP2OldP()const{return myNewP2OldPValue;};
00092   const RingHom& myOldP2NewP()const{return myOldP2NewPValue;};
00093   const DivMaskRule myDivMaskRule()const{return myDivMaskRuleValue;};
00094   CoeffEncoding::type myCoeffRingType() const { return myCoeffRingTypeValue; }
00095   void mySetCoeffRingType(CoeffEncoding::type CT); ///< Field or FrFldOfGCDDomain
00096   unsigned int myComponent(const unsigned int i)const{return myMaxComponentIndex-i;}; //Complement to myMaxComponentIndex
00097   unsigned int myComponent(ConstRefPPMonoidElem T)const;// the real component of a PP
00098   unsigned int myPhonyComponent(ConstRefPPMonoidElem T)const;// the phony component of a PP
00099   size_t TmpStdDeg(ConstRefPPMonoidElem)const;// the real degree even when the poly is a module elem
00100   bool operator==(const GRingInfo&)const;
00101   // Are equal myNewSPRValue and myDivMaskRuleValue only
00102   friend bool AreCompatible(const GRingInfo&,const GRingInfo&);
00103   friend std::ostream& operator<<(std::ostream& out, const GRingInfo& theGRI);
00104   bool AmIModule()const{return AmIModuleValue;};
00105 
00106   ConstRefRingElem myE()const{return indet(myNewSPR(),ModuleVarIndex(myNewSPR()));};
00107   std::vector<RingElem> myEY()const{return myEYValue;};
00108   std::vector<RingElem> myY()const;
00109   RingElem myY(const size_t i)const{return indet(myNewSPR(),i+NumIndets(myNewSPRValue)-1-GradingDim(myNewSPRValue));};
00110   RingElem myY(const degree& the_d)const;
00111   ConstRefRingElem myEY(const size_t i)const{return myEYValue[i];};
00112   RingElem myE(const size_t i)const{return power(myE(),myComponent(i));};
00113   bool AmIGraded()const{return myEYValue.empty();};
00114   bool IsMyGradingPosPlus()const{return myGradingPosPlusValue;};
00115   //void SetMyGradingPosPlus(bool b){myGradingPosPlusValue=b;};
00116   ComputationInputAndGradingType myInputAndGrading()const{return myInputAndGradingValue;};
00117   friend ComputationInputAndGradingType  DetermineComputationType(const size_t GrDim,
00118                                                                   const bool IsHomog);
00119   bool DetermineIfMyGradingIsPosPlus(const SparsePolyRing&);
00120 
00121 private:
00122   const SparsePolyRing myNewSPRValue;// embedding info
00123   const SparsePolyRing myOldSPRValue;
00124   const FreeModule myFreeModuleValue;
00125   const FreeModule myOutputFreeModuleValue;
00126   RingHom myNewP2OldPValue;// completely defined by myNewSPR,myOldSPRValue
00127   RingHom myOldP2NewPValue;
00128   const DivMaskRule myDivMaskRuleValue;
00129   const bool AmIModuleValue;
00130   static const unsigned int myMaxComponentIndex=10000;
00131   std::vector<RingElem> myEYValue;
00132   CoeffEncoding::type myCoeffRingTypeValue;
00133   ComputationInputAndGradingType myInputAndGradingValue;
00134   bool myGradingPosPlusValue;
00135 
00136 // FM and the two ring hom. Do we want a separate Module2RingEmbedding class?
00137 //myReductionRule
00138 //myLPPMonoid (?)
00139 
00140 };// end class GRingInfo
00141 
00142 
00143 
00144 
00145 inline unsigned int Component(ConstRefPPMonoidElem T,
00146                               const GRingInfo& theGRI)
00147 {
00148   if (!theGRI.AmIModule()) return 0;// True Ring
00149   return log(T,ModuleVarIndex(theGRI.myNewSPR()));
00150 }
00151 
00152 
00153 enum ClearType {clear};
00154 
00155 class GPoly;
00156 
00157 
00158 typedef std::list<GPoly> GPolyList;
00159 
00160 
00161 /*-- class GPoly --------------------------------------------------*/
00162 /**
00163 
00164 This class is only a wrapper around the polys.
00165 Some other data useful for GBasis computation is added.
00166 
00167 */
00168 /*-----------------------------------------------------------------*/
00169 
00170   class GPoly
00171   {
00172   public:
00173     enum ReductionMarker { Full, OnlyTail };
00174 
00175   public:
00176     GPoly(ConstRefRingElem,
00177           const GRingInfo&,
00178     unsigned int age=0);
00179     GPoly(ConstRefRingElem,
00180           const PPWithMask&,
00181     ConstRefRingElem,
00182     const GRingInfo&,
00183     unsigned int age=0);///< this ctor takes LPP and LC from input for Dynamic Algorithm
00184     GPoly(RefRingElem,
00185           const GRingInfo&,
00186     const ClearType,
00187     unsigned int age=0);  ///< this ctor resets RefRingElem
00188     GPoly(RefRingElem,
00189           const PPWithMask&,
00190     ConstRefRingElem,
00191     const GRingInfo&,
00192     const ClearType,
00193     unsigned int age=0);///< this ctor resets RefRingElem and takes LPP and LC from input for Dynamic Algorithm
00194      explicit  GPoly(const GRingInfo&);
00195     GPoly(const GPoly&);
00196     ~GPoly(){};
00197     inline bool operator<(const GPoly& f) const {return myAge<f.myAge;};
00198     GPoly& operator=(const GPoly& rhs);
00199     void AssignClear(GPoly&);
00200     bool operator==(const GPoly&)const;
00201     void myAppendClear(RefRingElem);  ///< Dangerous
00202     void myAppendClear(GPoly&); ///< Dangerous
00203     const GRingInfo& myGRingInfo()const{return myGRingInfoValue;};
00204     CoeffEncoding::type myCoeffRingType()const{return myGRingInfoValue.myCoeffRingType();};
00205     bool operator!=(const GPoly&)const;
00206     inline bool IsActive() const {return myIsActive;}
00207     inline void Deactivate(){myIsActive=false;};
00208     void myAssignSPoly(const GPair&, const unsigned int age);
00209     friend unsigned int Component(const GPoly& g){return g.myComponent;};
00210     void MultiplyByPP(ConstRefPPMonoidElem);
00211     friend ConstRefRingElem LC(const GPoly&);
00212     friend bool  IsZero(const GPoly&);
00213     friend std::ostream& operator<<(std::ostream&, const GPoly&);
00214     friend ConstRefPPMonoidElem LPP(const GPoly& f);
00215     friend const PPWithMask& LPPwMask(const GPoly& f);
00216 
00217     inline friend unsigned int len(const GPoly& gp) {return gp.myLen;};
00218     inline friend const degree& wdeg(const GPoly& gp) {return gp.myWDeg;};
00219     inline friend size_t sugar(const GPoly& gp) {return gp.mySugar;};
00220     inline friend degree wsugar(const GPoly& gp) {return gp.myWSugar;};
00221     inline friend ConstRefRingElem poly(const GPoly& gp) {return gp.myPolyValue;};
00222     inline friend unsigned int Age(const GPoly& gp) {return gp.myAge;};
00223     inline friend unsigned int MakeKey(const GPoly&);
00224     //  friend unsigned int nterms(const GPoly& gp);
00225 
00226     friend const SparsePolyRing& owner(const GPoly& gp);
00227     friend const PPMonoid& PPM(const GPoly& gp);
00228     friend const ring& CoeffRing(const GPoly& gp);
00229 
00230     /**@name Pseudo-saturation functions */
00231     //@{
00232     // real body should be in SparsePolyRing
00233     void smart_dehomog_DRL(size_t DHVar);
00234     void smart_dehomog(size_t DHVar);
00235     friend size_t max_common_wdeg(GPoly&,size_t Var);
00236     friend void GPolyList2PolyListClear(GPolyList&,PolyList&);
00237     friend void GPolyList2PolyList(const GPolyList&,PolyList&);
00238 
00239     //@}
00240 
00241     /**@name Public reduction functions */
00242     //@{
00243     //  void reduce(const std::vector<GPoly*>& G); // is this useful??
00244     void myReduce(const Reductors& theReductors);
00245     void myReduceTail(const GPoly& g);
00246     void myReduceTail(const Reductors& theReductors);
00247     //@}
00248 
00249     /**@name member fields of GPoly  */
00250     //@{
00251   private:
00252     friend class GReductor;
00253 
00254     PPWithMask myLPPwMask; ///< precomputed LPP of the polynomial, stored with DivMask
00255     RingElem myLCValue;// use iterator, can be big
00256     RingElem myPolyValue; ///< the polynomial proper
00257     //const SparsePolyRing& myPolyRing; ///< owner(myPoly) as SparsePolyRing
00258     const GRingInfo& myGRingInfoValue;
00259     bool myIsActive; ///< mutable, the rest const ... a cosa serve?
00260     unsigned int myLen; ///< precomputed length of the polynomial: for geobuckets
00261     unsigned int myComponent; /// <the module component of the LPP
00262     degree myWDeg; ///< precomputed degree of the polynomial
00263     size_t mySugar; ///< "sugar" of the polynomial: a sort of degree
00264     degree myWSugar; ///< "wsugar" of the polynomial: a sort of degree
00265     unsigned int myAge; ///< age of the polynomial: for ordering reducers
00266     //@}
00267 
00268     //----------  GPoly private member functions  ----------
00269     void myPolySetSPoly(const GPoly& f, const GPoly& g); ///< set only s-polynomial in myPoly
00270     inline ConstRefRingElem myPoly() const {return myPolyValue;}; // DANGER DANGER DANGER: the LPP, LC, wdeg, StdDeg, sugar, wsugar of this polynomial DIFFER form the corresponding fields for the
00271                                                                    // GPoly if we are using the Dynamic Algorithm. NEVER use it if you can avoid it
00272 
00273     void myUpdateLenLPPLCDegComp();
00274     friend void monic(std::list<GPoly>&);
00275     //    friend void ChooseReduction(char r='g');   ///< 'g' = geobucket; 'b' = basic;
00276 
00277     /**@name Private functions defined in reduce.C*/
00278     //@{
00279     friend GPoly* FindReducer(const GPoly&, const Reductors& theReductors);
00280     //@}
00281 
00282     /**@name Private reduction functions (defined in reduce.C)
00283        they change only "myPoly":
00284        public functions calling these must update the other fields */
00285     //@{
00286     bool ReduceBasic(const GPoly& g, ReductionMarker Red=Full);
00287     void ReduceBasic(const Reductors& theReductors, ReductionMarker Red=Full);
00288     void ReduceGeobucket(const Reductors& theReductors,ReductionMarker Red=Full);
00289     void ReduceGeobucketGCD(const Reductors& theReductors,ReductionMarker Red);
00290     void ReduceGeobucketField(const Reductors& theReductors, ReductionMarker Red);
00291 
00292     void ReduceBasicGCD(const Reductors& theReductors, ReductionMarker Red=Full);
00293     void ReduceBasicField(const Reductors& theReductors, ReductionMarker Red=Full);
00294     bool ReduceBasicGCD(const GPoly& g, ReductionMarker Red=Full);
00295     bool ReduceBasicField(const GPoly& g, ReductionMarker Red=Full);
00296     //@}
00297 
00298     // these functions need to access myPoly(). See if they can be pared down/put here
00299     // they are located in GReductor.C
00300     friend void DeEmbedPoly(ModuleElem&,const GPoly&,size_t);
00301     friend void IntEmbedGPolyList(GPolyList&, GPolyList&);
00302     friend void DeEmbedPoly(RefRingElem, const GPoly&);
00303   };//class GPoly
00304 
00305   // These are only for internal use
00306   typedef std::list<GPoly*> GPolyPtrList;
00307   typedef std::vector<GPoly*> GPolyPtrVector;
00308 
00309 
00310   GPoly* FindReducer(const PPWithMask& pm,
00311                      const unsigned int component,
00312                      const Reductors& theReductors);
00313   GPoly* FindReducer(const GPoly&, const Reductors& theReductors);
00314 
00315   //  std::vector<GPoly*>::const_iterator FindReducer(const geobucket&, const std::vector<GPoly*> & G);
00316 
00317 
00318    void monic(PolyList&);
00319    void monic(GPolyList&);
00320    void power(RefRingElem theResult,
00321                const std::vector<RingElem>& theV,
00322                const degree& the_d);
00323 
00324   // -------------------- inline functions -------------------- //
00325 
00326   inline ConstRefPPMonoidElem LPP(const GPoly& f)
00327   {
00328     return PP(f.myLPPwMask);
00329   }
00330 
00331   inline ConstRefRingElem LC(const GPoly& f)
00332   {
00333     return f.myLCValue;
00334   }
00335 
00336   inline const PPWithMask& LPPwMask(const GPoly& f)
00337   {
00338     return f.myLPPwMask;
00339   }
00340 
00341 
00342 // inline unsigned int nterms(const GPoly& gp)
00343 // {
00344 //   //  const SparsePolyRing& P = dynamic_cast<const SparsePolyRing&>(owner(gp.myPoly));
00345 //   //  return AsSparsePolyRing(owner(gp.myPoly))->NumTerms(raw(gp.myPoly));
00346 //   return AsSparsePolyRing(owner(gp))->NumTerms(raw(gp.myPoly));
00347 // }
00348 
00349 
00350   inline const SparsePolyRing& owner(const GPoly& gp)
00351   {
00352     return gp.myGRingInfoValue.myNewSPR();
00353   }
00354 
00355 
00356   inline const PPMonoid& PPM(const GPoly& gp)
00357   {
00358     return PPM(owner(gp));
00359   }
00360 
00361 
00362   inline const ring& CoeffRing(const GPoly& gp)
00363   {
00364     return CoeffRing(owner(gp));
00365   }
00366 
00367 
00368   // -------------------- ReductorData -------------------- //
00369   class ReductorData
00370 
00371   {
00372   public:
00373     ReductorData(GPoly* p, unsigned int p_component, unsigned int count=0);
00374     ReductorData(const ReductorData&);
00375     ~ReductorData(){};
00376     bool operator<(const ReductorData& RD) const {return myKey<RD.myKey;};
00377     friend std::ostream& operator<<(std::ostream&, const ReductorData&);
00378     //inline friend unsigned int Deg(const ReductorData& RD) {return Deg(*myGPoly);};
00379     friend const SparsePolyRing& owner(const Reductors&);
00380     friend const PPMonoid& PPM(const Reductors&);
00381     friend unsigned int Component(const ReductorData& RD){return RD.myComponent;};
00382     bool IamNotToBeUsed()const{return myIamNotToBeUsedValue;};
00383     void mySetIamNotToBeUsed(const bool b){myIamNotToBeUsedValue=b;};
00384     GPoly* myGetGPolyPtr()const{return myGPolyPtr;};
00385 
00386 
00387 
00388   private:
00389     friend class Reductors;
00390     GPoly* myGPolyPtr;
00391     unsigned int myKey; ///< integer "key" used to sort the list of reducers
00392     unsigned int myComponent;
00393     mutable PPWithMask myLPPwMask;
00394     mutable unsigned int myCount; ///< how many times it has been used
00395     mutable bool IamBorelUpdated; ///< true if its degree is the current degree (Homogeneous algorithm)
00396     bool myIamNotToBeUsedValue;///<true if I don't want to use this element for reduction, i.e. interreducing
00397 
00398     friend GPoly* FindReducer(const PPWithMask& pp,const unsigned int pp_component,
00399                                 const Reductors& theReductors);
00400     bool myBorelUpdate(ConstRefPPMonoidElem pp, const Reductors& theReductors);
00401   };
00402 
00403 
00404   class Reductors{
00405 
00406   public:
00407     enum UseBorelMarker { UseBorel, DontUseBorel };
00408 
00409     Reductors(const GRingInfo& P);
00410     Reductors(const GRingInfo& P, const UseBorelMarker);
00411     ~Reductors(){};
00412     void Insert(GPoly*, const unsigned int count=0);
00413     UseBorelMarker IhaveBorelReductors()const
00414     {if(IhaveBorelReductorsFlag) return UseBorel; else return DontUseBorel;};
00415 
00416     unsigned int size() const {return myReductors.size();};
00417     void myStampaReductors(std::ostream&) const;
00418     const GRingInfo& myGRingInfo()const{return myGRingInfoValue;};
00419     //    GPoly* LastGPolyPtr(){return myReductors.back().myGPolyPtr;};//copia ptr  // never used
00420     //    PPMonoidElem LastGPolyLPP(){return myReductors.back().myLPP;};//copia PP  // never used
00421     void interreduce(const GPoly&);
00422     void OrderedInterreduce(const GPoly&);
00423     void SuperInterreduce(const GPoly&);
00424 
00425     friend const SparsePolyRing& owner(const Reductors&);
00426     friend const PPMonoid& PPM(const Reductors&);
00427     friend void interreduce(Reductors&, GPoly);
00428     friend void OrderedInterreduce(Reductors&, GPoly);
00429     friend void reduce(const Reductors&);
00430     friend void ReduceTail(const Reductors&);
00431     friend GPoly* FindReducer(const PPWithMask& pp,
00432                               const unsigned int pp_component,
00433                               const Reductors& theReductors);
00434     // HERE TO BE NOTICED friend const SparsePolyRing& owner(const Reductors&);
00435     // HERE TO BE NOTICED friend const PPMonoid& PPM(const Reductors&);
00436       
00437     // This function takes params that are part of GReductor class.
00438     // In the future, a new interface class will be built that have this funct. as a member
00439     // This new class would insulate Reductors from end user, which will see only
00440     // this new interface class which would rule all reductors functions.
00441     // data in a GReductor will be pruned accordingly.
00442     void myBorelReductorsUpdateInNextDegree();
00443     void clear();
00444     std::vector<ReductorData>::iterator find(GPoly*);// Find the (unique) Reductor data which ptr is equal to GPolyPtr. Returns end() if nothing is found.
00445 
00446     //    friend void swap(Reductors&,Reductors&); // ANNA: no longer needed?
00447 
00448     //@name member fields for Reductors
00449     //@{
00450   private:
00451     /// the poly used for reductions NB polys are ptrs to myPolys
00452     std::vector<ReductorData> myReductors;
00453     mutable std::vector<ReductorData> myBorelReductors;
00454     GPolyList myBorelGPolys;
00455     bool IhaveBorelReductorsFlag;
00456     const GRingInfo& myGRingInfoValue;
00457     //@}
00458 
00459   };// End class Reductors
00460 
00461 
00462   PPMonoidElem MakeVarIToNth(const PPMonoid& PPM,
00463                              const unsigned int,
00464                              const unsigned int);
00465 
00466   SparsePolyRing owner(const PolyList& thePL);
00467   SparsePolyRing owner(const std::vector<RingElem>& thePV);
00468   SparsePolyRing owner(const GPolyList& theGPL);
00469 
00470   void PolyList2PolyVectorClear(PolyList&,std::vector<RingElem>&);
00471   void PolyVector2PolyListClear(std::vector<RingElem>&,PolyList&);
00472 
00473 }// end namespace cocoa
00474 
00475 
00476 
00477 // RCS header/log on the next few lines
00478 // $Header: /Volumes/Home/cocoa/cvs-repository/CoCoALib-0.99/include/CoCoA/TmpGPoly.H,v 1.1 2007/03/09 18:56:56 bigatti Exp $
00479 // $Log: TmpGPoly.H,v $
00480 // Revision 1.1  2007/03/09 18:56:56  bigatti
00481 // -- added Tmp prefix to Groebner related files
00482 //
00483 // Revision 1.1.1.1  2007/03/09 15:16:11  abbott
00484 // Imported files
00485 //
00486 // Revision 1.13  2007/03/08 18:42:06  cocoa
00487 // Cleaned up whitespace.
00488 //
00489 // Revision 1.12  2007/03/07 22:24:03  bigatti
00490 // -- reintroduced TmpGTypes.H (waiting for a better solution)
00491 //
00492 // Revision 1.11  2007/03/07 17:04:31  cocoa
00493 // -- several changes by M.Caboara: more operations on ideals,
00494 //    exception cleaner, coding conventions, WSugar, dynamic
00495 //
00496 // Revision 1.10  2006/12/22 11:37:40  cocoa
00497 // Removed operator<< for PolyList and GPolyList.  A few consequential changes.
00498 //
00499 // Revision 1.9  2006/12/06 17:11:16  cocoa
00500 // -- removed #include "config.H"
00501 //
00502 // Revision 1.8  2006/12/04 13:55:54  cocoa
00503 // -- added: sugar for GradingDim > 0  (called wsugar)
00504 //
00505 // Revision 1.7  2006/11/24 17:17:58  cocoa
00506 // -- reorganized includes of header files
00507 //
00508 // Revision 1.6  2006/11/20 14:57:17  cocoa
00509 // -- added: (standard) sugar for modules
00510 // -- fixed: non-homogeneous sysygies
00511 // -- minor fixes     [M.Caboara]
00512 //
00513 // Revision 1.5  2006/11/02 13:25:44  cocoa
00514 // Simplification of header files: the OpenMath classes have been renamed.
00515 // Many minor consequential changes.
00516 //
00517 // Revision 1.4  2006/10/06 16:32:06  cocoa
00518 // -- changed: GPoly::SPoly --> GPoly::myAssignSPoly
00519 // -- changed: Len(const GPoly&) --> len(const GPoly&)
00520 // -- added:   poly(const GPoly&)
00521 // -- added:   GPoly::myUpdateLenLPPDegComp()
00522 // -- in reduce.C added functions for computing sugar during reduction
00523 //
00524 // Revision 1.3  2006/10/06 14:04:16  cocoa
00525 // Corrected position of #ifndef in header files.
00526 // Separated CoCoA_ASSERT into assert.H from config.H;
00527 // many minor consequential changes (have to #include assert.H).
00528 // A little tidying of #include directives (esp. in Max's code).
00529 //
00530 // Revision 1.2  2006/08/17 09:28:56  cocoa
00531 // -- added: sugar
00532 // -- added: controls on homogeneity
00533 //
00534 // Revision 1.1.1.1  2006/05/30 11:39:36  cocoa
00535 // Imported files
00536 
00537 #endif

Generated on Wed May 23 13:45:24 2007 for CoCoALib by  doxygen 1.4.6