Changeset 667a9c in git


Ignore:
Timestamp:
May 29, 2009, 1:34:22 PM (14 years ago)
Author:
Christian Eder
Branches:
(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')
Children:
c92fb1263e2fdce703509276003f67dd8351d229
Parents:
30bb07aae70a2a23ab764df7a9aa5063f1dd3698
Message:
bad stuff updated


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

Legend:

Unmodified
Added
Removed

  • kernel/f5data.h

    r30bb07 r667a9c  
    33*  Computer Algebra System SINGULAR     *
    44****************************************/
    5 /* $Id: f5data.h,v 1.10 2009-03-29 17:17:09 ederc Exp $ */
     5/* $Id: f5data.h,v 1.11 2009-05-29 11:34:22 ederc Exp $ */
    66/*
    77* ABSTRACT: labeled polynomial interface
    88*/
    9 #ifndef F5DATA_HEADER
    10 #define F5DATA_HEADER
    11 #ifdef HAVE_F5
     9#ifndef F5CDATA_HEADER
     10#define F5CDATA_HEADER
     11#ifdef HAVE_F5C
    1212/*!
    1313=========================================================

  • kernel/f5gb.cc

    r30bb07 r667a9c  
    14461446        // DEBUGGING STUFF
    14471447        LNode* temp    =   gPrev->getFirst();
    1448     // computing new groebner basis gbPrev
     1448   
     1449
     1450        /////////////////////////////////////////////////////////////////////////////////
     1451        //                                                                             //
     1452        // one needs to choose one of the following 3 implementations of the algorithm //
     1453        // F5,F5R or F5C                                                               //
     1454        //                                                                             //
     1455        /////////////////////////////////////////////////////////////////////////////////                                                                           
     1456       
     1457       
     1458        //   
     1459        // remove this comment to get "F5"
     1460        //
     1461        /*
    14491462        if(gPrev->getLength() > gbLength) {
    14501463            if(i < IDELEMS(id)) {
    … …  
    14581471                        gbAdd->m[j] =   temp->getPoly();
    14591472                    }
    1460                         //if(1 == temp->getDel()) {
    1461                         //    pWrite(temp->getPoly());
    1462                         //}
    14631473                }
    14641474                    gbPrev          =   idAdd(gbPrev,gbAdd);
    1465                     //idShow(gbPrev);
    14661475            }
    14671476            else {
    … …  
    14741483                gbPrev          =   idAdd(gbPrev,gbAdd);
    14751484            }
     1485        }
     1486        gbLength    =   gPrev->getLength();
     1487        */
     1488       
     1489
     1490        //
     1491        // remove this comment to get "F5R"
     1492        //
     1493        /*
     1494        if(gPrev->getLength() > gbLength) {
     1495            if(i < IDELEMS(id)) {
     1496                ideal gbAdd =   idInit(gPrev->getLength()-gbLength,1);
     1497                LNode*  temp =   gPrevTag;
     1498                int counter =   0;
     1499                for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
     1500                    temp        =   temp->getNext();
     1501                    if(0 == temp->getDel()) {
     1502                        counter++;
     1503                        gbAdd->m[j] =   temp->getPoly();
     1504                    }
     1505                }
     1506                    gbPrev          =   idAdd(gbPrev,gbAdd);
     1507            }
     1508            else {
     1509                ideal gbAdd =   idInit(gPrev->getLength()-gbLength,1);
     1510                LNode*  temp =   gPrevTag;
     1511                for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
     1512                    temp        =   temp->getNext();
     1513                    gbAdd->m[j] =   temp->getPoly();
     1514                }
     1515                gbPrev          =   idAdd(gbPrev,gbAdd);
     1516            }
    14761517            // interreduction stuff
     1518            // comment this out if you want F5 instead of F5R
    14771519            if(i<IDELEMS(id)) {
    1478                 //int timer2  =   initTimer();
    1479                 //startTimer();
    1480                 //idShow(gbPrev);
    14811520                ideal tempId    =   kInterRed(gbPrev);
    1482                 //idShow(kInterRed(gbPrev));
    1483                 //idShow(tempId);
    14841521                gbPrev          =   tempId;
    1485                 //timer2  =   getTimer();
    1486                 //Print("Timer INTERREDUCTION: %d\n",timer2);
    1487                 //idShow(gbPrev);
    1488                 //qsortDegree(&gbPrev->m[0],&gbPrev->m[IDELEMS(gbPrev)-1]);
     1522            }
     1523        }
     1524        gbLength    =   gPrev->getLength();
     1525        */
     1526       
     1527
     1528        //
     1529        // Remove this comment to get "F5C"
     1530        // computing new groebner basis gbPrev
     1531        //
     1532         
     1533        if(gPrev->getLength() > gbLength) {
     1534            if(i < IDELEMS(id)) {
     1535                ideal gbAdd =   idInit(gPrev->getLength()-gbLength,1);
     1536                LNode*  temp =   gPrevTag;
     1537                for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
     1538                    temp        =   temp->getNext();
     1539                        gbAdd->m[j] =   temp->getPoly();
     1540                }
     1541                    gbPrev          =   idAdd(gbPrev,gbAdd);
     1542            }
     1543            else {
     1544                ideal gbAdd =   idInit(gPrev->getLength()-gbLength,1);
     1545                LNode*  temp =   gPrevTag;
     1546                for(j=0;j<=gPrev->getLength()-gbLength-1;j++) {
     1547                    temp        =   temp->getNext();
     1548                    gbAdd->m[j] =   temp->getPoly();
     1549                }
     1550                gbPrev          =   idAdd(gbPrev,gbAdd);
     1551            }
     1552            if(i<IDELEMS(id)) {
     1553                ideal tempId    =   kInterRed(gbPrev);
     1554                Print("HERE\n");
     1555                gbPrev          =   tempId;
    14891556                delete gPrev;
    1490                 //sleep(5);
    1491                 //Print("RULES FIRST NOW1: %p\n",rules->getFirst());
    1492                 //Print("HIER\n");
    14931557                delete rules;
    1494                 //delete rTag;
    1495                 //Print("HIER AUCH\n");
    1496                 //Print("%p\n",rules->getFirst());
    14971558                gPrev    =   new LList(pOne,1,gbPrev->m[0]);
    14981559                gPrev->insert(pOne,1,gbPrev->m[1]);
    1499                 //poly tempPoly = pInit();
    1500                 //pLcm(pHead(gbPrev->m[0]),pHead(gbPrev->m[1]),tempPoly);
    1501                 //tempPoly    =   pDivide(tempPoly,pOne());
    1502                 //pSetCoeff(tempPoly,nOne);
    15031560                rules    =   new RList();
    15041561                rTag     =   new RTagList(rules->getFirst());
    1505                
    1506                 //Print("%p\n",rules->getFirst());
    1507                 //pWrite(tempPoly);
    1508                 //rules->insert(2,tempPoly);
    1509                 //rTag->insert(rules->getFirst());
    1510                 //Print("%p\n",rules->getFirst());
    1511                 //Print("%p\n",rTag->getFirst());
    1512                 //Print("%p\n",rules->getFirst());
    1513                 //Print("%p\n",rules->getFirst()->getNext()->getNext());
    1514                 //Print("HIERLALA\n");
    1515             //pWrite(rules->getFirst()->getRuleTerm());
    1516            // Print("RULES FIRST NOW2: %p\n",rules->getFirst());
    15171562                for(k=2; k<IDELEMS(gbPrev); k++) {
    15181563                    gPrev->insert(pOne,k+1,gbPrev->m[k]);
    15191564                    for(l=0; l<k; l++) {
    1520                         //pWrite(gbPrev->m[k]);
    1521                         //pWrite(gbPrev->m[l]);
    1522                         //poly tempPoly2  =   pOne();
    1523                         //pLcm(pHead(gbPrev->m[k]),pHead(gbPrev->m[l]),tempPoly2);
    1524                         //tempPoly2   =   pDivide(tempPoly2,pOne());
    1525                         //pSetCoeff(tempPoly2,nOne);
    1526                         //pWrite(tempPoly2);
    1527                         //rules->insert(k+1,tempPoly2);
    15281565                    }
    15291566                    rTag->insert(rules->getFirst());
    … …  
    15311568            }
    15321569            gbLength    =   gPrev->getLength();
    1533             /*
    1534             if(gPrev->getLength() == 4) {
    1535                 poly temp1  =   pInit();
    1536                 poly temp2  =   pInit();
    1537                 poly u      =   pInit();
    1538                 temp1       =   pCopy(gbPrev->m[3]);
    1539                 temp2       =   pCopy(gbPrev->m[2]);
    1540                 u           =   pCopy(gbPrev->m[0]);
    1541                 pIter(u);
    1542                 pIter(u);
    1543                 pIter(u);
    1544                 pIter(u);
    1545                 //pWrite(u);
    1546                 number n    =   nInit(3);
    1547                 pSetCoeff(u,n);
    1548                 poly tempNew        =   pAdd(temp1,pMult(u,temp2));
    1549                 gbPrev->m[3]        =   tempNew;
    1550                 LNode* tempNode4    =   gPrev->getFirst();
    1551                 tempNode4           =   tempNode4->getNext()->getNext()->getNext();
    1552                 tempNode4->setPoly(tempNew);
    1553                 //Print("HIER\n");
    1554             }
    1555             */
    1556         //gPrev->print();
    1557         //int anzahl  =   1;
    1558         //while(NULL != temp) {
    1559         //    Print("%d. Element: ",anzahl);
    1560         //    pWrite(temp->getPoly());
    1561         //    Print("\n");
    1562         //    temp    =   temp->getNext();
    1563         //    anzahl++;
    1564         //}
    1565         //sleep(5);
    1566         //Print("GROEBNER BASIS:\n====================================================\n");
    1567         //idShow(gbPrev);
    1568         //Print("===================================================\n");
    1569         //Print("JA\n");
    1570         //Print("LENGTH OF GPREV: %d\n",gPrev->getLength());
    1571         //idShow(gbPrev);
    1572     }
    1573         //idShow(gbPrev);
     1570        } 
     1571   
     1572
     1573
    15741574    }
    15751575    //Print("\n\nADDING TIME IN REDUCTION: %d\n\n",reductionTime);
    … …  
    15771577    timer   =   getTimer();
    15781578    Print("Highest Degree during computations: %d\n",highestDegree);
    1579     Print("Time for computations: %d/10000 seconds\n",timer);
     1579    Print("Time for computations: %d/1000 seconds\n",timer);
     1580    Print("Number of elements in gb: %d\n",IDELEMS(gbPrev));
    15801581    //LNode* temp    =   gPrev->getFirst();
    15811582    //while(NULL != temp) {

  • kernel/f5gb.h

    r30bb07 r667a9c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.h,v 1.39 2009-05-13 16:55:03 ederc Exp $ */
     4/* $Id: f5gb.h,v 1.40 2009-05-29 11:34:22 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
    … …  
    3636bool compareMonomials(int* m1, int** m2, int numberOfRules);
    3737
    38 /*
    39 ==============================================
    40 generating the list lp of ideal generators and
    41 test if 1 is in lp(return 1) or not(return 0)
    42 ==============================================
    43 */
    44 void generate_input_list(LPoly* lp, ideal id, poly one);
    4538
    4639/*

  • kernel/f5lists.cc

    r30bb07 r667a9c  
    11#include "mod2.h"
    22
    3 #ifdef HAVE_F5
     3#ifdef HAVE_F5C
    44#include "kutil.h"
    55#include "structs.h"

  • kernel/f5lists.h

    r30bb07 r667a9c  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5lists.h,v 1.20 2009-05-14 08:47:01 ederc Exp $ */
     4/* $Id: f5lists.h,v 1.21 2009-05-29 11:34:22 ederc Exp $ */
    55/*
    66* ABSTRACT: list interface
    77*/
    88#include "f5data.h"
    9 #ifndef F5LISTS_HEADER
    10 #define F5LISTS_HEADER
    11 
    12 #ifdef HAVE_F5
     9#ifndef F5CLISTS_HEADER
     10#define F5CLISTS_HEADER
     11
     12#ifdef HAVE_F5C
    1313/*
    1414============================
    … …  
    5353        LNode*  insert(LPoly* lp);
    5454        LNode*  insert(poly t, int i, poly p, Rule* r);
     55        LNode*  insertByDeg(LPoly* lp);
    5556        // insert new elements to the list in front from the labeled / classical polynomial view
    5657        // needed for sPolyList
    … …  
    110111        void    insert(LPoly* lp);
    111112        void    insert(poly t,int i, poly p, Rule* r = NULL);
    112          // insertion in front of the list
     113        void    insertByDeg(LPoly* lp);
     114        // insertion in front of the list
    113115        // needed for sPolyList
    114116        void    insertSP(LPoly* lp);
Note: See TracChangeset for help on using the changeset viewer.