Changeset fe88079 in git


Ignore:
Timestamp:
Mar 5, 2009, 3:30:23 PM (15 years ago)
Author:
Christian Eder
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '4188d308699580d975efd0f6cca8dcb41c396f70')
Children:
e67578de8a1ef6cb0775436fca233d5068c4d649
Parents:
9cb4078b918c5799bfa2896f95e3c4bfc8f5bd73
Message:
interreduction stuff added, still commented out and tested


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

Legend:

Unmodified
Added
Removed
  • kernel/f5data.h

    r9cb4078 rfe88079  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: f5data.h,v 1.8 2009-03-04 20:23:05 ederc Exp $ */
     5/* $Id: f5data.h,v 1.9 2009-03-05 14:30:23 ederc Exp $ */
    66/*
    77* ABSTRACT: labeled polynomial interface
     
    212212    public:
    213213        inline          Rule(int i, poly term);
     214        inline          ~Rule();
    214215        inline  int     getIndex();
    215216        inline  poly    getTerm();
     
    221222}
    222223
     224Rule::~Rule() {
     225    //pDelete(&term);
     226}
     227
    223228int Rule::getIndex() {
    224229    return index;
  • kernel/f5gb.cc

    r9cb4078 rfe88079  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.cc,v 1.38 2009-03-04 20:23:04 ederc Exp $ */
     4/* $Id: f5gb.cc,v 1.39 2009-03-05 14:30:23 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
     
    7878    f_i         =   tempNF;
    7979    gPrev->insert(ONE,i,f_i);
     80    //gPrev->insert(ONE,gPrev->getLength()+1,f_i);
    8081    // tag the first element in gPrev of the current index for findReductor()
    8182    lTag->setFirstCurrentIdx(gPrev->getLast());
     
    278279*/
    279280inline bool criterion2(poly t, LNode* l, RList* rules, RTagList* rTag) {
    280     //Print("------------------------------IN CRITERION 2-----------------------------------------\n");
    281         //Print("RULES: \n");
     281    Print("------------------------------IN CRITERION 2-----------------------------------------\n");
     282        Print("RULES: \n");
    282283        RNode* tempR    =   rules->getFirst();
    283         //while(NULL != tempR->getRule()) {
    284         //    Print("ADDRESS OF RULE: %p\n",tempR->getRule());
    285         //    pWrite(tempR->getRuleTerm());
    286         //    Print("ADDRESS OF TERM: %p\n",tempR->getRuleTerm());
    287         //    Print("%d\n\n",tempR->getRuleIndex());
    288         //    tempR   =   tempR->getNext();
    289         //}
    290         //Print("TESTED ELEMENT: ");
    291         //pWrite(l->getPoly());
    292         //pWrite(l->getTerm());
    293         //pWrite(ppMult_qq(t,l->getTerm()));
    294         //Print("%d\n\n",l->getIndex());
     284        while(NULL != tempR->getRule()) {
     285            Print("ADDRESS OF RNODE: %p\n",tempR);
     286            Print("ADDRESS OF RULE: %p\n",tempR->getRule());
     287            pWrite(tempR->getRuleTerm());
     288            Print("ADDRESS OF TERM: %p\n",tempR->getRuleTerm());
     289            Print("%d\n\n",tempR->getRuleIndex());
     290            tempR   =   tempR->getNext();
     291        }
     292        Print("TESTED ELEMENT: ");
     293        pWrite(l->getPoly());
     294        pWrite(l->getTerm());
     295        pWrite(ppMult_qq(t,l->getTerm()));
     296        Print("%d\n\n",l->getIndex());
    295297// start at the previously added element to gPrev, as all other elements will have the same index for sure
    296298    RNode* testNode =   new RNode();
     
    305307        //Print("DEBUG\n");
    306308        //Print("L INDEX: %d\n",l->getIndex());
    307             testNode    =   rTag->get(l->getIndex());
     309            /*-------------------------------------
     310             * TODO: WHEN INTERREDUCING THE GB THE
     311             *       INDEX OF THE PREVIOUS ELEMENTS
     312             *       GETS HIGHER!
     313             *-----------------------------------*/
     314            testNode    =   rules->getFirst();
     315            //testNode    =   rTag->get(l->getIndex());
    308316            //Print("TESTNODE ADDRESS: %p\n",testNode);
    309317        }
     
    314322    //Print("%p\n",testNode->getRule());
    315323    // NOTE: testNode is possibly NULL as rTag->get() returns NULL for elements of index <=1!
     324    //Print("TESTNODE: %p\n",testNode);
     325    //pWrite(testNode->getRuleTerm());
    316326    if(NULL != testNode && NULL != testNode->getRule()) {   
    317327        //pWrite(testNode->getRuleTerm());
     
    329339          && l->getIndex() == testNode->getRuleIndex()) {
    330340        //pWrite(testNode->getRuleTerm());
    331                 //pWrite(testNode->getRuleTerm());
    332         //pWrite(t);
    333         //pWrite(l->getTerm());
    334         //pWrite(u1);
     341                pWrite(testNode->getRuleTerm());
     342        pWrite(t);
     343        pWrite(l->getTerm());
     344        pWrite(u1);
    335345        //Print("%d\n",testNode->getRuleIndex());
    336346        if(pLmDivisibleBy(testNode->getRuleTerm(),u1)) {
    337             //Print("Criterion 2 NOT passed!\n");
     347            Print("Criterion 2 NOT passed!\n");
    338348            pDelete(&u1);
    339349            return true;
     
    341351                testNode    =   testNode->getNext();
    342352    }
     353    //delete testNode;
    343354    pDelete(&u1);
    344355    return false;
     
    420431                            //Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ZERO REDUCTION~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
    421432                                                        reductionsToZero++;
     433                        Print("IN SPOLS 1\n");
    422434                            rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    423435                            //Print("RULE ADDED: \n");
     
    428440                        }
    429441                        else {
     442                        Print("IN SPOLS 2\n");
    430443                            rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    431444                            //Print("RULE ADDED: \n");
     
    451464                            //Print("~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ZERO REDUCTION~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~\n");
    452465                        reductionsToZero++;
     466                        Print("IN SPOLS 3\n");
    453467                        rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    454468                        //Print("RULE ADDED: \n");
     
    458472                    }
    459473                    else {
     474                        Print("IN SPOLS 4\n");
    460475                        rules->insert(temp->getLp1Index(),ppMult_qq(temp->getT1(),temp->getLp1Term()));
    461476                        //Print("RULE ADDED: \n");
     
    570585        //pWrite(gPrevRedCheck->getPoly());
    571586        LNode* tempRed          =   new LNode();
    572         //Print("TESTED POLYNOMIAL IN THE FOLLOWING: ");
    573         //pWrite(l->getPoly());
     587        Print("TESTED POLYNOMIAL IN THE FOLLOWING: ");
     588        pWrite(l->getPoly());
    574589        //Print("HIER\n");
    575590        tempRed  =   findReductor(l,gPrevRedCheck,gPrev,rules,lTag,rTag);
     591        //Print("TEMPRED NEXT: %p\n",tempRed->getNext());
    576592        //Print("--------------------------------HIER DEBUG 2----------------------------------\n");
    577593        // if a reductor for l is found and saved in tempRed
     
    579595            // if label of reductor is greater than the label of l we have to built a new element
    580596            // and add it to sPolyList
    581             //Print("REDUCTOR POLYNOMIAL: ");
    582             //pWrite(tempRed->getPoly());
    583             //Print("TERM: ");
    584             //pWrite(tempRed->getTerm());
     597            Print("REDUCTOR POLYNOMIAL: ");
     598            pWrite(tempRed->getPoly());
     599            Print("TEMPRED: %p\n",tempRed);
     600            Print("TERM: ");
     601            pWrite(tempRed->getTerm());
    585602            if(pLmCmp(tempRed->getTerm(),l->getTerm()) == 1) {
    586603                // needed sinc pSub destroys the arguments!
     
    605622                    // for debugging
    606623                    //pWrite(tempRed->getPoly());
    607                     //Print("RULE ADDED\n");
     624                    Print("RULE ADDED\n");
    608625                    rules->insert(tempRed->getIndex(),tempRed->getTerm());
    609626                    tempRed->getLPoly()->setRule(rules->getFirst()->getRule());
    610                     //Print("%p\n",sPolyList->getFirst());
    611                     //Print("%p\n",sPolyList->getFirst()->getLPoly());
    612                     //Print("SPOLYLIST LENGTH: %d\n",sPolyList->getLength());
     627                    Print("%p\n",sPolyList->getFirst());
     628                    Print("%p\n",sPolyList->getFirst()->getLPoly());
     629                    Print("SPOLYLIST LENGTH: %d\n",sPolyList->getLength());
    613630                    //sPolyList->print();
    614631                   
    615632                    sPolyList->insertByLabel(tempRed);
    616                     //sPolyList->print();
     633                    sPolyList->print();
    617634                    //Print("SPOLYLIST LENGTH: %d\n",sPolyList->getLength());
    618635                    //Print("OH JE\n");
     
    622639                    reductionsToZero++;
    623640                    //Print("RULE ADDED\n");
    624         //Print("wieder hier2\n");
     641        Print("wieder hier2\n");
    625642                    rules->insert(tempRed->getIndex(),tempRed->getTerm());
    626643                    pWrite(rules->getFirst()->getRuleTerm());
     
    667684            if(NULL != l->getPoly()) {
    668685                pNorm(l->getPoly());
    669                 //Print("----------------------------------ADDED TO GPREV IN TOPREDUCTION:-------------------------------------- ");
    670                 //pWrite(l->getPoly());
    671                 //pWrite(l->getTerm());
    672                 //Print("INDEX: %d\n\n\n", l->getIndex());
     686                Print("----------------------------------ADDED TO GPREV IN TOPREDUCTION:-------------------------------------- ");
     687                pWrite(l->getPoly());
     688                pWrite(l->getTerm());
     689                Print("INDEX: %d\n\n\n", l->getIndex());
    673690                //sleep(20);
    674691                gPrev->insert(l->getLPoly());
     
    705722    // not from the first element of gPrev with the current index
    706723    temp    =   gPrevRedCheck;
     724    //temp    =   lTag->getFirstCurrentIdx(); 
     725    //Print("GPREVREDCHECK: %p\n",gPrevRedCheck);
     726    //pWrite(gPrevRedCheck->getPoly());
    707727    // search for reductors until we are at the end of gPrev resp. at the
    708728    // end of the elements of the current index
     
    783803    RList* rules    =   new RList();
    784804    Print("RULES FIRST: %p\n",rules->getFirst());
     805    Print("RULES FIRST DATA: %p\n",rules->getFirst()->getRule());
    785806    RTagList* rTag  =   new RTagList(rules->getFirst());
    786807    i = 1;
     
    837858        Print("%d\n",gPrev->getLength()-gbLength-1);
    838859            for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
    839                 Print("YES\n");
     860                //Print("YES\n");
    840861                temp        =   temp->getNext();
    841862                if(temp) {
    842                     Print("%p\n",temp);
    843                     pWrite(temp->getPoly());
    844                     Print("%p\n",temp->getNext());
     863                    //Print("%p\n",temp);
     864                    //pWrite(temp->getPoly());
     865                    //Print("%p\n",temp->getNext());
    845866                }
    846867                gbAdd->m[j] =   temp->getPoly();
    847868                //pWrite(temp->getPoly());
    848869            }
    849             Print("HIER AUCH\n");
     870            //Print("HIER AUCH\n");
    850871            gbPrev          =   idAdd(gbPrev,gbAdd);
    851872            // interreduction stuff
     
    856877                qsortDegree(&gbPrev->m[0],&gbPrev->m[IDELEMS(gbPrev)-1]);
    857878                delete gPrev;
    858                 Print("RULES FIRST NOW1: %p\n",rules->getFirst());
     879                //Print("RULES FIRST NOW1: %p\n",rules->getFirst());
    859880                delete rules;
    860                 Print("HIERLALA\n");
    861                 LList* gPrev    =   new LList(pOne,1,gbPrev->m[0]);
     881                //Print("%p\n",rules->getFirst());
     882                gPrev    =   new LList(pOne,1,gbPrev->m[0]);
    862883                gPrev->insert(pOne,1,gbPrev->m[1]);
    863884                poly tempPoly = pInit();
     
    865886                pLcm(pHead(gbPrev->m[0]),pHead(gbPrev->m[1]),tempPoly);
    866887                rules    =   new RList();
     888                //Print("%p\n",rules->getFirst());
     889                //pWrite(tempPoly);
    867890                rules->insert(2,tempPoly);
    868             pWrite(rules->getFirst()->getRuleTerm());
     891                //Print("%p\n",rules->getFirst());
     892                //Print("%p\n",rules->getFirst()->getNext()->getNext());
     893                //Print("HIERLALA\n");
     894            //pWrite(rules->getFirst()->getRuleTerm());
    869895            Print("RULES FIRST NOW2: %p\n",rules->getFirst());
    870896                for(k=2; k<IDELEMS(gbPrev); k++) {
    871897                    gPrev->insert(pOne,k+1,gbPrev->m[k]);
    872898                    for(l=0; l<k; l++) {
     899                        pWrite(gbPrev->m[k]);
     900                        pWrite(gbPrev->m[l]);
    873901                        pLcm(pHead(gbPrev->m[k]),pHead(gbPrev->m[l]),tempPoly);
    874902                        pSetCoeff(tempPoly,nOne);
     
    877905                }
    878906            }
    879             */
     907           */
    880908            gbLength    =   gPrev->getLength();
    881909
    882910        }
    883         Print("%p\n",gPrev->getFirst());
    884         //gPrev->print();
     911        gPrev->print();
    885912        //int anzahl  =   1;
    886913        //while(NULL != temp) {
  • kernel/f5lists.cc

    r9cb4078 rfe88079  
    736736*/
    737737RNode::RNode() {
     738    Print("HIER RNODE CONSTRUCTOR\n");
    738739    data    =   NULL;
    739740    next    =   NULL;
     
    757758
    758759RNode* RNode::insert(int i, poly t) {
     760    Print("IN INSERT: ");
     761    pWrite(t);
    759762    Rule*   r           =   new Rule(i,t);
     763    Print("ADDRESS OF RULE: %p\n",r);
    760764    RNode* newElement   =   new RNode(r);
     765    Print("ADDRESS OF RNODE: %p\n",newElement);
     766    Print("ADDRESS OF RNODE DATA: %p\n",newElement->getRule());
    761767    newElement->next    =   this;
    762768    return newElement;
     
    800806        Print("1 %p\n",first);
    801807        if(first) {
     808            Print("1' %p\n",first->getRule());
    802809            Print("2 %p\n",first->getNext());
     810            //Print("3 %p\n",first->getNext()->getRule());
    803811            //Print("3 %p\n",first->getNext()->getRuleTerm());
    804812        }
Note: See TracChangeset for help on using the changeset viewer.