Changeset 338842d in git


Ignore:
Timestamp:
Mar 1, 2009, 9:31:55 PM (14 years ago)
Author:
Christian Eder
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
18765e261637faef8a8abfb3019c46a6d8e668a5
Parents:
5887d78d81d30fb2177cf296ce90d01565c6ae3b
Message:
gPrevRedCheck is no longer part of LPoly, less data to take care of


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

Legend:

Unmodified
Added
Removed

  • kernel/f5gb.cc

    r5887d7 r338842d  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.cc,v 1.36 2009-02-28 21:14:06 ederc Exp $ */
     4/* $Id: f5gb.cc,v 1.37 2009-03-01 20:31:54 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    150150    //Print("3rd gPrev: ");
    151151    //pWrite(gPrev->getFirst()->getNext()->getNext()->getPoly());
    152  
    153  
     152    //delete sPolyList;
     153    //delete critPairs;
     154    //gPrev->print();
    154155    return gPrev;
    155156}
    … …  
    632633    // try l as long as there are reductors found by findReductor()
    633634    do {
    634         LNode* tempRed  =   new LNode();
     635        LNode* gPrevRedCheck    =   new LNode(lTag->getFirstCurrentIdx());
     636        LNode* tempRed          =   new LNode();
    635637        //Print("TESTED POLYNOMIAL IN THE FOLLOWING: ");
    636638        //pWrite(l->getPoly());
    637639        //Print("HIER\n");
    638         tempRed  =   findReductor(l,gPrev,rules,lTag,rTag);
     640        tempRed  =   findReductor(l,gPrevRedCheck,gPrev,rules,lTag,rTag);
    639641        //Print("--------------------------------HIER DEBUG 2----------------------------------\n");
    640642        // if a reductor for l is found and saved in tempRed
    … …  
    713715                   
    714716                    //pWrite(l->getPoly());
    715                     l->setGPrevRedCheck(NULL);
     717                    gPrevRedCheck   =   lTag->getFirstCurrentIdx();
    716718                }
    717719                else {
    … …  
    753755=====================================================================
    754756*/
    755 LNode* findReductor(LNode* l, LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag) {
     757LNode* findReductor(LNode* l, LNode* gPrevRedCheck, LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag) {
    756758    // allociation of memory for the possible reductor
    757759    //Print("IN FIND REDUCTOR\n");
    … …  
    765767    // that we can start searching for new reducers from this point and
    766768    // not from the first element of gPrev with the current index
    767     if(NULL != l->getGPrevRedCheck()) {
    768         temp    =   l->getGPrevRedCheck()->getNext();
    769     }
    770     // no reductors were searched for l before, thus start at the first
    771     // element of gPrev with the current index, tagged by lTag
    772     else {
    773         temp    =   lTag->getFirstCurrentIdx();
    774     }
     769    temp    =   gPrevRedCheck;
    775770    // search for reductors until we are at the end of gPrev resp. at the
    776771    // end of the elements of the current index
    777772    while(NULL != temp && temp->getIndex() == l->getIndex()) {
     773        //pWrite(temp->getPoly());
     774        //Print("INDEX: %d\n",temp->getIndex());
    778775        // does the head of the element of gPrev divides the head of
    779776        // the to be reduced element?
    … …  
    807804                    if(!criterion1(gPrev,u,temp,lTag)) {
    808805                            //Print("HIER DEBUG\n");
    809                             l->setGPrevRedCheck(temp);
     806                            gPrevRedCheck   =   temp;
    810807                            LNode* redNode  =   new LNode(ppMult_qq(u,temp->getTerm()),temp->getIndex(),red,NULL,NULL);
    811808                            return redNode;
    … …  
    860857    }
    861858    ideal idNew     =   kInterRed(id);
    862     idDelete(&id);
    863859    id              =   idNew;
     860    idShow(id);
    864861    qsortDegree(&id->m[0],&id->m[IDELEMS(id)-1]);
    865862    LList* gPrev    =   new LList(ONE, i, id->m[0]);
    … …  
    927924    //    temp    =   temp->getNext();
    928925    // }
    929     delete(gPrev);
     926    idShow(id);
     927    //gPrev->print();
     928    //delete gPrev;
     929    //delete lTag;
     930    //delete rTag;
    930931    return(gbPrev);
    931932

  • kernel/f5gb.h

    r5887d7 r338842d  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.h,v 1.30 2009-02-28 21:14:06 ederc Exp $ */
     4/* $Id: f5gb.h,v 1.31 2009-03-01 20:31:54 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    107107=====================================================================
    108108*/
    109 LNode* findReductor(LNode* l, LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag);
     109LNode* findReductor(LNode* l, LNode* gPrevRedCheck, LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag);
    110110
    111111/*

  • kernel/f5lists.cc

    r5887d7 r338842d  
    2929    data                =   NULL;
    3030    next                =   NULL;
    31     gPrevRedCheck       =   NULL;
    3231}
    3332 LNode::LNode(LPoly* lp) {
    3433    data                =   lp;
    3534    next                =   NULL;
    36     gPrevRedCheck       =   NULL;
    3735}
    3836       
    … …  
    4139    data                =   lp;
    4240    next                =   l;
    43     gPrevRedCheck       =   NULL;
    44 }
    45 
    46 LNode::LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck) {
     41}
     42
     43LNode::LNode(poly t, int i, poly p, Rule* r) {
    4744LPoly* lp           =   new LPoly(t,i,p,r);
    4845data                =   lp;
    4946next                =   NULL;
    50 gPrevRedCheck       =   gPCheck;
    5147}
    5248       
    53 LNode::LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck, LNode* l) {
     49LNode::LNode(poly t, int i, poly p, Rule* r, LNode* l) {
    5450    LPoly* lp           =   new LPoly(t,i,p,r);
    5551    data                =   lp;
    5652    next                =   l;
    57     gPrevRedCheck       =   gPCheck;
    5853}
    5954
    … …  
    6156    data                =   ln->getLPoly();
    6257    next                =   ln->getNext();
    63     gPrevRedCheck       =   NULL;
    6458}
    6559       
    6660LNode::~LNode() {
    6761    //delete next;
    68     delete gPrevRedCheck;
    6962    delete data;   
    7063}
    71        
     64
     65void LNode::deleteAll() {
     66    while(NULL != next) {
     67        Print("%p\n",next);
     68        pWrite(next->data->getPoly());
     69        next->deleteAll();
     70    }
     71    delete data;
     72}
     73
    7274// insert new elements to the list always at the end (labeled / classical polynomial view)
    7375// needed for list gPrev
    … …  
    8284       
    8385LNode* LNode::insert(poly t, int i, poly p, Rule* r) {
    84     LNode* newElement   =   new LNode(t, i, p, r, NULL, NULL);
     86    LNode* newElement   =   new LNode(t, i, p, r, NULL);
    8587    this->next          =   newElement;
    8688    return newElement;
    … …  
    9799       
    98100LNode* LNode::insertSP(poly t, int i, poly p, Rule* r) {
    99     LNode* newElement   =   new LNode(t, i, p, r, NULL, this);
     101    LNode* newElement   =   new LNode(t, i, p, r, this);
    100102     //Print("INSERTED IN SPOLYLIST: ");
    101103  //pWrite(t);
    … …  
    109111    //pWrite(t);
    110112       if(NULL == this || NULL == data) {
    111         LNode* newElement   =   new LNode(t, i, p, r, NULL, this);
     113        LNode* newElement   =   new LNode(t, i, p, r, this);
    112114        return newElement;
    113115    }
    … …  
    117119        if(-1 == pLmCmp(t,this->getTerm())) {
    118120            //Print("HIERDRIN\n");
    119             LNode* newElement   =   new LNode(t, i, p, r, NULL, this);
     121            LNode* newElement   =   new LNode(t, i, p, r, this);
    120122            //Print("%p\n",this);
    121123            //Print("%p\n",newElement->next);
    … …  
    128130                //pWrite(temp->getTerm());
    129131 if(-1 == pLmCmp(t,temp->next->getTerm())) {
    130                     LNode* newElement   =   new LNode(t, i, p, r, NULL, temp->next);
     132                    LNode* newElement   =   new LNode(t, i, p, r, temp->next);
    131133                    temp->next          =   newElement;
    132134                    return this;
    … …  
    141143            }
    142144        //Print("HIER\n");
    143             LNode* newElement   =   new LNode(t, i, p, r, NULL, temp->next);
     145            LNode* newElement   =   new LNode(t, i, p, r, temp->next);
    144146            temp->next          =   newElement;
    145147            return this;
    … …  
    181183}
    182184
    183 LNode* LNode::getGPrevRedCheck() {
    184     return gPrevRedCheck;
    185 }
    186 
    187185// set the data from the LPoly saved in LNode
    188186void LNode::setPoly(poly p) {
    … …  
    196194void LNode::setIndex(int i) {
    197195    data->setIndex(i);
    198 }
    199 
    200 void LNode::setGPrevRedCheck(LNode* l) {
    201     gPrevRedCheck   =   l;
    202196}
    203197
    … …  
    265259
    266260LList::~LList() {
    267     delete first;
     261    LNode* temp;
     262    while(first) {
     263        temp    =   first;
     264        first   =   first->getNext();
     265        delete  temp;
     266    }
    268267}
    269268
    … …  
    787786}
    788787
     788RList::~RList() {
     789    delete first;
     790}
     791
    789792void RList::insert(int i, poly t) {
    790793    first = first->insert(i,t);
    … …  
    824827}
    825828
    826  RTagNode::~RTagNode() {
     829RTagNode::~RTagNode() {
    827830    delete next;
    828831    delete data;   
    … …  
    896899}
    897900
     901RTagList::~RTagList() {
     902    delete first;
     903}
     904
    898905// declaration with first as parameter in LTagNode due to sorting of LTagList
    899906void RTagList::insert(RNode* r) {

  • kernel/f5lists.h

    r5887d7 r338842d  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5lists.h,v 1.12 2009-02-26 09:01:52 ederc Exp $ */
     4/* $Id: f5lists.h,v 1.13 2009-03-01 20:31:55 ederc Exp $ */
    55/*
    66* ABSTRACT: list interface
    … …  
    3939        LPoly*  data;
    4040        LNode*  next;
    41         LNode*  gPrevRedCheck;
    4241    public:
    4342        // generating new list elements from the labeled / classical polynomial view
    … …  
    4544                LNode(LPoly* lp);
    4645                LNode(LPoly* lp, LNode* l);
    47                 LNode(poly t, int i, poly p, Rule* r=NULL, LNode* gPCheck=NULL);
    48                 LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck, 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);
    4948                LNode(LNode* ln);
    5049                ~LNode();
     50        void    deleteAll();
    5151        // insert new elements to the list at the end from the labeled / classical polynomial view
    5252        // needed for gPrev
    … …  
    7373        int     getIndex();
    7474        Rule*   getRule();
    75         LNode*  getGPrevRedCheck();
    7675        // set the data from the LPoly saved in LNode
    7776        void    setPoly(poly p);
    7877        void    setTerm(poly t);
    7978        void    setIndex(int i);
    80         void    setGPrevRedCheck(LNode* l);
    8179        void    setNext(LNode* l);
    8280        // test if for any list element the polynomial part of the data is equal to *p
Note: See TracChangeset for help on using the changeset viewer.