Changeset cfb8edb in git


Ignore:
Timestamp:
Oct 11, 2008, 2:12:46 PM (15 years ago)
Author:
Christian Eder
Branches:
(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', '0604212ebb110535022efecad887940825b97c3f')
Children:
8645e5f59e03edb18edbba2d145fc6b64d5f8a30
Parents:
d4c53aac75e5ad01a534a848edf63e78a64b5b26
Message:
:


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

Legend:

Unmodified
Added
Removed
  • kernel/f5gb.cc

    rd4c53a rcfb8edb  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.cc,v 1.9 2008-08-07 13:18:36 Singular Exp $ */
     4/* $Id: f5gb.cc,v 1.10 2008-10-11 12:12:46 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
     
    6767lpoly *f5_inc(lpoly* lp, lpoly* g_prev)
    6868{
    69        
    70        
    71         return lp;
     69        long length = 1;
     70       
     71        while(g_prev->getNext() != NULL) {
     72                length++;
     73                g_prev++;
     74        }
     75        Print("Laenge der Liste: %d\n",length);
     76        /*critpair *critpairs = new critpair[length];
     77        * int i = 1;
     78        *
     79        * while(g_prev->getNext()->getNext() != NULL) {
     80        *        critpairs[i] = {lp, g_prev, critpairs[i+1]};
     81        *        i++;
     82        *        g_prev++;
     83        * }
     84        * *critpairs[length] = {lp, g_prev+length-1, NULL};
     85        *
     86        * return lp;
     87        */
    7288}   
    7389
     
    7995ideal F5main(ideal i, ring r)
    8096{
    81       ideal iTmp, g_basis;
    82       long j, k;
    83       poly one = pInit();
    84       pSetCoeff(one, nInit(1));
    85       pWrite(one);
    86       lpoly *lp, *gb;
    87       intvec* sort;
    88       iTmp = idInit(IDELEMS(i),i->rank);
     97        ideal iTmp, g_basis;
     98        long j, k;
     99        poly one = pInit();
     100        pSetCoeff(one, nInit(1));
     101        pWrite(one);
     102        lpoly *lp, *gb;
     103        intvec* sort;
     104        iTmp = idInit(IDELEMS(i),i->rank);
    89105 
    90       for(j=0; j<IDELEMS(i); j++)
    91       {
    92               if(NULL != i->m[j])
    93               {
    94                       iTmp->m[j] = i->m[j];
    95               }
    96       }
    97 
    98       iTmp = kInterRed(i,0); 
    99       qsort_degree(&iTmp->m[0],&iTmp->m[IDELEMS(iTmp)-1]);
    100       idShow(iTmp);
    101      
    102       lp = new lpoly[IDELEMS(iTmp)];
    103      
    104       for(j=0; j <IDELEMS(iTmp); j++){
     106        for(j=0; j<IDELEMS(i); j++)
     107        {
     108                if(NULL != i->m[j])
     109                {
     110                        iTmp->m[j] = i->m[j];
     111                }
     112        ;}
     113       
     114        iTmp = kInterRed(i,0); 
     115        qsort_degree(&iTmp->m[0],&iTmp->m[IDELEMS(iTmp)-1]);
     116        idShow(iTmp);
     117       
     118        // generating the list lp of ideal generators
     119        lp = new lpoly[IDELEMS(iTmp)];
     120       
     121        for(j=0; j <IDELEMS(iTmp)-1; j++){
    105122                lp[j].setPoly(iTmp->m[j]);
    106123               
    107124                if(pComparePolys(lp[j].getPoly(), one)){
    108                                 Print("1 in GB");
    109                                 return(NULL);
     125                        Print("1 in GB\n");
     126                        return(iTmp);
    110127                }
    111128               
    112129                lp[j].setIndex(j+1);
    113130                lp[j].setTerm(one);
     131                lp[j].setDel(false);
     132                lp[j].setNext(&lp[j+1]);
    114133                Print("Labeled Polynomial %d: ",j+1);
    115                 Print("Signature Term: ");
     134                Print("Label Term: ");
    116135                pWrite(lp[j].getTerm());
    117                 Print("Signature Index: %d\n", lp[j].getIndex());
     136                Print("Index: %d\n", lp[j].getIndex());
     137                Print("Delete? %d\n", lp[j].getDel());
    118138                pWrite(lp[j].getPoly());
    119139                Print("\n\n");
    120                          
    121       }
    122      
    123       // PROBLEM: muss signatur mitliefern, daher datentyp
    124       //          ideal nicht zu gebrauchen?
    125       gb = new lpoly;
    126       gb = &lp[IDELEMS(iTmp)-1];
    127       pWrite((*gb).getPoly());
    128 
    129       for(j=IDELEMS(iTmp)-2; j>0; j--){
    130              //PROBLEM: muss dynamisch Speicher allozieren
    131              gb = f5_inc(&lp[j], gb);
    132              for(k=0; k< IDELEMS(iTmp); k++){
    133                     if(gb[k].getPoly()){
    134                     }
    135              }
    136 
    137 
    138 
    139                
    140       }
     140        }
     141
     142        lp[IDELEMS(iTmp)-1].setPoly(iTmp->m[IDELEMS(iTmp)-1]);
     143       
     144        if(pComparePolys(lp[IDELEMS(iTmp)-1].getPoly(), one)){
     145                        Print("1 in GB\n");
     146                        return(iTmp);
     147        }
     148       
     149        lp[IDELEMS(iTmp)-1].setIndex(IDELEMS(iTmp));
     150        lp[IDELEMS(iTmp)-1].setTerm(one);
     151        lp[IDELEMS(iTmp)-1].setDel(false);
     152        lp[IDELEMS(iTmp)-1].setNext(NULL);
     153        Print("Labeled Polynomial %d: ",IDELEMS(iTmp));
     154        Print("Label Term: ");
     155        pWrite(lp[IDELEMS(iTmp)-1].getTerm());
     156        Print("Index: %d\n", lp[IDELEMS(iTmp)-1].getIndex());
     157        Print("Delete? %d\n", lp[IDELEMS(iTmp)-1].getDel());
     158        pWrite(lp[IDELEMS(iTmp)-1].getPoly());
     159        Print("\n\n");
     160       
     161        // PROBLEM: muss signatur mitliefern, daher datentyp
     162        //          ideal nicht zu gebrauchen?
     163       
     164
     165        // gb: Grobner Bases, pointer on the first element in the list,
     166        // end of the list is marked by next = NULL
     167       
     168        gb = new lpoly;
     169        gb = &lp[IDELEMS(iTmp)-1];
     170        (*gb).setNext(NULL);
     171        Print("last element in sequence = first element in gb:\n");
     172        pWrite((*gb).getPoly());
     173        Print("Next: %p\n", lp[IDELEMS(iTmp)-2].getNext());
     174        Print("Next: %p\n", lp[IDELEMS(iTmp)-1].getNext());
     175       
     176        for(j=IDELEMS(iTmp)-2; j>0; j--){
     177                //PROBLEM: muss dynamisch Speicher allozieren
     178                gb = f5_inc(&lp[j], gb);
    141179               
     180                for(k=0; k< IDELEMS(iTmp); k++){
    142181                       
    143 
    144 
    145         return iTmp;
     182                        if(pComparePolys(gb[k].getPoly(),one)){
     183                                Print("1 in GB\n");
     184                                return(iTmp);
     185                        }
     186
     187                }
     188       
     189         
     190        }
     191
     192        Print("Es klappt!\n");
     193        return(iTmp);
     194                       
     195
     196
    146197}
    147198
  • kernel/f5gb.h

    rd4c53a rcfb8edb  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: f5gb.h,v 1.8 2008-08-07 13:18:36 Singular Exp $ */
     4/* $Id: f5gb.h,v 1.9 2008-10-11 12:12:46 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
     
    1111#ifdef HAVE_F5
    1212#include "lpolynom.h"
    13 
    14 
    15 // structure of the rules, i.e. index and term
    16 struct rule
    17 {
    18         long index;
    19         poly term;
    20 };
    2113
    2214
  • kernel/lpolynom.cc

    rd4c53a rcfb8edb  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: lpolynom.cc,v 1.2 2008-08-07 13:18:36 Singular Exp $ */
     4/* $Id: lpolynom.cc,v 1.3 2008-10-11 12:12:46 ederc Exp $ */
    55/*
    66* ABSTRACT: lpolynomial definition
     
    4545}
    4646
     47
     48void lpoly::setDel(bool b)
     49{
     50        del = b;
     51}
     52
     53void lpoly::setNext(lpoly* l)
     54{
     55        next = l;
     56}
     57
    4758poly lpoly::getPoly()
    4859{
     
    6071}
    6172
     73bool lpoly::getDel()
     74{
     75        return del;
     76}
     77
     78lpoly *lpoly::getNext()
     79{
     80        return next;
     81}
    6282
    6383#endif
  • kernel/lpolynom.h

    rd4c53a rcfb8edb  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: lpolynom.h,v 1.2 2008-08-07 13:18:36 Singular Exp $ */
     4/* $Id: lpolynom.h,v 1.3 2008-10-11 12:12:46 ederc Exp $ */
    55/*
    66* ABSTRACT: f5gb interface
     
    1616{
    1717        private:
    18                 poly term;
    19                 long index;
    20                 poly polynomial;
     18                poly    term; //term of signature
     19                long    index; //index of signature
     20                poly    polynomial; //standard polynomial data
     21                bool    del; //for deletion in TopReduction Subalgorithm
     22                lpoly   *next; //pointer on the next labeled polynomial in the list
     23        public:
     24                void    setPoly(poly p);
     25                poly    getPoly();
     26                void    setTerm(poly t);
     27                poly    getTerm();
     28                void    setIndex(long i);
     29                long    getIndex();
     30                void    setDel(bool b);
     31                bool    getDel();
     32                void    setNext(lpoly *l);
     33                lpoly   *getNext();
     34};
    2135
    22         public:
    23                 void setPoly(poly p);
    24                 poly getPoly();
    25                 void setTerm(poly t);
    26                 poly getTerm();
    27                 void setIndex(long i);
    28                 long getIndex();
     36
     37// structure of the critical pairs, just the addresses of the corresponding generator labeled polynomials
     38struct critpair
     39{
     40        lpoly       *cp1;   // first  component
     41        lpoly       *cp2;   // second component
     42        critpair    *next;  // next critical pair
    2943};
     44
    3045
    3146#endif
Note: See TracChangeset for help on using the changeset viewer.