Changeset 22579cf in git

Timestamp:

Mar 15, 2011, 7:17:44 PM (12 years ago)

Author:

Oleksandr Motsak <motsak@…>

Branches:

(u'jengelh-datetime', 'ceac47cbc86fe4a15902392bdbb9bd2ae0ea02c6')(u'spielwiese', 'a800fe4b3e9d37a38c5a10cc0ae9dfa0c15a4ee6')

Children:

273fed0aea0c3cb00dc08f02c5d5340a2a781f23

Parents:

91b031a4e88cb480f4ba993bf5904694c62d9b34

Message:

FIX: betti and convertion to list should not change a resolution (syzstr)!
FIX: La Scala must return min/full-res and should forget about syRing!
FIX: is syRing NOT needed after La Scala resolution is finished...
FIX: printing of resolution will not change the resolution anymore? (convetion to list?)

From: Oleksandr Motsak <motsak@mathematik.uni-kl.de>

git-svn-id: file:///usr/local/Singular/svn/trunk@13975 2c84dea3-7e68-4137-9b89-c4e89433aadc

Files:

• Singular/iparith.cc (modified) (2 diffs)
• Singular/ipconv.cc (modified) (1 diff)
• Singular/ipshell.cc (modified) (6 diffs)
• Singular/subexpr.cc (modified) (1 diff)
• kernel/kstd2.cc (modified) (1 diff)
• kernel/ring.cc (modified) (1 diff)
• kernel/syz1.cc (modified) (5 diffs)

Singular/iparith.cc

@@ -2983 +2983 @@
     }
   }
+
+  // test the La Scala case' output
+  assume( (iiOp == LRES_CMD) == (r->syRing != NULL) );
+  assume( (iiOp == LRES_CMD) == (r->resPairs != NULL) );
+  assume( (r->minres != NULL) || (r->fullres != NULL) );
+
   return FALSE;
 }
@@ -4190 +4196 @@
 {
   intvec *weights=(intvec*)atGet(v,"isHomog",INTVEC_CMD);
-  res->data=(char *)syMinimize((syStrategy)v->Data());
+
+  syStrategy tmp=(syStrategy)v->Data();
+  tmp = syMinimize(tmp); // enrich itself!
+
+  res->data=(char *)tmp; 
+  
   if (weights!=NULL)
     atSet(res, omStrDup("isHomog"),ivCopy(weights),INTVEC_CMD);
+
   return FALSE;
 }

Singular/ipconv.cc

@@ -236 +236 @@
 
   syStrategy tmp=(syStrategy)in->CopyD();
+
   out->data=(void *)syConvRes(tmp,TRUE,add_row_shift);
 }

Singular/ipshell.cc

@@ -2110 +2110 @@
       }
       R->order[j]=rOrderName(omStrDup((char*)vv->m[0].Data())); // assume STRING
+
       if (j==0) R->block0[0]=1;
       else
@@ -2511 +2512 @@
 {
   syStrategy syzstr=(syStrategy)u->Data();
+
   BOOLEAN minim=(int)(long)w->Data();
   int row_shift=0;
@@ -2522 +2524 @@
      (*weights) -= add_row_shift;
   }
+  
   res->data=(void *)syBettiOfComputation(syzstr,minim,&row_shift,weights);
   //row_shift += add_row_shift;
   //Print("row_shift=%d, add_row_shift=%d\n",row_shift,add_row_shift);
   atSet(res,omStrDup("rowShift"),(void*)add_row_shift,INT_CMD);
+
   return FALSE;
 }
@@ -2542 +2546 @@
 lists syConvRes(syStrategy syzstr,BOOLEAN toDel,int add_row_shift)
 {
-  if ((syzstr->fullres==NULL) && (syzstr->minres==NULL))
+  resolvente fullres = syzstr->fullres;
+  resolvente minres = syzstr->minres;
+
+  const int length = syzstr->length;
+
+  if ((fullres==NULL) && (minres==NULL))
   {
     if (syzstr->hilb_coeffs==NULL)
     {
-      syzstr->fullres = syReorder(syzstr->res,syzstr->length,syzstr);
+      fullres = syReorder(syzstr->res, length, syzstr);
     }
     else
     {
-      syzstr->minres = syReorder(syzstr->orderedRes,syzstr->length,syzstr);
-      syKillEmptyEntres(syzstr->minres,syzstr->length);
-    }
-  }
+      minres = syReorder(syzstr->orderedRes, length, syzstr);
+      syKillEmptyEntres(minres, length);
+    }
+  }
+
   resolvente tr;
   int typ0=IDEAL_CMD;
-  if (syzstr->minres!=NULL)
-    tr = syzstr->minres;
+
+  if (minres!=NULL)
+    tr = minres;
   else
-    tr = syzstr->fullres;
-  resolvente trueres=NULL;
-  intvec ** w=NULL;
-  if (syzstr->length>0)
-  {
-    trueres=(resolvente)omAlloc0((syzstr->length)*sizeof(ideal));
-    for (int i=(syzstr->length)-1;i>=0;i--)
+    tr = fullres;
+  
+  resolvente trueres=NULL; intvec ** w=NULL;
+
+  if (length>0)
+  {
+    trueres = (resolvente)omAlloc0((length)*sizeof(ideal));
+    for (int i=(length)-1;i>=0;i--)
     {
       if (tr[i]!=NULL)
@@ -2576 +2588 @@
     if (syzstr->weights!=NULL)
     {
-      w = (intvec**)omAlloc0((syzstr->length)*sizeof(intvec*));
-      for (int i=(syzstr->length)-1;i>=0;i--)
+      w = (intvec**)omAlloc0(length*sizeof(intvec*));
+      for (int i=length-1;i>=0;i--)
       {
         if (syzstr->weights[i]!=NULL) w[i] = ivCopy(syzstr->weights[i]);
@@ -2583 +2595 @@
     }
   }
-  lists li = liMakeResolv(trueres,syzstr->length,syzstr->list_length,typ0,
-                          w,add_row_shift);
-  if (w != NULL) omFreeSize(w, (syzstr->length)*sizeof(intvec*));
-  if (toDel) syKillComputation(syzstr);
+  
+  lists li = liMakeResolv(trueres, length, syzstr->list_length,typ0,
+                          w, add_row_shift);
+
+  if (w != NULL) omFreeSize(w, length*sizeof(intvec*));
+  
+  if (toDel)
+    syKillComputation(syzstr);
+  else
+  {
+    if( fullres != NULL && syzstr->fullres == NULL )
+      syzstr->fullres = fullres;
+
+    if( minres != NULL && syzstr->minres == NULL )
+      syzstr->minres = minres;
+  }
+  
   return li;
+
+  
 }
 

Singular/subexpr.cc

@@ -144 +144 @@
           break;
         case RESOLUTION_CMD:
-          syPrint((syStrategy)d);
+        {
+          syStrategy tmp=(syStrategy)d; 
+          syPrint(tmp);
           break;
+        }
         case STRING_CMD:
           PrintNSpaces(spaces);

kernel/kstd2.cc

@@ -816 +816 @@
   }
 }
+
 /*2
 *  reduction procedure for the normal form

kernel/ring.cc

@@ -3340 +3340 @@
     r->pFDeg = pWTotaldegree; // may be improved: p_Totaldegree for lp/dp/ls/.. blocks
   }
+  
   if (rOrd_is_Totaldegree_Ordering(r) || rOrd_is_WeightedDegree_Ordering(r))
     r->pFDeg = pDeg;

kernel/syz1.cc

@@ -1790 +1790 @@
       return ivCopy(syzstr->betti);
   }
-  if ((syzstr->fullres==NULL) && (syzstr->minres==NULL))
+
+  resolvente fullres = syzstr->fullres;
+  resolvente minres = syzstr->minres;
+  const int length = syzstr->length;
+  
+  if ((fullres==NULL) && (minres==NULL))
   {
      if (syzstr->hilb_coeffs==NULL)
      {
-        syzstr->fullres = syReorder(syzstr->res,syzstr->length,syzstr);
+        fullres = syReorder(syzstr->res, length, syzstr);
      }
      else
      {
-        syzstr->minres = syReorder(syzstr->orderedRes,syzstr->length,syzstr);
-        syKillEmptyEntres(syzstr->minres,syzstr->length);
+        minres = syReorder(syzstr->orderedRes, length, syzstr);
+        syKillEmptyEntres(minres, length);
      }
-   }
+  }
+  
   intvec *result=NULL;
-  if (syzstr->fullres!=NULL)
-    result = syBetti(syzstr->fullres,syzstr->length,&dummy,weights,minim,row_shift);
+  
+  if (fullres!=NULL)
+    result = syBetti(fullres,length,&dummy,weights,minim,row_shift);
   else
-    result = syBetti(syzstr->minres,syzstr->length,&dummy,weights,minim,row_shift);
+    result = syBetti(minres,length,&dummy,weights,minim,row_shift);
+
+
+  return result; /// Don't change the syzstr???
+
+  // TODO: cleanup thses!
+  if( fullres != NULL && syzstr->fullres == NULL )
+    syzstr->fullres = fullres;
+  if( minres != NULL && syzstr->minres == NULL )
+    syzstr->minres = minres;
+
   if ((result!=NULL)
   && ((minim) || (syzstr->resPairs!=NULL))
   && std_weights)
   {
-    syzstr->betti = ivCopy(result);
-  }
+    syzstr->betti = ivCopy(result); // cache the result...
+  }
+  
   return result;
 }
@@ -1926 +1944 @@
 void syPrint(syStrategy syzstr)
 {
-  if ((syzstr->resPairs==NULL) && (syzstr->fullres==NULL)
-     && (syzstr->minres==NULL))
+  if ( (syzstr->resPairs==NULL) &&
+       (syzstr->fullres==NULL)  &&
+       (syzstr->minres==NULL) &&
+       (syzstr->resolution == NULL) )
   {
     PrintS("No resolution defined\n");
     return;
   }
-  int l=0;
-  if (syzstr->resolution==NULL)
-  {
-    int j;
+
+  intvec* resolution = syzstr->resolution;
+  
+  if (resolution==NULL)
+  {
     if (syzstr->resPairs!=NULL)
     {
-      syzstr->resolution = new intvec(syzstr->length+1);
-      SRes rP=syzstr->resPairs;
-      assume(idRankFreeModule(syzstr->res[1],
-                                 (syzstr->syRing != NULL ? syzstr->syRing : currRing))==syzstr->res[1]->rank);
-      (*syzstr->resolution)[0] = syzstr->res[1]->rank;
-      while ((l<syzstr->length) && (rP[l]!=NULL))
-      {
-        j=0;
-        while ((j<(*syzstr->Tl)[l]) &&
-          ((rP[l][j].lcm!=NULL) || (rP[l][j].syz!=NULL)))
-        {
-          if (rP[l][j].isNotMinimal==NULL)
-            ((*syzstr->resolution)[l+1])++;
+      resolution = new intvec(syzstr->length+1);
+      SRes rP = syzstr->resPairs;
+//      assume(idRankFreeModule(syzstr->res[1], (syzstr->syRing != NULL ? syzstr->syRing : currRing))==syzstr->res[1]->rank);
+      (*resolution)[0] = syzstr->res[1]->rank;
+      int k=0;
+      while ((k<syzstr->length) && (rP[k]!=NULL))
+      {
+        int j = 0;
+        while ((j<(*syzstr->Tl)[k]) &&
+          ((rP[k][j].lcm!=NULL) || (rP[k][j].syz!=NULL)))
+        {
+          if (rP[k][j].isNotMinimal==NULL)
+            ((*resolution)[k+1])++;
           j++;
         }
-        l++;
+        k++;
       }
     }
     else
     {
+      resolution = new intvec(syzstr->length+2);
       resolvente rr;
-      syzstr->resolution = new intvec(syzstr->length+2);
       if (syzstr->minres!=NULL)
         rr = syzstr->minres;
       else
         rr = syzstr->fullres;
-      (*syzstr->resolution)[0]
+      (*resolution)[0]
         = si_max(1,(int)idRankFreeModule(rr[0],
                                  (syzstr->syRing != NULL ? syzstr->syRing : currRing)));
-      while ((l<syzstr->length) && (rr[l]!=NULL))
-      {
-        j = IDELEMS(rr[l]);
-        while ((j>0) && (rr[l]->m[j-1]==NULL)) j--;
-        ((*syzstr->resolution)[l+1]) = j;
-        l++;
+      int k=0;
+      while ((k<syzstr->length) && (rr[k]!=NULL))
+      {
+        (*resolution)[k+1] = idSize(rr[k]);
+        k++;
       }
     }
@@ -1979 +1999 @@
   int sl=strlen(sn);
   syPrintEmptySpaces1(sl);
-  l = 0;
+  int k = 0;
   loop
   {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+    if ((k>=resolution->length()) || ((*resolution)[k]==0))
       break;
-    Print("%d",(*syzstr->resolution)[l]);
+    Print("%d",(*resolution)[k]);
     syPrintEmptySpaces1(sl+5);
-    l++;
+    k++;
   }
   PrintLn();
-  l = 0;
+  k = 0;
   loop
   {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+    if ((k>=resolution->length()) || ((*resolution)[k]==0))
       break;
     PrintS(sn);
-    if (((l+1)>=syzstr->resolution->length()) || ((*syzstr->resolution)[(l+1)]==0))
+    if (((k+1)>=resolution->length()) || ((*resolution)[(k+1)]==0))
       break;
     PrintS(" <-- ");
-    syPrintEmptySpaces((*syzstr->resolution)[l]);
-    l++;
+    syPrintEmptySpaces((*resolution)[k]);
+    k++;
   }
   PrintLn();
   PrintLn();
-  l = 0;
+  k = 0;
   loop
   {
-    if ((l>=syzstr->resolution->length()) || ((*syzstr->resolution)[l]==0))
+    if ((k>=resolution->length()) || ((*resolution)[k]==0))
       break;
-    Print("%d",l);
-    syPrintEmptySpaces1(sl+5+syLengthInt((*syzstr->resolution)[l])-
-                         syLengthInt(l));
-    l++;
+    Print("%d",k);
+    syPrintEmptySpaces1(sl+5+syLengthInt((*resolution)[k])-
+                         syLengthInt(k));
+    k++;
   }
   PrintLn();
@@ -2019 +2039 @@
     PrintLn();
   }
+
+  if (syzstr->resolution == NULL) syzstr->resolution = resolution; 
 }
 
@@ -2516 +2538 @@
     rChangeCurrRing(origR);
   pLmDelete(&redpol);
+
   if (TEST_OPT_PROT) PrintLn();
+
+  if (syzstr->minres==NULL)
+      if (syzstr->resPairs!=NULL)
+        if (syzstr->hilb_coeffs==NULL)
+          syzstr->minres = syReadOutMinimalRes(syzstr);
+  
   return syzstr;
 }