Changeset 7ae776 in git


Ignore:
Timestamp:
Oct 15, 1998, 3:51:20 PM (26 years ago)
Author:
Thomas Siebert <siebert@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'c7af8613769b29c741d6c338945669719f1fc4f8')
Children:
77ff8e26463d0b2d6d61c497d5e9481b95774339
Parents:
418830be6fe749d83810516ecdd58947efec2554
Message:
a new implementation of minres for homogeneous input


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

Legend:

Unmodified
Added
Removed
  • Singular/ideals.cc

    r418830b r7ae776  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: ideals.cc,v 1.38 1998-09-30 14:12:47 Singular Exp $ */
     4/* $Id: ideals.cc,v 1.39 1998-10-15 13:51:17 siebert Exp $ */
    55/*
    66* ABSTRACT - all basic methods to manipulate ideals
     
    655655  if ((currRing->OrdSgn == 1) && (homog))
    656656  {
    657     lists re=min_std(h1,currQuotient,(tHomog)homog,&wth,NULL,0,2);
     657    lists re=min_std(h1,currQuotient,(tHomog)homog,&wth,NULL,0,3);
    658658    h2 = (ideal)re->m[1].data;
    659659    re->m[1].data = NULL;
  • Singular/syz.cc

    r418830b r7ae776  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz.cc,v 1.11 1998-10-06 14:37:54 siebert Exp $ */
     4/* $Id: syz.cc,v 1.12 1998-10-15 13:51:18 siebert Exp $ */
    55
    66/*
     
    217217}
    218218
     219/*2
     220* make Gauss for one element
     221*/
     222static void syGaussForOne(ideal syz, int elnum, int ModComp)
     223{
     224  int k,j,i;
     225  poly unit1,unit2;
     226  poly actWith=syz->m[elnum];
     227
     228  syz->m[elnum] = NULL;
     229  if (currRing->ch<2) pCleardenom(actWith);
     230/*--makes Gauss alg. for the column ModComp--*/
     231  unit1 = pTakeOutComp1(&(actWith), ModComp);
     232  k=0;
     233  while (k<IDELEMS(syz))
     234  {
     235    if (syz->m[k]!=NULL)
     236    {
     237      unit2 = pTakeOutComp1(&(syz->m[k]), ModComp);
     238      syz->m[k] = pMult(syz->m[k],pCopy(unit1));
     239      syz->m[k] = pSub(syz->m[k],
     240        pMult(pCopy(actWith),unit2));
     241      if (syz->m[k]==NULL)
     242      {
     243        Print("Hier muss noch was gemacht werden\n");
     244      }
     245    }
     246    k++;
     247  }
     248  pDelete(&actWith);
     249  pDelete(&unit1);
     250}
     251static void syDeleteAbove1(ideal up, int k)
     252{
     253  poly p,pp;
     254  if (up!=NULL)
     255  {
     256    for (int i=0;i<IDELEMS(up);i++)
     257    {
     258      p = up->m[i];
     259      while ((p!=NULL) && (pGetComp(p)==k))
     260      {
     261        pp = pNext(p);
     262        pNext(p) = NULL;
     263        pDelete(&p);
     264        p = pp;
     265      }
     266      up->m[i] = p;
     267      if (p!=NULL)
     268      {
     269        while (pNext(p)!=NULL)
     270        {
     271          if (pGetComp(pNext(p))==k)
     272          {
     273            pp = pNext(pNext(p));
     274            pNext(pNext(p)) = NULL;
     275            pDelete(&pNext(p));
     276            pNext(p) = pp;
     277          }
     278          else
     279            pIter(p);
     280        }
     281      }
     282    }
     283  }
     284}
     285/*2
     286*minimizes the resolution res
     287*assumes homogeneous or local case
     288*/
     289static void syMinStep1(resolvente res, int length)
     290{
     291  int i,j,k,l,index=0;
     292  poly p;
     293  ideal deg0=NULL,reddeg0=NULL;
     294  intvec *have_del=NULL,*to_del=NULL;
     295
     296  while ((index<length) && (res[index]!=NULL))
     297  {
     298/*---we take out dependend elements from syz---------------------*/
     299    if (res[index+1]!=NULL)
     300    {
     301      deg0 = idJet(res[index+1],0);
     302      reddeg0 = kInterRed(deg0);
     303      idDelete(&deg0);
     304      have_del = new intvec(IDELEMS(res[index]));
     305      for (i=0;i<IDELEMS(reddeg0);i++)
     306      {
     307        if (reddeg0->m[i]!=NULL)
     308        {
     309          j = pGetComp(reddeg0->m[i]);
     310          pDelete(&(res[index]->m[j-1]));
     311          res[index]->m[j-1] = NULL;
     312          (*have_del)[j-1] = 1;
     313        }
     314      }
     315      idDelete(&reddeg0);
     316    }
     317    if (index>0)
     318    {
     319/*--- we search for units and perform Gaussian elimination------*/
     320      j = to_del->length();
     321      while (j>0)
     322      {
     323        if ((*to_del)[j-1]==1)
     324        {
     325          k = 0;
     326          while (k<IDELEMS(res[index]))
     327          {
     328            p = res[index]->m[k];
     329            while ((p!=NULL) && ((!pIsConstantComp(p)) || (pGetComp(p)!=j)))
     330              pIter(p);
     331            if ((p!=NULL) && (pIsConstantComp(p)) && (pGetComp(p)==j)) break;
     332            k++;
     333          }
     334          if (k>=IDELEMS(res[index]))
     335          {
     336            Print("out of range\n");
     337          }
     338          syGaussForOne(res[index],k,j);
     339          if (res[index+1]!=NULL)
     340            syDeleteAbove1(res[index+1],k+1);
     341          (*to_del)[j-1] = 0;
     342        }
     343        j--;
     344      }
     345    }
     346    if (to_del!=NULL) delete to_del;
     347    to_del = have_del;
     348    have_del = NULL;
     349    index++;
     350  }
     351  PrintLn();
     352  syKillEmptyEntres(res,length);
     353}
     354
    219355void syMinimizeResolvente(resolvente res, int length, int first)
    220356{
    221357  int syzIndex=first;
    222   intvec * dummy;
     358  intvec *dummy;
    223359
    224360  if (syzIndex<1) syzIndex=1;
    225 /*                            Noch zu testen!!
    226 *  if ((syzIndex==1) && (idHomModule(res[0],currQuotient,&dummy)))
    227 *  {
    228 *    delete dummy;
    229 *    resolvente res1=syFastMin(res,length);
    230 *    int i;
    231 *    for (i=0;i<length;i++)
    232 *    {
    233 *      idDelete(&res[i]);
    234 *      res[i] = res1[i];
    235 *    }
    236 *    Free((ADDRESS)res1,length*sizeof(ideal));
    237 *    return;
    238 *  }
    239 */
     361  if ((syzIndex==1) && (idHomModule(res[0],currQuotient,&dummy)))
     362  {
     363    syMinStep1(res,length);
     364    delete dummy;
     365    return;
     366  }
    240367  while ((syzIndex<length-1) && (res[syzIndex]!=NULL) && (res[syzIndex+1]!=NULL))
    241368  {
     
    10301157  return j;
    10311158}
    1032 
    1033 /*2
    1034 * determines the generators of a minimal resolution
    1035 * contained in res
    1036 */
    1037 static int ** syScanRes(resolvente res, int length)
    1038 {
    1039   int i=0,j,k;
    1040   int **result=(int**)Alloc0(length*sizeof(int*));
    1041   poly p;
    1042   ideal tid;
    1043 
    1044   while ((i<length) && (!idIs0(res[i])))
    1045   {
    1046     result[i] = (int*)Alloc0(IDELEMS(res[i])*sizeof(int));
    1047     for (j=IDELEMS(res[i])-1;j>=0;j--)
    1048     {
    1049       if (res[i]->m[j]==NULL) (result[i])[j] = -1;
    1050     }
    1051     if (i>0)
    1052     {
    1053       tid = idJet(res[i],0);
    1054       Print("Der %d-te 0-jet ist:\n",i);
    1055       for (j=0;j<IDELEMS(tid);j++)
    1056       {
    1057         if (tid->m[j]!=0)
    1058         {
    1059           Print("poly %d :",j);pWrite(tid->m[j]);
    1060         }
    1061       }
    1062       for (j=0;j<IDELEMS(tid);j++)
    1063       {
    1064         p = tid->m[j];
    1065         while (p!=NULL)
    1066         {
    1067           pNorm(p);
    1068           k = (result[i-1])[pGetComp(p)-1];
    1069           if ((k==0) || (k==-2))
    1070           {
    1071             (result[i-1])[pGetComp(p)-1] = j+1;
    1072             (result[i])[j] = -2;
    1073             break;
    1074           }
    1075           else if (k>0)
    1076           {
    1077             p = pSub(p,pCopy(tid->m[k-1]));
    1078           }
    1079           else if (k==-1)
    1080           {
    1081             Print("Something is rotten in the state of Denmark\n");
    1082           }
    1083         }
    1084         tid->m[j] = p;
    1085       }
    1086       Print("Der %d-te 0-jet ist:\n",i);
    1087       for (j=0;j<IDELEMS(tid);j++)
    1088       {
    1089         if (tid->m[j]!=0)
    1090         {
    1091           Print("poly %d :",j);pWrite(tid->m[j]);
    1092         }
    1093       }
    1094       idDelete(&tid);
    1095     }
    1096     i++;
    1097   }
    1098   Print("Die gescannte Struktur ist:\n");
    1099   for (i=0;i<length;i++)
    1100   {
    1101     Print("Fuer den %d-ten Module:\n",i);
    1102     if (!idIs0(res[i]))
    1103       for (j=0;j<IDELEMS(res[i]);j++) Print(" %d",(result[i])[j]);
    1104     Print("\n");
    1105   }
    1106   return result;
    1107 }
    1108 
    1109 static void syReduce(ideal toRed,poly redWith,int redComp)
    1110 {
    1111   int i;
    1112   poly p=redWith,pp,ppp;
    1113   number n;
    1114 
    1115   while ((p!=NULL) && (pGetComp(p)!=redComp)) pIter(p);
    1116   if (p==NULL)
    1117   {
    1118     Print("Hier ist was faul!\n");
    1119   }
    1120   else
    1121   {
    1122     n = nCopy(pGetCoeff(p));
    1123   }
    1124   p = redWith;
    1125   for (i=0;i<IDELEMS(toRed);i++)
    1126   {
    1127     pp = toRed->m[i];
    1128     while ((pp!=NULL) && (pGetComp(pp)!=redComp)) pIter(pp);
    1129     if (pp!=NULL)
    1130     {
    1131       ppp = pMultCopyN(p,pGetCoeff(pp));
    1132       pMultN(toRed->m[i],n);
    1133       toRed->m[i] = pSub(toRed->m[i],ppp);
    1134     }
    1135   }
    1136   nDelete(&n);
    1137 }
    1138 
    1139 resolvente syFastMin(resolvente res,int length)
    1140 {
    1141   int **res_shape=syScanRes(res,length);
    1142   int i,j,k;
    1143   poly p;
    1144   resolvente result=(ideal*)Alloc0(length*sizeof(ideal));
    1145  
    1146   for (i=0;(i<length) && !idIs0(res[i]);i++)
    1147   {
    1148     k = 0;
    1149     result[i] = idInit(IDELEMS(res[i]),res[i]->rank);
    1150     for (j=IDELEMS(res[i])-1; j>=0;j--)
    1151     {
    1152       if ((res_shape[i])[j]==0)
    1153       {
    1154         result[i]->m[k] = pCopy(res[i]->m[j]);
    1155         k++;
    1156       }
    1157     }
    1158     if (i>0)
    1159     {
    1160       for (j=IDELEMS(res[i-1])-1;j>=0;j--)
    1161       {
    1162         if ((res_shape[i-1])[j]>0)
    1163         {
    1164           k = (res_shape[i-1])[j]-1;
    1165           syReduce(result[i],res[i]->m[k],j+1);
    1166         }
    1167       }
    1168     }
    1169   }
    1170   return result;
    1171 }
  • Singular/syz.h

    r418830b r7ae776  
    44*  Computer Algebra System SINGULAR     *
    55****************************************/
    6 /* $Id: syz.h,v 1.10 1998-09-29 21:14:46 siebert Exp $ */
     6/* $Id: syz.h,v 1.11 1998-10-15 13:51:19 siebert Exp $ */
    77/*
    88* ABSTRACT: Resolutions
     
    9393syStrategy syForceMin(lists li);
    9494syStrategy syMinimize(syStrategy syzstr);
     95void syKillEmptyEntres(resolvente res,int length);
    9596#endif
  • Singular/syz1.cc

    r418830b r7ae776  
    22*  Computer Algebra System SINGULAR     *
    33****************************************/
    4 /* $Id: syz1.cc,v 1.32 1998-09-22 14:09:03 Singular Exp $ */
     4/* $Id: syz1.cc,v 1.33 1998-10-15 13:51:20 siebert Exp $ */
    55/*
    66* ABSTRACT: resolutions
     
    169169           /*4 handle module case:*/
    170170           if (pGetComp(p1)==pGetComp(p2)) return 0;
    171            else if
    172               (currcomponents[pGetComp(p1)]>currcomponents[pGetComp(p2)])
     171           else if 
     172              (currcomponents[pGetComp(p1)]>currcomponents[pGetComp(p2)]) 
    173173                return 1;
    174174           else return -1;
     
    194194  int n1 = normal_syzcomp2dpc(p1, p2);
    195195  int n2 = SyVecSyzCmp(p1, p2);
    196 
     196 
    197197  if (n1 != n2)
    198198  {
     
    281281  }
    282282  for (int i=0;i<pVariables;i++)
    283   {
     283  { 
    284284    binomials[i*(highdeg_1)/*i,0*/]=0;
    285285  }
     
    323323  poly q,result=q=pNew();
    324324  int j;
    325 
     325 
    326326  if (pGetOrder(p)>0)
    327327  {
    328     loop
     328    loop 
    329329    {
    330330      spMemcpy(q,p);
     
    346346    poly lastmon=NULL;
    347347    int i=0;
    348     loop
     348    loop 
    349349    {
    350350      if (pGetOrder(p)!=i)
     
    380380  poly q,result=q=pNew();
    381381  int j;
    382 
     382 
    383383  if (pGetOrder(p)>0)
    384384  {
    385     loop
     385    loop 
    386386    {
    387387      spMemcpy(q,p);
     
    404404    poly lastmon=NULL;
    405405    int i=0;
    406     loop
     406    loop 
    407407    {
    408408      if (pGetOrder(p)!=i)
     
    439439  poly q,result=q=pNew();
    440440  int j;
    441 
     441 
    442442  if (pGetOrder(p)>0)
    443443  {
    444     loop
     444    loop 
    445445    {
    446446      spMemcpy(q,p);
     
    462462    poly lastmon=NULL;
    463463    int i=0;
    464     loop
     464    loop 
    465465    {
    466466      if (pGetOrder(p)!=i)
     
    574574{
    575575  poly temp1 = pCopy(m1);
    576 
     576 
    577577  poly p1 = normal_sySPAdd(m1, m2, m);
    578578  poly p2 = syVecSpoly(m2, temp1, m);
    579 
     579 
    580580  pTest(p1);
    581581  pTest(p2);
    582   if (p1 != NULL)
     582  if (p1 != NULL) 
    583583  {
    584584    if (p2 == NULL || ! pEqual(p1, p2))
     
    591591    }
    592592  }
    593   else if (p2 != NULL)
     593  else if (p2 != NULL) 
    594594    PrintS("Error in SySpoly\n");
    595595
     
    683683        break;
    684684    }
    685     else
     685    else 
    686686    {
    687687      j = currcomponents[pGetComp(m1)]-currcomponents[pGetComp(m2)];
     
    695695          break;
    696696      }
    697       else
     697      else 
    698698      {
    699699        if (j<0/*currcomponents[pGetComp(m1)]<currcomponents[pGetComp(m2)]*/)
     
    809809#if defined(HAVE_SY_VECTOR) && ! defined (SY_VEC_DEBUG)
    810810    res = sySpolyProc(m2, m1,a);
    811 #else
     811#else   
    812812  if (pGetOrder(m1)>0)
    813813  {
     
    940940      arg->m[(*iv)[i]-1] = NULL;
    941941      (resPairs[0])[i].order = pTotaldegree((resPairs[0])[i].syz);
    942     }
     942    } 
    943943  }
    944944  else
     
    983983  if (p==NULL) return;
    984984  if (realcomp==0) realcomp=1;
    985 
     985 
    986986  if (index>1)
    987987    tc = trind1[pGetComp(p)]-1;
     
    10361036}
    10371037
    1038 //#define OLD_PAIR_ORDER
    1039 #ifdef OLD_PAIR_ORDER
    10401038static intvec* syLinStrat(SSet nextPairs, syStrategy syzstr,
    10411039                          int howmuch, int index)
     
    10641062          if (o_r->m[l]!=NULL)
    10651063          {
    1066             isDivisible = isDivisible ||
     1064            isDivisible = isDivisible || 
    10671065              pDivisibleBy2(o_r->m[l],tso.lcm);
    10681066          }
     
    10871085  return result;
    10881086}
    1089 #else
    1090 static intvec* syLinStrat(SSet nextPairs, syStrategy syzstr,
     1087
     1088static intvec* syLinStrat1(SSet nextPairs, syStrategy syzstr,
    10911089                          int howmuch, int index)
    10921090{
     
    11151113          if (o_r->m[l]!=NULL)
    11161114          {
    1117             isDivisible = isDivisible ||
     1115            isDivisible = isDivisible || 
    11181116              pDivisibleBy2(o_r->m[l],tso.lcm);
    11191117          }
     
    11291127    else
    11301128    {
    1131       nextPairs[i].p =
     1129      nextPairs[i].p = 
    11321130        sySPoly(tso.p1, tso.p2,tso.lcm);
    11331131      (*spl)[i] = pLength(nextPairs[i].p);
     
    11421140    for (i1=0;i1<howmuch;i1++)
    11431141    {
    1144       if (i2==-1)
     1142      if (i2==-1) 
    11451143      {
    11461144        if ((*spl)[i1]!=-1)
     
    11701168  return result;
    11711169}
    1172 #endif
     1170
    11731171/*3
    11741172* reduces all pairs of degree deg in the module index
    11751173* put the reduced generators to the resolvente which contains
    1176 * the truncated kStd
     1174* the truncated kStd 
    11771175*/
    11781176static void syRedNextPairs(SSet nextPairs, syStrategy syzstr,
     
    11931191  while ((k>0) && (syzstr->res[index]->m[k-1]==NULL)) k--;
    11941192  while ((ks>0) && (syzstr->res[index+1]->m[ks-1]==NULL)) ks--;
    1195   spl1 = syLinStrat(nextPairs,syzstr,howmuch,index);
     1193  spl1 = syLinStrat1(nextPairs,syzstr,howmuch,index);
    11961194//Print("\n");Print("Ordnungsvektor: ");spl1->show(1,1);Print("\n");
    11971195  i=0;
     
    12011199    if ((tso.p1!=NULL) && (tso.p2!=NULL))
    12021200    {
    1203       coefgcd =
     1201      coefgcd = 
    12041202        nGcd(pGetCoeff(tso.p1),pGetCoeff(tso.p2));
    12051203      tso.syz = pHead(tso.lcm);
     
    13101308        if (index % 2==0)
    13111309          euler++;
    1312         else
     1310        else 
    13131311          euler--;
    13141312      }
     
    13541352  }
    13551353  delete spl1;
    1356 }
     1354} 
    13571355
    13581356/*3
     
    13681366
    13691367  while ((k>0) && (res->m[k-1]==NULL)) k--;
    1370   while ((i<(*syzstr->Tl)[index-1]) && (((sPairs)[i].syz==NULL) ||
     1368  while ((i<(*syzstr->Tl)[index-1]) && (((sPairs)[i].syz==NULL) || 
    13711369          ((sPairs)[i].order<deg)))
    13721370    i++;
    13731371  if ((i>=(*syzstr->Tl)[index-1]) || ((sPairs)[i].order>deg)) return;
    13741372  while ((i<(*syzstr->Tl)[index-1]) && (((sPairs)[i].syz==NULL) ||
    1375          ((sPairs)[i].order==deg)))
     1373         ((sPairs)[i].order==deg))) 
    13761374  {
    13771375    if ((sPairs)[i].syz!=NULL)
    13781376    {
    13791377      j = k-1;
    1380       while ((j>=0) && (res->m[j]!=NULL) &&
     1378      while ((j>=0) && (res->m[j]!=NULL) && 
    13811379             ((sPairs)[i].syz!=NULL))
    13821380      {
     
    13841382        {
    13851383          //Print("r");
    1386           (sPairs)[i].syz =
     1384          (sPairs)[i].syz = 
    13871385            //spSpolyRed(res->m[j],(sPairs)[i].syz,NULL);
    13881386            sySPolyRed((sPairs)[i].syz,res->m[j]);
     
    14631461  {
    14641462    int an=0,en=sP-1;
    1465     loop
     1463    loop 
    14661464    {
    14671465      if (an>=en-1)
     
    15371535      pSetComp(p,j+1);
    15381536      ii = first;
    1539       loop
     1537      loop 
    15401538      {
    15411539        j1 = bci[ii];
     
    15931591        {
    15941592          int ii=index-1,jj=pGetComp(q);
    1595           while (ii>0)
     1593          while (ii>0) 
    15961594          {
    15971595            jj = pGetComp(syzstr->res[ii]->m[jj-1]);
     
    16411639  SSet result;
    16421640  SRes resPairs=syzstr->resPairs;
    1643 
     1641 
    16441642  if (an>syzstr->length) return NULL;
    16451643  if (en>syzstr->length) en=syzstr->length;
     
    17091707      {
    17101708        t = *actdeg+*index;
    1711         if (((resPairs[*index])[i].lcm!=NULL) ||
     1709        if (((resPairs[*index])[i].lcm!=NULL) || 
    17121710              ((resPairs[*index])[i].syz!=NULL))
    17131711        {
     
    17221720        }
    17231721        i++;
    1724       }
     1722      } 
    17251723    }
    17261724    (*index)++;
     
    17821780*  int newdeg=*actdeg,newindex=-1,i,t;
    17831781*  SSet result;
    1784 *
     1782* 
    17851783*  while (*index>=0)
    17861784*  {
     
    18631861*        }
    18641862*        i++;
    1865 *      }
     1863*      } 
    18661864*    }
    18671865*    (*index)--;
     
    19121910  int result;
    19131911
    1914   if (syzstr->res[index]==NULL)
     1912  if (syzstr->res[index]==NULL) 
    19151913  {
    19161914    syzstr->res[index] = idInit(init-1,1);
     
    19491947  {
    19501948    int i,j;
    1951 
     1949 
    19521950    if (syzstr->resPairs!=NULL)
    19531951    {
     
    20662064    int i,j=-1,jj=-1,l;
    20672065    SRes rP=syzstr->resPairs;
    2068 
     2066   
    20692067    l = syzstr->length;
    20702068    while ((l>0) && (rP[l-1]==NULL)) l--;
     
    20742072    {
    20752073      i = 0;
    2076       while ((i<(*syzstr->Tl)[l]) &&
     2074      while ((i<(*syzstr->Tl)[l]) && 
    20772075        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)))
    20782076      {
    2079         if (rP[l][i].isNotMinimal==NULL)
     2077        if (rP[l][i].isNotMinimal==NULL) 
    20802078        {
    20812079          if (j<rP[l][i].order-l)
     
    20942092    {
    20952093      j = 0;
    2096       while ((j<(*syzstr->Tl)[i]) &&
     2094      while ((j<(*syzstr->Tl)[i]) && 
    20972095        ((rP[i][j].lcm!=NULL) || (rP[i][j].syz!=NULL)))
    20982096      {
     
    21472145  {
    21482146    SRes rP=syzstr->resPairs;
    2149 
     2147   
    21502148    l = syzstr->length;
    21512149    while ((l>0) && (rP[l-1]==NULL)) l--;
     
    21552153    {
    21562154      i = 0;
    2157       while ((i<(*syzstr->Tl)[l]) &&
     2155      while ((i<(*syzstr->Tl)[l]) && 
    21582156        ((rP[l][i].lcm!=NULL) || (rP[l][i].syz!=NULL)) &&
    21592157        (rP[l][i].isNotMinimal!=NULL))
     
    21692167    return l;
    21702168  }
    2171   else
     2169  else 
    21722170    return sySize(syzstr);
    21732171}
     
    22232221}
    22242222
     2223static void syLoadResTrad(syStrategy syzstr)
     2224{
     2225  resolvente rr;
     2226  int l=0,j;
     2227
     2228  if (syzstr->minres!=NULL)
     2229    rr = syzstr->minres;
     2230  else
     2231    rr = syzstr->fullres;
     2232  if (syzstr->resolution!=NULL) delete syzstr->resolution;
     2233  syzstr->resolution = new intvec(syzstr->length+2);
     2234  (*syzstr->resolution)[0] = max(1,idRankFreeModule(rr[0]));
     2235  while ((l<syzstr->length) && (rr[l]!=NULL))
     2236  {
     2237    j = IDELEMS(rr[l]);
     2238    while ((j>0) && (rr[l]->m[j-1]==NULL)) j--;
     2239    ((*syzstr->resolution)[l+1]) = j;
     2240    l++;
     2241  }
     2242}
     2243
    22252244/*3
    22262245* prints the resolution as sequence of free modules
     
    22282247void syPrint(syStrategy syzstr)
    22292248{
    2230   if ((syzstr->resPairs==NULL) && (syzstr->fullres==NULL)
     2249  if ((syzstr->resPairs==NULL) && (syzstr->fullres==NULL) 
    22312250     && (syzstr->minres==NULL))
    22322251  {
     
    22462265      {
    22472266        j=0;
    2248         while ((j<(*syzstr->Tl)[l]) &&
     2267        while ((j<(*syzstr->Tl)[l]) && 
    22492268          ((rP[l][j].lcm!=NULL) || (rP[l][j].syz!=NULL)))
    22502269        {
     
    22582277    else
    22592278    {
    2260       resolvente rr;
    2261       syzstr->resolution = new intvec(syzstr->length+2);
    2262       if (syzstr->minres!=NULL)
    2263         rr = syzstr->minres;
    2264       else
    2265         rr = syzstr->fullres;
    2266       (*syzstr->resolution)[0] = max(1,idRankFreeModule(rr[0]));
    2267       while ((l<syzstr->length) && (rr[l]!=NULL))
    2268       {
    2269         j = IDELEMS(rr[l]);
    2270         while ((l>0) && (rr[l]->m[j-1]==NULL)) j--;
    2271         ((*syzstr->resolution)[l+1]) = j;
    2272         l++;
    2273       }
     2279      syLoadResTrad(syzstr);
    22742280    }
    22752281  }
     
    23292335  resolvente fullres;
    23302336  fullres = (resolvente)Alloc0((length+1)*sizeof(ideal));
    2331   if (totake==NULL)
     2337  if (totake==NULL) 
    23322338    totake = res;
    23332339  for (i=length-1;i>0;i--)
     
    24712477  if (toStrip==NULL) return p;
    24722478  poly pp=p;
    2473 
     2479 
    24742480  while ((pp!=NULL) && ((*toStrip)[pGetComp(pp)]!=0))
    24752481    pDelete1(&pp);
    24762482  p = pp;
    2477   if (pp!=NULL)
     2483  if (pp!=NULL) 
    24782484  {
    24792485    while (pNext(pp)!=NULL)
     
    25222528          pGetCoeff(tq) = nNeg(pGetCoeff(tq));
    25232529          q = syAdd(q,syMultT1(tempStripped,tq));
    2524         }
     2530        } 
    25252531        pIter(p);
    25262532      }
     
    25372543}
    25382544
    2539 static void syKillEmptyEntres(resolvente res,int length)
     2545void syKillEmptyEntres(resolvente res,int length)
    25402546{
    25412547  int i,j,jj,k,rj;
     
    25582564        {
    25592565          ri->m[j] = ri->m[j+k];
    2560           (*changes)[j+k+1] = j+1;
     2566          (*changes)[j+k+1] = j+1; 
    25612567          j++;
    25622568        }
     
    26222628        else
    26232629        {
    2624           if (sPairs[i].syzind<l)
     2630          if (sPairs[i].syzind<l) 
    26252631          {
    26262632            l = sPairs[i].syzind;
     
    26342640    j++;
    26352641    k = l;
    2636   }
     2642  } 
    26372643  return result;
    26382644}
    26392645
    2640 static resolvente syReadOutMinimalRes(syStrategy syzstr,
     2646static resolvente syReadOutMinimalRes(syStrategy syzstr, 
    26412647           BOOLEAN computeStd=FALSE)
    26422648{
     
    26592665  pSetmProc oldSetm=pSetm;
    26602666  pCompProc oldComp0=pComp0;
    2661 
     2667 
    26622668  if ((currRing->order[0]==ringorder_dp)
    26632669  &&  (currRing->order[1]==ringorder_C)
     
    26842690    rChangeCurrRing(&tmpR, TRUE);
    26852691  }
    2686 #if ! defined(HAVE_SY_VECTOR) || defined(SY_VEC_DEBUG)
     2692#if ! defined(HAVE_SY_VECTOR) || defined(SY_VEC_DEBUG) 
    26872693  pSetm =syzSetm;
    26882694#endif
     
    27542760      syzstr->minres = syzstr->fullres;
    27552761      syzstr->fullres = NULL;
     2762      syLoadResTrad(syzstr);
    27562763    }
    27572764  }
     
    28082815  ring origR = currRing;
    28092816
    2810   if ((idIs0(arg)) ||
     2817  if ((idIs0(arg)) || 
    28112818      ((idRankFreeModule(arg)>0) && (!idHomModule(arg,NULL,&(syzstr->cw)))))
    28122819  {
     
    28332840  {
    28342841    ord=NULL;
    2835   }
     2842  } 
    28362843/*--- changes to a dpC-ring with special comp0------*/
    28372844  else
     
    28512858    //pChangeRing(pVariables,1,ord,b0,b1,currRing->wvhdl);
    28522859    rChangeCurrRing(&tmpR, TRUE);
    2853   }
     2860  } 
    28542861/*--- initializes the data structures---------------*/
    28552862  syzstr->Tl = new intvec(*length);
     
    28582865  {
    28592866    temp->m[i] = pOrdPolyInsertSetm(pCopy(arg->m[i]));
    2860     if (temp->m[i]!=NULL)
     2867    if (temp->m[i]!=NULL) 
    28612868    {
    28622869      j = pTotaldegree(temp->m[i]);
     
    28702877  binomials = (int*)Alloc(pVariables*(highdeg+1)*sizeof(int));
    28712878  syBinomSet();
    2872 #if ! defined(HAVE_SY_VECTOR) || defined(SY_VEC_DEBUG)
     2879#if ! defined(HAVE_SY_VECTOR) || defined(SY_VEC_DEBUG) 
    28732880  pSetm =syzSetm;
    28742881  for (i=0;i<IDELEMS(temp);i++)
     
    29052912  nextPairs = syChosePairs(syzstr,&index,&howmuch,&actdeg);
    29062913  //if (TEST_OPT_PROT) Print("(%d,%d)",howmuch,index);
    2907 /*--- computes the resolution ----------------------*/
     2914/*--- computes the resolution ----------------------*/ 
    29082915  while (nextPairs!=NULL)
    29092916  {
     
    29232930    else
    29242931      syRedGenerOfCurrDeg(syzstr,actdeg,index+1);
    2925 /*--- creates new pairs -----------------------------*/
     2932/*--- creates new pairs -----------------------------*/     
    29262933    syCreateNewPairs(syzstr,index,i);
    2927     if (index<(*length)-1)
     2934    if (index<(*length)-1) 
    29282935    {
    29292936      syCreateNewPairs(syzstr,index+1,j);
     
    29532960    Free((ADDRESS)b0,3*sizeof(int));
    29542961    Free((ADDRESS)b1,3*sizeof(int));
    2955   }
     2962  } 
    29562963  syzstr->binom = binomials;
    29572964  syzstr->highdeg_1 = highdeg_1;
Note: See TracChangeset for help on using the changeset viewer.