Changeset fcb8022 in git


Ignore:
Timestamp:
Feb 8, 2009, 8:17:54 PM (14 years ago)
Author:
Christian Eder
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
35d0d1a7256e75184cea2fe4d2e02762b243b544
Parents:
9bb97ef0a0e640ba336498902b874a16dc7b978e
Message:
rTag update


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

Legend:

Unmodified
Added
Removed

  • kernel/f5data.cc

    r9bb97e rfcb8022  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5data.cc,v 1.3 2009-02-06 20:12:35 ederc Exp $ */
     4/* $Id: f5data.cc,v 1.4 2009-02-08 19:17:54 ederc Exp $ */
    55/*
    66* ABSTRACT: lpolynomial definition
    … …  
    3030================================================================
    3131*/
    32 LPoly::LPoly(poly t,int i,poly p,bool d) {
    33     set(t,i,p,d);
     32LPoly::LPoly(poly t,int i,poly p) {
     33    set(t,i,p);
    3434}
    3535
    … …  
    4646}
    4747
    48 void LPoly::setDel(bool b) {
    49     del = b;
    50 }
    51 
    5248poly LPoly::getPoly() {
    5349    return polynomial;
    … …  
    6258}
    6359
    64 bool LPoly::getDel() const {
    65     return del;
    66 }
    67 
    68 void LPoly::set(poly t, int i, poly p, bool d) {
     60void LPoly::set(poly t, int i, poly p) {
    6961    this->setTerm(t);
    7062    this->setIndex(i);
    7163    this->setPoly(p);
    72     this->setDel(d);
    7364}
    7465
    … …  
    169160    return origin;
    170161}
     162
     163void Rule::setOrigin(LPoly* l) {
     164    origin  =   l;
     165}
    171166#endif

  • kernel/f5data.h

    r9bb97e rfcb8022  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5data.h,v 1.3 2009-02-06 20:12:35 ederc Exp $ */
     4/* $Id: f5data.h,v 1.4 2009-02-08 19:17:54 ederc Exp $ */
    55/*
    66* ABSTRACT: labeled polynomial interface
    … …  
    2828class LPoly {
    2929    private:
    30         poly    term; //term of signature
    31         int     index; //index of signature
    32         poly    polynomial; //standard polynomial data
    33         bool    del; //for deletion in TopReduction Subalgorithm
     30        poly    term;           //term of signature
     31        int     index;          //index of signature
     32        poly    polynomial;     //standard polynomial data
    3433    public:
    35                 LPoly(poly t, int i, poly p, bool d = false);
     34                LPoly(poly t, int i, poly p);
    3635        void    setPoly(poly p);
    3736        poly    getPoly();
    … …  
    4039        void    setIndex(int i);
    4140        int     getIndex();
    42         void    setDel(bool b);
    43         bool    getDel() const;
    44         void    set(poly t, int i, poly p, bool d);
     41        void    set(poly t, int i, poly p);
    4542        LPoly*  get();
    4643};
    … …  
    9390        poly    getTerm();
    9491        LPoly*  getOrigin();
     92        void    setOrigin(LPoly* l);
    9593};
    9694#endif

  • kernel/f5gb.cc

    r9bb97e rfcb8022  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.cc,v 1.23 2009-02-06 20:12:35 ederc Exp $ */
     4/* $Id: f5gb.cc,v 1.24 2009-02-08 19:17:54 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    2525#include "f5lists.h"
    2626
    27 
     27int reductionsToZero   =  0;
     28//*reductionsToZero       =   0;
    2829
    2930/*
    … …  
    6970==================================================
    7071*/
    71 LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE, int* reductionsToZero) {
     72LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE) {
    7273    int j;
    7374    // tag the first element of index i-1 for criterion 1
    … …  
    100101        // NOTE: inside there is a second check of criterion 2 if new rules are
    101102        // added
    102         computeSPols(critPairsMinDeg,rTag,rules,sPolyList,reductionsToZero);
     103        computeSPols(critPairsMinDeg,rTag,rules,sPolyList);
    103104         
    104         reducedLPolys   =   reduction(sPolyList, completed, gbPrev, reductionsToZero);
     105        reducedLPolys   =   reduction(sPolyList, completed, gPrev, lTag, rTag, gbPrev);
    105106    }
    106107    return gPrev;
    … …  
    124125    poly* u2            =   new poly(pInit());
    125126    poly* lcm           =   new poly(pInit());
     127    poly t              =   pHead(first->getPoly());
    126128    // computation of critical pairs
    127129    while( NULL != l) {
    … …  
    130132        pLcm(first->getPoly(), l->getPoly(), *lcm);
    131133        pSetCoeff(*lcm,nOne);
    132         // computing factors u1 & u2 for new labels
    133         *u1 = pDivide(*lcm,pHead(first->getPoly()));
     134        // computing factors u2 for new labels
     135        pWrite(t);
     136        *u1 = pDivide(*lcm,t);
     137        pWrite(*u1);
    134138        pSetCoeff(*u1,nOne);
     139        pWrite(pHead(l->getPoly()));
    135140        *u2 = pDivide(*lcm, pHead(l->getPoly()));
    136141        pSetCoeff(*u2,nOne);
     142        Print("IN CRITPAIRS\n");
    137143        pWrite(*u2);
    138144        // testing both new labels by the F5 Criterion
    … …  
    178184    poly u1 = ppMult_qq(*t,l->getTerm());
    179185    while(NULL != testNode) {
    180         if(pLmDivisibleByNoComp(pHead(testNode->getPoly()),u1)) {
     186        if(pLmDivisibleByNoComp(testNode->getPoly(),u1)) {
    181187            Print("Criterion 1 NOT passed!\n");
    182188            return true;
    … …  
    240246==================================
    241247*/
    242 void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList, int* reductionsToZero) {
     248void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList) {
    243249    CNode* temp =   first;
    244250    poly zero   =   pInit();
    … …  
    266272                            // will never be used again as it is zero => no problems with
    267273                            // further criterion2() tests and termination conditions
    268                             *reductionsToZero++;
     274                            reductionsToZero++;
    269275                            rules->insert(temp->getLp1Index(),temp->getT1(),NULL);
     276                            rTag->setFirst(rules->getFirst());
    270277                        }
    271278                        else {
    272279                            sPolyList->insert(temp->getT1(),temp->getLp1Index(),sp);
    273280                            rules->insert(temp->getLp1Index(),temp->getT1(),sPolyList->getFirst()->getLPoly());
     281                            rTag->setFirst(rules->getFirst());
    274282                        }
    275283                        // data is saved in sPolyList or zero => delete sp
    … …  
    290298                        // will never be used again as it is zero => no problems with
    291299                        // further criterion2() tests and termination conditions
    292                         *reductionsToZero++;
     300                        reductionsToZero++;
    293301                        rules->insert(temp->getLp1Index(),temp->getT1(),NULL);
     302                        rTag->setFirst(rules->getFirst());
     303
    294304                    }
    295305                    else {
    296306                        sPolyList->insert(temp->getT1(),temp->getLp1Index(),sp);
    297307                        rules->insert(temp->getLp1Index(),temp->getT1(),sPolyList->getFirst()->getLPoly());
     308                        rTag->setFirst(rules->getFirst());
    298309                    }
    299310                    // data is saved in sPolyList or zero => delete sp
    … …  
    316327========================================================================
    317328*/
    318 LNode* reduction(LList* sPolyList, LList* completed, ideal gbPrev, int* reductionsToZero) {
    319     poly zero   =   pInit();
     329LNode* reduction(LList* sPolyList, LList* completed, LList* gPrev, LTagList* lTag, RTagList* rTag,
     330                 ideal gbPrev) {
     331    // temporary normal form and zero polynomial for testing
     332    poly tempNF =   pInit();
     333    poly zero   =   pInit(); 
    320334    // compute only if there are any S-polynomials to be reduced
    321335    if(NULL != sPolyList->getFirst()->getLPoly()) {
    322336        LNode* temp =   sPolyList->getFirst();
    323337        while(NULL != temp->getLPoly()) {
    324             temp->setPoly(kNF(gbPrev,currQuotient,temp->getPoly()));
     338            poly test   =   temp->getPoly();
     339            Print("ADDRESS BEFORE:  %p\n",&test);
     340            tempNF = kNF(gbPrev,currQuotient,temp->getPoly()); 
     341            temp->setPoly(tempNF);
     342            Print("ADDRESS AFTER:  %p\n",&test);
    325343            Print("Nach NORMAL FORM: ");
    326344            pWrite(temp->getPoly());
    327             // test if temp->getPoly() is zero polynomial
    328             if(!pCmp(temp->getPoly(),zero)) {
    329                 *reductionsToZero++;
     345            // test if normal form is zero
     346            if(0 == pLmCmp(temp->getPoly(),zero)) {
     347            Print("HIER\n");
     348                reductionsToZero++;
    330349                // TODO: sPolyList -> delete first element of list as it is zero and done
    331             }
    332             //completed   =   topReduction();
    333             // in topReduction() the investigated first element of sPolyList will be deleted after its
    334             // reduction has finished => the next to be investigated element is the newly first element
    335             // in sPolyList => the while loop is finite
    336             // first possible after implementation of topReduction(): temp = sPolyList->getFirst();
    337             temp    =   temp->getNext();
     350               
     351                temp = temp->getNext();
     352                // TODO: problem is that when deleting the first element, the origin of the
     353                // corresponding rule is deleted!
     354                //sPolyList->setFirst(temp);
     355            }
     356            else {
     357            //Print("HIER\n");
     358                topReduction(temp, completed, gPrev, lTag, rTag);
     359                // in topReduction() the investigated first element of sPolyList will be deleted after its
     360                // reduction has finished => the next to be investigated element is the newly first element
     361                // in sPolyList => the while loop is finite
     362                // first possible after implementation of topReduction(): temp = sPolyList->getFirst();
     363                temp    =   temp->getNext();
     364            }
    338365        }
    339366    }
    … …  
    349376=====================================================================================
    350377*/
    351 LNode* topReduction(LNode* l, LList* gPrev, LList* completed) {
    352     LPoly* red  =   findReductor(l, gPrev, completed);
    353     return NULL;
     378void topReduction(LNode* l, LList* completed, LList* gPrev, LTagList* lTag, RTagList* rTag) {
     379    Print("In topREDUCTION!\n");
     380    LRed* red   =   new LRed();
     381    do {
     382        red  =   findReductor(l, completed, gPrev, lTag, rTag,
     383                              red->getGPrevRedCheck(), red->getCompletedRedCheck());
     384        // no reductor found
     385        if(NULL == red) {
     386            pNorm(l->getPoly());
     387            completed->insert(l->getLPoly());
     388           
     389        }
     390        // reductor found
     391        else {
     392            Print("REDUCTOR VORHER:  ");
     393            pWrite(red->getPoly());
     394            red->setPoly(ppMult_nn(red->getPoly(),pGetCoeff(l->getPoly())));
     395            Print("REDUCTOR NACHHER:  ");
     396            pWrite(red->getPoly());
     397        }           
     398    } while(NULL != red);
    354399}
    355400
    … …  
    361406=====================================================================
    362407*/
    363 LPoly* findReductor(LNode* l, LList* gPrev, LList* completed) {
     408LRed* findReductor(LNode* l,LList* completed,LList* gPrev,LTagList* lTag,RTagList* rTag,
     409                    LNode* gPrevRedCheck, LNode* completedRedCheck) {
     410    number nOne     =   nInit(1);
     411    poly u          =   pInit();
     412    poly redPoly    =   pInit();
     413    poly t          =   pHead(l->getPoly());
     414    LNode* temp     =   new LNode();
     415    // setting starting point for search of reductors in gPrev
     416    if(NULL != gPrevRedCheck) {
     417        temp =   gPrevRedCheck;
     418    }
     419    else {
     420        temp =   gPrev->getFirst();
     421    }
     422    // search only for reductors with the same index, as reductions with elements of lower
     423    // index where already done in reduction() beforehand
     424    while(NULL != temp->getLPoly() && temp->getIndex() == l->getIndex()) {
     425        // divides head term t?
     426        if(pLmDivisibleByNoComp(temp->getPoly(),t)) {
     427            u       =   pDivide(t,pHead(temp->getPoly()));
     428            pSetCoeff(u,nOne);
     429            // multiply reductor with factor and normalize it, i.e. LC = 1
     430            redPoly =   ppMult_qq(u,temp->getPoly());
     431            pNorm(redPoly);
     432            u       =   ppMult_qq(u,temp->getTerm());
     433            Print("IN FIND REDUCTOR:  ");
     434            pWrite(u);
     435            pWrite(redPoly);
     436            // same label? NOTE: also used to
     437            if(pLmCmp(u,l->getTerm()) != 0) {
     438                // passing criterion 2?
     439                Print("HIER DRIN\n");
     440                if(!criterion2(&u,temp,rTag)) {
     441                    // passing criterion 1?
     442                    if(!criterion1(&u,temp,lTag)) {
     443                        // set tag findRedCheck such that you can start at this point when the
     444                        // next time a reductor is searched for in findReductor()
     445                        LRed* red      =   new LRed(u,temp->getIndex(),redPoly,temp->getNext(),completedRedCheck);
     446                        return red;
     447                    }
     448                }
     449            }
     450        }
     451        temp    =   temp->getNext();
     452    }
     453
     454    // do the same as above now for the elements in completed
     455    if(NULL != completedRedCheck) {
     456        temp    =   completedRedCheck;
     457    }
     458    else {
     459        temp    =   completed->getFirst();
     460    }
     461    // search only for reductors with the same index, as reductions with elements of lower
     462    // index where already done in reduction() beforehand
     463    while(NULL != temp->getLPoly()) {
     464        // divides head term t?
     465        if(pLmDivisibleByNoComp(temp->getPoly(),t)) {
     466            u       =   pDivide(t,pHead(temp->getPoly()));
     467            redPoly =   ppMult_qq(u,temp->getPoly());
     468            u       =   ppMult_qq(u,temp->getTerm());
     469            Print("IN FIND REDUCTOR1:  ");
     470            pWrite(u);
     471            pWrite(redPoly);
     472            // same label? NOTE: also used to
     473            if(pLmCmp(u,l->getTerm()) != 0) {
     474                // passing criterion 2?
     475                if(!criterion2(&u,temp,rTag)) {
     476                    // passing criterion 1?
     477                    if(!criterion1(&u,temp,lTag)) {
     478                        // set tag findRedCheck such that you can start at this point when the
     479                        // next time a reductor is searched for in findReductor()
     480                        LRed* red      =   new LRed(u,temp->getIndex(),redPoly,gPrevRedCheck,temp->getNext());
     481                        return red;
     482                    }
     483                }
     484            }
     485        }
     486        temp    =   temp->getNext();
     487    }
     488
     489    // no reductor found
    364490    return NULL;
    365491}
    … …  
    374500ideal F5main(ideal id, ring r) {
    375501    int i,j;
    376     int* reductionsToZero   =   new int;
    377     *reductionsToZero       =   0;
     502    //static int* reductionsToZero   =   new int;
     503    //*reductionsToZero       =   0;
    378504    // 1 polynomial for defining initial labels & further tests
    379505    poly ONE = pOne();
    … …  
    407533    idShow(id);
    408534    LList* gPrev    =   new LList(ONE, i, id->m[0]);
     535    int gbLength    =   gPrev->getLength();
    409536    pWrite(id->m[0]);
    410537    poly p = pHead(id->m[0]);
    … …  
    415542    // computing the groebner basis of the elements of index < actual index
    416543    Print("Laenge der bisherigen Groebner Basis: %d\n",gPrev->getLength());
    417     ideal gbPrev    =   idInit(gPrev->getLength(),1);
     544    ideal gbPrev    =   idInit(gbLength,1);
    418545    // initializing the groebner basis of elements of index < actual index
    419546    gbPrev->m[0]    =   gPrev->getFirst()->getPoly();
    … …  
    422549
    423550    for(i=2; i<=IDELEMS(id); i++) {
    424         gPrev   =   F5inc(i, id->m[i-1], gPrev, gbPrev, ONE, reductionsToZero);
     551        gPrev   =   F5inc(i, id->m[i-1], gPrev, gbPrev, ONE);
     552        // comuting new groebner basis gbPrev
     553        ideal gbAdd =   idInit(gPrev->getLength()-gbLength,1);
     554        LNode*  temp    =   gPrev->getFirst();
     555        for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
     556            gbAdd->m[j] =   temp->getPoly();
     557            temp        =   temp->getNext();
     558        }
     559        gbPrev  =   idAdd(gbPrev,gbAdd);
     560        Print("GROEBNER BASIS:\n====================================================\n");
     561        idShow(gbPrev);
     562        Print("===================================================\n");
     563
    425564        Print("JA\n");
    426         //TODO: idAdd for computing gbPrev with the actual index!
    427565    }
    428     // only for debugging
    429     //LNode* current;
    430     //LList* g_curr = new LList(lp);
    431     //}
    432     //for(i=2; i<IDELEMS(id); i++) {
    433         //g_curr = F5inc(&i,&id->m[i],g_prev);
    434         //if(g_curr->polyTest(&ONE)) {
    435         //    Print("One Polynomial in Input => Computations stopped\n");
    436          //   ideal id_new = idInit(1,1);
    437         //    id_new->m[0] = ONE;
    438         //    return(id_new);               
    439         //}
    440     //}
    441     Print("\n\nNumber of zero-reductions:  %d\n",*reductionsToZero);
    442     return(id);
     566    Print("\n\nNumber of zero-reductions:  %d\n",reductionsToZero);
     567    return(gbPrev);
    443568
    444569

  • kernel/f5gb.h

    r9bb97e rfcb8022  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.h,v 1.22 2009-02-06 20:12:35 ederc Exp $ */
     4/* $Id: f5gb.h,v 1.23 2009-02-08 19:17:54 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    3535==================================================
    3636*/
    37 LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE, int* reductionToZero);
     37LList* F5inc(int i, poly f_i, LList* gPrev, ideal gbPrev, poly ONE);
    3838
    3939/*
    … …  
    7272==================================
    7373*/
    74 void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList, int* reductionsToZero);
     74void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList);
    7575
    7676/*
    … …  
    7979========================================================================
    8080*/
    81 LNode* reduction(LList* sPolyList, LList* completed, ideal gbPrev, int* reductionsToZero);
     81LNode* reduction(LList* sPolyList, LList* completed, LList* gPrev, LTagList* lTag, RTagList* rTag,
     82                 ideal gbPrev);
    8283
    8384/*
    … …  
    8788=====================================================================================
    8889*/
    89 LNode* topReduction(LNode* l, LList* gPrev, LList* completed);
     90void topReduction(LNode* l, LList* completed, LList* gPrev, LTagList* lTag, RTagList* rTag);
    9091
    9192/*
    … …  
    9495=====================================================================
    9596*/
    96 LPoly* findReductor(LNode* l, LList* gPrev, LList* completed);
     97LRed* findReductor(LNode* l,LList* completed,LList* gPrev,LTagList* lTag,RTagList* rTag,
     98                    LNode* gPrevRedCheck, LNode* completedRedCheck);
    9799
    98100/*

  • kernel/f5lists.cc

    r9bb97e rfcb8022  
    126126}
    127127
    128 bool LNode::getDel() {
    129     return data->getDel();
    130 }
    131 
    132128// set the data from the LPoly saved in LNode
    133129void LNode::setPoly(poly p) {
    … …  
    141137void LNode::setIndex(int i) {
    142138    data->setIndex(i);
    143 }
    144 
    145 void LNode::setDel(bool d) {
    146     data->setDel(d);
    147139}
    148140
    … …  
    224216}
    225217
     218void LList::setFirst(LNode* l) {
     219    LNode* temp =   first;
     220    first       =   l;
     221    delete(temp);
     222}
     223
     224/*
     225===================================
     226functions working on the class LRed
     227===================================
     228*/
     229LRed::LRed() {
     230    data                =   NULL;
     231    gPrevRedCheck       =   NULL;
     232    completedRedCheck   =   NULL;
     233}
     234
     235LRed::LRed(poly t,int i,poly p,LNode* g, LNode* c) {
     236    LPoly* lp           =   new LPoly(t,i,p);
     237    data                =   lp;
     238    gPrevRedCheck       =   g;
     239    completedRedCheck   =   c;
     240}
     241
     242LPoly* LRed::getLPoly() {
     243    return data;
     244}
     245
     246LNode* LRed::getGPrevRedCheck() {
     247    return gPrevRedCheck;
     248}
     249
     250LNode* LRed::getCompletedRedCheck() {
     251    return completedRedCheck;
     252}
     253
     254// get the data from the LPoly saved in LNode
     255poly LRed::getPoly() {
     256    return data->getPoly();
     257}
     258
     259poly LRed::getTerm() {
     260    return data->getTerm();
     261}
     262
     263int LRed::getIndex() {
     264    return data->getIndex();
     265}
     266
     267// set the data from the LPoly saved in LNode
     268void LRed::setPoly(poly p) {
     269    data->setPoly(p);
     270}
     271
     272void LRed::setTerm(poly t) {
     273    data->setTerm(t);
     274}
     275
     276void LRed::setIndex(int i) {
     277    data->setIndex(i);
     278}
     279
     280
    226281/*
    227282=======================================
    … …  
    336391        }
    337392        if( c->getDeg() == this->data->getDeg() ) { // same degree than the first list element
    338             if(0 == pLmCmp(u1,ppMult_qq(this->data->getT1(), this->data->getLp1Term())) ||
    339                -1 == pLmCmp(u1,ppMult_qq(this->data->getT1(), this->data->getLp1Term()))) {
     393            if(1 != pLmCmp(u1,ppMult_qq(this->data->getT1(), this->data->getLp1Term()))) {
    340394                pWrite(u1);
    341395                Print("Multi-Term in CritPairs Sortierung altes Element: ");
    … …  
    378432                }
    379433                if( c->getDeg() == temp->next->data->getDeg() ) {
    380                     if(0 == pLmCmp(u1,ppMult_qq(temp->next->data->getT1(),temp->next->data->getLp1Term())) ||
    381                        -1 == pLmCmp(u1,ppMult_qq(temp->next->data->getT1(),temp->next->data->getLp1Term()))) {
     434                    if(1 != pLmCmp(u1,ppMult_qq(temp->next->data->getT1(),temp->next->data->getLp1Term()))) {
    382435                        CNode* newElement   =   new CNode(c, temp->next);
    383436                        temp->next          =   newElement;
    … …  
    605658}
    606659
     660LPoly* RNode::getRuleOrigin() {
     661    return data->getOrigin();
     662}
     663
    607664/*
    608665====================================
    … …  
    660717}
    661718       
    662 // declaration with first as parameter due to sorting of LTagList
     719// declaration with first as parameter due to sorting of RTagList
    663720RTagNode* RTagNode::insert(RNode* r) {
    664721    Print("Hier1\n");
    … …  
    689746}
    690747
     748void RTagNode::set(RNode* r) {
     749    this->data  =   r;
     750}
    691751
    692752/*
    … …  
    719779    return first->get(idx, length);
    720780}
     781
     782void RTagList::setFirst(RNode* r) {
     783    first->set(r);
     784}
    721785#endif

  • kernel/f5lists.h

    r9bb97e rfcb8022  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5lists.h,v 1.6 2009-02-06 20:12:35 ederc Exp $ */
     4/* $Id: f5lists.h,v 1.7 2009-02-08 19:17:54 ederc Exp $ */
    55/*
    66* ABSTRACT: list interface
    … …  
    2020class LNode;
    2121class LList;
     22class LRed;
    2223class LTagNode;
    2324class LTagList;
    … …  
    6566        poly    getTerm();
    6667        int     getIndex();
    67         bool    getDel();
    6868        // set the data from the LPoly saved in LNode
    6969        void    setPoly(poly p);
    7070        void    setTerm(poly t);
    7171        void    setIndex(int i);
    72         void    setDel(bool d);
    7372        // test if for any list element the polynomial part of the data is equal to *p
    7473        bool    polyTest(poly* p);
    … …  
    10099        LNode*  getNext(LNode* l);
    101100        int     getLength();
     101        void    setFirst(LNode* l);
     102};
     103
     104
     105/*
     106=========================================
     107class LRed (nodes for lists of Reductors)
     108=========================================
     109*/
     110class LRed {
     111    private:
     112        LPoly* data;
     113        LNode* gPrevRedCheck;
     114        LNode* completedRedCheck;
     115    public:
     116        // generating new list elements from the labeled / classical polynomial view
     117                LRed();
     118                LRed(poly t, int i, poly p, LNode* g, LNode* c);
     119                ~LRed();
     120        // get the LPoly* out of LNode*
     121        LPoly*  getLPoly();
     122        // get the last reductor tested in subalgorithm findReductor() in f5gb.cc
     123        LNode*  getGPrevRedCheck();
     124        LNode*  getCompletedRedCheck();
     125        // get data from the labeled polynomial
     126        poly    getPoly();
     127        poly    getTerm();
     128        int     getIndex();
     129        // set the data from the LPoly saved in LNode
     130        void    setPoly(poly p);
     131        void    setTerm(poly t);
     132        void    setIndex(int i);
    102133};
    103134
    … …  
    217248        int     getRuleIndex();
    218249        poly    getRuleTerm();
     250        LPoly*  getRuleOrigin();
    219251};
    220252
    … …  
    259291        RNode*      getRNode();
    260292        RNode*      get(int idx, int length);
     293        void        set(RNode*);
    261294};
    262295
    … …  
    280313        RNode*  getFirst();
    281314        RNode*  get(int idx);
     315        void    setFirst(RNode* r);
    282316};
    283317#endif
Note: See TracChangeset for help on using the changeset viewer.