Changeset 87beab7 in git for kernel/f5lists.cc


Ignore:
Timestamp:
Feb 11, 2009, 10:24:08 PM (15 years ago)
Author:
Christian Eder
Branches:
(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')
Children:
34fcf813ea36a30ddd0d8107abf9a73b247be289
Parents:
c5d8ddb1112344ad68257ea0c296d5b17aee0433
Message:
lots of stuff debugged, lots of wrong loop terminations improved, still problems with reduction subalgorithms reduction(), topReduction() & findReductor()


git-svn-id: file:///usr/local/Singular/svn/trunk@11370 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/f5lists.cc

    rc5d8dd r87beab7  
    2727// generating new list elements (labeled / classical polynomial / LNode view)
    2828LNode::LNode() {
    29     data = NULL;
    30     next = NULL;
     29    data                =   NULL;
     30    next                =   NULL;
     31    gPrevRedCheck       =   NULL;
     32    completedRedCheck   =   NULL;
    3133}
    3234 LNode::LNode(LPoly* lp) {
    33     data = lp;
    34     next = NULL;
     35    data                =   lp;
     36    next                =   NULL;
     37    gPrevRedCheck       =   NULL;
     38    completedRedCheck   =   NULL;
    3539}
    3640       
    3741LNode::LNode(LPoly* lp, LNode* l) {
    38     data = lp;
    39     next = l;
    40 }
    41 LNode::LNode(poly t, int i, poly p) {
    42     LPoly* lp = new LPoly(t,i,p);
    43     data = lp;
    44     next = NULL;
     42Print("HIER LNODE\n");
     43    data                =   lp;
     44    next                =   l;
     45    gPrevRedCheck       =   NULL;
     46    completedRedCheck   =   NULL;
     47}
     48
     49LNode::LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck, LNode* CompCheck) {
     50LPoly* lp = new LPoly(t,i,p,r);
     51data                =   lp;
     52next                =   NULL;
     53gPrevRedCheck       =   gPCheck;
     54completedRedCheck   =   CompCheck;
    4555}
    4656       
    47 LNode::LNode(poly t, int i, poly p, LNode* l) {
    48     LPoly* lp = new LPoly(t,i,p);
    49     data = lp;
    50     next = l;
     57LNode::LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck, LNode* CompCheck, LNode* l) {
     58    LPoly* lp           =   new LPoly(t,i,p,r);
     59    data                =   lp;
     60    next                =   l;
     61    gPrevRedCheck       =   gPCheck;
     62    completedRedCheck   =   CompCheck;
    5163}
    5264
    5365 LNode::LNode(LNode* ln) {
    54     data = ln->getLPoly();
    55     next = ln->getNext();
     66    data                =   ln->getLPoly();
     67    next                =   ln->getNext();
     68    gPrevRedCheck       =   NULL;
     69    completedRedCheck   =   NULL;
    5670}
    5771       
    5872LNode::~LNode() {
    5973    delete next;
     74    delete gPrevRedCheck;
     75    delete completedRedCheck;
    6076    delete data;   
    6177}
    … …  
    6379// insert new elements to the list always in front (labeled / classical polynomial view)
    6480LNode* LNode::insert(LPoly* lp) {
     81    Print("HIER\n");
    6582    LNode* newElement = new LNode(lp, this);
    6683    return newElement;
    6784}
    6885       
    69 LNode* LNode::insert(poly t, int i, poly p) {
    70     LNode* newElement = new LNode(t, i, p, this);
     86LNode* LNode::insert(poly t, int i, poly p, Rule* r) {
     87    LNode* newElement = new LNode(t, i, p, r, NULL, NULL, this);
    7188    return newElement;
    7289}
    … …  
    7491// insert new elemets to the list w.r.t. increasing labels
    7592// only used for the S-polys to be reduced (TopReduction building new S-polys with higher label)
    76 LNode* LNode::insertByLabel(poly t, int i, poly p) {
     93LNode* LNode::insertByLabel(poly t, int i, poly p, Rule* r) {
    7794    if(0 == pLmCmp(t,this->getTerm()) || -1 == pLmCmp(t,this->getTerm())) {
    78         LNode* newElement   =   new LNode(t, i, p, this);
     95        LNode* newElement   =   new LNode(t, i, p, r, this);
    7996        return newElement;
    8097    }
    … …  
    83100        while( NULL != temp->next->data ) {
    84101            if( 0 == pLmCmp(t,temp->next->getTerm()) || -1 == pLmCmp(t,temp->next->getTerm())) {
    85                 LNode* newElement   =   new LNode(t, i, p, temp->next);
     102                LNode* newElement   =   new LNode(t, i, p, r, temp->next);
    86103                temp->next          =   newElement;
    87104                return this;
    … …  
    91108            }
    92109        }
    93         LNode* newElement   =   new LNode(t, i, p, NULL);
     110        LNode* newElement   =   new LNode(t, i, p, r, NULL);
    94111        temp->next          =   newElement;
    95112        return this;
    … …  
    126143}
    127144
     145Rule* LNode::getRule() {
     146    return data->getRule();
     147}
     148
     149LNode* LNode::getGPrevRedCheck() {
     150    return gPrevRedCheck;
     151}
     152
     153LNode* LNode::getCompletedRedCheck() {
     154    return completedRedCheck;
     155}
     156
    128157// set the data from the LPoly saved in LNode
    129158void LNode::setPoly(poly p) {
    … …  
    137166void LNode::setIndex(int i) {
    138167    data->setIndex(i);
     168}
     169
     170void LNode::setGPrevRedCheck(LNode* l) {
     171    gPrevRedCheck   =   l;
     172}
     173
     174void LNode::setCompletedRedCheck(LNode* l) {
     175    completedRedCheck   =   l;
    139176}
    140177
    … …  
    171208}
    172209
    173 LList::LList(poly t,int i,poly p) {
    174     first   =   new LNode(t,i,p);
     210LList::LList(poly t,int i,poly p,Rule* r) {
     211    first   =   new LNode(t,i,p,r);
    175212    length  =   1;
    176213}
    … …  
    186223}
    187224
    188 void LList::insert(poly t,int i, poly p) {
    189     first = first->insert(t,i,p);
     225void LList::insert(poly t,int i, poly p, Rule* r) {
     226    first = first->insert(t,i,p,r);
    190227    length++;
    191228}
    192229
    193 void LList::insertByLabel(poly t, int i, poly p) {
    194     first = first->insertByLabel(t,i,p);
     230void LList::insertByLabel(poly t, int i, poly p, Rule* r) {
     231    first = first->insertByLabel(t,i,p,r);
     232    length++;
     233}
     234
     235void LList::insertByLabel(LNode* l) {
     236    first = first->insertByLabel(l->getTerm(),l->getIndex(),l->getPoly(),l->getRule());
    195237    length++;
    196238}
    … …  
    222264}
    223265
    224 /*
    225 ===================================
    226 functions working on the class LRed
    227 ===================================
    228 */
    229 LRed::LRed() {
    230     data                =   NULL;
    231     gPrevRedCheck       =   NULL;
    232     completedRedCheck   =   NULL;
    233 }
    234 
    235 LRed::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 
    242 LPoly* LRed::getLPoly() {
    243     return data;
    244 }
    245 
    246 LNode* LRed::getGPrevRedCheck() {
    247     return gPrevRedCheck;
    248 }
    249 
    250 LNode* LRed::getCompletedRedCheck() {
    251     return completedRedCheck;
    252 }
    253 
    254 // get the data from the LPoly saved in LNode
    255 poly LRed::getPoly() {
    256     return data->getPoly();
    257 }
    258 
    259 poly LRed::getTerm() {
    260     return data->getTerm();
    261 }
    262 
    263 int LRed::getIndex() {
    264     return data->getIndex();
    265 }
    266 
    267 // set the data from the LPoly saved in LNode
    268 void LRed::setPoly(poly p) {
    269     data->setPoly(p);
    270 }
    271 
    272 void LRed::setTerm(poly t) {
    273     data->setTerm(t);
    274 }
    275 
    276 void LRed::setIndex(int i) {
    277     data->setIndex(i);
    278 }
    279266
    280267
    … …  
    284271=======================================
    285272*/
     273LTagNode::LTagNode() {
     274    data    =   NULL;
     275    next    =   NULL;
     276}
    286277
    287278LTagNode::LTagNode(LNode* l) {
    … …  
    333324=======================================
    334325*/
     326LTagList::LTagList() {
     327    LTagNode* first =   new LTagNode();
     328    length          =   0;
     329}
    335330
    336331LTagList::LTagList(LNode* l) {
    … …  
    347342LNode* LTagList::get(int idx) {
    348343    return first->get(idx, length);
     344}
     345
     346LNode* LTagList::getFirst() {
     347    return first->getLNode();
     348}
     349
     350
     351/*
     352=====================================
     353functions working on the class TopRed
     354=====================================
     355*/
     356
     357TopRed::TopRed() {
     358    _completed  =   NULL;
     359    _toDo       =   NULL;
     360}
     361
     362TopRed::TopRed(LList* c, LList* t) {
     363    _completed  =   c;
     364    _toDo       =   t;
     365}
     366
     367LList* TopRed::getCompleted() {
     368    return _completed;
     369}
     370
     371LList* TopRed::getToDo() {
     372    return _toDo;
    349373}
    350374
    … …  
    635659}
    636660
    637 RNode* RNode::insert(int i, poly t, LPoly* l) {
    638     Rule*   r           =   new Rule(i,t,l);
     661RNode* RNode::insert(int i, poly t) {
     662    Rule*   r           =   new Rule(i,t);
    639663    RNode* newElement   =   new RNode(r);
    640664    newElement->next    =   this;
    … …  
    658682}
    659683
    660 LPoly* RNode::getRuleOrigin() {
    661     return data->getOrigin();
    662 }
    663 
    664684/*
    665685====================================
    … …  
    675695}
    676696
    677 void RList::insert(int i, poly t, LPoly* l) {
    678     first = first->insert(i,t,l);
     697void RList::insert(int i, poly t) {
     698    first = first->insert(i,t);
    679699}
    680700
    … …  
    734754RNode* RTagNode::get(int idx, int length) {
    735755    if(idx==1 || idx==0) {
     756        // NOTE: We set this NULL as putting it the last element in the list, i.e. the element having
     757        //       RNode* = NULL would cost lots of iterations at each step of F5inc, with increasing
     758        //       length of the list this should be prevented
    736759        return NULL;
    737760    }
    … …  
    739762        int j;
    740763        RTagNode* temp = this;
    741         for(j=1; j<=length-idx+1; j++) {
     764    Print("\n\nHIER IN GET IDX\n");
     765    Print("FOR LOOP: %d\n",length-idx+1);   
     766    for(j=1; j<=length-idx+1; j++) {
    742767            temp = temp->next;
    743768        }
    … …  
    750775}
    751776
     777void RTagNode::print() {
     778    RTagNode* temp  =   this;
     779    Print("1. element: %d",getRNode()->getRule()->getIndex());
     780    pWrite(getRNode()->getRule()->getTerm());
     781    temp    =   temp->next;
     782    int i   =   2;
     783    while(NULL != temp->getRNode()) {
     784        Print("%d. element: %d",i,getRNode()->getRule()->getIndex());
     785        pWrite(getRNode()->getRule()->getTerm());
     786        temp    =   temp->next;
     787        i++;
     788    }
     789}
    752790/*
    753791=======================================
    … …  
    769807void RTagList::insert(RNode* r) {
    770808    first = first->insert(r);
    771     length++;
     809    Print("LENGTH:%d\n",length);
     810    length = length +1;
     811    Print("LENGTH:%d\n",length);
    772812}
    773813
    … …  
    783823    first->set(r);
    784824}
     825
     826void RTagList::print() {
     827    first->print();
     828}
     829
     830int RTagList::getLength() {
     831    return length;
     832}
    785833#endif
Note: See TracChangeset for help on using the changeset viewer.