Changeset a05c71 in git


Ignore:
Timestamp:
Aug 31, 2009, 3:55:46 PM (14 years ago)
Author:
Christian Eder
Branches:
(u'spielwiese', '8d54773d6c9e2f1d2593a28bc68b7eeab54ed529')
Children:
fb1212fa95dcc1179dddfd72a79683e1282d5662
Parents:
f414c0965b52eb8faa2ff8c9afef799657e50a29
Message:
termination tests included in procedure findReducers()


git-svn-id: file:///usr/local/Singular/svn/trunk@12090 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
kernel
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • kernel/f5data.h

    rf414c0 ra05c71  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: f5data.h,v 1.13 2009-07-16 07:47:51 ederc Exp $ */
     5/* $Id: f5data.h,v 1.14 2009-08-31 13:55:46 ederc Exp $ */
    66/*
    77* ABSTRACT: labeled polynomial interface
    … …  
    1717=========================================================
    1818*/
    19 class LPoly;
     19class LPolyOld;
    2020class CPairOld;
    21 class Rule;
     21class RuleOld;
    2222
    2323
    … …  
    2727============================
    2828*/
    29 class LPoly {
     29class LPolyOld {
    3030    private:
    3131        poly    term;           //term of signature
    3232        int     index;          //index of signature
    3333        poly    polynomial;     //standard polynomial data
    34         Rule*   _rule;
     34        RuleOld*   _RuleOld;
    3535        bool    del;
    3636    public:
    37         inline          LPoly(poly t, int i, poly p, Rule* r=NULL);
     37        inline          LPolyOld(poly t, int i, poly p, RuleOld* r=NULL);
    3838        inline  void    setPoly(poly p);
    3939        inline  poly    getPoly();
    … …  
    4242        inline  void    setIndex(int i);
    4343        inline  int     getIndex();
    44         inline  void    setRule(Rule* r);
    45         inline  Rule*   getRule();
     44        inline  void    setRuleOld(RuleOld* r);
     45        inline  RuleOld*   getRuleOld();
    4646        inline  void    setDel(bool d);
    4747        inline  bool    getDel();
    48         inline  void    set(poly t, int i, poly p, Rule* r);
    49         inline  LPoly*  get();
     48        inline  void    set(poly t, int i, poly p, RuleOld* r);
     49        inline  LPolyOld*  get();
    5050};
    5151
    52 LPoly::LPoly(poly t,int i,poly p, Rule* r) {
     52LPolyOld::LPolyOld(poly t,int i,poly p, RuleOld* r) {
    5353    set(t,i,p,r);
    5454    del =   0;
    5555}
    5656
    57 void LPoly::setPoly(poly p)  {
     57void LPolyOld::setPoly(poly p)  {
    5858    //poly _p     =   pInit();
    5959    //_p          =   pCopy(p);
    … …  
    6161}
    6262
    63 void LPoly::setTerm(poly t) {
     63void LPolyOld::setTerm(poly t) {
    6464    //poly _t     =   pInit();
    6565    //_t          =   pCopy(t);
    … …  
    6767}
    6868
    69 void LPoly::setIndex(int i) {
     69void LPolyOld::setIndex(int i) {
    7070    index = i;
    7171}
    7272
    73 void LPoly::setRule(Rule* r) {
    74     _rule   =   r;
    75 }
    76 
    77 void LPoly::setDel(bool d) {
     73void LPolyOld::setRuleOld(RuleOld* r) {
     74    _RuleOld   =   r;
     75}
     76
     77void LPolyOld::setDel(bool d) {
    7878    del =   d;
    7979}
    8080
    81 poly LPoly::getPoly() {
     81poly LPolyOld::getPoly() {
    8282    return polynomial;
    8383}
    8484
    85 poly LPoly::getTerm() {
     85poly LPolyOld::getTerm() {
    8686    return term;
    8787}
    8888
    89 int LPoly::getIndex() {
     89int LPolyOld::getIndex() {
    9090    return index;
    9191}
    9292
    93 Rule* LPoly::getRule() {
    94     return _rule;
    95 }
    96 
    97 bool LPoly::getDel() {
     93RuleOld* LPolyOld::getRuleOld() {
     94    return _RuleOld;
     95}
     96
     97bool LPolyOld::getDel() {
    9898    return del;
    9999}
    100100
    101 void LPoly::set(poly t, int i, poly p, Rule* r) {
     101void LPolyOld::set(poly t, int i, poly p, RuleOld* r) {
    102102    this->setTerm(t);
    103103    this->setIndex(i);
    104104    this->setPoly(p);
    105     this->setRule(r);
    106 }
    107 
    108 LPoly* LPoly::get() {
     105    this->setRuleOld(r);
     106}
     107
     108LPolyOld* LPolyOld::get() {
    109109    return this;
    110110}
    … …  
    120120        long    deg;            // total degree of the critical pair
    121121        poly    t1;             // first term for label
    122         LPoly*  lp1;            // first labeled poly
     122        LPolyOld*  lp1;            // first labeled poly
    123123        poly    t2;             // second term for label
    124         LPoly*  lp2;            // second labeled poly
    125         Rule*   testedRule;     // already tested by rules up to lastRuleTested
     124        LPolyOld*  lp2;            // second labeled poly
     125        RuleOld*   testedRuleOld;     // already tested by RuleOlds up to lastRuleOldTested
    126126    public:
    127         inline          CPairOld(long degree, poly term1, LPoly* lpoly1, poly term2, LPoly* lpoly2, Rule* r = NULL);
     127        inline          CPairOld(long degree, poly term1, LPolyOld* LPolyOld1, poly term2, LPolyOld* LPolyOld2, RuleOld* r = NULL);
    128128        inline  long    getDeg();
    129129        inline  poly    getT1();
    130130        inline  poly*   getAdT1();
    131         inline  LPoly*  getAdLp1();
     131        inline  LPolyOld*  getAdLp1();
    132132        inline  poly    getLp1Poly();
    133133        inline  poly    getLp1Term();
    … …  
    135135        inline  poly    getT2();
    136136        inline  poly*   getAdT2();
    137         inline  LPoly*  getAdLp2();
     137        inline  LPolyOld*  getAdLp2();
    138138        inline  poly    getLp2Poly();
    139139        inline  poly    getLp2Term();
    140140        inline  int     getLp2Index();
    141         inline  Rule*   getTestedRule();
    142         inline  void    setTestedRule(Rule* r);
     141        inline  RuleOld*   getTestedRuleOld();
     142        inline  void    setTestedRuleOld(RuleOld* r);
    143143};
    144144
    145 CPairOld::CPairOld(long degree, poly term1, LPoly* lpoly1, poly term2, LPoly* lpoly2, Rule* r) {
     145CPairOld::CPairOld(long degree, poly term1, LPolyOld* LPolyOld1, poly term2, LPolyOld* LPolyOld2, RuleOld* r) {
    146146   deg              =   degree;
    147147   t1               =   term1;
    148    lp1              =   lpoly1;
     148   lp1              =   LPolyOld1;
    149149   t2               =   term2;
    150    lp2              =   lpoly2;
    151    testedRule       =   r;
     150   lp2              =   LPolyOld2;
     151   testedRuleOld       =   r;
    152152}
    153153
    … …  
    172172}
    173173
    174 LPoly* CPairOld::getAdLp1() {
     174LPolyOld* CPairOld::getAdLp1() {
    175175    return lp1;
    176176}
    177177
    178 LPoly* CPairOld::getAdLp2() {
     178LPolyOld* CPairOld::getAdLp2() {
    179179    return lp2;
    180180}
    … …  
    204204}
    205205
    206 Rule* CPairOld::getTestedRule() {
    207     return testedRule;
    208 }
    209 
    210 void CPairOld::setTestedRule(Rule* r) {
    211     testedRule      =   r;
     206RuleOld* CPairOld::getTestedRuleOld() {
     207    return testedRuleOld;
     208}
     209
     210void CPairOld::setTestedRuleOld(RuleOld* r) {
     211    testedRuleOld      =   r;
    212212}
    213213
    … …  
    215215/*!
    216216========================================================
    217 structure of rules(i.e. already computed / known labels)
     217structure of RuleOlds(i.e. already computed / known labels)
    218218========================================================
    219219*/
    220 class Rule {
     220class RuleOld {
    221221    private:
    222         int     index;      // index of the labeled polynomial the rule comes from
    223         poly    term;       // term of the labeled polynomial the rule comes from
     222        int     index;      // index of the labeled polynomial the RuleOld comes from
     223        poly    term;       // term of the labeled polynomial the RuleOld comes from
    224224    public:
    225         inline          Rule(int i, poly term);
    226         inline          ~Rule();
     225        inline          RuleOld(int i, poly term);
     226        inline          ~RuleOld();
    227227        inline  int     getIndex();
    228228        inline  poly    getTerm();
    229229};
    230230
    231 Rule::Rule(int i, poly t) {
     231RuleOld::RuleOld(int i, poly t) {
    232232    index   =   i;
    233233    term    =   t;
    234234}
    235235
    236 Rule::~Rule() {
     236RuleOld::~RuleOld() {
    237237    //pDelete(&term);
    238238}
    239239
    240 int Rule::getIndex() {
     240int RuleOld::getIndex() {
    241241    return index;
    242242}
    243243
    244 poly Rule::getTerm() {
     244poly RuleOld::getTerm() {
    245245    return term;
    246246}

  • kernel/f5gb.cc

    rf414c0 ra05c71  
    112112==================================================
    113113*/
    114 LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE, LTagList* lTag, RList* rules, RTagList* rTag, int termination) {
     114LList* F5inc(int i, poly f_i, LList* gPrev, LList* reducers, ideal gbPrev, poly ONE, LTagList* lTag, RList* rules, RTagList* rTag, int termination) {
    115115    //Print("in f5inc\n");           
    116116    //pWrite(rules->getFirst()->getRuleTerm());
    … …  
    168168        //sPolyList->print();
    169169        //reduction(sPolyList, critPairs, gPrev, rules, lTag, rTag, gbPrev);
    170         newReduction(sPolyList, critPairs, gPrev, rules, lTag, rTag, gbPrev, termination);
     170        newReduction(sPolyList, critPairs, gPrev, reducers, rules, lTag, rTag, gbPrev, termination);
    171171        //timer3      =  getTimer();
    172172        //reductionTime = reductionTime + timer3;
    … …  
    251251    poly lcm            =   pOne();
    252252    poly t              =   pHead(newElement->getPoly());
    253     Rule* testedRule    =   NULL;
     253    RuleOld* testedRuleOld    =   NULL;
    254254    if(NULL != rules->getFirst()) {
    255         testedRule  =   rules->getFirst()->getRule();
     255        testedRuleOld  =   rules->getFirst()->getRuleOld();
    256256    }
    257257    // computation of critical pairs
    … …  
    271271           && !criterion2(gPrev->getFirst()->getIndex(), u1, newElement, rules, rTag)
    272272           && !criterion1(gPrev,u1,newElement,lTag) && !criterion1(gPrev,u2,temp,lTag)) {
    273             // if they pass the test, add them to CListOld critPairs, having the LPoly with greater
     273            // if they pass the test, add them to CListOld critPairs, having the LPolyOld with greater
    274274            // label as first element in the CPairOld
    275275            if(newElement->getIndex() == temp->getIndex() &&
    276276            -1 == pLmCmp(ppMult_qq(u1, newElement->getTerm()),ppMult_qq(u2, temp->getTerm()))) {
    277277                CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u2,
    278                                 temp->getLPoly(), u1, newElement->getLPoly(), testedRule);                   
     278                                temp->getLPolyOld(), u1, newElement->getLPolyOld(), testedRuleOld);                   
    279279                critPairs->insert(cp);
    280280            }
    281281            else {
    282282                CPairOld* cp   =   new CPairOld(pDeg(ppMult_qq(u2,pHead(temp->getPoly()))), u1,
    283                                 newElement->getLPoly(), u2, temp->getLPoly(), testedRule);                   
     283                                newElement->getLPolyOld(), u2, temp->getLPolyOld(), testedRuleOld);                   
    284284                critPairs->insert(cp);
    285285            }
    … …  
    437437    }
    438438    if(NULL != testNode) {
    439         if(testNode->getRule() == l->getRule()) {
     439        if(testNode->getRuleOld() == l->getRuleOld()) {
    440440            //Print("%p\n%p\n",testNode->getRule(),l->getRule());
    441441            //Print("EQUAL\n");
    … …  
    445445        }
    446446    }
    447     while(NULL != testNode && testNode->getRule() != l->getRule()
    448           && l->getIndex() == testNode->getRuleIndex()) {
     447    while(NULL != testNode && testNode->getRuleOld() != l->getRuleOld()
     448          && l->getIndex() == testNode->getRuleOldIndex()) {
    449449        //Print("%p\n",testNode);
    450450        //pWrite(testNode->getRuleTerm());
    … …  
    453453        //pWrite(u1);
    454454        //Print("%d\n",testNode->getRuleIndex());
    455         if(pLmDivisibleByNoComp(testNode->getRuleTerm(),u1)) {
     455        if(pLmDivisibleByNoComp(testNode->getRuleOldTerm(),u1)) {
    456456            //Print("-----------------Criterion 2 NOT passed!-----------------------------------\n");
    457457            //Print("INDEX: %d\n",l->getIndex());
    … …  
    475475=================================================================================================================
    476476*/
    477 inline bool criterion2(poly t, LPoly* l, RList* rules, Rule* testedRule) {
     477inline bool criterion2(poly t, LPolyOld* l, RList* rules, RuleOld* testedRuleOld) {
    478478    //Print("------------------------------IN CRITERION 2/2-----------------------------------------\n");
    479     //Print("LAST RULE TESTED: %p",testedRule);
     479    //Print("LAST RuleOld TESTED: %p",testedRuleOld);
    480480    /*
    481481    Print("RULES: \n");
    … …  
    497497    poly u1 = ppMult_qq(t,l->getTerm());
    498498        // first element added to rTag was NULL, check for this
    499         while(NULL != testNode && testNode->getRule() != testedRule) {
     499        while(NULL != testNode && testNode->getRuleOld() != testedRuleOld) {
    500500        //pWrite(testNode->getRuleTerm());
    501         if(pLmDivisibleByNoComp(testNode->getRuleTerm(),u1)) {
     501        if(pLmDivisibleByNoComp(testNode->getRuleOldTerm(),u1)) {
    502502            //Print("--------------------------Criterion 2 NOT passed!------------------------------\n");
    503503            //Print("INDEX: %d\n",l->getIndex());
    … …  
    529529    while(NULL != temp) {
    530530        //Print("JA\n");
    531         // only if a new rule was added since the last test in subalgorithm criticalPair()
     531        // only if a new RuleOld was added since the last test in subalgorithm criticalPair()
    532532        //if(rules->getFirst() != rTag->getFirst()) {
    533         if(!criterion2(temp->getT1(),temp->getAdLp1(),rules,temp->getTestedRule())) {
     533        if(!criterion2(temp->getT1(),temp->getAdLp1(),rules,temp->getTestedRuleOld())) {
    534534                // the second component is tested only when it has the actual index, otherwise there is
    535                 // no new rule to test since the last test in subalgorithm criticalPair()
     535                // no new RuleOld to test since the last test in subalgorithm criticalPair()
    536536                if(highestDegree < pDeg(ppMult_qq(temp->getT1(),temp->getLp1Poly()))) {
    537537                    highestDegree   = pDeg(ppMult_qq(temp->getT1(),temp->getLp1Poly()));
    … …  
    539539                }   
    540540                if(temp->getLp2Index() == temp->getLp1Index()) {
    541                     if(!criterion2(temp->getT2(),temp->getAdLp2(),rules,temp->getTestedRule())) {
     541                    if(!criterion2(temp->getT2(),temp->getAdLp2(),rules,temp->getTestedRuleOld())) {
    542542                        // computation of S-polynomial
    543543                        //poly p1 =   temp->getLp1Poly();
    … …  
    556556                            // S-polynomial also of a zero S-polynomial
    557557                            //zeroList->insert(temp->getAdT1(),temp->getLp1Index(),&sp);
    558                             // origin of rule can be set NULL as the labeled polynomial
     558                            // origin of RuleOld can be set NULL as the labeled polynomial
    559559                            // will never be used again as it is zero => no problems with
    560560                            // further criterion2() tests and termination conditions
    … …  
    566566                            rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    567567                            numberOfRules++;
    568                             //Print("RULE ADDED: \n");
     568                            //Print("RuleOld ADDED: \n");
    569569                            //pWrite(rules->getFirst()->getRuleTerm());
    570570                            //rules->print();
    … …  
    579579                            rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    580580                            numberOfRules++;
    581                             //Print("RULE ADDED: \n");
     581                            //Print("RuleOld ADDED: \n");
    582582                            //pWrite(rules->getFirst()->getRuleTerm()); 
    583583                            //rules->print();
    584                             sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rules->getFirst()->getRule());
     584                            sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rules->getFirst()->getRuleOld());
    585585                            //sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rNew);
    586586                        }
    … …  
    603603                    if(NULL == sp) {
    604604                        // zeroList->insert(temp->getAdT1(),temp->getLp1Index(),&sp);
    605                         // origin of rule can be set NULL as the labeled polynomial
     605                        // origin of RuleOld can be set NULL as the labeled polynomial
    606606                        // will never be used again as it is zero => no problems with
    607607                        // further criterion2() tests and termination conditions
    … …  
    611611                        rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    612612                        numberOfRules++;
    613                         //Print("RULE ADDED: \n");
     613                        //Print("RuleOld ADDED: \n");
    614614                        //pWrite(rules->getFirst()->getRuleTerm());
    615615                        //rules->print();
    … …  
    631631                        rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    632632                        numberOfRules++;
    633                         //Print("RULE ADDED: \n");
     633                        //Print("RuleOld ADDED: \n");
    634634                        //pWrite(rules->getFirst()->getRuleTerm());
    635635                        //rules->print();
    636636                        //Print("%d\n",rules->getFirst()->getRuleIndex());
    637637                        //Print("%p\n",sPolyList->getFirst());
    638                         sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rules->getFirst()->getRule());
     638                        sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rules->getFirst()->getRuleOld());
    639639                        //sPolyList->insertByLabel(ppMult_qq(temp->getT1(),temp->getLp1Term()),temp->getLp1Index(),sp,rNew);
    640640                    }
    … …  
    706706========================================================================
    707707*/
    708 void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag,
     708void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, LList* reducers, RList* rules, LTagList* lTag, RTagList* rTag,
    709709                 ideal gbPrev, int termination) {
    710710    //Print("##########################################In REDUCTION!########################################\n");
    … …  
    734734            // with label index = current label index: this is done such that there
    735735            // is no label corruption during the reduction process
    736             findReducers(temp,sPolyList,gbPrev,gPrev,critPairs,rules,lTag,rTag, termination);
     736            findReducers(temp,sPolyList,gbPrev,gPrev,reducers,critPairs,rules,lTag,rTag, termination);
    737737        //}
    738738        //else {
    … …  
    768768 * ================================================================================
    769769*/
    770 void findReducers(LNode* l, LList* sPolyList, ideal gbPrev, LList* gPrev, CListOld* critPairs, RList* rules, LTagList* lTag, RTagList* rTag, int termination) {
     770void findReducers(LNode* l, LList* sPolyList, ideal gbPrev, LList* gPrev, LList* reducers, CListOld* critPairs, RList* rules, LTagList* lTag, RTagList* rTag, int termination) {
    771771    int canonicalize    =   0;
    772772    //int timerRed        =   0;
    … …  
    775775    LList* good         =   new LList();
    776776    LList* bad          =   new LList();
    777     LList* monomials    =   new LList(l->getLPoly());
     777    LList* monomials    =   new LList(l->getLPolyOld());
    778778    poly u              =   pOne();
    779779    number nOne         =   nInit(1);
    … …  
    794794        //Print("\n\n\nTO BE REDUCED:  ");
    795795        //pWrite(l->getPoly());
     796        //pWrite(l->getTerm());
    796797        //pWrite(tempPoly);
    797798        while(NULL != tempPoly) {
    … …  
    835836                    else {
    836837                        if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 0) {
    837                          Print("NOT ALLOWED REDUCER:\n");
    838                                       pWrite(u);
    839                                       pWrite(tempRed->getTerm());
    840                                       pWrite(tempRed->getPoly());
    841                                       addToG  = 0;
     838                         //Print("NOT ALLOWED REDUCER, EQUAL LABELS:\n");
     839                                      //pWrite(u);
     840                                      //pWrite(tempRed->getTerm());
     841                                      //pWrite(pHead(tempRed->getPoly()));
     842                                      //addToG  = 0;
    842843                        }
    843844                        if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) != 0) {
    … …  
    848849                                    if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1) {
    849850                                        if(NULL == redPoly) {
    850                                             bad->insert(tempRed->getLPoly());
     851                                            bad->insert(tempRed->getLPolyOld());
    851852                                            addToG  = 1;
    852853                                            //poly tempRedPoly    =   tempRed->getPoly();
    … …  
    886887                            }
    887888                            else {
    888                               Print("CRIT 1  ");
     889                              //Print("CRIT 1  ");
    889890                                   
    890891                                      if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1 ) {
    891                                       Print("NOT ALLOWED REDUCER:\n");
    892                                       pWrite(u);
    893                                       pWrite(tempRed->getTerm());
    894                                       pWrite(tempRed->getPoly());
    895                                       addToG  = 0;
     892                                      //Print("NOT ALLOWED REDUCER, CRIT 1:\n");
     893                                      //pWrite(u);
     894                                      //pWrite(tempRed->getTerm());
     895                                      //pWrite(tempRed->getPoly());
     896                                      if(pLmDivisibleByNoComp(tempRed->getTerm(),l->getTerm())) {
     897                                        //Print("REDUCER LABEL:  ");
     898                                        //pWrite(tempRed->getTerm());
     899addToG  = 0;
     900                                      }
    896901                                    }
    897902                            }
    898903                        }
    899904                        else {
    900                           Print("CRIT 2  ");
     905                          //Print("CRIT 2  ");
    901906                                    if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1) {
    902                                       Print("NOT ALLOWED REDUCER:\n");
    903                                       pWrite(u);
    904                                       pWrite(tempRed->getTerm());
    905                                       pWrite(tempRed->getPoly());
    906                                       addToG  = 0;
     907                                      //Print("NOT ALLOWED REDUCER, CRIT 2:\n");
     908                                      //pWrite(u);
     909                                      //pWrite(tempRed->getTerm());
     910                                      //pWrite(tempRed->getPoly());
     911                                      if(pLmDivisibleByNoComp(tempRed->getTerm(),l->getTerm())) {
     912                                        //Print("REDUCER LABEL:  ");
     913                                        //pWrite(tempRed->getTerm());
     914addToG  = 0;
     915                                      }
    907916                                    }
    908917                        }
    … …  
    912921                tempRed =   tempRed->getNext();
    913922            }
     923            // reduction process with elements in LList* reducers
     924          if(NULL != tempPoly) {
     925            //Print("HERE\n");
     926            tempRed =   reducers->getFirst();
     927            while(NULL != tempRed) {
     928                //Print("TEMPREDPOLY:  ");
     929                //pWrite(tempRed->getPoly());
     930              //pWrite(tempPoly); 
     931              if(pLmDivisibleByNoComp(tempRed->getPoly(),tempPoly)) {
     932                    //Print("A\n");
     933                    u   =   pDivideM(pHead(tempPoly),pHead(tempRed->getPoly()));
     934                    //Print("U:  ");
     935                    //pWrite(u);
     936                    if(tempRed->getIndex() != idx) {
     937                            // passing criterion1 ?
     938                            if(!criterion1(gPrev,u,tempRed,lTag)) {
     939                                    poly tempRedPoly    =   tempRed->getPoly();
     940                                    //Print("REDUCER: ");
     941                                    //pWrite(ppMult_qq(u,tempRedPoly));
     942                                    pIter(tempRedPoly);
     943                                    int lTempRedPoly    =   pLength(tempRedPoly);
     944                                    kBucketExtractLm(bucket);
     945                                    kBucket_Minus_m_Mult_p(bucket,u,tempRedPoly,&lTempRedPoly);
     946                                    canonicalize++;
     947                                    //Print("Reduction\n");
     948                                    if(!(canonicalize % 50)) {
     949                                        kBucketCanonicalize(bucket);
     950                                    }
     951                                    tempPoly    =   kBucketGetLm(bucket);
     952                                    //Print("TEMPPOLY:  ");
     953                                    //pWrite(tempPoly);
     954                                    if(NULL != tempPoly) {
     955                                        tempRed     =   gPrev->getFirst();
     956                                        continue;
     957                                    }
     958                                    else {
     959                                        break;
     960                                    }
     961                             }   
     962                   
     963                    }
     964                    else {
     965                        if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 0) {
     966                         //Print("NOT ALLOWED REDUCER, EQUAL LABELS:\n");
     967                                      //pWrite(u);
     968                                      //pWrite(tempRed->getTerm());
     969                                      //pWrite(pHead(tempRed->getPoly()));
     970                                      //addToG  = 0;
     971                        }
     972                        if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) != 0) {
     973                            // passing criterion2 ?
     974                            if(!criterion2(gPrev->getFirst()->getIndex(), u,tempRed,rules,rTag)) {
     975                                // passing criterion1 ?
     976                                if(!criterion1(gPrev,u,tempRed,lTag)) {
     977                                    if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1) {
     978                                        if(NULL == redPoly) {
     979                                            bad->insert(tempRed->getLPolyOld());
     980                                            addToG  = 1;
     981                                            //poly tempRedPoly    =   tempRed->getPoly();
     982                                            //break;
     983                                        }
     984                                    }
     985                                    else {
     986                                        poly tempRedPoly    =   tempRed->getPoly();
     987                                        //Print("REDUCER: ");
     988                                        //pWrite(ppMult_qq(u,tempRedPoly));
     989                                        pIter(tempRedPoly);
     990                                        int lTempRedPoly    =   pLength(tempRedPoly);
     991                                        //Print("HEAD MONOMIAL KBUCKET: ");
     992                                        //pWrite(kBucketGetLm(bucket));
     993                                        kBucketExtractLm(bucket);
     994                                        kBucket_Minus_m_Mult_p(bucket,u,tempRedPoly,&lTempRedPoly);
     995                                        canonicalize++;
     996                                        //Print("REDUCTION\n");
     997                                        addToG  = 1;
     998                                        if(!(canonicalize % 50)) {
     999                                            kBucketCanonicalize(bucket);
     1000                                        }
     1001                                        //Print("HEAD MONOMIAL KBUCKET: ");
     1002                                        //pWrite(kBucketGetLm(bucket));
     1003                                        tempPoly    =   kBucketGetLm(bucket);
     1004                                        //Print("TEMPPOLY:  ");
     1005                                        //pWrite(tempPoly);
     1006                                        if(NULL != tempPoly) {
     1007                                            tempRed     =   gPrev->getFirst();
     1008                                            continue;
     1009                                        }
     1010                                        else {
     1011                                            break;
     1012                                        }
     1013                                    }
     1014                                }   
     1015                            }
     1016                            else {
     1017                              //Print("CRIT 1  ");
     1018                                   
     1019                                      if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1 ) {
     1020                                      //Print("NOT ALLOWED REDUCER, CRIT 1:\n");
     1021                                      //pWrite(u);
     1022                                      //pWrite(tempRed->getTerm());
     1023                                      //pWrite(tempRed->getPoly());
     1024                                      if(pLmDivisibleByNoComp(tempRed->getTerm(),l->getTerm())) {
     1025                                        //Print("REDUCER LABEL:  ");
     1026                                        //pWrite(tempRed->getTerm());
     1027                                        addToG  = 0;
     1028                                      }
     1029                                    }
     1030                            }
     1031                        }
     1032                        else {
     1033                          //Print("CRIT 2  ");
     1034                                    if(pLmCmp(ppMult_qq(u,tempRed->getTerm()),l->getTerm()) == 1) {
     1035                                      //Print("NOT ALLOWED REDUCER, CRIT 2:\n");
     1036                                      //pWrite(u);
     1037                                      //pWrite(tempRed->getTerm());
     1038                                      //pWrite(tempRed->getPoly());
     1039                                      if(pLmDivisibleByNoComp(tempRed->getTerm(),l->getTerm())) {
     1040                                        //Print("REDUCER LABEL:  ");
     1041                                        //pWrite(tempRed->getTerm());
     1042addToG  = 0;
     1043                                      }
     1044                                    }
     1045                        }
     1046                    }
     1047                   
     1048                }
     1049                tempRed =   tempRed->getNext();
     1050            }
     1051          }
    9141052            if(NULL != tempPoly) {
    9151053                if(NULL == redPoly) {
    … …  
    9321070        }
    9331071        else {
    934             Print("\nELEMENT ADDED TO GPREV: ");
     1072            //Print("\nELEMENT ADDED TO GPREV: ");
    9351073            pNorm(redPoly);
    936             pWrite(pHead(redPoly));
    937             pWrite(l->getTerm());
     1074            //pWrite(pHead(redPoly));
     1075            //pWrite(l->getTerm());
    9381076            //Print("%d\n",canonicalize);
    9391077            l->setPoly(redPoly);
    940             gPrev->insert(l->getLPoly());
     1078            if(addToG == 0 && termination == 1) {
     1079              reducers->insert(l->getLPolyOld());
     1080            }
     1081            else {
     1082              gPrev->insert(l->getLPolyOld());
     1083            }
    9411084            //Print("%d\n\n",termination);
    9421085            if(termination == 1) {
    … …  
    9471090            else {
    9481091              notInG++;
    949               Print("\nNONONO");
    950               pWrite(pHead(l->getPoly()));
    951               pWrite(l->getTerm());
     1092              //Print("\nNONONO");
     1093              //pWrite(pHead(l->getPoly()));
     1094              //pWrite(l->getTerm());
    9521095            }
    9531096            }
    … …  
    9891132                            if(NULL != temp) {
    9901133                                pNorm(temp);
    991                                 LNode* tempBadNew   =   new LNode(ppMult_qq(u,tempBad->getTerm()),tempBad->getIndex(),temp,rules->getFirst()->getRule());
     1134                                LNode* tempBadNew   =   new LNode(ppMult_qq(u,tempBad->getTerm()),tempBad->getIndex(),temp,rules->getFirst()->getRuleOld());
    9921135                                //pWrite(temp);
    9931136                                //pWrite(tempBadNew->getPoly());
    … …  
    11211264                    //tempRed->setDel(1);
    11221265                    //rules->insert(tempRed->getIndex(),tempRed->getTerm());
    1123                     LNode* tempRedNew   =   new LNode(tempRed->getTerm(),tempRed->getIndex(),temp,rules->getFirst()->getRule());
     1266                    LNode* tempRedNew   =   new LNode(tempRed->getTerm(),tempRed->getIndex(),temp,rules->getFirst()->getRuleOld());
    11241267                    //tempRed->getLPoly()->setRule(rules->getFirst()->getRule());
    11251268                    tempRedNew->setDel(1);
    … …  
    11741317                //Print("ELEMENT ADDED TO GPREV: ");
    11751318                //pWrite(l->getPoly());
    1176                 gPrev->insert(l->getLPoly());
     1319                gPrev->insert(l->getLPolyOld());
    11771320                //Print("TEMP RED == 0  ");
    11781321                //pWrite(l->getPoly());
    … …  
    12421385                        if(NULL != tempSpoly) {
    12431386                            pNorm(tempSpoly);
    1244                             sPolyList->insertByLabel(ppMult_qq(u,temp->getTerm()),temp->getIndex(),tempSpoly,rules->getFirst()->getRule());
     1387                            sPolyList->insertByLabel(ppMult_qq(u,temp->getTerm()),temp->getIndex(),tempSpoly,rules->getFirst()->getRuleOld());
    12451388                    //Print("NEW ONE: ");
    12461389                    //pWrite(tempSpoly);
    … …  
    13351478    //idShow(id);
    13361479    LList* gPrev    =   new LList(ONE, i, id->m[0]);
     1480    LList* reducers =   new LList();
    13371481    //idShow(id);
    13381482    //Print("%p\n",id->m[0]);
    … …  
    13571501        //Print("%p\n",gPrevTag);   
    13581502        //pWrite(gPrevTag->getPoly());
    1359         gPrev   =   F5inc(i, id->m[i-1], gPrev, gbPrev, ONE, lTag, rules, rTag, termination);
     1503        gPrev   =   F5inc(i, id->m[i-1], gPrev, reducers, gbPrev, ONE, lTag, rules, rTag, termination);
    13601504        //Print("%d\n",gPrev->count(gPrevTag->getNext()));
    13611505        //Print("%d\n",gPrev->getLength());

  • kernel/f5gb.h

    rf414c0 ra05c71  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.h,v 1.43 2009-08-30 15:26:00 ederc Exp $ */
     4/* $Id: f5gb.h,v 1.44 2009-08-31 13:55:46 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    3434==========================================================================
    3535*/
    36 bool compareMonomials(int* m1, int** m2, int numberOfRules);
     36bool compareMonomials(int* m1, int** m2, int numberOfRuleOlds);
    3737
    3838
    … …  
    4343==================================================
    4444*/
    45 LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE, LTagList* lTag, RList* rules, RTagList* rTag,int termination);
     45LList* F5inc(int i, poly f_i, LList* gPrev,LList* reducers, ideal gbPrev, poly ONE, LTagList* lTag, RList* rules, RTagList* rTag,int termination);
    4646
    4747/*
    … …  
    5252================================================================
    5353*/
    54 void criticalPair(LList* gPrev, CListOld* critPairs, LTagList* lTag, RTagList* rTag, RList* rules);
     54void criticalPair(LList* gPrev, CListOld* critPairs, LTagList* lTag, RTagList* rTag, RList* RuleOlds);
    5555
    5656/*
    … …  
    6666=====================================
    6767*/
    68 inline bool criterion2(int idx, poly t, LNode* l, RList* rules, RTagList* rTag);
     68inline bool criterion2(int idx, poly t, LNode* l, RList* RuleOlds, RTagList* rTag);
    6969
    7070/*
    7171==========================================================================================================
    72 Criterion 2, i.e. Rewritten Criterion, for its second call in sPols(), with added lastRuleTested parameter
     72Criterion 2, i.e. Rewritten Criterion, for its second call in sPols(), with added lastRuleOldTested parameter
    7373==========================================================================================================
    7474*/
    75 inline bool criterion2(poly t, LPoly* l, RList* rules, Rule* testedRule);
     75inline bool criterion2(poly t, LPolyOld* l, RList* RuleOlds, RuleOld* testedRuleOld);
    7676
    7777/*
    … …  
    8080==================================
    8181*/
    82 inline void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList);
     82inline void computeSPols(CNode* first, RTagList* rTag, RList* RuleOlds, LList* sPolyList);
    8383
    8484/*
    … …  
    8787========================================================================
    8888*/
    89 inline void reduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag,
     89inline void reduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* RuleOlds, LTagList* lTag, RTagList* rTag,
    9090                 ideal gbPrev);
    9191
    … …  
    9595========================================================================
    9696*/
    97 inline void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag, ideal gbPrev, int termination);
     97inline void newReduction(LList* sPolyList, CListOld* critPairs, LList* gPrev, LList* reducers, RList* rules, LTagList* lTag, RTagList* rTag, ideal gbPrev, int termination);
    9898
    9999/*!
    … …  
    106106 *
    107107 * the "bad" ones are the reducers which corrupt the label of temp, they are tested
    108  * later on for possible new rules and S-polynomials to be added to the algorithm
     108 * later on for possible new RuleOlds and S-polynomials to be added to the algorithm
    109109 * ================================================================================
    110110 */
    111 void findReducers(LNode* l, LList* sPolyList, ideal gbPrev, LList* gPrev, CListOld* critPairs, RList* rules, LTagList* lTag, RTagList* rTag, int termination);
     111void findReducers(LNode* l, LList* sPolyList, ideal gbPrev, LList* gPrev, LList* reducers, CListOld* critPairs, RList* rules, LTagList* lTag, RTagList* rTag, int termination);
    112112
    113113/*
    … …  
    117117=====================================================================================
    118118*/
    119 inline void topReduction(LNode* l, LList* sPolyList, LList* gPrev, CListOld* critPairs, RList* rules, LTagList* lTag, RTagList* rTag, ideal gbPrev);
     119inline void topReduction(LNode* l, LList* sPolyList, LList* gPrev, CListOld* critPairs, RList* RuleOlds, LTagList* lTag, RTagList* rTag, ideal gbPrev);
    120120
    121121/*
    … …  
    133133=====================================================================
    134134*/
    135 inline LNode* findReductor(LNode* l, LList* sPolyList, LNode* gPrevRedCheck, LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag);
     135inline LNode* findReductor(LNode* l, LList* sPolyList, LNode* gPrevRedCheck, LList* gPrev, RList* RuleOlds, LTagList* lTag,RTagList* rTag);
    136136
    137137/*

  • kernel/f5lists.cc

    rf414c0 ra05c71  
    3030    next                =   NULL;
    3131}
    32 LNode::LNode(LPoly* lp) {
     32LNode::LNode(LPolyOld* lp) {
    3333    data                =   lp;
    3434    next                =   NULL;
    3535}
    3636       
    37 LNode::LNode(LPoly* lp, LNode* l) {
     37LNode::LNode(LPolyOld* lp, LNode* l) {
    3838//Print("HIER LNODE\n");
    3939    data                =   lp;
    … …  
    4141}
    4242
    43 LNode::LNode(poly t, int i, poly p, Rule* r) {
    44 LPoly* lp           =   new LPoly(t,i,p,r);
     43LNode::LNode(poly t, int i, poly p, RuleOld* r) {
     44LPolyOld* lp           =   new LPolyOld(t,i,p,r);
    4545data                =   lp;
    4646next                =   NULL;
    4747}
    4848       
    49 LNode::LNode(poly t, int i, poly p, Rule* r, LNode* l) {
    50     LPoly* lp           =   new LPoly(t,i,p,r);
     49LNode::LNode(poly t, int i, poly p, RuleOld* r, LNode* l) {
     50    LPolyOld* lp           =   new LPolyOld(t,i,p,r);
    5151    data                =   lp;
    5252    next                =   l;
    … …  
    5454
    5555LNode::LNode(LNode* ln) {
    56     data                =   ln->getLPoly();
     56    data                =   ln->getLPolyOld();
    5757    next                =   ln->getNext();
    5858}
    … …  
    7575// insert new elements to the list always at the end (labeled / classical polynomial view)
    7676// needed for list gPrev
    77 inline LNode* LNode::insert(LPoly* lp) {
     77inline LNode* LNode::insert(LPolyOld* lp) {
    7878    //Print("LAST GPREV: ");
    7979    //pWrite(this->getPoly());
    … …  
    8989}
    9090       
    91 inline LNode* LNode::insert(poly t, int i, poly p, Rule* r) {
     91inline LNode* LNode::insert(poly t, int i, poly p, RuleOld* r) {
    9292    if(NULL == this) {
    9393        LNode* newElement   =   new LNode(t,i,p,r,this);
    … …  
    103103// insert new elements to the list always in front (labeled / classical polynomial view)
    104104// needed for sPolyList
    105 inline LNode* LNode::insertSP(LPoly* lp) {
     105inline LNode* LNode::insertSP(LPolyOld* lp) {
    106106    LNode* newElement   =   new LNode(lp, this);
    107107    //Print("INSERTED IN SPOLYLIST: ");
    … …  
    110110}
    111111       
    112 inline LNode* LNode::insertSP(poly t, int i, poly p, Rule* r) {
     112inline LNode* LNode::insertSP(poly t, int i, poly p, RuleOld* r) {
    113113    LNode* newElement   =   new LNode(t, i, p, r, this);
    114114     //Print("INSERTED IN SPOLYLIST: ");
    … …  
    118118// insert new elemets to the list w.r.t. increasing labels
    119119// only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
    120 inline LNode* LNode::insertByLabel(poly t, int i, poly p, Rule* r) {
     120inline LNode* LNode::insertByLabel(poly t, int i, poly p, RuleOld* r) {
    121121    //Print("ADDING SOLYS TO THE LIST\n");
    122122    //Print("new element: ");
    … …  
    222222}
    223223
    224 // get the LPoly* out of LNode*
    225 LPoly* LNode::getLPoly() {
     224// get the LPolyOld* out of LNode*
     225LPolyOld* LNode::getLPolyOld() {
    226226    return data;
    227227}
    228228
    229 // get the data from the LPoly saved in LNode
     229// get the data from the LPolyOld saved in LNode
    230230poly LNode::getPoly() {
    231231    return data->getPoly();
    … …  
    240240}
    241241
    242 Rule* LNode::getRule() {
    243     return data->getRule();
    244 }
    245 
    246 void LNode::setRule(Rule* r) {
    247     return data->setRule(r);
     242RuleOld* LNode::getRuleOld() {
     243    return data->getRuleOld();
     244}
     245
     246void LNode::setRuleOld(RuleOld* r) {
     247    return data->setRuleOld(r);
    248248}
    249249
    … …  
    252252}
    253253
    254 // set the data from the LPoly saved in LNode
     254// set the data from the LPolyOld saved in LNode
    255255void LNode::setPoly(poly p) {
    256256    data->setPoly(p);
    … …  
    333333}
    334334
    335 LList::LList(LPoly* lp) {
     335LList::LList(LPolyOld* lp) {
    336336    first   =   new LNode(lp);
    337337    last    =   first;
    … …  
    339339}
    340340
    341 LList::LList(poly t,int i,poly p,Rule* r) {
     341LList::LList(poly t,int i,poly p,RuleOld* r) {
    342342    first   =   new LNode(t,i,p,r);
    343343    last    =   first;
    … …  
    356356
    357357// insertion at the end of the list, needed for gPrev
    358 void LList::insert(LPoly* lp) {
     358void LList::insert(LPolyOld* lp) {
    359359    last = last->insert(lp);
    360360    if(NULL == first) {
    … …  
    369369}
    370370
    371 void LList::insert(poly t,int i, poly p, Rule* r) {
     371void LList::insert(poly t,int i, poly p, RuleOld* r) {
    372372    last = last->insert(t,i,p,r);
    373373    if(NULL == first) {
    … …  
    379379
    380380// insertion in front of the list, needed for sPolyList
    381 void LList::insertSP(LPoly* lp) {
     381void LList::insertSP(LPolyOld* lp) {
    382382    first = first->insertSP(lp);
    383383    length++;
    … …  
    385385}
    386386
    387 void LList::insertSP(poly t,int i, poly p, Rule* r) {
     387void LList::insertSP(poly t,int i, poly p, RuleOld* r) {
    388388    first = first->insertSP(t,i,p,r);
    389389    length++;
    … …  
    392392
    393393
    394 void LList::insertByLabel(poly t, int i, poly p, Rule* r) {
     394void LList::insertByLabel(poly t, int i, poly p, RuleOld* r) {
    395395    first = first->insertByLabel(t,i,p,r);
    396396    length++;
    … …  
    483483
    484484// NOTE: We insert at the beginning of the list and length = i-1, where i is the actual index.
    485 //       Thus given actual index i and idx being the index of the LPoly under investigation
     485//       Thus given actual index i and idx being the index of the LPolyOld under investigation
    486486//       the element on position length-idx is the right one
    487487LNode* LTagNode::get(int idx, int length) {
    … …  
    719719}
    720720
    721 LPoly* CNode::getAdLp1() {
     721LPolyOld* CNode::getAdLp1() {
    722722    return this->data->getAdLp1();
    723723}
    724724
    725 LPoly* CNode::getAdLp2() {
     725LPolyOld* CNode::getAdLp2() {
    726726    return this->data->getAdLp2();
    727727}
    … …  
    767767}
    768768
    769 Rule* CNode::getTestedRule() {
    770     return this->data->getTestedRule();
     769RuleOld* CNode::getTestedRuleOld() {
     770    return this->data->getTestedRuleOld();
    771771}
    772772
    … …  
    854854}
    855855
    856 RNode::RNode(Rule* r) {
     856RNode::RNode(RuleOld* r) {
    857857    data    =   r;
    858858    next    =   NULL;
    … …  
    860860
    861861RNode::~RNode() {
    862     //Print("DELETE RULE\n");
     862    //Print("DELETE RuleOld\n");
    863863    delete  data;
    864864}
    865865
    866 RNode* RNode::insert(Rule* r) {
     866RNode* RNode::insert(RuleOld* r) {
    867867    RNode* newElement   =   new RNode(r);
    868868    newElement->next    =   this;
    … …  
    873873    //Print("IN INSERT: ");
    874874    //pWrite(t);
    875     Rule*   r           =   new Rule(i,t);
    876     //Print("ADDRESS OF RULE: %p\n",r);
     875    RuleOld*   r           =   new RuleOld(i,t);
     876    //Print("ADDRESS OF RuleOld: %p\n",r);
    877877    RNode* newElement   =   new RNode(r);
    878878    //Print("ADDRESS OF RNODE: %p\n",newElement);
    879     //Print("ADDRESS OF RNODE DATA: %p\n",newElement->getRule());
     879    //Print("ADDRESS OF RNODE DATA: %p\n",newElement->getRuleOld());
    880880    newElement->next    =   this;
    881881    return newElement;
    … …  
    883883
    884884
    885 RNode* RNode::insertOrdered(Rule* r) {
     885RNode* RNode::insertOrdered(RuleOld* r) {
    886886    RNode* newElement   =   new RNode(r);
    887887    RNode* temp         =   this;
    … …  
    890890        return newElement;
    891891    }
    892     if(1 == pLmCmp(newElement->getRuleTerm(),temp->getRuleTerm())) {
     892    if(1 == pLmCmp(newElement->getRuleOldTerm(),temp->getRuleOldTerm())) {
    893893        newElement->next =   temp;
    894894        return newElement;
    895895    }
    896896    else {
    897         while(NULL != temp && 1 ==  pLmCmp(temp->getRuleTerm(),newElement->getRuleTerm())) {
     897        while(NULL != temp && 1 ==  pLmCmp(temp->getRuleOldTerm(),newElement->getRuleOldTerm())) {
    898898            temp    =   temp->getNext();
    899899        }
    … …  
    908908}   
    909909
    910 Rule* RNode::getRule() {
     910RuleOld* RNode::getRuleOld() {
    911911    return data;
    912912}
    913913
    914 int RNode::getRuleIndex() {
     914int RNode::getRuleOldIndex() {
    915915    return data->getIndex();
    916916}
    917917
    918 poly RNode::getRuleTerm() {
     918poly RNode::getRuleOldTerm() {
    919919    return data->getTerm();
    920920}
    … …  
    923923    RNode* temp  =   this;
    924924    while(NULL != temp) {
    925         pWrite(temp->getRuleTerm());
    926         Print("%d\n\n",temp->getRuleIndex());
     925        pWrite(temp->getRuleOldTerm());
     926        Print("%d\n\n",temp->getRuleOldIndex());
    927927        temp    =   temp->getNext();
    928928    }
    … …  
    938938}
    939939
    940 RList::RList(Rule* r) {
     940RList::RList(RuleOld* r) {
    941941    first = new RNode(r);
    942942}
    … …  
    950950        //Print("1 %p\n",first);
    951951        //if(first) {
    952             //Print("1' %p\n",first->getRule());
     952            //Print("1' %p\n",first->getRuleOld());
    953953            //Print("2 %p\n",first->getNext());
    954             //Print("3 %p\n",first->getNext()->getRule());
    955             //Print("3 %p\n",first->getNext()->getRuleTerm());
     954            //Print("3 %p\n",first->getNext()->getRuleOld());
     955            //Print("3 %p\n",first->getNext()->getRuleOldTerm());
    956956        //}
    957957        delete  temp;
    … …  
    964964}
    965965
    966 void RList::insert(Rule* r) {
     966void RList::insert(RuleOld* r) {
    967967    first = first->insert(r);
    968968}
    969969
    970 void RList::insertOrdered(Rule* r) {
     970void RList::insertOrdered(RuleOld* r) {
    971971    first   =   first->insertOrdered(r);
    972972}
    … …  
    976976}
    977977
    978 Rule* RList::getRule() {
    979     return this->getRule();
     978RuleOld* RList::getRuleOld() {
     979    return this->getRuleOld();
    980980}
    981981
    … …  
    10291029
    10301030// NOTE: We insert at the beginning of the list and length = i-1, where i is the actual index.
    1031 //       Thus given actual index i and idx being the index of the LPoly under investigation
     1031//       Thus given actual index i and idx being the index of the LPolyOld under investigation
    10321032//       the element on position length-idx+1 is the right one
    10331033RNode* RTagNode::get(int idx, int length) {
    … …  
    10581058    RTagNode* temp  =   this;
    10591059    if(NULL != temp && NULL != temp->getRNode()) {
    1060         Print("1. element: %d,  ",getRNode()->getRule()->getIndex());
    1061         pWrite(getRNode()->getRule()->getTerm());
     1060        Print("1. element: %d,  ",getRNode()->getRuleOld()->getIndex());
     1061        pWrite(getRNode()->getRuleOld()->getTerm());
    10621062        temp    =   temp->next;
    10631063        int i   =   2;
    10641064        while(NULL != temp->getRNode() && NULL != temp) {
    1065             Print("%d. element: %d,  ",i,getRNode()->getRule()->getIndex());
    1066             pWrite(getRNode()->getRule()->getTerm());
     1065            Print("%d. element: %d,  ",i,getRNode()->getRuleOld()->getIndex());
     1066            pWrite(getRNode()->getRuleOld()->getTerm());
    10671067            temp    =   temp->next;
    10681068            i++;

  • kernel/f5lists.h

    rf414c0 ra05c71  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5lists.h,v 1.23 2009-07-16 07:47:51 ederc Exp $ */
     4/* $Id: f5lists.h,v 1.24 2009-08-31 13:55:46 ederc Exp $ */
    55/*
    66* ABSTRACT: list interface
    … …  
    3232/*
    3333=======================================
    34 class LNode (nodes for lists of LPolys)
     34class LNode (nodes for lists of LPolyOlds)
    3535=======================================
    3636*/
    3737class LNode {
    3838    private:
    39         LPoly*  data;
     39        LPolyOld*  data;
    4040        LNode*  next;
    4141    public:
    4242        // generating new list elements from the labeled / classical polynomial view
    4343                LNode();
    44                 LNode(LPoly* lp);
    45                 LNode(LPoly* lp, LNode* l);
    46                 LNode(poly t, int i, poly p, Rule* r=NULL);
    47                 LNode(poly t, int i, poly p, Rule* r, LNode* l);
     44                LNode(LPolyOld* lp);
     45                LNode(LPolyOld* lp, LNode* l);
     46                LNode(poly t, int i, poly p, RuleOld* r=NULL);
     47                LNode(poly t, int i, poly p, RuleOld* r, LNode* l);
    4848                LNode(LNode* ln);
    4949                ~LNode();
    … …  
    5151        // insert new elements to the list at the end from the labeled / classical polynomial view
    5252        // needed for gPrev
    53         LNode*  insert(LPoly* lp);
    54         LNode*  insert(poly t, int i, poly p, Rule* r);
    55         LNode*  insertByDeg(LPoly* lp);
     53        LNode*  insert(LPolyOld* lp);
     54        LNode*  insert(poly t, int i, poly p, RuleOld* r);
     55        LNode*  insertByDeg(LPolyOld* lp);
    5656        // insert new elements to the list in front from the labeled / classical polynomial view
    5757        // needed for sPolyList
    58         LNode*  insertSP(LPoly* lp);
    59         LNode*  insertSP(poly t, int i, poly p, Rule* r);
     58        LNode*  insertSP(LPolyOld* lp);
     59        LNode*  insertSP(poly t, int i, poly p, RuleOld* r);
    6060        // insert new elements to the list with resp. to increasing labels
    6161        // only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
    62         LNode*  insertByLabel(poly t, int i, poly p, Rule* r);
     62        LNode*  insertByLabel(poly t, int i, poly p, RuleOld* r);
    6363        LNode*  insertByLabel(LNode* l);
    6464        LNode*  insertFirst(LNode* l);
    … …  
    6969        // only used for the S-polys, which are already sorted by increasing degree by CListOld
    7070        LNode*  deleteByDeg();
    71         // get the LPoly* out of LNode*
    72         LPoly*  getLPoly();
    73         // get the data from the LPoly saved in LNode
     71        // get the LPolyOld* out of LNode*
     72        LPolyOld*  getLPolyOld();
     73        // get the data from the LPolyOld saved in LNode
    7474        poly    getPoly();
    7575        poly    getTerm();
    7676        int     getIndex();
    77         Rule*   getRule();
     77        RuleOld*   getRuleOld();
    7878        bool    getDel();
    79         // set the data from the LPoly saved in LNode
     79        // set the data from the LPolyOld saved in LNode
    8080        void    setPoly(poly p);
    8181        void    setTerm(poly t);
    8282        void    setIndex(int i);
    8383        void    setNext(LNode* l);
    84         void    setRule(Rule* r);
     84        void    setRuleOld(RuleOld* r);
    8585        void    setDel(bool d);
    8686        // test if for any list element the polynomial part of the data is equal to *p
    … …  
    9494/*
    9595============================
    96 class LList(lists of LPolys)
     96class LList(lists of LPolyOlds)
    9797============================
    9898*/
    … …  
    104104    public:
    105105                LList();
    106                 LList(LPoly* lp);
    107                 LList(poly t,int i,poly p, Rule* r = NULL);
     106                LList(LPolyOld* lp);
     107                LList(poly t,int i,poly p, RuleOld* r = NULL);
    108108                ~LList();
    109109        // insertion at the end of the list
    110110        // needed for gPrev
    111         void    insert(LPoly* lp);
    112         void    insert(poly t,int i, poly p, Rule* r = NULL);
    113         void    insertByDeg(LPoly* lp);
     111        void    insert(LPolyOld* lp);
     112        void    insert(poly t,int i, poly p, RuleOld* r = NULL);
     113        void    insertByDeg(LPolyOld* lp);
    114114        // insertion in front of the list
    115115        // needed for sPolyList
    116         void    insertSP(LPoly* lp);
    117         void    insertSP(poly t,int i, poly p, Rule* r = NULL);
    118         void    insertByLabel(poly t, int i, poly p, Rule* r = NULL);
     116        void    insertSP(LPolyOld* lp);
     117        void    insertSP(poly t,int i, poly p, RuleOld* r = NULL);
     118        void    insertByLabel(poly t, int i, poly p, RuleOld* r = NULL);
    119119        void    insertByLabel(LNode* l);
    120120        void    insertFirst(LNode* l);
    … …  
    133133/*
    134134==============================================
    135 class LtagNode (nodes for lists of LPoly tags)
     135class LtagNode (nodes for lists of LPolyOld tags)
    136136==============================================
    137137*/
    … …  
    155155/*
    156156=========================================================================
    157 class LTagList(lists of LPoly tags, i.e. first elements of a given index)
     157class LTagList(lists of LPolyOld tags, i.e. first elements of a given index)
    158158=========================================================================
    159159*/
    … …  
    215215        CPairOld*  getData();
    216216        CNode*  getNext();
    217         LPoly*  getAdLp1();
    218         LPoly*  getAdLp2();
     217        LPolyOld*  getAdLp1();
     218        LPolyOld*  getAdLp2();
    219219        poly    getLp1Poly();
    220220        poly    getLp2Poly();
    … …  
    227227        int     getLp1Index();
    228228        int     getLp2Index();
    229         Rule*   getTestedRule();
     229        RuleOld*   getTestedRuleOld();
    230230        void    print();
    231231};
    … …  
    254254/*
    255255======================================
    256 class RNode (nodes for lists of Rules)
     256class RNode (nodes for lists of RuleOlds)
    257257======================================
    258258*/
    259259class RNode {
    260260    private:
    261         Rule*   data;
     261        RuleOld*   data;
    262262        RNode*  next;
    263263    public:
    264264                RNode();
    265                 RNode(Rule* r);
     265                RNode(RuleOld* r);
    266266                ~RNode();
    267         RNode*  insert(Rule* r);
     267        RNode*  insert(RuleOld* r);
    268268        RNode*  insert(int i, poly t);
    269         RNode*  insertOrdered(Rule* r);
     269        RNode*  insertOrdered(RuleOld* r);
    270270        RNode*  getNext();
    271         Rule*   getRule();
    272         int     getRuleIndex();
    273         poly    getRuleTerm();
    274         void    print();
    275 };
    276 
    277 /*
    278 ============================
    279 class RList (lists of Rules)
     271        RuleOld*   getRuleOld();
     272        int     getRuleOldIndex();
     273        poly    getRuleOldTerm();
     274        void    print();
     275};
     276
     277/*
     278============================
     279class RList (lists of RuleOlds)
    280280============================
    281281*/
    … …  
    287287    public:
    288288                RList();
    289                 RList(Rule* r);
     289                RList(RuleOld* r);
    290290                ~RList();
    291         void    insert(Rule* r);
     291        void    insert(RuleOld* r);
    292292        void    insert(int i, poly t);
    293         void    insertOrdered(Rule* r);
     293        void    insertOrdered(RuleOld* r);
    294294        RNode*  getFirst();
    295         Rule*   getRule();
     295        RuleOld*   getRuleOld();
    296296        void    print();
    297297};
    … …  
    301301/*
    302302=============================================
    303 class RtagNode (nodes for lists of Rule tags)
     303class RtagNode (nodes for lists of RuleOld tags)
    304304=============================================
    305305*/
    … …  
    325325/*
    326326========================================================================
    327 class RTagList(lists of Rule tags, i.e. first elements of a given index)
     327class RTagList(lists of RuleOld tags, i.e. first elements of a given index)
    328328========================================================================
    329329*/
Note: See TracChangeset for help on using the changeset viewer.