Changeset c1489f2 in git


Ignore:
Timestamp:
Oct 19, 1999, 2:42:51 PM (25 years ago)
Author:
Olaf Bachmann <obachman@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
828c28214a338ded17f2365a5cc851ddddadfac3
Parents:
d2b6cf082728946a490177ca3d6aba074109fe5c
Message:
* stuff from Thomas
* various bug fixes


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

Legend:

Unmodified
Added
Removed
  • Singular/LIB/standard.lib

    rd2b6cf rc1489f2  
    1 // $Id: standard.lib,v 1.46 1999-09-20 20:00:35 obachman Exp $
     1// $Id: standard.lib,v 1.47 1999-10-19 12:42:51 obachman Exp $
    22//////////////////////////////////////////////////////////////////////////////
    33
    4 version="$Id: standard.lib,v 1.46 1999-09-20 20:00:35 obachman Exp $";
     4version="$Id: standard.lib,v 1.47 1999-10-19 12:42:51 obachman Exp $";
    55info="
    66LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
     
    469469@ref{nres};
    470470@ref{lres};
     471@ref{hres};
    471472@ref{sres}.
    472473@ref{resolution}
  • Singular/Makefile.in

    rd2b6cf rc1489f2  
    8282    ring.cc shortfl.cc silink.cc sing_mp.cc\
    8383    sing_dld.cc sing_dbm.cc kspoly.cc \
    84     subexpr.cc syz.cc syz0.cc syz1.cc\
     84    subexpr.cc syz.cc syz0.cc syz1.cc syz2.cc\
    8585    timer.cc weight.cc \
    8686    mpsr_Put.cc mpsr_PutPoly.cc mpsr_GetPoly.cc \
     
    510510        $(CXXM) ${CPPFLAGS} ${DEFS} $< >> $@
    511511
    512 %.dd: %.cc mod2.h $(ASO_OBJS)
     512%.dd: %.cc mod2.h
    513513        echo $(@:.dd=.og) $(@:.dd=.op) $(@:.dd=.ob) " " \\ > $@
    514514        $(CXXM) -DGENTABLE ${CPPFLAGS} ${DEFSG} $< >> $@
    515515
    516 %.d: %.c mod2.h $(ASO_OBJS)
     516%.d: %.c mod2.h
    517517        echo $(@:.d=.og) $(@:.d=.op) $(@:.d=.ob) " " \\ > $@
    518518        $(CCM) ${CPPFLAGS} ${DEFSG} $< >> $@
  • Singular/ideals.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ideals.cc,v 1.63 1999-10-19 11:41:40 Singular Exp $ */
     4/* $Id: ideals.cc,v 1.64 1999-10-19 12:42:42 obachman Exp $ */
    55/*
    66* ABSTRACT - all basic methods to manipulate ideals
     
    14961496#endif
    14971497  return e;
    1498 }
    1499 
    1500 /*2
    1501 * computes syzygies and minimizes the input (h1)
    1502 * ONLY used in syMinRes
    1503 */
    1504 ideal idSyzMin (ideal h1,ideal  quot, tHomog h,intvec **w,
    1505                   BOOLEAN setRegularity, int &deg)
    1506 {
    1507   poly  p;
    1508   intvec * reord;
    1509   int   i, l=0, j, k, quotdim, quotgen,length=0,reg;
    1510   BOOLEAN isMonomial=TRUE;
    1511 
    1512   if (idIs0(h1))
    1513     return idFreeModule(1);
    1514   idSkipZeroes(h1);
    1515 
    1516   ring orig_ring=currRing;
    1517   ring syz_ring=rAddSyzComp(currRing);
    1518   pSetSyzComp(k);
    1519 
    1520   ideal s_h1=idRingCopy(h1,orig_ring);
    1521   ideal s_quot=idRingCopy(quot,orig_ring);
    1522 
    1523   ideal s_h3=idPrepare(s_h1,s_quot,h,k,&quotgen,&quotdim,w);
    1524   for (i=IDELEMS(s_h1);i!=0;i--)
    1525     pDelete(&(s_h1->m[i-1]));
    1526 
    1527   if (s_h3==NULL)
    1528   {
    1529     idDelete(&s_h1);
    1530     if (s_quot!=NULL) idDelete(&s_quot);
    1531 
    1532     if (syz_ring!=orig_ring)
    1533     {
    1534       rChangeCurrRing(orig_ring,TRUE);
    1535       rKill(syz_ring);
    1536     }
    1537     pSetSyzComp(0);
    1538 
    1539     for (i=IDELEMS(h1);i!=0;i--)
    1540       pDelete(&(h1->m[i-1]));
    1541     return idFreeModule(1);
    1542   }
    1543 
    1544   reord = new intvec(IDELEMS(h1)+1);
    1545   i = -1;
    1546   ideal e=idInit(16,s_h3->rank);
    1547   for (j=0; j<IDELEMS(s_h3); j++)
    1548   {
    1549     if (s_h3->m[j] != NULL)
    1550     {
    1551       p = s_h3->m[j];
    1552       if (pGetComp(p) > k)
    1553       {
    1554         s_h3->m[j]=NULL;
    1555         pShift(&p,-k);
    1556         if (p!=NULL)
    1557         {
    1558           i++;
    1559           if (i+1 >= IDELEMS(e))
    1560           {
    1561             pEnlargeSet(&(e->m),IDELEMS(e),16);
    1562             IDELEMS(e) += 16;
    1563           }
    1564           e->m[i] = p;
    1565         }
    1566       }
    1567       else
    1568       {
    1569         while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=k))
    1570           pIter(p);
    1571         if (pIsConstantComp(pNext(p)))
    1572         {
    1573           (*reord)[pGetComp(pNext(p))-k] = l+1;
    1574           s_h1->m[l] = s_h3->m[j];
    1575           s_h3->m[j] = pCopy(s_h1->m[l]);
    1576           pDelete(&pNext(p));
    1577           l++;
    1578         }
    1579         isMonomial=isMonomial && (pGetComp(pNext(s_h3->m[j]))>k);
    1580         pDelete(&pNext(s_h3->m[j]));
    1581       }
    1582     }
    1583   }
    1584   if ((!isMonomial)
    1585   && (!TEST_OPT_NOTREGULARITY)
    1586   && (setRegularity)
    1587   && (h==isHomog))
    1588   {
    1589     idSkipZeroes(s_h3);
    1590     resolvente res;
    1591     if (syz_ring==orig_ring)
    1592       res = sySchreyerResolvente(s_h3,0,&length);
    1593     else
    1594     {
    1595       rChangeCurrRing(orig_ring,TRUE);
    1596       ideal h3=idRingCopy(s_h3,syz_ring);
    1597       res = sySchreyerResolvente(h3,0,&length);
    1598       idDelete(&h3);
    1599       rChangeCurrRing(syz_ring,FALSE);
    1600       idDelete(&s_h3);
    1601       rChangeCurrRing(orig_ring,TRUE);
    1602     }
    1603     pSetSyzComp(0);
    1604     intvec * dummy = syBetti(res,length,&reg, *w);
    1605     deg = reg+2;
    1606     delete dummy;
    1607     for (j=0;j<length;j++)
    1608     {
    1609       if (res[j]!=NULL) idDelete(&(res[j]));
    1610     }
    1611     Free((ADDRESS)res,length*sizeof(ideal));
    1612     if(syz_ring!=orig_ring)
    1613       rChangeCurrRing(syz_ring,TRUE);
    1614   }
    1615   else
    1616   {
    1617     idDelete(&s_h3);
    1618   }
    1619   ideal ee;
    1620   if(syz_ring!=orig_ring)
    1621   {
    1622     rChangeCurrRing(orig_ring,TRUE);
    1623     ee=idRingCopy(e,syz_ring);
    1624     rChangeCurrRing(syz_ring,FALSE);
    1625     idDelete(&e);
    1626     rChangeCurrRing(orig_ring,TRUE);
    1627     rKill(syz_ring);
    1628   }
    1629   else
    1630   {
    1631     ee=e;
    1632     e=NULL;
    1633   }
    1634   pSetSyzComp(0);
    1635 
    1636   for (i=IDELEMS(ee);i!=0;i--)
    1637   {
    1638     if (ee->m[i-1]!=NULL)
    1639     {
    1640       p = ee->m[i-1];
    1641       while (p!=NULL)
    1642       {
    1643         j = pGetComp(p);
    1644         pSetComp(p,(*reord)[j]);
    1645         pSetmComp(p);
    1646         pIter(p);
    1647       }
    1648       ee->m[i-1] = pOrdPolyMerge(ee->m[i-1]);
    1649     }
    1650   }
    1651   idSkipZeroes(ee);
    1652   delete reord;
    1653 
    1654   return ee;
    16551498}
    16561499
  • Singular/ideals.h

    rd2b6cf rc1489f2  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: ideals.h,v 1.11 1998-11-12 14:44:36 siebert Exp $ */
     6/* $Id: ideals.h,v 1.12 1999-10-19 12:42:42 obachman Exp $ */
    77/*
    88* ABSTRACT - all basic methods to manipulate ideals
     
    8383ideal   idSyzygies (ideal h1,ideal quot, tHomog h,intvec **w,
    8484           BOOLEAN setRegularity, int &deg);
    85 ideal idSyzMin (ideal h1,ideal  quot, tHomog h,intvec **w,
    86            BOOLEAN setRegularity, int &deg);
    8785ideal   idLiftStd  (ideal h1, ideal quot, matrix *m, tHomog h=testHomog);
    8886
  • Singular/iparith.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: iparith.cc,v 1.179 1999-10-14 14:27:06 obachman Exp $ */
     4/* $Id: iparith.cc,v 1.180 1999-10-19 12:42:43 obachman Exp $ */
    55
    66/*
     
    180180  { "highcorner",  0, HIGHCORNER_CMD,     CMD_1},
    181181  { "homog",       0, HOMOG_CMD ,         CMD_12},
     182  { "hres",        0, HRES_CMD ,          CMD_2},
    182183  { "ideal",       0, IDEAL_CMD ,         IDEAL_CMD},
    183184  { "if",          0, IF_CMD ,            IF_CMD},
     
    18561857  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
    18571858  {
    1858     //if (BTEST1(28))
    1859     //{
    1860     //  r=syMinRes(u_id,maxl,&l, iiOp==MRES_CMD);
    1861     //}
    1862     //else
    1863     {
    1864       intvec * iv=(intvec*)atGet(u,"isHomog");
    1865       r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
    1866     }
     1859    intvec * iv=(intvec*)atGet(u,"isHomog");
     1860    r=syResolution(u_id,maxl, iv, iiOp==MRES_CMD);
    18671861  }
    18681862  else if (iiOp==SRES_CMD)
    18691863  //  r=sySchreyerResolvente(u_id,maxl+1,&l);
    18701864    r=sySchreyer(u_id,maxl+1);
    1871   else /* LRES */
     1865  else if (iiOp == LRES_CMD)
    18721866  {
    18731867    int dummy;
     
    18801874    }
    18811875    r=syLaScala3(u_id,&dummy);
     1876  }
     1877  else
     1878  {
     1879    int dummy;
     1880    if((currQuotient!=NULL)||
     1881    (!idHomIdeal (u_id,NULL)))
     1882    {
     1883       WerrorS
     1884       ("`hres` not implemented for inhomogeneous input or qring");
     1885       return TRUE;
     1886    }
     1887    r=syHilb(u_id,&dummy);
    18821888  }
    18831889  if (r==NULL) return TRUE;
     
    22282234,{jjHOMOG_ID,  HOMOG_CMD,      IDEAL_CMD,      IDEAL_CMD,  POLY_CMD PROFILER}
    22292235,{jjHOMOG_ID,  HOMOG_CMD,      MODUL_CMD,      MODUL_CMD,  POLY_CMD PROFILER}
     2236,{jjRES,       HRES_CMD,       RESOLUTION_CMD, IDEAL_CMD,  INT_CMD PROFILER}
    22302237,{jjCALL2MANY, IDEAL_CMD,      IDEAL_CMD,      DEF_CMD,    DEF_CMD PROFILER}
    22312238,{jjFETCH,     IMAP_CMD,       ANY_TYPE/*set by p*/,RING_CMD,  ANY_TYPE PROFILER}
     
    42114218  if ((iiOp == RES_CMD) || (iiOp == MRES_CMD))
    42124219  {
    4213     if (BTEST1(28))
    4214     {
    4215       r=syMinRes((ideal)u->Data(),maxl,&l,iiOp==MRES_CMD);
    4216     }
    4217     else
    4218     {
    4219       intvec * iv=(intvec*)atGet(u,"isHomog");
    4220       if (iv!=NULL)
    4221       {
    4222         weights = (intvec**)Alloc0SizeOf(void_ptr);
    4223         weights[0] = ivCopy(iv);
    4224         l=1;
    4225       }
    4226       r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
    4227     }
     4220    intvec * iv=(intvec*)atGet(u,"isHomog");
     4221    if (iv!=NULL)
     4222    {
     4223      weights = (intvec**)Alloc0SizeOf(void_ptr);
     4224      weights[0] = ivCopy(iv);
     4225      l=1;
     4226    }
     4227    r=syResolvente((ideal)u->Data(),maxl,&l, &weights, iiOp==MRES_CMD);
    42284228  }
    42294229  else
  • Singular/kstd2.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstd2.cc,v 1.36 1999-10-18 11:19:27 obachman Exp $ */
     4/* $Id: kstd2.cc,v 1.37 1999-10-19 12:42:44 obachman Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: alg. of Buchberger
     
    4040  return NULL;
    4141}
    42 
    43 /*2
    44 *  reduction procedure for the syz
    45 *  and TEST_OPT_MINRES: special minimizing during computations
    46 *  assumes homogeneous case and degree-ordering
    47 */
    48 #if 0
    49 static int redSyz (LObject* h,kStrategy strat)
    50 {
    51   int j = 0,i=0,pos;
    52   BOOLEAN exchanged=pDivisibleBy((*h).p2,(*h).p1);
    53   poly p,q;
    54   unsigned long not_sev;
    55 
    56   if (exchanged)
    57   {
    58     q = kFromInput((*h).p1,strat);
    59     if (q==NULL)
    60     {
    61       exchanged = FALSE;
    62     }
    63     else
    64     {
    65       while (i<=strat->Ll)
    66       {
    67         if ((strat->L[i].p1==strat->P.p1) || (strat->L[i].p2==strat->P.p1))
    68         {
    69           deleteInL(strat->L,&strat->Ll,i,strat);
    70         }
    71         else
    72           i++;
    73       }
    74       i = 0;
    75     }
    76   }
    77   if (TEST_OPT_DEBUG)
    78   {
    79     PrintS("red:");
    80     wrp(h->p);
    81   }
    82   loop
    83   {
    84     i = 0;
    85     j = strat->sl + 1;
    86     not_sev = ~ PGetShortExpVector(h->p);
    87     while (i <= strat->tl)
    88     {
    89       if (pShortDivisibleBy(strat->T[i], strat->T[i].sev, h->p, not_sev))
    90       {
    91         if ((!exchanged) && (pEqual((*h).p,strat->T[i].p)))
    92         {
    93           j = 0;
    94           while (j<=strat->sl)
    95           {
    96             if (strat->S[j] == strat->T[i].p) break;
    97           }
    98           if (j <= strat->sl) break;
    99         }
    100         else
    101         {
    102           break;
    103         }
    104       }
    105       i++;
    106     }
    107 
    108     if (i > strat->tl)
    109     {
    110       // nothing to reduce with
    111       if (exchanged)
    112       {
    113         assume(q!= NULL);
    114         if (pGetComp((*h).p) > strat->syzComp)
    115         {
    116           pDelete(&((*h).p));
    117           pDelete(&q);
    118           return;
    119         }
    120         else
    121         {
    122           if (!TEST_OPT_INTSTRATEGY)
    123           {
    124             pos = posInS(strat->S,strat->sl,(*h).p);
    125             pNorm((*h).p);
    126             (*h).p = redtailSyz((*h).p,pos-1,strat);
    127           }
    128           p = (*h).p;
    129           while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=strat->syzComp))
    130             pIter(p);
    131           pDelete(&pNext(p));
    132           pNext(p) = q;
    133           q = NULL;
    134         }
    135       }
    136       else if (!TEST_OPT_INTSTRATEGY)
    137       {
    138         pos = posInS(strat->S,strat->sl,(*h).p);
    139         pNorm((*h).p);
    140         (*h).p = redtailSyz((*h).p,pos-1,strat);
    141       }
    142       if (q != NULL) pDelete(&q);
    143       enterTBba((*h),strat->tl+1,strat);
    144       return;
    145     }
    146 
    147     // found one to reduce
    148     if (j <= strat->sl)
    149     {
    150       // might have found a better one ?
    151       q = kFromInput(strat->S[j],strat);
    152       if (q!=NULL)
    153       {
    154         exchanged = TRUE;
    155         p = strat->S[j];
    156         if (!TEST_OPT_INTSTRATEGY)
    157           pNorm((*h).p);
    158         else
    159         {
    160           //pContent((*h).p);
    161           pCleardenom((*h).p);// also does a pContent
    162         }
    163         strat->S[j] = (*h).p;
    164         (*h).p = p;
    165          strat->T[i].p = strat->S[j];
    166         for (i=0;i<=strat->Ll;i++)
    167         {
    168           if (strat->L[i].p1==p) strat->L[i].p1=strat->S[j];
    169           if (strat->L[i].p2==p) strat->L[i].p2=strat->S[j];
    170         }
    171       }
    172     }
    173 
    174     if (TEST_OPT_DEBUG)
    175     {
    176       PrintS(" with ");
    177       wrp(strat->T[i].p);
    178     }
    179     kbReducePoly(h, &(strat->T[i]), strat->kNoether);
    180     if (TEST_OPT_DEBUG)
    181     {
    182       PrintS("\nto "); wrp((*h).p);PrintLn();
    183     }
    184     if ((*h).p == NULL)
    185     {
    186       if (h->lcm!=NULL) pFree1((*h).lcm);
    187 #ifdef KDEBUG
    188       (*h).lcm=NULL;
    189 #endif
    190       if (q != NULL) pDelete(&q);
    191       return;
    192     }
    193   }
    194 }
    195 
    196 #else
    197 
    198 static int redSyz (LObject* h,kStrategy strat)
    199 {
    200   int j = 0,i=0,pos;
    201   BOOLEAN exchanged=pDivisibleBy((*h).p2,(*h).p1);
    202   poly p,q;
    203   unsigned long not_sev;
    204 
    205   if (exchanged)
    206   {
    207     q = kFromInput((*h).p1,strat);
    208     if (q==NULL)
    209     {
    210       exchanged = FALSE;
    211     }
    212     else
    213     {
    214       while (i<=strat->Ll)
    215       {
    216         if ((strat->L[i].p1==strat->P.p1) || (strat->L[i].p2==strat->P.p1))
    217         {
    218           deleteInL(strat->L,&strat->Ll,i,strat);
    219         }
    220         else
    221           i++;
    222       }
    223       i = 0;
    224     }
    225   }
    226   if (TEST_OPT_DEBUG)
    227   {
    228     PrintS("red:");
    229     wrp(h->p);
    230   }
    231   h->sev = pGetShortExpVector(h->p);
    232   not_sev = ~ h->sev;
    233   loop
    234   {
    235     if (pShortDivisibleBy(strat->S[j], strat->sevS[j], h->p, not_sev))
    236     {
    237       if ((!exchanged) && (pEqual((*h).p,strat->S[j])))
    238       {
    239         q = kFromInput(strat->S[j],strat);
    240         if (q!=NULL)
    241         {
    242           exchanged = TRUE;
    243           p = strat->S[j];
    244           if (!TEST_OPT_INTSTRATEGY)
    245             pNorm((*h).p);
    246           else
    247           {
    248             //pContent((*h).p);
    249             pCleardenom((*h).p);// also does a pContent
    250           }
    251           strat->S[j] = (*h).p;
    252           strat->sevS[j] = ~ not_sev;
    253           (*h).p = p;
    254           h->sev = strat->sevS[j];
    255           while ((i<=strat->tl) && (strat->T[i].p!=p)) i++;
    256           if (i<=strat->tl) strat->T[i].SetP(strat->S[j]);
    257           for (i=0;i<=strat->Ll;i++)
    258           {
    259             if (strat->L[i].p1==p) strat->L[i].p1=strat->S[j];
    260             if (strat->L[i].p2==p) strat->L[i].p2=strat->S[j];
    261           }
    262         }
    263       }
    264       //if (strat->interpt) test_int_std(strat->kIdeal);
    265       /*- compute the s-polynomial -*/
    266       if (TEST_OPT_DEBUG)
    267       {
    268         PrintS(" with ");
    269         wrp(strat->S[j]);
    270       }
    271       (*h).p = ksOldSpolyRed(strat->S[j],(*h).p,strat->kNoether);
    272       if (TEST_OPT_DEBUG)
    273       {
    274         PrintS("\nto "); wrp((*h).p);PrintLn();
    275       }
    276       if ((*h).p == NULL)
    277       {
    278         if (h->lcm!=NULL) pFree1((*h).lcm);
    279 #ifdef KDEBUG
    280         (*h).lcm=NULL;
    281 #endif
    282         return 0;
    283       }
    284 /*- try to reduce the s-polynomial -*/
    285       j = 0;
    286       h->sev = pGetShortExpVector(h->p);
    287       not_sev = ~ h->sev;
    288     }
    289     else
    290     {
    291       if (j >= strat->sl)
    292       {
    293         if (exchanged)
    294         {
    295           if (pGetComp((*h).p) > strat->syzComp)
    296           {
    297             pDelete(&((*h).p));
    298             return 0;
    299           }
    300           else
    301           {
    302             if (!TEST_OPT_INTSTRATEGY)
    303             {
    304               pos = posInS(strat->S,strat->sl,(*h).p);
    305               pNorm((*h).p);
    306               (*h).p = redtailSyz((*h).p,pos-1,strat);
    307             }
    308             p = (*h).p;
    309             while ((pNext(p)!=NULL) && (pGetComp(pNext(p))<=strat->syzComp))
    310                pIter(p);
    311             pDelete(&pNext(p));
    312             pNext(p) = q;
    313           }
    314         }
    315         else if (!TEST_OPT_INTSTRATEGY)
    316         {
    317           pos = posInS(strat->S,strat->sl,(*h).p);
    318           pNorm((*h).p);
    319           (*h).p = redtailSyz((*h).p,pos-1,strat);
    320         }
    321         enterTBba((*h),strat->tl+1,strat);
    322         return 1;
    323       }
    324       j++;
    325     }
    326   }
    327 }
    328 
    329 #endif
    33042
    33143/*2
     
    805517  else
    806518    strat->red = redHomog;
    807   if (TEST_OPT_MINRES && strat->homog && (strat->syzComp >0))
    808   {
    809     strat->red = redSyz;
    810     strat->posInT = posInT0;
    811   }
    812 
    813519  if (pLexOrder && strat->honey)
    814520    strat->initEcart = initEcartNormal;
     
    926632        {
    927633          pCleardenom(strat->P.p);
    928           if ((!TEST_OPT_MINRES)||(strat->syzComp==0)||(!strat->homog))
    929           {
    930             strat->P.p = redtailBba(strat->P.p,pos-1,strat);
    931             pCleardenom(strat->P.p);
    932           }
     634          strat->P.p = redtailBba(strat->P.p,pos-1,strat);
     635          pCleardenom(strat->P.p);
    933636        }
    934637        else
    935638        {
    936639          pNorm(strat->P.p);
    937           if ((!TEST_OPT_MINRES)||(strat->syzComp==0)||(!strat->homog))
    938           {
    939             strat->P.p = redtailBba(strat->P.p,pos-1,strat);
    940           }
     640          strat->P.p = redtailBba(strat->P.p,pos-1,strat);
    941641        }
    942642
     
    962662                  strat);
    963663        enterpairs(strat->P.p,strat->sl,strat->P.ecart,pos,strat);
    964         // do we really need to recompute posInS
    965         strat->enterS(strat->P,posInS(strat->S,strat->sl,strat->P.p), strat);
     664        // posInS only depends only onthe leading term
     665        strat->enterS(strat->P, pos, strat);
    966666        if (hilb!=NULL) khCheck(Q,w,hilb,hilbeledeg,hilbcount,strat);
    967667      }
  • Singular/kstdfac.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kstdfac.cc,v 1.26 1999-10-18 11:19:27 obachman Exp $ */
     4/* $Id: kstdfac.cc,v 1.27 1999-10-19 12:42:45 obachman Exp $ */
    55/*
    66*  ABSTRACT -  Kernel: factorizing alg. of Buchberger
     
    288288      if (TEST_OPT_INTSTRATEGY)
    289289      {
    290         if (!TEST_OPT_MINRES||(n->syzComp==0)||(!n->homog))
    291         {
    292           n->P.p = redtailBba(n->P.p,pos-1,n);
    293           pCleardenom(n->P.p);
    294         }
     290        n->P.p = redtailBba(n->P.p,pos-1,n);
     291        pCleardenom(n->P.p);
    295292      }
    296293      else
    297294      {
    298295        pNorm(n->P.p);
    299         if (!TEST_OPT_MINRES||(n->syzComp==0)||(!n->homog))
    300         {
    301           n->P.p = redtailBba(n->P.p,pos-1,n);
    302         }
     296        n->P.p = redtailBba(n->P.p,pos-1,n);
    303297      }
    304298      if (TEST_OPT_DEBUG)
     
    498492        if (TEST_OPT_INTSTRATEGY)
    499493        {
    500           if (!TEST_OPT_MINRES||(strat->syzComp==0)||(!strat->homog))
    501           {
    502             strat->P.p = redtailBba(strat->P.p,strat->sl,strat);
    503             if (strat->redTailChange) pCleardenom(strat->P.p);
    504           }
     494          strat->P.p = redtailBba(strat->P.p,strat->sl,strat);
     495          if (strat->redTailChange) pCleardenom(strat->P.p);
    505496        }
    506497        else
    507498        {
    508499          pNorm(strat->P.p);
    509           if (!TEST_OPT_MINRES||(strat->syzComp==0)||(!strat->homog))
    510           {
    511             strat->P.p = redtailBba(strat->P.p,strat->sl,strat);
    512           }
     500          strat->P.p = redtailBba(strat->P.p,strat->sl,strat);
    513501        }
    514502        if (strat->redTailChange)
     
    534522      if (strat->P.lcm!=NULL) pFree1(strat->P.lcm);
    535523      int i;
    536 //      for(i=0;i<IDELEMS(fac);i++)
    537 //      {
    538 //        int pos;
    539 //        if (strat->sl==-1) pos=0;
    540 //        else pos=posInS(strat->S,strat->sl,fac->m[i]);
    541 //        if (TEST_OPT_INTSTRATEGY)
    542 //        {
    543 //          if (!TEST_OPT_MINRES||(strat->syzComp==0)||(!strat->homog))
    544 //          {
    545 //            fac->m[i] = redtailBba(fac->m[i],pos-1,strat);
    546 //            pCleardenom(fac->m[i]);
    547 //          }
    548 //        }
    549 //        else
    550 //        {
    551 //          pNorm(fac->m[i]);
    552 //          if (!TEST_OPT_MINRES||(strat->syzComp==0)||(!strat->homog))
    553 //          {
    554 //            fac->m[i] = redtailBba(fac->m[i],pos-1,strat);
    555 //          }
    556 //        }
    557 //      }
    558524
    559525      for(i=IDELEMS(fac)-1;i>=0;i--)
     
    579545        if (TEST_OPT_INTSTRATEGY)
    580546        {
    581           if (!TEST_OPT_MINRES||(n->syzComp==0)||(!n->homog))
    582           {
    583             n->P.p = redtailBba(n->P.p,pos-1,n);
    584             if (n->redTailChange) pCleardenom(n->P.p);
    585           }
     547          n->P.p = redtailBba(n->P.p,pos-1,n);
     548          if (n->redTailChange) pCleardenom(n->P.p);
    586549        }
    587550        else
    588551        {
    589552          pNorm(n->P.p);
    590           if (!TEST_OPT_MINRES||(n->syzComp==0)||(!n->homog))
    591           {
    592             n->P.p = redtailBba(n->P.p,pos-1,n);
    593           }
     553          n->P.p = redtailBba(n->P.p,pos-1,n);
    594554        }
    595555
  • Singular/kutil.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: kutil.cc,v 1.42 1999-10-18 16:05:24 obachman Exp $ */
     4/* $Id: kutil.cc,v 1.43 1999-10-19 12:42:45 obachman Exp $ */
    55/*
    66* ABSTRACT: kernel: utils for kStd
     
    12711271*set[0] is the smallest with respect to the ordering-procedure
    12721272*pComp
     1273* Assumption: posInS only depends on the leading term
     1274*             otherwise, bba has to be changed
    12731275*/
    12741276int posInS (polyset set,int length,poly p)
  • Singular/misc.cc

    rd2b6cf rc1489f2  
    266266  {"redTail",      Sy_bit(OPT_REDTAIL),        ~Sy_bit(OPT_REDTAIL)  },
    267267  {"intStrategy",  Sy_bit(OPT_INTSTRATEGY),    ~Sy_bit(OPT_INTSTRATEGY)  },
    268   /* 27 stop at HC (finiteDeterminacyTest) */
    269   {"minRes",       Sy_bit(OPT_MINRES),         ~Sy_bit(OPT_MINRES)  },
    270268  /* 30: use not regularity for syz */
    271269  {"notRegularity",Sy_bit(OPT_NOTREGULARITY),  ~Sy_bit(OPT_NOTREGULARITY)  },
  • Singular/polys-comp.h

    rd2b6cf rc1489f2  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: polys-comp.h,v 1.14 1999-10-01 19:34:20 obachman Exp $ */
     6/* $Id: polys-comp.h,v 1.15 1999-10-19 12:42:46 obachman Exp $ */
    77
    88/***************************************************************
     
    8989#endif // WORDS_BIGENDIAN
    9090
     91inline int rComp0(poly p1, poly p2)
     92{
     93  _pMonCmp(p1, p2, return 0, return 1, return -1);
     94}
     95
    9196#endif // POLYS_COMP_H
    9297
  • Singular/polys-impl.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys-impl.cc,v 1.29 1999-10-19 12:04:29 Singular Exp $ */
     4/* $Id: polys-impl.cc,v 1.30 1999-10-19 12:42:47 obachman Exp $ */
    55
    66/***************************************************************
     
    11021102      return FALSE;
    11031103    }
     1104    if (p != NULL)
     1105    {
     1106      if (pGetComp(old) == pGetComp(p))
     1107      {
     1108        i = pVariables;
     1109        for (i=pVariables;i; i--)
     1110        {
     1111          if (pGetExp(old, i) != pGetExp(p, i)) break;
     1112        }
     1113        if (i == 0)
     1114        {
     1115          Warn("different Compare, but same exponent vector for");
     1116          wrp(old);
     1117          Print(" in %s%d\n", f, l);
     1118          return FALSE;
     1119        }
     1120      }
     1121    }
    11041122  }
    11051123  return TRUE;
  • Singular/polys.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: polys.cc,v 1.49 1999-10-19 09:50:41 Singular Exp $ */
     4/* $Id: polys.cc,v 1.50 1999-10-19 12:42:47 obachman Exp $ */
    55
    66/*
     
    141141        {
    142142          int c=pGetComp(p);
    143           if (c > o->data.syz.limit)
     143          if (c > o->data.syz.limit)
    144144            p->exp.l[o->data.syz.place]= 1;
    145           else
     145          else
    146146            p->exp.l[o->data.syz.place]= 0;
    147147          break;
     
    253253
    254254
    255 int rComp0(poly p1, poly p2)
    256 {
    257   _pMonCmp(p1, p2, return 0, return 1, return -1);
    258 }
    259 
    260255/*----------pComp handling for syzygies---------------------*/
    261256static void newHeadsB(polyset actHeads,int length)
  • Singular/ring.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ring.cc,v 1.75 1999-10-19 12:04:29 Singular Exp $ */
     4/* $Id: ring.cc,v 1.76 1999-10-19 12:42:48 obachman Exp $ */
    55
    66/*
     
    778778      }
    779779    }
    780 #ifndeg NDEBUG
     780#ifndef NDEBUG
    781781    else if (r->order[l] == ringorder_s)
    782782    {
  • Singular/syz.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz.cc,v 1.25 1999-10-14 17:59:35 Singular Exp $ */
     4/* $Id: syz.cc,v 1.26 1999-10-19 12:42:48 obachman Exp $ */
    55
    66/*
     
    574574}
    575575
    576 
    577 resolvente syMinRes(ideal arg, int maxlength, int * length, BOOLEAN minim)
    578 {
    579   resolvente res;
    580   resolvente newres;
    581   tHomog hom;
    582   ideal temp=NULL;
    583   intvec *w,*w1=NULL;
    584   int i,k,syzIndex = 0,j;
    585   int Kstd1_OldDeg=Kstd1_deg;
    586   BOOLEAN isIdeal=FALSE,oldDegBound=TEST_OPT_DEGBOUND;
    587 
    588   if (maxlength!=-1) *length = maxlength+1;
    589   else              *length = 4;
    590   res = (resolvente)Alloc0((*length)*sizeof(ideal));
    591   res[0] = idCopy(arg);
    592   hom=(tHomog)idHomModule(res[0],currQuotient,&w);
    593 //Print("die %d Modulegewichte sind:\n",w->length());
    594 //w->show();
    595 //PrintLn();
    596   if (hom==isHomog)
    597   {
    598     //if (w!=NULL)
    599     //{
    600     //  w->show();
    601     //  PrintLn();
    602     //  if (res[0]!=NULL) jjPRINT_MA0(idModule2Matrix(idCopy(res[0])),NULL);
    603     //}
    604     int maxxx = 0;
    605     if (w!=NULL) maxxx = w->length();
    606     if (maxxx==1)
    607     {
    608       maxxx = 2;
    609       isIdeal = TRUE;
    610     }
    611     w1 = new intvec(maxxx+IDELEMS(arg));
    612     if (!isIdeal)
    613     {
    614       for (i=0;i<maxxx;i++)
    615       {
    616         (*w1)[i] = (*w)[i];
    617       }
    618     }
    619     for (i=maxxx;i<maxxx+IDELEMS(arg);i++)
    620     {
    621       if (res[0]->m[i-maxxx]!=0)
    622         (*w1)[i] = pFDeg(res[0]->m[i-maxxx])+(*w)[pGetComp(res[0]->m[i-maxxx])];
    623     }
    624     if (w!=NULL) {delete w;w=NULL;}
    625   }
    626   while ((!idIs0(res[syzIndex]))
    627   && ((maxlength==-1)
    628     || (syzIndex<maxlength)))
    629    // (syzIndex<maxlength+(int)minim)))
    630   /*compute one step more for minimizing*/
    631   {
    632     if (Kstd1_deg!=0) Kstd1_deg++;
    633     if (syzIndex+1==*length)
    634     {
    635       newres = (resolvente)Alloc0((*length+4)*sizeof(ideal));
    636       for (j=0;j<*length;j++) newres[j] = res[j];
    637       Free((ADDRESS)res,*length*sizeof(ideal));
    638       *length += 4;
    639       res=newres;
    640     }
    641     if (minim || (syzIndex!=0))
    642     {
    643       temp = kInterRed(res[syzIndex],currQuotient);
    644       idDelete(&res[syzIndex]);
    645       res[syzIndex] = temp;
    646     }
    647     temp = NULL;
    648     if ((hom==isHomog) && (currRing->OrdSgn==1))
    649     {
    650 //PrintS("Input: ");
    651 //for (i=0;i<IDELEMS(res[syzIndex]);i++)
    652 //{
    653 //Print("Element %d: ",i);pWrite(res[syzIndex]->m[i]);
    654 //}
    655       if ((currQuotient==NULL)&&(syzIndex==0)&& (!TEST_OPT_DEGBOUND))
    656       {
    657         res[/*syzIndex+*/1] = idSyzMin(res[0/*syzIndex*/],
    658           NULL/*currQuotient*/,hom,&w1,TRUE,Kstd1_deg);
    659         if ((!TEST_OPT_NOTREGULARITY) && (Kstd1_deg>0)) test |= Sy_bit(OPT_DEGBOUND);
    660 //Print("Regularity is %d \n",Kstd1_deg);
    661       }
    662       else
    663         res[syzIndex+1] = idSyzMin(res[syzIndex],
    664           currQuotient,hom,&w1,FALSE,Kstd1_deg);
    665 //PrintS("Input: ");
    666 //for (i=0;i<IDELEMS(res[syzIndex+1]);i++)
    667 //{
    668 //Print("Element %d: ",i);pWrite(res[syzIndex+1]->m[i]);
    669 //}
    670     }
    671     else
    672       res[syzIndex+1] = idSyzygies(res[syzIndex],currQuotient,hom,&w1);
    673 //Print("im %d-ten Syzygienmodul: \n",syzIndex+1);
    674 //for (i=0;i<IDELEMS(res[syzIndex+1]);i++)
    675 //{
    676 //Print("El %d: ",i);pWrite(res[syzIndex+1]->m[i]);
    677 //}
    678     syzIndex++;
    679     if ((maxlength!=-1) && (syzIndex==maxlength)) idDelete(&res[syzIndex]);
    680     if (TEST_OPT_PROT) Print("[%d]\n",syzIndex);
    681     if  ((hom==isHomog) && (res[syzIndex]!=NULL))
    682     {
    683 //Print("die %d Modulegewichte sind:\n",w1->length());
    684 //w1->show();
    685 //PrintLn();
    686       k = idRankFreeModule(res[syzIndex]);
    687       w = new intvec(k+IDELEMS(res[syzIndex])+1);
    688       for (i=1;i<=k;i++)
    689       {
    690         (*w)[i] = pFDeg(res[syzIndex-1]->m[i-1])
    691                   +(*w1)[pGetComp(res[syzIndex-1]->m[i-1])];
    692       }
    693       for (i=k+1;i<k+1+IDELEMS(res[syzIndex]);i++)
    694       {
    695         if (res[syzIndex]->m[i-k-1]!=NULL)
    696           (*w)[i] = pFDeg(res[syzIndex]->m[i-k-1])
    697                     +(*w)[pGetComp(res[syzIndex]->m[i-k-1])];
    698       }
    699       delete w1;
    700       w1 = w;
    701       w = NULL;
    702     }
    703   }
    704   if (w1!=NULL) delete w1;
    705   if (maxlength!=-1)
    706   {
    707     if ((syzIndex<maxlength-1) && (res[syzIndex]!=NULL)) syzIndex++;
    708     while (syzIndex<maxlength)
    709     {
    710       res[syzIndex]=idInit(1,1);
    711       syzIndex++;
    712     }
    713   }
    714   Kstd1_deg=Kstd1_OldDeg;
    715   if (!oldDegBound)
    716     test &= ~Sy_bit(OPT_DEGBOUND);
    717   return res;
    718 }
    719 
    720576int syDetect(ideal id,int index,BOOLEAN homog,int * degrees,int * tocancel)
    721577{
  • Singular/syz.h

    rd2b6cf rc1489f2  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: syz.h,v 1.19 1999-10-14 14:27:34 obachman Exp $ */
     6/* $Id: syz.h,v 1.20 1999-10-19 12:42:49 obachman Exp $ */
    77/*
    88* ABSTRACT: Resolutions
     
    1313#endif
    1414
     15// Logarithm of estimate of maximal number of new components
     16#define SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE 8
     17// Logarithm of "distance" between a new component and prev component
     18#define SYZ_SHIFT_BASE_LOG (BIT_SIZEOF_LONG - 1 - SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE)
     19#define SYZ_SHIFT_BASE (1 << SYZ_SHIFT_BASE_LOG)
    1520struct sSObject{
    1621                 poly  p;
     
    4752  intvec * resolution;
    4853  intvec * cw;
     54  intvec * betti;
    4955  short list_length;
    5056  short references;
     
    7278
    7379syStrategy syResolution(ideal arg, int maxlength,intvec * w, BOOLEAN minim);
    74 
    75 resolvente syMinRes(ideal arg, int maxlength, int * length, BOOLEAN minim);
    7680
    7781void syMinimizeResolvente(resolvente res, int length, int first);
     
    106110syStrategy syMinimize(syStrategy syzstr);
    107111void syKillEmptyEntres(resolvente res,int length);
     112#ifdef PDEBUG
     113int syzcomp2dpc(poly p1, poly p2);
     114#else
     115#define syzcomp2dpc rComp0
     116#endif
    108117
    109118extern int *  currcomponents;
    110119extern long *  currShiftedComponents;
    111120
     121int syzcomp1dpc(poly p1, poly p2);
     122void syDeletePair(SObject * so);
     123void syInitializePair(SObject * so);
     124void syCopyPair(SObject * argso, SObject * imso);
     125void syCompactifyPairSet(SSet sPairs, int sPlength, int first);
     126void syCompactify1(SSet sPairs, int* sPlength, int first);
     127SRes syInitRes(ideal arg,int * length, intvec * Tl, intvec * cw=NULL);
     128void syResetShiftedComponents(syStrategy syzstr, int index,int hilb=0);
     129void syEnlargeFields(syStrategy syzstr,int index);
     130void syEnterPair(syStrategy syzstr, SObject * so, int * sPlength,int index);
     131SSet syChosePairs(syStrategy syzstr, int *index, int *howmuch, int * actdeg);
     132int syInitSyzMod(syStrategy syzstr, int index, int init=17);
     133long syReorderShiftedComponents(long * sc, int n);
     134
    112135#endif
  • Singular/syz1.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz1.cc,v 1.42 1999-10-14 14:27:34 obachman Exp $ */
     4/* $Id: syz1.cc,v 1.43 1999-10-19 12:42:49 obachman Exp $ */
    55/*
    66* ABSTRACT: resolutions
     
    2929#include "syz.h"
    3030#include "kbuckets.h"
     31#include "polys-comp.h"
    3132#include <limits.h>
    3233
     
    3839long *  currShiftedComponents=NULL;
    3940
    40 // Logarithm of estimate of maximal number of new components
    41 #define SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE 8
    42 // Logarithm of "distance" between a new component and prev component
    43 #define SYZ_SHIFT_BASE_LOG (BIT_SIZEOF_LONG - 1 - SYZ_SHIFT_MAX_NEW_COMP_ESTIMATE)
    44 #define SYZ_SHIFT_BASE (1 << SYZ_SHIFT_BASE_LOG)
    45 
    4641
    4742/*---head-term-polynomials for the reduction------------*/
     
    4944/*---counts number of applications of GM-criteria-------*/
    5045//static int crit;
    51 //static int zeroRed;
    52 //static int dsim;
    53 //static int simple;
    54 static int euler;
    55 /*---controls the ordering------------------------------*/
    56 static intvec * orderedcomp;
    57 static int *binomials;
    58 static int highdeg;
    59 static int highdeg_1;
    60 
    61 // uncomment to play around with new spolys for syzygies
    62 // #include "syzvector.cc"
     46//static int euler;
    6347
    6448/*3
    6549* deletes all entres of a pair
    6650*/
    67 static void syDeletePair(SObject * so)
     51void syDeletePair(SObject * so)
    6852{
    6953  pDelete(&(*so).p);
     
    7862  (*so).isNotMinimal = NULL;
    7963  (*so).length = -1;
     64  (*so).reference = -1;
    8065}
    8166
     
    8368* initializes all entres of a pair
    8469*/
    85 static void syInitializePair(SObject * so)
     70void syInitializePair(SObject * so)
    8671{
    8772  (*so).p = NULL;
     
    9681  (*so).isNotMinimal = NULL;
    9782  (*so).length = -1;
     83  (*so).reference = -1;
    9884}
    9985
     
    10187* puts all entres of a pair to another
    10288*/
    103 static void syCopyPair(SObject * argso, SObject * imso)
     89void syCopyPair(SObject * argso, SObject * imso)
    10490{
    10591  *imso=*argso;
     
    115101  (*argso).isNotMinimal = NULL;
    116102  (*argso).length = -1;
     103  (*argso).reference = -1;
    117104}
    118105
     
    122109* assumes a pair to be empty if .lcm does so
    123110*/
    124 static void syCompactifyPairSet(SSet sPairs, int sPlength, int first)
     111void syCompactifyPairSet(SSet sPairs, int sPlength, int first)
    125112{
    126113  int k=first,kk=0;
     
    150137* assumes a pair to be empty if .lcm does so
    151138*/
    152 static void syCompactify1(SSet sPairs, int* sPlength, int first)
     139void syCompactify1(SSet sPairs, int* sPlength, int first)
    153140{
    154141  int k=first,kk=0;
     
    174161}
    175162
     163static pCompProc syOldComp1;
    176164/*3
    177165* replaces comp1dpc during homogeneous syzygy-computations
     
    208196* exp[0]
    209197*/
    210 static int syzcomp1dpc(poly p1, poly p2)
     198int syzcomp1dpc(poly p1, poly p2)
    211199{
    212200  int i = pVariables;
     
    232220*/
    233221
    234 extern int rComp0(poly p1, poly p2);
    235 #ifdef NDEBUG
    236 #define syzcomp2dpc rComp0
    237 #else
     222#ifdef PDEBUG
    238223static int syzcomp2dpc_test(poly p1, poly p2)
    239224{
     
    294279  return -1;
    295280}
    296 static int syzcomp2dpc(poly p1, poly p2)
     281int syzcomp2dpc(poly p1, poly p2)
    297282{
    298283  int test = syzcomp2dpc_test(p1, p2);
     
    306291  return test;
    307292}
    308 #endif // NDEBUG
     293#endif // PDEBUG
    309294
    310295/*3
     
    419404* assumes that the basering is degree-compatible
    420405*/
    421 static SRes syInitRes(ideal arg,int * length, intvec * Tl, intvec * cw=NULL)
     406SRes syInitRes(ideal arg,int * length, intvec * Tl, intvec * cw)
    422407{
    423408  if (idIs0(arg)) return NULL;
     
    460445
    461446// rearrange shifted components
    462 static long syReorderShiftedComponents(long * sc, int n)
     447long syReorderShiftedComponents(long * sc, int n)
    463448{
    464449  long holes = 0;
     
    538523}
    539524
    540 static void syResetShiftedComponents(syStrategy syzstr, int index)
     525void syResetShiftedComponents(syStrategy syzstr, int index,int hilb)
    541526{
    542527  assume(index > 0);
     
    553538                  currShiftedComponents,
    554539                  IDELEMS(syzstr->res[index-1]));
    555     ideal id = syzstr->res[index];
    556     for (i=0; i<IDELEMS(id); i++)
    557     {
    558       pResetSetm(id->m[i]);
     540    if (hilb==0)
     541    {
     542      ideal id = syzstr->res[index];
     543      for (i=0; i<IDELEMS(id); i++)
     544      {
     545        pResetSetm(id->m[i]);
     546      }
     547    }
     548    else if (hilb==1)
     549    {
     550      assume (index>1);
     551      assume (syzstr->resPairs[index-1]!=NULL);
     552      SSet Pairs=syzstr->resPairs[index-1];
     553      SSet Pairs1=syzstr->resPairs[index];
     554      int till=(*syzstr->Tl)[index-1];
     555      for (i=0;i<till;i++)
     556      {
     557        if (Pairs[i].syz!=NULL)
     558          pResetSetm(Pairs[i].syz);
     559      }
     560      till=(*syzstr->Tl)[index];
     561      for (i=0;i<till;i++)
     562      {
     563        if (Pairs1[i].p!=NULL)
     564          pResetSetm(Pairs1[i].p);
     565      }
    559566    }
    560567    currcomponents  = prev_c;
     
    843850#endif
    844851
    845 static void syEnlargeFields(syStrategy syzstr,int index)
     852void syEnlargeFields(syStrategy syzstr,int index)
    846853{
    847854  pEnlargeSet(&(syzstr->res[index]->m),IDELEMS(syzstr->res[index]),16);
     
    912919      pGetCoeff(p) = nNeg(pGetCoeff(p));
    913920      pSetComp(p,tso.ind2+1);
    914       rSetmS(p, Components, ShiftedComponents); // actuelleler index
     921      rSetmS(p, Components, ShiftedComponents); // actueller index
    915922      pNext(p) = pHead(tso.lcm);
    916923      pIter(p);
    917924      pSetComp(p,tso.ind1+1);
    918       rSetmS(p, Components, ShiftedComponents); // actuaeller index
     925      rSetmS(p, Components, ShiftedComponents); // actueller index
    919926      pSetCoeff(p,nDiv(pGetCoeff(tso.p2),coefgcd));
    920927      nDelete(&coefgcd);
     
    11411148  (*sPlength)++;
    11421149}
    1143 static void syEnterPair(syStrategy syzstr, SObject * so, int * sPlength,int index)
     1150void syEnterPair(syStrategy syzstr, SObject * so, int * sPlength,int index)
    11441151{
    11451152  int ll;
     
    11611168      temp[ll].isNotMinimal = (syzstr->resPairs[index])[ll].isNotMinimal;
    11621169      temp[ll].length = (syzstr->resPairs[index])[ll].length;
     1170      temp[ll].reference = (syzstr->resPairs[index])[ll].reference;
    11631171    }
    11641172    Free((ADDRESS)syzstr->resPairs[index],(*syzstr->Tl)[index]*sizeof(SObject));
     
    13931401* works with slanted degree (i.e. deg=realdeg-index)
    13941402*/
    1395 static SSet syChosePairs(syStrategy syzstr, int *index,
    1396                int *howmuch, int * actdeg)
     1403SSet syChosePairs(syStrategy syzstr, int *index, int *howmuch, int * actdeg)
    13971404{
    13981405  return syChosePairsPutIn(syzsts,index,howmuch,actdeg,0,syzstr->length);
     
    15601567* initialize a module
    15611568*/
    1562 static int syInitSyzMod(syStrategy syzstr, int index, int init=17)
     1569int syInitSyzMod(syStrategy syzstr, int index, int init)
    15631570{
    15641571  int result;
     
    17111718    if (syzstr->cw!=NULL)
    17121719      delete syzstr->cw;
     1720    if (syzstr->betti!=NULL)
     1721      delete syzstr->betti;
    17131722    if (syzstr->resolution!=NULL)
    17141723      delete syzstr->resolution;
     
    17291738{
    17301739  int dummy;
     1740  if (syzstr->betti!=NULL)
     1741  {
     1742    return ivCopy(syzstr->betti);
     1743  }
     1744  intvec *result;
    17311745  if (syzstr->resPairs!=NULL)
    17321746  {
     
    17581772    j = j+sh;
    17591773    jj = jj+2;
    1760     intvec *result=new intvec(j,jj-sh,0);
     1774    result=new intvec(j,jj-sh,0);
    17611775    IMATELEM(*result,1,1) = max(1,idRankFreeModule(syzstr->res[1]));
    17621776    for (i=sh;i<jj;i++)
     
    17711785      }
    17721786    }
    1773     return result;
     1787    syzstr->betti = result;
    17741788  }
    17751789  else if (syzstr->fullres!=NULL)
    1776     return syBetti(syzstr->fullres,syzstr->length,&dummy,NULL,minim);
     1790    syzstr->betti = syBetti(syzstr->fullres,syzstr->length,&dummy,NULL,minim);
    17771791  else
    1778     return syBetti(syzstr->minres,syzstr->length,&dummy,NULL,minim);
     1792    syzstr->betti = syBetti(syzstr->minres,syzstr->length,&dummy,NULL,minim);
     1793  return ivCopy(syzstr->betti);
    17791794}
    17801795
     
    25592574  }
    25602575/*--- changes to the original ring------------------*/
     2576  kBucketDestroy(&syzstr->bucket);
    25612577  if (syzstr->syRing != NULL)
    25622578  {
     
    25722588  tres = syReorder(tres,syzstr->length,syzstr,FALSE,syzstr->res);
    25732589  syKillEmptyEntres(tres,syzstr->length);
    2574   kBucketDestroy(&syzstr->bucket);
    25752590  idSkipZeroes(tres[0]);
    25762591  return tres;
     
    25932608      {
    25942609        syzstr->minres = syReorder(syzstr->orderedRes,syzstr->length,syzstr);
    2595         syKillEmptyEntres(syzstr->minres,syzstr->length);
    25962610      }
    25972611    }
     
    27622776}
    27632777
    2764 #define HAVE_HILB_SYZ
    2765 #ifdef HAVE_HILB_SYZ
    2766 #include "syz2.cc"
    2767 #endif
  • Singular/syz2.cc

    rd2b6cf rc1489f2  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz2.cc,v 1.2 1999-09-29 10:59:42 obachman Exp $ */
     4/* $Id: syz2.cc,v 1.3 1999-10-19 12:42:50 obachman Exp $ */
    55/*
    66* ABSTRACT: resolutions
    77*/
    8 
     8#include <limits.h>
     9
     10#include "mod2.h"
     11#include "tok.h"
     12#include "mmemory.h"
     13#include "syz.h"
     14#include "polys.h"
     15#include "febase.h"
     16#include "kstd1.h"
     17#include "kutil.h"
     18#include "stairc.h"
     19#include "ipid.h"
     20#include "cntrlc.h"
     21#include "ipid.h"
     22#include "intvec.h"
     23#include "ipshell.h"
     24#include "limits.h"
     25#include "numbers.h"
     26#include "modulop.h"
     27#include "ideals.h"
     28#include "intvec.h"
     29#include "ring.h"
     30#include "lists.h"
     31#include "kbuckets.h"
     32#include "polys-comp.h"
    933
    1034//#define SHOW_PROT
     
    2145#define USE_HEURISTIC2
    2246
     47extern void rSetmS(poly p, int* Components, long* ShiftedComponents);
    2348#ifdef SHOW_CRIT
    2449static int crit;
    2550static int crit1;
    2651static int spfl;
     52static int cons_pairs;
     53static int crit_fails;
    2754#endif
    2855typedef struct sopen_pairs open_pairs;
     
    5178#endif
    5279  actdeg += index;
     80  long * ShiftedComponents = syzstr->ShiftedComponents[index-1];
     81  int* Components = syzstr->truecomponents[index-1];
    5382
    5483  while ((l>0) && ((syzstr->resPairs[index])[l-1].lcm==NULL)) l--;
    5584  rr = l-1;
    56   while ((rr>=0) && (((syzstr->resPairs[index])[rr].p==NULL) ||
     85  while ((rr>=0) && (((syzstr->resPairs[index])[rr].p==NULL) || 
    5786        ((syzstr->resPairs[index])[rr].order>actdeg))) rr--;
    58   r2 = rr+1;
     87  r2 = rr+1; 
    5988  while ((rr>=0) && ((syzstr->resPairs[index])[rr].order==actdeg)
    6089         && ((syzstr->resPairs[index])[rr].syzind<0))
     
    79108    {
    80109      int tc=pGetComp(toHandle);
    81       tsyz = pCopy((syzstr->resPairs[index])[r1].syz);
    82110      (syzstr->resPairs[index])[r1].syzind = 0;
    83111      for (i=0; i<r1;i++)
     
    90118          if (tcp!=NULL)
    91119          {
    92             while ((tcp!=NULL) &&
     120            while ((tcp!=NULL) && 
    93121              ((tcp->first_poly!=i)||(tcp->second_poly!=r1))) tcp = tcp->next;
    94122          }
     
    98126            p = pOne();
    99127            pLcm((syzstr->resPairs[index])[i].p,toHandle,p);
    100             //pSetComp(p,pGetComp(tsyz));
    101             pSetm(p);
     128            rSetmS(p,Components, ShiftedComponents);
    102129            j = 0;
    103130            while (j<i)
    104             {
     131            { 
    105132              if (nP->m[j]!=NULL)
    106133              {
     
    143170                      while ((ti<l) && (((syzstr->resPairs[index])[ti].ind1!=j)||
    144171                             ((syzstr->resPairs[index])[ti].ind2!=i))) ti++;
    145                       if (ti<l)
     172                      if (ti<l) 
    146173                      {
    147174#ifdef SHOW_SPRFL
     
    205232          tso.length = -1;
    206233          currcomponents = syzstr->truecomponents[index];
     234          currShiftedComponents = syzstr->ShiftedComponents[index];
     235          rChangeSComps(currcomponents,
     236                        currShiftedComponents,
     237                        IDELEMS(syzstr->res[index])); // actueller index
    207238          number coefgcd =
    208239            nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
     
    213244          pDelete(&tt);
    214245          coefgcd = nNeg(coefgcd);
    215           pp = pCopy(tsyz);
     246          pp = pCopy((syzstr->resPairs[index])[r1].syz);
    216247          tt = pDivide(tso.lcm,tso.p2);
    217248          pSetCoeff(tt,nDiv(pGetCoeff(tso.p2),coefgcd));
     
    221252          nDelete(&coefgcd);
    222253          currcomponents = syzstr->truecomponents[index-1];
    223           pSetComp(tso.lcm,pGetComp(tsyz));
     254          currShiftedComponents = syzstr->ShiftedComponents[index-1];
     255          pSetComp(tso.lcm,pGetComp((syzstr->resPairs[index])[r1].syz));
     256          rChangeSComps(currcomponents,
     257                        currShiftedComponents,
     258                        IDELEMS(syzstr->res[index])); // actueller index
    224259#ifdef SHOW_PROT
    225260Print("erzeuge Paar im Modul %d,%d mit: \n",index,tso.order);
     
    233268        }
    234269      }
    235       pDelete(&tsyz);
    236       tsyz = NULL;
    237270    }
    238271#ifdef INVERT_PAIRS
     
    258291* set the vectors of truecomponents
    259292*/
    260 static void syOrder_Hilb(poly p,syStrategy syzstr,int index,
     293static BOOLEAN syOrder_Hilb(poly p,syStrategy syzstr,int index,
    261294                    int realcomp)
    262295{
     
    264297  int *trind1=syzstr->truecomponents[index-1];
    265298  int *trind=syzstr->truecomponents[index];
     299  long *shind=syzstr->ShiftedComponents[index];
    266300  poly pp;
    267301  polyset o_r=syzstr->orderedRes[index]->m;
    268 
    269   if (p==NULL) return;
     302  BOOLEAN ret = FALSE;
     303
     304  // if != 0, then new element can go into same component
     305  // i.e., we do not need to leave space in shifted components
     306  long same_comp = 0;
     307
     308  if (p==NULL) return FALSE;
    270309  if (realcomp==0) realcomp=1;
    271310  ie = IDELEMS(syzstr->orderedRes[index]);
     
    284323    {
    285324      orc = pGetComp(o_r[j]);
    286       if (trind1[orc]>tc) break;
     325      if (trind1[orc]>tc+1) break;
     326      else if (trind1[orc] == tc+1)
     327      {
     328        same_comp = 1;
     329      }
    287330      j++;
    288331      if (j==ie) break;
    289     }
    290   }
     332    }
     333  }
     334  if (j == ie)
     335  {
     336    // new element is the last in ordered module
     337    if (same_comp == 0)
     338      same_comp = SYZ_SHIFT_BASE;
     339
     340    // test wheter we have enough space for new shifted component
     341    if ((LONG_MAX - same_comp) <= shind[ie])
     342    {
     343      long new_space = syReorderShiftedComponents(shind, ie+1);
     344      assume((LONG_MAX - same_comp) > shind[ie]);
     345      ret = TRUE;
     346      if (TEST_OPT_PROT) Print("(T%u)", new_space);
     347    }
     348
     349    // yes, then set new shifted component
     350    assume(ie == 0 || shind[ie] > 0);
     351    shind[ie+1] = shind[ie] + same_comp;
     352  }
     353  else
     354  {
     355    // new element must come in between
     356    // i.e. at place j+1
     357    long prev, next;
     358
     359    // test whether new component can get shifted value
     360    prev = shind[j];
     361    next = shind[j+1];
     362    assume(next > prev);
     363    if ((same_comp && prev + 2 >= next) || (!same_comp && next - prev < 4))
     364    {
     365       long new_space = syReorderShiftedComponents(shind, ie+1);
     366      prev = shind[j];
     367      next = shind[j+1];
     368      assume((same_comp && prev + 2 < next) || (!same_comp && next - prev >= 4));
     369      ret = TRUE;
     370     if (TEST_OPT_PROT) Print("(B%u)", new_space);
     371    }
     372
     373    // make room for insertion of j+1 shifted component
     374    for (k=ie+1; k > j+1; k--) shind[k] = shind[k-1];
     375
     376    if (same_comp)
     377    {
     378      // can simply add one
     379      shind[j+1] = prev + 1;
     380      assume(shind[j+1] + 1 < shind[j+2]);
     381    }
     382    else
     383    {
     384      // need to leave more breathing room - i.e. value goes in
     385      // between
     386      shind[j+1]  = prev + ((next - prev) >> 1);
     387      assume (shind[j] + 1 < shind[j+1] && shind[j+1] + 1 < shind[j+2]);
     388    }
     389  }
     390
    291391  if (o_r[j]!=NULL)
    292392  {
     
    305405    trind[k] = trind[k-1];
    306406  trind[realcomp] = j+1;
     407  return ret;
    307408}
    308409
     
    333434  tso.syz = pHead(syz);
    334435  pSetComp(tso.syz,newEl+1);
    335   pSetm(tso.syz);
    336436  tso.lcm = pHead(tso.syz);
    337437  tso.length = pLength(syz);
    338   syOrder_Hilb(syz,syzstr,index,newEl+1);
     438  if (syOrder_Hilb(syz,syzstr,index,newEl+1))
     439    syResetShiftedComponents(syzstr, index+1,1);
     440  rSetmS(tso.syz,syzstr->truecomponents[index],syzstr->ShiftedComponents[index]);
    339441#ifdef SHOW_PROT
    340442Print("erzeuge Halbpaar im Module %d,%d mit: \n",index,tso.order);
     
    508610*/
    509611static void syRedNextPairs_Hilb(SSet nextPairs, syStrategy syzstr,
    510                int howmuch, int index,int actord=-1,int* toSub=NULL)
    511 {
    512 pComp0=syzcomp1dpc;
     612               int howmuch, int index,int actord,int* toSub,
     613               int *maxindex,int *maxdeg)
     614{
    513615  int i,j,k=IDELEMS(syzstr->res[index]);
    514616  int ks=IDELEMS(syzstr->res[index+1]),kk,l,ll;
     617  int ks1=IDELEMS(syzstr->orderedRes[index+1]);
    515618  int kres=(*syzstr->Tl)[index];
    516619  int toGo=0;
     
    526629  int step=1,jj,j1,j2;
    527630#endif
     631  long * ShiftedComponents = syzstr->ShiftedComponents[index];
     632  int* Components = syzstr->truecomponents[index];
     633  assume(Components != NULL && ShiftedComponents != NULL);
     634  BOOLEAN need_reset;
    528635
    529636  actord += index;
     
    531638  while ((k>0) && (syzstr->res[index]->m[k-1]==NULL)) k--;
    532639  while ((ks>0) && (syzstr->res[index+1]->m[ks-1]==NULL)) ks--;
     640  while ((ks1>0) && (syzstr->orderedRes[index+1]->m[ks1-1]==NULL)) ks1--;
    533641  while ((kres>0) &&
    534642        ((redset[kres-1].p==NULL) || (redset[kres-1].order>actord))) kres--;
     
    576684  while (kk>=0)
    577685  {
    578     if (toGo==0)
     686    if (toGo==0) 
    579687    {
    580688      while (kk>=0)
     
    604712    if ((tso.p1!=NULL) && (tso.p2!=NULL))
    605713    {
     714#ifdef SHOW_CRIT
     715      cons_pairs++;
     716#endif
    606717      //tso.p = sySPoly(tso.p1, tso.p2,tso.lcm);
    607718      tso.p = ksOldCreateSpoly(tso.p2, tso.p1);
     
    619730        q = kBucketGetLm(syzstr->bucket);
    620731        j = 0;
    621         while (j<kres)
     732        while (j<kres) 
    622733        {
    623           if ((redset[j].p!=NULL) && (pDivisibleBy1(redset[j].p,q))
     734          if ((redset[j].p!=NULL) && (pDivisibleBy1(redset[j].p,q)) 
    624735              && ((redset[j].ind1!=tso.ind1) || (redset[j].ind2!=tso.ind2)))
    625736          {
     
    631742#endif
    632743            currcomponents = syzstr->truecomponents[index];
     744            currShiftedComponents = syzstr->ShiftedComponents[index];
     745            rChangeSComps(currcomponents,
     746                          currShiftedComponents,
     747                          IDELEMS(syzstr->res[index]));
    633748            sySPRedSyz(syzstr,redset[j],q);
    634749            currcomponents = syzstr->truecomponents[index-1];
     750            currShiftedComponents = syzstr->ShiftedComponents[index-1];
     751            rChangeSComps(currcomponents,
     752                          currShiftedComponents,
     753                          IDELEMS(syzstr->res[index]));
    635754            number up = kBucketPolyRed(syzstr->bucket,redset[j].p,
    636755                         redset[j].length, NULL);
     
    689808          syEnlargeFields(syzstr,index+1);
    690809        currcomponents = syzstr->truecomponents[index];
     810        currShiftedComponents = syzstr->ShiftedComponents[index];
     811            rChangeSComps(currcomponents,
     812                          currShiftedComponents,
     813                          IDELEMS(syzstr->res[index]));
    691814        syzstr->res[index+1]->m[ks] = syRed_Hilb(tso.syz,syzstr,index+1);
    692815        currcomponents = syzstr->truecomponents[index-1];
     816        currShiftedComponents = syzstr->ShiftedComponents[index-1];
     817            rChangeSComps(currcomponents,
     818                          currShiftedComponents,
     819                          IDELEMS(syzstr->res[index-1]));
    693820        if (syzstr->res[index+1]->m[ks]!=NULL)
    694821        {
     
    696823          toGo--;
    697824          pNorm(syzstr->res[index+1]->m[ks]);
    698 pComp0=syzcomp2dpc;
    699           syHalfPair(syzstr->res[index+1]->m[ks],ks,syzstr,index+1);
    700 pComp0=syzcomp1dpc;
     825          syHalfPair(syzstr->res[index+1]->m[ks],ks1,syzstr,index+1);
    701826          ks++;
     827          ks1++;
     828          if (index+1>*maxindex) *maxindex = index+1;
     829          if (actord-index>*maxdeg) *maxdeg = actord-index;
    702830        }
    703831        else
     
    761889      i = 0;
    762890      delete spl1;
    763       spl1 = ivStrip(spl2);
     891      spl1 = ivStrip(spl2); 
    764892      delete spl2;
    765893      if (spl1!=NULL)
     
    768896        kk = (*spl1)[i]-1;
    769897      }
    770     }
     898    } 
    771899#endif
    772900#ifdef USE_HEURISTIC2
    773901    if ((kk<0) && (toGo>0))
    774902    {
     903#ifdef SHOW_CRIT
     904      crit_fails++;
     905#endif
    775906      i = 0;
    776907      delete spl1;
     
    783914  }
    784915  delete spl1;
    785 pComp0=syzcomp2dpc;
    786916}
    787917
     
    837967* wrt. the ideal generated by elements of lower degrees
    838968*/
    839 static void syRedGenerOfCurrDeg_Hilb(syStrategy syzstr, int deg, int index)
    840 {
    841   ideal res=syzstr->res[index];
    842   int i=0,j,kk=(*syzstr->Tl)[index],k=IDELEMS(res);
    843   SSet sPairs1=syzstr->resPairs[index];
    844   SSet sPairs=syzstr->resPairs[index-1];
     969static void syRedGenerOfCurrDeg_Hilb(syStrategy syzstr, int deg,int *maxindex,int *maxdeg)
     970{
     971  ideal res=syzstr->res[1];
     972  int i=0,j,k=IDELEMS(res),k1=IDELEMS(syzstr->orderedRes[1]);
     973  SSet sPairs1=syzstr->resPairs[1];
     974  SSet sPairs=syzstr->resPairs[0];
    845975
    846976  while ((k>0) && (res->m[k-1]==NULL)) k--;
    847   while ((kk>0) && ((sPairs1[kk-1].p==NULL)||((sPairs1[kk-1].order>deg)))) kk--;
    848   while ((i<(*syzstr->Tl)[index-1]) && (((sPairs)[i].syz==NULL) ||
     977  while ((k1>0) && (syzstr->orderedRes[1]->m[k1-1]==NULL)) k1--;
     978  while ((i<(*syzstr->Tl)[0]) && (((sPairs)[i].syz==NULL) ||
    849979          ((sPairs)[i].order<deg)))
    850980    i++;
    851   if ((i>=(*syzstr->Tl)[index-1]) || ((sPairs)[i].order>deg)) return;
    852   while ((i<(*syzstr->Tl)[index-1]) && (((sPairs)[i].syz==NULL) ||
     981  if ((i>=(*syzstr->Tl)[0]) || ((sPairs)[i].order>deg)) return;
     982  while ((i<(*syzstr->Tl)[0]) && (((sPairs)[i].syz==NULL) ||
    853983         ((sPairs)[i].order==deg)))
    854984  {
     
    859989Print("syz: ");pWrite((sPairs)[i].syz);
    860990#endif
    861       (sPairs)[i].syz = syRed_Hilb((sPairs)[i].syz,syzstr,index);
     991      (sPairs)[i].syz = syRed_Hilb((sPairs)[i].syz,syzstr,1);
    862992#ifdef SHOW_PROT
    863993Print("erhalte Erzeuger: \n");
     
    869999        if (k==IDELEMS(res))
    8701000        {
    871           syEnlargeFields(syzstr,index);
    872           res=syzstr->res[index];
     1001          syEnlargeFields(syzstr,1);
     1002          res=syzstr->res[1];
    8731003        }
    8741004        if (BTEST1(6))
     
    8771007          {
    8781008            PrintS("\nminimal generator: ");
    879             pWrite((syzstr->resPairs[index-1])[i].syz);
    880             PrintS("comes from: ");pWrite((syzstr->resPairs[index-1])[i].p1);
    881             PrintS("and: ");pWrite((syzstr->resPairs[index-1])[i].p2);
     1009            pWrite((syzstr->resPairs[0])[i].syz);
     1010            PrintS("comes from: ");pWrite((syzstr->resPairs[0])[i].p1);
     1011            PrintS("and: ");pWrite((syzstr->resPairs[0])[i].p2);
    8821012          }
    8831013        }
    8841014        res->m[k] = (sPairs)[i].syz;
    8851015        pNorm(res->m[k]);
    886         syHalfPair(res->m[k],k,syzstr,index);
    887         kk++;
     1016        syHalfPair(res->m[k],k1,syzstr,1);
     1017        k1++;
    8881018        k++;
     1019        if (1>*maxindex) *maxindex = 1;
     1020        if (deg-1>*maxdeg) *maxdeg = deg-1;
    8891021      }
    8901022    }
     
    8931025}
    8941026
     1027/*3
     1028* reorders the result (stored in orderedRes) according
     1029* to the seqence given by res
     1030*/
     1031static void syReOrdResult_Hilb(syStrategy syzstr,int maxindex,int maxdeg)
     1032{
     1033  ideal reor,toreor;
     1034  int i,j,k,l,m,togo;
     1035  syzstr->betti = new intvec(maxdeg,maxindex+1,0);
     1036  (*syzstr->betti)[0] = 1;
     1037  for (i=1;i<=syzstr->length;i++)
     1038  {
     1039    if (!idIs0(syzstr->orderedRes[i]))
     1040    {
     1041      toreor = syzstr->orderedRes[i];
     1042      k = IDELEMS(toreor);
     1043      while ((k>0) && (toreor->m[k-1]==NULL)) k--;
     1044      reor = idInit(k,toreor->rank);
     1045      togo = IDELEMS(syzstr->res[i]);
     1046      for (j=0;j<k;j++)
     1047      {
     1048        if (toreor->m[j]!=NULL) (IMATELEM(*syzstr->betti,pFDeg(toreor->m[j])-i+1,i+1))++;
     1049        reor->m[j] = toreor->m[j];
     1050        toreor->m[j] = NULL;
     1051      }
     1052      m = 0;
     1053      for (j=0;j<togo;j++)
     1054      {
     1055        if (syzstr->res[i]->m[j]!=NULL)
     1056        {
     1057          l = 0;
     1058          while ((l<k) && (syzstr->res[i]->m[j]!=reor->m[l])) l++;
     1059          if (l<k)
     1060          {
     1061            toreor->m[m] = reor->m[l];
     1062            reor->m[l] = NULL;
     1063            m++;
     1064          }
     1065        }
     1066      }
     1067      idDelete(&reor);
     1068    }
     1069  }
     1070}
     1071
     1072/*2
     1073* the CoCoA-algorithm for free resolutions, using a formula
     1074* for remaining pairs based on Hilbert-functions
     1075*/
    8951076syStrategy syHilb(ideal arg,int * length)
    8961077{
    8971078  int i,j,*ord,*b0,*b1,actdeg=32000,index=0,reg=-1;
    8981079  int startdeg,howmuch,toSub=0;
     1080  int maxindex=0,maxdeg=0;
    8991081  ideal temp=NULL;
    9001082  SSet nextPairs;
    901   sip_sring tmpR;
     1083  ring tmpR=NULL;
    9021084  ring origR = currRing;
    9031085  pSetmProc oldSetm=pSetm;
    9041086  pCompProc oldComp0=pComp0;
    905 
    906   if (idIs0(arg)) return NULL;
    907   if ((currRing->order[0]==ringorder_dp)
    908   &&  (currRing->order[1]==ringorder_C)
    909   &&  (currRing->order[2]==0))
    910   {
    911     ord=NULL;
    912   }
    913 /*--- changes to a dpC-ring with special comp0------*/
    914   else
    915   {
    916     ord = (int*)Alloc0(3*sizeof(int));
    917     b0 = (int*)Alloc0(3*sizeof(int));
    918     b1 = (int*)Alloc0(3*sizeof(int));
    919     ord[0] = ringorder_dp;
    920     ord[1] = ringorder_C;
    921     b0[1] = 1;
    922     b1[0] = pVariables;
    923     tmpR  = *origR;
    924     tmpR.order = ord;
    925     tmpR.block0 = b0;
    926     tmpR.block1 = b1;
    927     rComplete(&tmpR);
    928     //pChangeRing(pVariables,1,ord,b0,b1,currRing->wvhdl);
    929     rChangeCurrRing(&tmpR, TRUE);
    930   }
     1087  syStrategy syzstr=(syStrategy)Alloc0SizeOf(ssyStrategy);
     1088
     1089  if ((idIs0(arg)) || (idRankFreeModule(arg)>0))
     1090  {
     1091    syzstr->minres = (resolvente)Alloc0(sizeof(ideal));
     1092    syzstr->length = 1;
     1093    syzstr->minres[0] = idInit(1,arg->rank);
     1094    return syzstr;
     1095  }
     1096  tmpR = (ring) Alloc0SizeOf(sip_sring);
     1097  tmpR->wvhdl = (int **)Alloc0(3 * sizeof(int *));
     1098  ord = (int*)Alloc0(3*sizeof(int));
     1099  b0 = (int*)Alloc0(3*sizeof(int));
     1100  b1 = (int*)Alloc0(3*sizeof(int));
     1101  ord[0] = ringorder_dp;
     1102  ord[1] = ringorder_S;
     1103  b0[0] = 1;
     1104  b1[0] = currRing->N;
     1105  tmpR->OrdSgn = 1;
     1106  tmpR->N = currRing->N;
     1107  tmpR->ch = currRing->ch;
     1108  tmpR->order = ord;
     1109  tmpR->block0 = b0;
     1110  tmpR->block1 = b1;
     1111  tmpR->P = currRing->P;
     1112  if (currRing->parameter!=NULL)
     1113  {
     1114    tmpR->minpoly=nCopy(currRing->minpoly);
     1115    tmpR->parameter=(char **)Alloc(rPar(currRing)*sizeof(char *));
     1116    for(i=0;i<tmpR->P;i++)
     1117    {
     1118      tmpR->parameter[i]=mstrdup(currRing->parameter[i]);
     1119    }
     1120  }
     1121  tmpR->names   = (char **)Alloc(tmpR->N * sizeof(char *));
     1122  for (i=0; i<tmpR->N; i++)
     1123  {
     1124    tmpR->names[i] = mstrdup(currRing->names[i]);
     1125  }
     1126  currcomponents = (int*)Alloc0((arg->rank+1)*sizeof(int));
     1127  currShiftedComponents = (long*)Alloc0((arg->rank+1)*sizeof(long));
     1128  for (i=0;i<=arg->rank;i++)
     1129  {
     1130    currShiftedComponents[i] = (i)*SYZ_SHIFT_BASE;
     1131    currcomponents[i] = i;
     1132  }
     1133  rComplete(tmpR, 1);
     1134  rChangeCurrRing(tmpR, TRUE);
     1135  rChangeSComps(currcomponents, currShiftedComponents, arg->rank);
     1136  syzstr->syRing = tmpR;
    9311137/*--- initializes the data structures---------------*/
    9321138#ifdef SHOW_CRIT
     
    9341140  crit1 = 0;
    9351141  spfl = 0;
    936 #endif
    937   syStrategy syzstr=(syStrategy)Alloc0(sizeof(ssyStrategy));
     1142  cons_pairs = 0;
     1143  crit_fails = 0;
     1144#endif
    9381145  syzstr->length = *length = pVariables+2;
    9391146  syzstr->Tl = new intvec(*length+1);
     
    9481155    }
    9491156  }
     1157  idTest(temp);
    9501158  idSkipZeroes(temp);
    951   pComp0 = syzcomp2dpc;
    952   currcomponents = (int*)Alloc0((arg->rank+1)*sizeof(int));
    953   for (i=0;i<=arg->rank;i++)
    954     currcomponents[i] = i;
    9551159  syzstr->resPairs = syInitRes(temp,length,syzstr->Tl,syzstr->cw);
    9561160  Free((ADDRESS)currcomponents,(arg->rank+1)*sizeof(int));
     1161  Free((ADDRESS)currShiftedComponents,(arg->rank+1)*sizeof(int));
    9571162  syzstr->res = (resolvente)Alloc0((*length+1)*sizeof(ideal));
    9581163  syzstr->orderedRes = (resolvente)Alloc0((*length+1)*sizeof(ideal));
     
    9821187    currcomponents = syzstr->truecomponents[max(index-1,0)];
    9831188    currShiftedComponents = syzstr->ShiftedComponents[max(index-1,0)];
     1189    rChangeSComps(currcomponents, currShiftedComponents,
     1190                  IDELEMS(syzstr->res[max(index-1,0)]));
    9841191    j = syInitSyzMod(syzstr,index+1);
    9851192    if (index>0)
    9861193    {
    987       syRedNextPairs_Hilb(nextPairs,syzstr,howmuch,index,actdeg,&toSub);
     1194      syRedNextPairs_Hilb(nextPairs,syzstr,howmuch,index,actdeg,&toSub,&maxindex,&maxdeg);
    9881195      sySetNewHilb(syzstr,toSub,index,actdeg);
    9891196      toSub = 0;
     
    9911198    }
    9921199    else
    993       syRedGenerOfCurrDeg_Hilb(syzstr,actdeg,index+1);
     1200      syRedGenerOfCurrDeg_Hilb(syzstr,actdeg,&maxindex,&maxdeg);
    9941201/*--- creates new pairs -----------------------------*/
    9951202#ifdef SHOW_PROT
     
    10021209Print("Bilde neue Paare in Modul %d!\n",index+1);
    10031210#endif
    1004       syCreateNewPairs_Hilb(syzstr,index+1,actdeg-1);
    1005     }
     1211      syCreateNewPairs_Hilb(syzstr,index+1,actdeg-1);    }
    10061212    index++;
    10071213    nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
    10081214  }
     1215  syReOrdResult_Hilb(syzstr,maxindex,maxdeg);
    10091216#ifdef SHOW_RESULT
    10101217Print("minimal resolution:\n");
     
    10231230Print("Criterion1 %d times applied\n",crit1);
    10241231Print("%d superfluous pairs\n",spfl);
     1232Print("%d pairs considered\n",cons_pairs);
     1233Print("Criterion fails %d times\n",crit_fails);
    10251234crit = 0;
    10261235crit1 = 0;
    10271236spfl = 0;
     1237cons_pairs = 0;
     1238crit_fails = 0;
    10281239#endif
    10291240  if (temp!=NULL) idDelete(&temp);
  • Singular/tok.h

    rd2b6cf rc1489f2  
    77* ABSTRACT: tokens, types for interpreter; general macros
    88*/
    9 /* $Id: tok.h,v 1.27 1999-08-16 15:43:57 Singular Exp $ */
     9/* $Id: tok.h,v 1.28 1999-10-19 12:42:51 obachman Exp $ */
    1010
    1111#ifndef MYYSTYPE
     
    7070  GETDUMP_CMD,
    7171  HIGHCORNER_CMD,
     72  HRES_CMD,
    7273  INSERT_CMD,
    7374  INT_CMD,
     
    183184#define OPT_REDTAIL       25
    184185#define OPT_INTSTRATEGY   26
    185 #define OPT_MINRES        28
    186186#define OPT_SB_1          29
    187187#define OPT_NOTREGULARITY 30
     
    203203#define TEST_OPT_STAIRCASEBOUND    BTEST1(OPT_STAIRCASEBOUND)
    204204#define TEST_OPT_REDTAIL           BTEST1(OPT_REDTAIL)
    205 #define TEST_OPT_MINRES            BTEST1(OPT_MINRES)
    206205#define TEST_OPT_SB_1              BTEST1(OPT_SB_1)
    207206#define TEST_OPT_NOTREGULARITY     BTEST1(OPT_NOTREGULARITY)
Note: See TracChangeset for help on using the changeset viewer.