Changeset 61d32c in git


Ignore:
Timestamp:
Feb 15, 2009, 9:33:56 PM (15 years ago)
Author:
Christian Eder
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '4188d308699580d975efd0f6cca8dcb41c396f70')
Children:
416ea2bc9e1b72d15cc10ae59eb6997e0a9e9355
Parents:
73e5a2e509b87abd4ed980fe5f5f004ee1cd75e2
Message:
still searching errors in reduction()


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

Legend:

Unmodified
Added
Removed
  • kernel/f5data.cc

    r73e5a2 r61d32c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5data.cc,v 1.5 2009-02-11 21:24:07 ederc Exp $ */
     4/* $Id: f5data.cc,v 1.6 2009-02-15 20:33:56 ederc Exp $ */
    55/*
    66* ABSTRACT: lpolynomial definition
     
    3535
    3636void LPoly::setPoly(poly p)  {
     37    //poly _p     =   pInit();
     38    //_p          =   pCopy(p);
    3739    polynomial = p;
    3840}
    3941
    4042void LPoly::setTerm(poly t) {
     43    //poly _t     =   pInit();
     44    //_t          =   pCopy(t);
    4145    term = t;
    4246}
  • kernel/f5gb.cc

    r73e5a2 r61d32c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.cc,v 1.27 2009-02-12 12:43:31 ederc Exp $ */
     4/* $Id: f5gb.cc,v 1.28 2009-02-15 20:33:56 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
     
    7777    pWrite(gPrev->getFirst()->getPoly());
    7878    Print("2nd gPrev: ");
    79     Print("%p",gPrev->getFirst()->getNext());
     79    pWrite(gPrev->getFirst()->getNext()->getPoly());
    8080    //pWrite(gPrev->getFirst()->getNext()->getPoly());   
    8181    CList* critPairs        =   new CList();
     
    103103        // DEBUG STUFF FOR SPOLYLIST
    104104        LNode* temp     =   sPolyList->getFirst();
    105         while(NULL != temp->getLPoly()) {
     105        while(NULL != temp && NULL != temp->getLPoly()) {
    106106            Print("Spolylist element: ");
    107107            pWrite(temp->getPoly());
     
    121121    }
    122122    lTag->insert(gPrev->getFirst());
     123    Print("COMPLETED FIRST IN F5INC: \n");
     124    pWrite(completed->getFirst()->getPoly());
    123125    return gPrev;
    124126}
     
    294296void computeSPols(CNode* first, RTagList* rTag, RList* rules, LList* sPolyList) {
    295297    CNode* temp         =   first;
    296     static poly sp      =   pInit();
     298    poly sp      =   pInit();
    297299    Print("###############################IN SPOLS##############################\n");
    298300    while(NULL != temp->getData()) {
     
    382384    if(NULL != sPolyList->getFirst()->getLPoly()) {
    383385        LNode* temp =   sPolyList->getFirst();
    384         Print("HIER REDUCTION\n");
    385         while(NULL != temp->getLPoly()) {
     386                Print("SPOLYLIST FIRST START: %p\n",temp);                     
     387        while(NULL != temp && NULL != temp->getLPoly()) {
    386388            if(NULL != completed->getFirst()->getLPoly()) {
    387389                                Print("BIS HIERHIN UND NICHT WEITER\n");       
    388390                                Print("%p\n",completed->getFirst());
    389391                                pWrite(completed->getFirst()->getPoly());
     392                Print("ADDRESS OF TERM: %p\n",completed->getFirst()->getTerm());
     393                pWrite(completed->getFirst()->getTerm());
    390394                        }
    391395                        tempNF = kNF(gbPrev,currQuotient,temp->getPoly()); 
    392             pWrite(tempNF);
    393             pWrite(temp->getPoly());
    394396            temp->setPoly(tempNF);
    395             pWrite(temp->getPoly());
    396397            // test if normal form is zero
    397398            if(NULL == tempNF) {
     
    400401                // TODO: problem is that when deleting the first element, the origin of the
    401402                // corresponding rule is deleted!
    402                 temp    =   temp->getNext();
     403                Print("LENGTH OF SPOLYLIST: %d\n",sPolyList->getLength());
     404                //temp    =   temp->getNext();
    403405                //sPolyList->setFirst(temp);
    404406                Print("///////////////////////////////////////////////////////////////////////\n");
    405                 Print("%p\n",temp);
    406                 Print("%p\n",temp->getLPoly());
     407                Print("SPOLYLIST FIRST ELEMENT: %p\n",temp);
     408                //Print("%p\n",temp->getLPoly());
    407409                Print("///////////////////////////////////////////////////////////////////////\n");
    408410            }
    409411            else {
    410                                 Print("HIERLALA\n");
    411                                 if(NULL != completed->getFirst()->getLPoly()) {
    412                                         Print("%p\n",completed->getFirst());
    413                                         pWrite(completed->getFirst()->getPoly());
    414                                 }
    415                                 //
    416                                 //
    417                                 //
    418                                 //
    419                                 // NOTE: until this point the element completed->getFirst()->getPoly() exists!!!
    420                                 //
    421                                 //
    422                                 //
    423                                 //
    424412                ret =   topReduction(temp, completed, gPrev, rules, lTag, rTag);
    425413                // in topReduction() the investigated first element of sPolyList will be deleted after its
     
    429417               
    430418                                completed   =   ret->getCompleted();
    431                                
    432                                 Print("%p\n",completed->getFirst());
    433                                 Print("%p\n",ret->getCompleted()->getFirst());
    434                                 pWrite(completed->getFirst()->getPoly());
    435             Print("~~~HIER~~~\n");
    436                         Print("%d\n",completed->getFirst()->getIndex());
     419                Print("ZURUECK IN REDUCTION COMPLETED TERM ADDRESS: %p\n",completed->getFirst()->getTerm());
     420                pWrite(completed->getFirst()->getTerm());
    437421                if(NULL != ret->getToDo()) {
    438422                    sPolyList->insertByLabel(ret->getToDo()->getFirst());
    439423                }
    440424            }
    441                         temp    =       sPolyList->getFirst();
    442                         Print("END WHILE LOOP: ");
    443                         Print("%p\n",completed->getFirst());
    444                         pWrite(completed->getFirst()->getPoly());
    445                                                
    446         }
    447     }
    448     return ret->getCompleted();
     425            if(NULL != temp) {
     426                sPolyList->setFirst(temp->getNext());
     427                temp    =       sPolyList->getFirst();
     428            }
     429            else {
     430                return completed;
     431            }
     432    Print("ADDRESS OF TERM: %p\n",completed->getFirst()->getTerm());
     433
     434                        //pWrite(completed->getFirst()->getPoly());
     435                        Print("SPOLYLIST FIRST NOW: %p\n",temp);                       
     436            //pWrite(temp->getPoly());
     437        }
     438    }
     439    Print("RETURN VALUE OF REDUCTION(): %p\n",completed->getFirst());
     440    Print("ADDRESS OF TERM: %p\n",completed->getFirst()->getTerm());
     441    Print("ADDRESS OF POLY: %p\n",completed->getFirst()->getPoly());
     442    pWrite(completed->getFirst()->getPoly());
     443    return completed;
    449444}   
    450445
     
    459454TopRed* topReduction(LNode* l, LList* completed, LList* gPrev, RList* rules, LTagList* lTag, RTagList* rTag) {
    460455    Print("##########################################In topREDUCTION!########################################\n");
    461     LNode* red   =   new LNode();
     456                        Print("L BEGIN TOP RED: %p\n",l->getLPoly());
     457            pWrite(l->getPoly());
     458            pWrite(l->getTerm());
     459            Print("ADDRESS OF TERM: %p\n",l->getTerm());
     460            //pWrite(completed->getFirst()->getPoly());
     461            LNode* red   =   new LNode();
     462   
    462463    do {
    463464        red  =   findReductor(l, completed, gPrev, rules, lTag, rTag,
    464465                              red->getGPrevRedCheck(), red->getCompletedRedCheck());
    465             Print("HIER TOP RED\n");
    466466        // no reductor found
    467467        if(NULL == red) {
    468             pWrite(l->getPoly());
    469             pNorm(l->getPoly());
    470             pWrite(l->getPoly());
    471             Print("________________________INSERT IN COMPLETED!____________________________\n");
    472468            completed->insert(l->getLPoly());
    473             Print("%p\n",completed->getFirst()->getLPoly());
    474                         Print("%d\n",completed->getFirst()->getIndex());
    475             pWrite(completed->getFirst()->getPoly());
     469            Print("AT INSERTION IN COMPLETED ADDRESS OF TERM: %p\n",l->getTerm());
     470            Print("AT INSERTION IN COMPLETED ADDRESS OF TERM II: %p\n",completed->getFirst()->getTerm());
     471            pWrite(completed->getFirst()->getTerm());
    476472            TopRed* ret =   new TopRed(completed,NULL);
    477473            return ret;
     
    479475        // reductor found
    480476        else {
    481             Print("REDUCTOR VORHER:  ");
    482             pWrite(red->getPoly());
    483477            red->setPoly(ppMult_nn(red->getPoly(),pGetCoeff(l->getPoly())));
    484             Print("REDUCTOR NACHHER:  ");
    485             pWrite(red->getPoly());
    486478        }           
    487479    } while(NULL != red);
     
    497489LNode* findReductor(LNode* l,LList* completed,LList* gPrev, RList* rules, LTagList* lTag,RTagList* rTag,
    498490                    LNode* gPrevRedCheck, LNode* completedRedCheck) {
    499     number nOne     =   nInit(1);
    500     static poly u          =   pInit();
    501     static poly redPoly    =   pInit();
     491    Print("HIER FIND REDUCTOR\n");
     492        number nOne     =   nInit(1);
     493    poly u          =   pOne();
     494    poly redPoly    =   pOne();
    502495    poly t          =   pHead(l->getPoly());
    503496    LNode* temp     =   new LNode();
    504497    // setting starting point for search of reductors in gPrev
    505     Print("----------------------------------------------------------------------------%p\n",completed->getFirst()->getLPoly());
    506498    if(NULL != gPrevRedCheck) {
    507499        temp =   gPrevRedCheck;
     
    512504    // search only for reductors with the same index, as reductions with elements of lower
    513505    // index were already done in reduction() beforehand
    514     while(NULL != temp->getLPoly() && temp->getIndex() == l->getIndex()) {
     506    while(NULL != temp && NULL != temp->getLPoly() && temp->getIndex() == l->getIndex()) {
    515507        // divides head term t?
    516         Print("HIER FIND\n");
    517508        if(pLmDivisibleByNoComp(temp->getPoly(),t)) {
    518509            u       =   pDivide(t,pHead(temp->getPoly()));
     
    522513            pNorm(redPoly);
    523514            u       =   ppMult_qq(u,temp->getTerm());
     515            pSetCoeff(u,nOne);
    524516            Print("IN FIND REDUCTOR:  ");
    525             pWrite(u);
    526             pWrite(redPoly);
    527             // same label? NOTE: also used to
    528             if(pLmCmp(u,l->getTerm()) != 0) {
    529                 // passing criterion 2?
    530                 if(!criterion2(&u,temp, rules, rTag)) {
    531                     // passing criterion 1?
    532                 Print("HIER DRIN\n");
    533                     if(!criterion1(&u,temp,lTag)) {
    534                         // set tag findRedCheck such that you can start at this point when the
    535                         // next time a reductor is searched for in findReductor()
    536                         LNode* red      =   new LNode(u,temp->getIndex(),redPoly,NULL,temp->getNext(),completedRedCheck);
    537                         return red;
    538                     }
    539                 }
    540             }
    541         }
    542         temp    =   temp->getNext();
    543     }
    544 
    545     // do the same as above now for the elements in completed
    546     if(NULL != completedRedCheck) {
    547         temp    =   completedRedCheck;
    548     }
    549     else {
    550         temp    =   completed->getFirst();
    551         Print("HIER FIND2\n");
    552                 Print("%p\n",temp->getLPoly());
    553     }
    554     // search only for reductors with the same index, as reductions with elements of lower
    555     // index where already done in reduction() beforehand
    556     while(NULL != temp->getLPoly()) {
    557         // divides head term t?
    558         if(pLmDivisibleByNoComp(temp->getPoly(),t)) {
    559             u       =   pDivide(t,pHead(temp->getPoly()));
    560             redPoly =   ppMult_qq(u,temp->getPoly());
    561             u       =   ppMult_qq(u,temp->getTerm());
    562             Print("IN FIND REDUCTOR1:  ");
    563517            pWrite(u);
    564518            pWrite(redPoly);
     
    571525                        // set tag findRedCheck such that you can start at this point when the
    572526                        // next time a reductor is searched for in findReductor()
     527                        LNode* red      =   new LNode(u,temp->getIndex(),redPoly,NULL,temp->getNext(),completedRedCheck);
     528                        return red;
     529                    }
     530                }
     531            }
     532        }
     533        temp    =   temp->getNext();
     534    }
     535    if(0 != completed->getLength()) {
     536    // do the same as above now for the elements in completed
     537    if(NULL != completedRedCheck) {
     538        temp    =   completedRedCheck;
     539    }
     540    else {
     541        Print("HIER DRIN\n");
     542        temp    =   completed->getFirst();
     543        pWrite(temp->getTerm());
     544    }
     545    // search only for reductors with the same index, as reductions with elements of lower
     546    // index where already done in reduction() beforehand
     547    while(NULL != temp && NULL != temp->getLPoly() && NULL != temp->getPoly()) {
     548        // divides head term t?
     549        if(pLmDivisibleByNoComp(temp->getPoly(),t)) {
     550            u       =   pDivide(t,pHead(temp->getPoly()));
     551            pSetCoeff(u,nOne);
     552            pWrite(u);
     553            redPoly =   ppMult_qq(u,temp->getPoly());
     554            pWrite(temp->getPoly());
     555            pWrite(temp->getTerm());
     556            u       =   ppMult_qq(u,temp->getTerm());
     557            // same label? NOTE: also used to
     558        if(pLmCmp(u,l->getTerm()) != 0) {
     559                // passing criterion 2?
     560                if(!criterion2(&u,temp, rules, rTag)) {
     561                    // passing criterion 1?
     562                    if(!criterion1(&u,temp,lTag)) {
     563                        // set tag findRedCheck such that you can start at this point when the
     564                        // next time a reductor is searched for in findReductor()
    573565                        LNode* red      =   new LNode(u,temp->getIndex(),redPoly,NULL,gPrevRedCheck,temp->getNext());
    574566                        return red;
     
    579571        temp    =   temp->getNext();
    580572    }
    581 
     573    }
    582574    // no reductor found
    583575    Print("HIER DU NULL!\n");
     
    617609    }
    618610    LList* gPrev    =   new LList(ONE, i, id->m[0]);
     611    Print("%p\n",id->m[0]);
     612    pWrite(id->m[0]);
     613    Print("%p\n",gPrev->getFirst()->getPoly());
     614    pWrite(gPrev->getFirst()->getPoly());
     615
    619616    lTag->insert(gPrev->getFirst());
    620617    // computing the groebner basis of the elements of index < actual index
  • kernel/f5lists.cc

    r73e5a2 r61d32c  
    4848
    4949LNode::LNode(poly t, int i, poly p, Rule* r, LNode* gPCheck, LNode* CompCheck) {
    50 LPoly* lp = new LPoly(t,i,p,r);
     50LPoly* lp           =  new LPoly(t,i,p,r);
    5151data                =   lp;
    5252next                =   NULL;
Note: See TracChangeset for help on using the changeset viewer.