CoCoALib-0.9905 date: 23 May 2007


TmpGReductor.H

Go to the documentation of this file.
00001 #ifndef CoCoA_GReductor_H
00002 #define CoCoA_GReductor_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/TmpGPoly.H"
00024 #include "CoCoA/TmpGPair.H"
00025 #include "CoCoA/TmpGRStats.H"
00026 
00027 
00028 namespace CoCoA
00029 {
00030 
00031   class FreeModule;     // forward declaration -- defined in FreeModule.H
00032   class SparsePolyRing; // forward declaration -- defined in SparsePolyRing.H
00033 
00034   SparsePolyRing NewSparsePolyRing(const ring& CoeffRing,
00035                                    const std::vector<symbol>& IndetNames,
00036                                    const PPOrdering& ord);
00037 
00038 
00039   class GReductor
00040   {
00041   public:
00042 
00043     GReductor(const GRingInfo&,
00044               const PolyList&,
00045               const int StatLevel=-1,
00046               const Reductors::UseBorelMarker=Reductors::DontUseBorel,
00047         const bool IsDynamic=false,
00048               const bool CopCriterion=true,
00049               const bool GMCriteria=true,
00050               const bool BCriterion=true,
00051               const bool DivCriterion=true);
00052     GReductor(const GRingInfo&,
00053               const GPolyList&,
00054               const int StatLevel=-1,
00055               const Reductors::UseBorelMarker=Reductors::DontUseBorel,
00056         const bool IsDynamic=false,
00057               const bool CopCriterion=true,
00058               const bool GMCriteria=true,
00059               const bool BCriterion=true,
00060               const bool DivCriterion=true);
00061     GReductor(const GReductor&);// copy ctor
00062     ~GReductor(){};
00063     GReductor(const GRingInfo&,
00064               GPolyList&,
00065               const ClearType,
00066               const int StatLevel=-1,
00067               const Reductors::UseBorelMarker=Reductors::DontUseBorel,
00068           const bool IsDynamic=false,
00069               const bool CopCriterion=true,
00070               const bool GMCriteria=true,
00071               const bool BCriterion=true,
00072               const bool DivCriterion=true);
00073     unsigned int myReductorsLen()const {return myTrueReductors.size();};
00074     unsigned int myGBasisLen()const {return myGB.size();};
00075     unsigned int myPairsLen() const{return myPairs.size();};
00076     bool myPreparationDone() const{return myPrepared;};
00077     bool IsDynamic() const{return IsDynamicAlgorithm;};
00078     bool WrongLPPFound() const{return myWrongLPPFoundValue;};
00079     void myGBasis(PolyList&);// GB output
00080     void myGBasis(GPolyList&);// GB output in GPoly form
00081     void myGBasisClear(GPolyList&); ///< GB output in GPoly form
00082     void myGBasis(VectorList&);
00083     void myDoAFFGBasis(); // I am working on sugar selection strategies
00084     void myDoGBasis(); ///< flag may be set for using Borel reductors
00085     void _myDoGBasis(); ///< flag may be set for using Borel reductors
00086     void myReduceCurrentSPoly();
00087     void myPrepareGBasis(); ///< flag may be set for using Borel reductors
00088     void myFinalizeGBasis();//Last operations (stats at the moment) immediately before shutting down a GB computation
00089     void myDoGBasis(const int ReductionNumber); // Performs ReductionNumber reductions, -1 means unlimited
00090     void myReduceUntilNonZeroRedSP(); // Reduces until an SPoly does not reduces to zero. Stop immediately when that happens (no updates)
00091      // DYNAMIC ALG: reduces until a non zero SPoly has a LPP with is different from the best possibile LPP w.r.t. HPoly.
00092      // In that case, settles the WrongLPP filed in the reductor.
00093     void myReduceUntilWrongLPPFound(RefPPMonoidElem,
00094                                     std::vector<RingElem>& );
00095     GPoly GetSPoly()const{return mySPoly;};// Reads the SPoly
00096     void GetCandidateGBasis(PolyList&)const;// the polys computed up to now and the non processed generators
00097     unsigned int GetAge()const{return myAge;};
00098     unsigned int GetNReductions()const{return myNReductions;};
00099     void SetSPoly(GPoly& p){mySPoly=p;};// Sets the SPoly
00100     void myDoSATGBasis(); ///< dehomog algorithm
00101     void myStampaPPGB(std::ostream&)const; ///< print ?
00102     void myStampaGB(std::ostream&)const; ///< print ?
00103     void myStampaPairs(std::ostream&)const; ///< print ?
00104     void myStampaReductors(std::ostream&)const; ///< print ?
00105     void myStampaStats(std::ostream& out) const{myStat.myStampa(out);}; ///< print ?
00106     friend std::ostream& operator<<(std::ostream& out, const GReductor& GR);
00107     const SparsePolyRing& myPRing()const{return myGRingInfoValue.myNewSPR();};
00108     const GRingInfo& myGRingInfo()const{return myGRingInfoValue;};
00109     void Rebuild(const PolyList&);///< rebuild the GReductor initliazinig it with the PL
00110     void myUpdateBasisOnly();///<Updates the Basis only.
00111     void myCreatePairs();// this should be const, but this requires
00112                                    //the GPair ctor to be const, and I have to think about that
00113     void myCreateSpecialPairs(GPolyList&);
00114     void myDoGBasisByBatch();//Tmp, DYNAMIC
00115     void myPrepareGBasisPairsExcluded();//Tmp, DYNAMIC
00116     void myBuildNewPairsAll(GPairList&);//Tmp, DYNAMIC
00117 
00118 
00119   public:
00120     static int ourDefaultStatLevel; ///< default verbosity level for statistics
00121   private:
00122     const GRingInfo myGRingInfoValue;
00123     GPairList myPairs;// here the polys are ptrs to myPolys
00124     Reductors myTrueReductors;// the true reductors.
00125     GPolyPtrList myGB;// the candidate Gbasis - NB polys are ptrs to myPolys
00126     GPolyList myPolys;// the REAL Polys, the other are ptrs
00127     GPoly mySPoly;
00128     degree myOldDeg;// used for flow control and stats. The degree itrefers is that of the pair
00129     degree myCurrentPairDeg;// used for flow control and stats. The degree itrefers is that of the pair
00130     Stats myStat;// the statistics
00131     double myReductionTime;// Used for statistics.
00132     double myTotalTime;// Used for statistics.
00133     bool myPrepared; // Default false. True after a myPreparexxxGBasis has been performed
00134     unsigned int myAge;
00135     unsigned int myNReductions;
00136     bool myCopCriterion;
00137     bool IsDynamicAlgorithm;
00138     bool myWrongLPPFoundValue; // DYNAMIC ALGORITHM
00139     bool myGMCriteria;
00140     bool myBCriterion;
00141     bool myDivCriterion; // This allows the elimination of poly (in the candidate GB) if its LPP is divided by the LPP of the new poly
00142                          // true always except for ring weyl
00143 
00144     unsigned int myGMInsert(GPairList&,GPair);
00145     void         myBuildNewPairs(GPairList&);
00146     void         myUpdateBasisAndPairs();
00147     void         myApplyBCriterion();
00148 
00149 // These two should go in GPoly (interface) with the
00150 // real body in PolyRing
00151 //void smart_dehomog(GPoly&,size_t);
00152 //void smart_dehomog_DRL(GPoly&,size_t);
00153 
00154 
00155   };// End class GReductor
00156 
00157    void monic(PolyList&);
00158 
00159    const GRingInfo& GetGRI(const GPolyList& theGPL);
00160    FreeModule owner(const VectorList& theVL);
00161 
00162     enum ModOrdTypeForcing {NoForcing,PosWDegTO,WDegTOPos,WDegPosTO};
00163     SparsePolyRing MakeNewPRingFromModule(const FreeModule& FM);
00164     SparsePolyRing MakeNewPRingFromModule(const FreeModule& FM,ModOrdTypeForcing MOType);
00165     SparsePolyRing MakeNewPRingForSimpleEmbedding(const SparsePolyRing& theOldP);
00166     SparsePolyRing MakeNewPRingForSimpleEmbedding(const SparsePolyRing& theOldP,ModOrdTypeForcing MOType);
00167     FreeModule MakeNewFreeModuleForSyz(const GPolyList& GPL);
00168     FreeModule MakeNewFreeModuleForSyz(const VectorList& VL);
00169     FreeModule MakeNewFreeModuleForSyz(const PolyList& PL);
00170     SparsePolyRing MakeElimRingFromOld(const SparsePolyRing& theOldP,
00171                                        const std::vector<long>& theElimVars,
00172                const bool IsHomog);
00173     SparsePolyRing MakeNewPRingFromModulePosFirst(const FreeModule& FM,
00174                     bool HomogInput);
00175 
00176     SparsePolyRing MakeNewPRingForSimpleEmbeddingPosFirst(const SparsePolyRing& OldP,
00177                                                           bool HomogInput);
00178     // Embed p in the CompIndex component, grading given by the embedding
00179     GPoly EmbedPoly(ConstRefRingElem p,
00180             const GRingInfo& theGRI,
00181         const size_t CompIndex);
00182     // Embed p in the CompIndex component, grading given by the_d
00183     GPoly EmbedPoly(ConstRefRingElem p,
00184             const GRingInfo& theGRI,
00185                     const degree& the_d,
00186         const size_t CompIndex);
00187 
00188    // Embed v
00189     GPoly EmbedVector(const ModuleElem& v,
00190               const GRingInfo& theGRI);
00191 
00192    // Embed v starting from the StartingFromCompIndex component
00193     GPoly EmbedVector(const ModuleElem& v,
00194               const GRingInfo& theGRI,
00195           const size_t StartingFromCompIndex);
00196 
00197    // Embed theVL
00198     GPolyList EmbedVectorList(const VectorList& theVL,
00199                               const GRingInfo& theGRI);
00200     // Embed theVL starting from the StartingFromCompIndex component
00201     GPolyList EmbedVectorList(const VectorList& theVL,
00202                               const GRingInfo& theGRI,
00203             const size_t StartingFromCompIndex);
00204 
00205     // Just transform the PolyList in a GPolyList
00206     GPolyList EmbedPolyList(PolyList& thePL,
00207                             const GRingInfo& theGRI);
00208 
00209 
00210     GPolyList EmbedPolyList(const PolyList& thePL,
00211                             const GRingInfo& theGRI,
00212                             const degree& the_d,
00213           const size_t CompIndex);
00214 
00215     // Embed with the shifts Shifts
00216     GPolyList EmbedPolyList(const PolyList& InputPolyList,
00217                             const GRingInfo& theGRI,
00218           const size_t CompIndex);
00219       
00220     // The embedding used in syzygy computations
00221     GPolyList SyzEmbedVectorList(const VectorList& InputVectorList,
00222                                  const GRingInfo& theGRI);
00223   // The embedding used in syzygy computations
00224     GPolyList SyzEmbedPolyList(const PolyList& InputPolyList,
00225                                  const GRingInfo& theGRI);
00226         
00227     // The embedding used in intersection computations
00228     GPolyList IntEmbedVectorLists(const VectorList& VL1,
00229                                   const VectorList& VL2,
00230                                   const GRingInfo& theGRI);
00231         
00232     // The embedding used in intersection computations
00233     GPolyList IntEmbedPolyLists(const PolyList& PL1,
00234                                 const PolyList& PL2,
00235                                 const GRingInfo& theGRI);
00236       
00237   // The special poly embedding used in colon computations
00238     GPolyList ColonEmbedVectorLists(const VectorList& VL1,
00239                                     const VectorList& VL2,
00240                                     const GRingInfo& theGRI);
00241         
00242     GPolyList ColonEmbedPolyLists(const PolyList& PL1,
00243                                   const PolyList& PL2,
00244                                   const GRingInfo& theGRI);
00245 
00246     void SyzEmbedGPolyList(GPolyList& theGPL);
00247 
00248     void IntEmbedGPolyList(GPolyList& theGPL1,
00249                             GPolyList& theGPL2);
00250 
00251     void ColonEmbedGPolyList(GPolyList& theGPL,
00252                               GPoly& the_gp);
00253 
00254     ModuleElem DeEmbedPoly(ConstRefRingElem p,                      
00255          const GRingInfo& theGRI,
00256                            const size_t ComponentsLimit); // the component in p that goes to the 0 component of the output vector v. Lesser components of p go to higher component of v
00257     
00258     ModuleElem DeEmbedPoly(ConstRefRingElem p,
00259                            const GRingInfo& theGRI);
00260 
00261     VectorList DeEmbedPolyList(const PolyList& PL,
00262                                const GRingInfo& theGRI);
00263 
00264     VectorList DeEmbedPolyList(const PolyList& PL,
00265                                const GRingInfo& theGRI,
00266              const std::size_t ComponentsLimit); // Poly whose LPP has last var degree bigger than this number disappear on DeEmbedding
00267 
00268 
00269 
00270     void DeEmbedPoly(ModuleElem& theOutputP,
00271                       const GPoly& the_gp,
00272                       const size_t ComponentsLimit); // the component in p that goes to the 0 component of the output vector v. Lesser components of p go to higher component of v
00273     
00274     void DeEmbedPoly(ModuleElem& theOutputP,
00275                       GPoly& the_gp);
00276 
00277     void DeEmbedPolyList(VectorList& theOutputVL,
00278                           GPolyList& theGPL);
00279 
00280     void DeEmbedPolyList(VectorList& theOutputVL,
00281                           const GPolyList& theGPL,
00282         const std::size_t ComponentsLimit); // Poly whose LPP has last var degree bigger than this number disappear on DeEmbedding
00283 
00284     void DeEmbedPoly(RefRingElem theOutputP,
00285                       GPoly& the_gp); // Poly whose LPP has last var degree bigger than this number disappear on DeEmbedding
00286 
00287     void DeEmbedPolyList(PolyList& theOutputPL,
00288                           GPolyList& theGPL,
00289         const std::size_t ComponentsLimit); // Poly whose LPP has last var degree bigger than this number disappear on DeEmbedding
00290 
00291     // input are embedded polys, output true (OldP) Polys
00292     // this is done directly and not passing through a VectorList to avoid copying
00293     RingElem DeEmbedPolyToP(ConstRefRingElem the_p,
00294                             const GRingInfo& theGRI);
00295 
00296     PolyList DeEmbedPolyListToPL(const PolyList& PL,
00297                                  const GRingInfo& theGRI,
00298                const std::size_t ComponentsLimit); // Poly whose LPP has last var degree bigger than this number disappear on DeEmbedding
00299 
00300 
00301     void PolyList2GPolyList(const PolyList&,GPolyList&,const GRingInfo&);
00302     void GPolyList2PolyList(const GPolyList&,PolyList&);
00303     void PolyList2GPolyListClear(PolyList&,GPolyList&,const GRingInfo&);
00304     void GPolyList2PolyListClear(GPolyList&,PolyList&);
00305     void homogenized(RefRingElem the_hp,
00306                      ConstRefRingElem the_p,
00307                      const std::vector<RingElem> the_Y); ///< hp = hom(p,y) in the ring with the y's
00308     void homogenized(ModuleElem& the_hv,
00309                      const ModuleElem& the_v,
00310                      const GRingInfo& theGRI);
00311     std::vector<long> PolyList2IndexList(const PolyList&);
00312     PPMonoidElem IndexList2PPMonoidElem(const PPMonoid&,
00313                                         const std::vector<long>&);
00314     std::vector<long> PPMonoidElem2IndexList(ConstRefPPMonoidElem);
00315     size_t FirstNonZeroPos(const ModuleElem&);
00316     bool IsHomogeneous(const PolyList&);
00317     bool IsHomogeneous(const VectorList&);
00318     std::vector<degree> DegStructure(ConstRefRingElem);
00319     std::vector<std::vector<degree> > DegStructure(const ModuleElem&);
00320     std::vector<std::vector<degree> > DegStructure(const PolyList&);
00321     std::vector<std::vector<std::vector<degree> > > DegStructure(const VectorList&);
00322     PolyList MakePolyList(ConstRefRingElem);
00323     VectorList MakeVectorList(const ModuleElem&);
00324     RingElem CoeffCommonDenominator(ConstRefRingElem f);
00325     PolyList WithoutDenominators(const PolyList& PL, SparsePolyRing Rx);
00326     PolyList WithDenominator1Hom(const PolyList& PL, SparsePolyRing P);
00327 
00328 
00329 }// end namespace cocoa
00330 
00331 
00332 
00333 // $Header: /Volumes/Home/cocoa/cvs-repository/CoCoALib-0.99/include/CoCoA/TmpGReductor.H,v 1.1 2007/03/09 18:56:56 bigatti Exp $
00334 // $Log: TmpGReductor.H,v $
00335 // Revision 1.1  2007/03/09 18:56:56  bigatti
00336 // -- added Tmp prefix to Groebner related files
00337 //
00338 // Revision 1.1.1.1  2007/03/09 15:16:11  abbott
00339 // Imported files
00340 //
00341 // Revision 1.13  2007/03/08 18:42:06  cocoa
00342 // Cleaned up whitespace.
00343 //
00344 // Revision 1.12  2007/03/07 22:24:03  bigatti
00345 // -- reintroduced TmpGTypes.H (waiting for a better solution)
00346 //
00347 // Revision 1.11  2007/03/07 17:04:31  cocoa
00348 // -- several changes by M.Caboara: more operations on ideals,
00349 //    exception cleaner, coding conventions, WSugar, dynamic
00350 //
00351 // Revision 1.10  2006/12/06 17:11:16  cocoa
00352 // -- removed #include "config.H"
00353 //
00354 // Revision 1.9  2006/11/24 17:20:07  cocoa
00355 // -- reorganized includes of header files
00356 //
00357 // Revision 1.8  2006/11/22 15:33:39  cocoa
00358 // -- changed handling of timings and number of reductions (M.Caboara)
00359 //
00360 // Revision 1.7  2006/11/20 14:57:17  cocoa
00361 // -- added: (standard) sugar for modules
00362 // -- fixed: non-homogeneous sysygies
00363 // -- minor fixes     [M.Caboara]
00364 //
00365 // Revision 1.6  2006/10/06 16:46:17  cocoa
00366 // -- syzygies for non-homogenous polynomials (Max)
00367 // -- wip: evolution of Groebner Framework (Max)
00368 //
00369 // Revision 1.5  2006/10/06 14:04:16  cocoa
00370 // Corrected position of #ifndef in header files.
00371 // Separated CoCoA_ASSERT into assert.H from config.H;
00372 // many minor consequential changes (have to #include assert.H).
00373 // A little tidying of #include directives (esp. in Max's code).
00374 //
00375 // Revision 1.4  2006/08/17 09:32:26  cocoa
00376 // -- added: flags for homogeneous input
00377 //
00378 // Revision 1.3  2006/08/07 21:23:25  cocoa
00379 // Removed almost all publicly visible references to SmallExponent_t;
00380 // changed to long in all PPMonoid functions and SparsePolyRing functions.
00381 // DivMask remains to sorted out.
00382 //
00383 // Revision 1.2  2006/07/19 07:13:00  cocoa
00384 // -- moved "IsHomogeneous" to SparsePolyRing/FreeModule
00385 //
00386 // Revision 1.1.1.1  2006/05/30 11:39:36  cocoa
00387 // Imported files
00388 //
00389 // Revision 1.16  2006/05/16 09:01:26  cocoa
00390 // -- added "const" to arg of homogenized
00391 // -- changed ordering matrix for modules (compatibility with GradedFreeModule)
00392 //
00393 // Revision 1.15  2006/05/12 17:03:16  cocoa
00394 // -- swapped arguments in homogenized
00395 //
00396 // Revision 1.14  2006/05/11 16:00:22  cocoa
00397 // -- fixed spelling of "homogenize"
00398 //
00399 // Revision 1.13  2006/05/04 14:25:16  cocoa
00400 // -- major cleaning of FreeModule: created GradedFreeModule and moved
00401 //    some code around
00402 //
00403 // Revision 1.12  2006/04/27 14:03:27  cocoa
00404 // -- tidied up include files
00405 //
00406 // Revision 1.11  2006/04/26 09:50:40  cocoa
00407 // -- added GReductor::ourDefaultStatLevel variable to allow CoCoAServer
00408 //    to set statistics level
00409 //
00410 // Revision 1.10  2006/04/21 16:45:17  cocoa
00411 // -- new functions by Max
00412 //
00413 // Revision 1.9  2006/04/11 16:42:31  cocoa
00414 // -- added functions for Elim
00415 //
00416 // Revision 1.8  2006/03/13 16:56:53  cocoa
00417 // -- changed: member data  myGRingInfoValue  is no longer a reference
00418 //
00419 // Revision 1.7  2006/03/02 13:45:57  cocoa
00420 // -- changes by Max
00421 //
00422 // Revision 1.6  2006/02/13 14:46:45  cocoa
00423 // -- changes by Max
00424 //
00425 // Revision 1.5  2006/02/13 13:45:04  cocoa
00426 // -- changes by Max (GRingInfo)
00427 //
00428 // Revision 1.4  2006/01/18 15:58:20  cocoa
00429 // -- new changes my Max
00430 //
00431 // Revision 1.3  2006/01/17 15:44:56  cocoa
00432 // -- chamges by Max for operations with modules
00433 //
00434 // Revision 1.2  2006/01/17 10:23:08  cocoa
00435 // Updated DivMask; many consequential changes.
00436 // A few other minor fixes.
00437 //
00438 // Revision 1.1.1.1  2005/10/17 10:46:54  cocoa
00439 // Imported files
00440 //
00441 // Revision 1.2  2005/07/01 16:08:16  cocoa
00442 // Friday check-in.  Major change to structure under PolyRing:
00443 // now SparsePolyRing and DUPolyRing are separated (in preparation
00444 // for implementing iterators).
00445 //
00446 // A number of other relatively minor changes had to be chased through
00447 // (e.g. IndetPower).
00448 //
00449 // Revision 1.1.1.1  2005/05/03 15:47:30  cocoa
00450 // Imported files
00451 //
00452 // Revision 1.2  2005/04/19 14:06:04  cocoa
00453 // Added GPL and GFDL licence stuff.
00454 //
00455 // Revision 1.1.1.1  2005/01/27 15:12:13  cocoa
00456 // Imported files
00457 //
00458 // Revision 1.5  2004/10/29 16:02:52  cocoa
00459 // -- added field myDivMaskImplPtr for creating GPolys with the same
00460 //    DivMask::base
00461 // -- calls to LCMwMask (instead of LCM) for fast divisibility tests
00462 // -- function IsDivisible had wrong semantics --> swapped arguments everywhere
00463 //
00464 // Revision 1.4  2004/06/16 16:13:41  cocoa
00465 // Improved I/O facilities with knock-on changes
00466 //
00467 // Revision 1.3  2004/03/04 11:37:17  cocoa
00468 // -- updated code for Borel reductors:
00469 //    ReductorData fields: myGPoly->myGPolyPtr;  new: myCount, IamBorelUpdated
00470 //    myBorelReductors is now in Reductors (was in GReductor)
00471 //    Reductors: field: IhaveBorelReductors;  type: enum UseBorelMarker
00472 //
00473 // Revision 1.2  2003/10/09 12:16:38  cocoa
00474 // New coding convention for rings.
00475 //
00476 // Revision 1.11  2003/06/23 17:09:54  abbott
00477 // Minor cleaning prior to public release.
00478 // Improved the include directives,
00479 //
00480 // Revision 1.10  2003/05/29 16:49:58  bigatti
00481 // - change: myRingSpecialIndex is now an int
00482 // - added:  flag for criterion (to be disables for non-comm Groebner)
00483 //
00484 // Revision 1.9  2003/05/28 14:23:09  bigatti
00485 // - new code for modules
00486 //
00487 // Revision 1.8  2003/05/14 17:06:07  bigatti
00488 // - new functions for "BorelReductorsPolys" and saturating algorithm
00489 //
00490 // Revision 1.7  2002/09/19 17:25:28  bigatti
00491 // - Cleaner code based on PolyRing
00492 //
00493 // Revision 1.6  2002/05/13 11:47:34  bigatti
00494 // - new data structure for "Reductors"
00495 //
00496 // Revision 1.5  2002/04/15 17:17:30  bigatti
00497 // - Max's new code
00498 //
00499 // Revision 1.4  2002/04/09 14:21:57  bigatti
00500 // - CKR criterion
00501 //
00502 // Revision 1.3  2002/01/31 17:29:47  bigatti
00503 // - new function: Stampa_Reductors_Stats
00504 //
00505 // Revision 1.2  2001/12/12 18:19:55  bigatti
00506 // - new structure of reduction
00507 //
00508 // Revision 1.1  2001/12/05 13:27:48  bigatti
00509 // Initial revision
00510 //
00511 
00512 #endif

Generated on Wed May 23 13:43:36 2007 for CoCoALib by  doxygen 1.4.6