Changeset 9713ee in git

Timestamp:

Jul 17, 2013, 7:36:30 PM (10 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

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

Children:

2b2e08e9ac466fdf41a00e09569fbe1ea27db681a667138296109b29e11fe1654025d4581abfc50a

Parents:

22c7f081eb5086ea769d4b1bf61d4ca3f4a88b04

Message:

chg: update grobcov.lib

File:

• Singular/LIB/grobcov.lib (modified) (12 diffs)

Singular/LIB/grobcov.lib

@@ -1 @@
-/////////////////////////////////////////////////////////////////////////////
+//////////////////////////////////////////////////////////////////////////////
 version="version grobcov.lib 4.0.0.0 Jun_2013 ";
 category="General purpose";
@@ -222 +222 @@
 {
   if (size(J)==0){return(ideal(0));}
+  int te=0;
   def RR=basering;
+  if(not(defined(@RP)))
+  {
+    te=1;
+    setglobalrings();
+  }
   setring(@RP);
   def Ja=imap(RR,J);
@@ -232 +238 @@
   setring(RR);
   def Jc=imap(@RP,Jb);
+  if(te){kill @R; kill @RP; kill @P;}
   return(Jc);
 };
@@ -3718 +3725 @@
 proc groupKSWsegments(list T)
 {
+  //"T_T="; T;
   int i; int j;
   list L;
@@ -4044 +4052 @@
 //              If all levels of a class of locus are 1, then the set is locally closed. Otherwise the level
 //              gives the depth of the component.
-proc locus(list GG)
+proc locus(list GG, list #)
 "USAGE:   locus(G);
                The input must be the grobcov  of a parametrical ideal
@@ -4063 +4071 @@
   int t1=1; int t2=1;
   def R=basering;
+  int moverdim=nvars(R);
+  list Lop=#;
+  if(size(Lop)>0){moverdim=Lop[1];}
   setglobalrings();
   list G1; list G2;
@@ -4071 +4082 @@
   {
     attrib(G[i][1],"IsSB",1);
-    d=dim(std(G[i][1]));
+    //d=dim(std(G[i][1]));
+    // ULL
+    d=locusdim(G[i][2],moverdim);
     if(d==0){G1[size(G1)+1]=G[i];}
     else
@@ -4257 +4270 @@
 // locusdg is the routine for computing the locus in dinamical geometry.
 //    It detects automatically a possible point that is to be avoided by the mover,
-//    whose coordinates must be the last two coordinates in the definition of the ring.
+//    whose coordinates must be the last coordinates in the definition of the ring (2 last by default,
+//    or the dd last if the option locusdg(G,dd) is specified).
 //    If such a point is detected, then it eliminates the segments of the grobcov that
 //    have this point as solution.
 //    Then it calls locus.
-proc locusdg(list GG)
+proc locusdg(list GG,list #)
 "USAGE:  locusdg(GG) ;
           The argument must be the output of grobcov
@@ -4272 +4286 @@
 {
   def R=basering;
+  int dd=2; int comment=0;
+  list DD=#;
+  if (size(DD)>1){comment=1;}
+  if(size(DD)>0){dd=DD[1];}
   int i; int j; int k;
   def B0=GG[1][2];
@@ -4307 +4325 @@
     if(te)
     {
-      //"T_N="; N;
+      string("locusdg detected that the mover must avoid point (",N,") in order to obtain the locus");
       // eliminate segments of GG where N is contained in the basis
       list nGP;
@@ -4323 +4341 @@
         if(te==0){nGP[size(nGP)+1]=GP[j];}
       }
-      //"T_nGP="; nGP;
-      // Now eliminate components for which the basis has dim>0, and all elements non reducing to 0
-      // modulo N do not contain the mover coordinates
-      list nnGP; poly r;
-      for(j=1; j<=size(nGP);j++)
-      {
-        if(not(indepparameters(nGP[j][2])))
-        {
-          if(dim(std(nGP[j][1]))==0){nnGP[size(nnGP)+1]=nGP[j];}
-          else
-          {
-            te=1; k=1;
-            while(te and k<=size(nGP[2]))
-            {
-              r=pdivi(nGP[j][2][k],N)[1];
-              if(r==0){k++;}
-              else
-              {
-                if(not(subset(variables(nGP[j][2][k]),vmov )))
-                {
-                  te=0;
-                }
-                else{k++;}
-              }
-            }
-            if(te==1){nnGP[size(nnGP)+1]=nGP[j];}
-          }
-        }
-      }
-    }
-    kill @RP; kill @P; kill @R;
-    return(locus(nnGP));
-  }
-}
+   }
+  }
+  //"T_nGP="; nGP;
+  kill @RP; kill @P; kill @R;
+  return(locus(nGP,dd));
+}
+//      // Now eliminate components for which the basis has dim>0, and all elements non reducing to 0
+//      // modulo N do not contain the mover coordinates
+//      list nnGP; poly r;
+//      for(j=1; j<=size(nGP);j++)
+//      {
+//        if(not(indepparameters(nGP[j][2])))
+//        {
+//          if(dim(std(nGP[j][1]))==0){nnGP[size(nnGP)+1]=nGP[j];}
+//          else
+//          {
+//            te=1; k=1;
+//            while(te and k<=size(nGP[2]))
+//            {
+//              r=pdivi(nGP[j][2][k],N)[1];
+//              if(r==0){k++;}
+//              else
+//              {
+//                if(not(subset(variables(nGP[j][2][k]),vmov )))
+//                {
+//                  te=0;
+//                }
+//                else{k++;}
+//              }
+//            }
+//            if(te==1){nnGP[size(nnGP)+1]=nGP[j];}
+//          }
+//        }
+//      }
+//
+//    }
+//    kill @RP; kill @P; kill @R;
+//    return(locus(nnGP));
+//  }
+//}
 example
 {"EXAMPLE:"; echo = 2;
@@ -4369 +4393 @@
 }
 
+// locusdim
+// input:
+//    B:         ideal, a basis of a segment of the grobcov
+//    dgdim: int, the dimension of the mover (for locusdg)
+//                by default dgdim is equal to the number of variables
+proc locusdim(ideal B, list #)
+{
+  def R=basering;
+  int dgdim;
+  int nv=nvars(R);
+  if (size(#)>0){dgdim=#[1];}
+  else {dgdim=nv;}
+  int d;
+  list v;
+  ideal vi;
+  int i;
+  for(i=1;i<=dgdim;i++)
+  {
+    v[size(v)+1]=varstr(nv-dgdim+i);
+    vi[size(v)+1]=var(nv-dgdim+i);
+  }
+  ideal B0;
+  for(i=1;i<=size(B);i++)
+  {
+    if(subset(variables(B[i]),vi))
+    {
+      B0[size(B0)+1]=B[i];
+    }
+  }
+  //"T_B0="; B0;
+  //"T_v="; v;
+  def RR=ringlist(R);
+  def RR0=RR;
+  RR0[2]=v;
+  def R0=ring(RR0);
+  //ringlist(R0);
+  setring(R0);
+  def B0r=imap(R,B0);
+  B0r=std(B0r);
+  d=dim(B0r);
+  setring R;
+  return(d);
+}
+
 
 //********************* End locus ****************************