Changeset c10f46 in git

Timestamp:

Aug 3, 2012, 1:06:22 PM (11 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', 'e7cc1ebecb61be8b9ca6c18016352af89940b21a')

Children:

b0732eb4254fbe76540d72c337f3d7f985adf948

Parents:

b8610796eaca5ba7db8dc75f8bc88d698e077b365abb0e7fdca82a2bad9778e410148c74d7b49a0b

Message:

Merge pull request #162 from steenpass/libs

changes in LIBs from master

Files:

• Singular/LIB/modstd.lib (modified) (34 diffs)
• Singular/LIB/parallel.lib (modified) (6 diffs)
• Singular/LIB/realclassify.lib (modified) (6 diffs)
• Tst/Short/parallel_l.tst (added)
• Tst/Short/realclassify_l.tst (added)
• factory/libfac/Makefile.am (modified) (1 diff)
• factory/libfac/charset/alg_factor.cc (modified) (29 diffs)
• factory/libfac/charset/charset.cc (modified) (1 diff)
• factory/libfac/configure (modified) (2 diffs)
• factory/libfac/configure.in (modified) (1 diff)
• factory/libfac/factor/Factor.cc (modified) (11 diffs)
• factory/libfac/tests/factor/f1 (deleted)
• factory/libfac/tests/factor/f10 (deleted)
• factory/libfac/tests/factor/f11 (deleted)
• factory/libfac/tests/factor/f12 (deleted)
• factory/libfac/tests/factor/f13 (deleted)
• factory/libfac/tests/factor/f14 (deleted)
• factory/libfac/tests/factor/f15 (deleted)
• factory/libfac/tests/factor/f16 (deleted)
• factory/libfac/tests/factor/f17 (deleted)
• factory/libfac/tests/factor/f18 (deleted)
• factory/libfac/tests/factor/f19 (deleted)
• factory/libfac/tests/factor/f2 (deleted)
• factory/libfac/tests/factor/f20 (deleted)
• factory/libfac/tests/factor/f21 (deleted)
• factory/libfac/tests/factor/f21a (deleted)
• factory/libfac/tests/factor/f22 (deleted)
• factory/libfac/tests/factor/f23 (deleted)
• factory/libfac/tests/factor/f24 (deleted)
• factory/libfac/tests/factor/f25 (deleted)
• factory/libfac/tests/factor/f26 (deleted)
• factory/libfac/tests/factor/f27 (deleted)
• factory/libfac/tests/factor/f28 (deleted)
• factory/libfac/tests/factor/f29 (deleted)
• factory/libfac/tests/factor/f3 (deleted)
• factory/libfac/tests/factor/f32 (deleted)
• factory/libfac/tests/factor/f33 (deleted)
• factory/libfac/tests/factor/f34 (deleted)
• factory/libfac/tests/factor/f35 (deleted)
• factory/libfac/tests/factor/f36 (deleted)
• factory/libfac/tests/factor/f37 (deleted)
• factory/libfac/tests/factor/f38 (deleted)
• factory/libfac/tests/factor/f39 (deleted)
• factory/libfac/tests/factor/f4 (deleted)
• factory/libfac/tests/factor/f40 (deleted)
• factory/libfac/tests/factor/f41 (deleted)
• factory/libfac/tests/factor/f42 (deleted)
• factory/libfac/tests/factor/f43 (deleted)
• factory/libfac/tests/factor/f5 (deleted)
• factory/libfac/tests/factor/f6 (deleted)
• factory/libfac/tests/factor/f7 (deleted)
• factory/libfac/tests/factor/f8 (deleted)
• factory/libfac/tests/factor/f9 (deleted)
• factory/libfac/tests/factor/p1 (deleted)
• factory/libfac/tests/factor/p2 (deleted)
• factory/libfac/tests/factor/p3 (deleted)
• factory/libfac/tests/factor/p4 (deleted)
• factory/libfac/tests/factor/p5.3 (deleted)
• factory/libfac/tests/factortest (deleted)
• factory/variable.cc (modified) (1 diff)
• factory/variable.h (modified) (2 diffs)

Singular/LIB/modstd.lib

@@ -1 +1 @@
 ////////////////////////////////////////////////////////////////////////////////
-version="$Id$";
+version="$Id: modstd.lib 14375 2011-08-23 09:29:47Z steidel $";
 category = "Commutative Algebra";
 info="
@@ -8 +8 @@
 @*        G. Pfister      pfister@mathematik.uni-kl.de
 @*        H. Schoenemann  hannes@mathematik.uni-kl.de
+@*        A. Steenpass    steenpass@mathematik.uni-kl.de
 @*        S. Steidel      steidel@mathematik.uni-kl.de
 
@@ -26 +27 @@
 LIB "poly.lib";
 LIB "ring.lib";
+LIB "parallel.lib";
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -243 +245 @@
       if(printlevel >= 11)
       {
-         "isIncluded(K,J) takes "+string(timer - t)+" seconds";
+         "isIncluded(J,K) takes "+string(timer - t)+" seconds";
          "j = "+string(j);
       }
@@ -373 +375 @@
 ////////////////////////////////////////////////////////////////////////////////
 
-proc primeTest(ideal I, bigint p)
+proc primeTest(def II, bigint p)
 {
+   if(typeof(II) == "string")
+   {
+      execute("ideal I = "+II+";");
+   }
+   else
+   {
+      ideal I = II;
+   }
+
+   I = simplify(I, 2);   // erase zero generators
+
    int i,j;
+   poly f;
+   number cnt;
    for(i = 1; i <= size(I); i++)
    {
-      for(j = 1; j <= size(I[i]); j++)
-      {
-         if((numerator(leadcoef(I[i][j])) mod p) == 0) { return(0); }
-         if((denominator(leadcoef(I[i][j])) mod p) == 0) { return(0); }
+      f = cleardenom(I[i]);
+      if(f == 0) { return(0); }
+      cnt = leadcoef(I[i])/leadcoef(f);
+      if((numerator(cnt) mod p) == 0) { return(0); }
+      if((denominator(cnt) mod p) == 0) { return(0); }
+      for(j = size(f); j > 0; j--)
+      {
+         if((leadcoef(f[j]) mod p) == 0) { return(0); }
       }
    }
@@ -390 +409 @@
 
 proc primeList(ideal I, int n, list #)
-"USAGE:  primeList(I,n); ( resp. primeList(I,n,L); ) I ideal, n integer
-RETURN:  the intvec of n greatest primes  <= 2147483647 (resp. n greatest primes
+"USAGE:  primeList(I,n[,ncores]); ( resp. primeList(I,n[,L,ncores]); ) I ideal,
+         n integer
+RETURN:  the intvec of n greatest primes <= 2147483647 (resp. n greatest primes
          < L[size(L)] union with L) such that none of these primes divides any
          coefficient occuring in I
+NOTE:    The number of cores to use can be defined by ncores, default is 1.
 EXAMPLE: example primList; shows an example
 "
@@ -399 +420 @@
    intvec L;
    int i,p;
+   int ncores = 1;
+   
+//-----------------  Initialize optional parameter ncores  ---------------------
+   if(size(#) > 0)
+   {
+      if(size(#) == 1)
+      {
+         if(typeof(#[1]) == "int")
+         {
+            ncores = #[1];
+            # = list();
+         }
+      }
+      else
+      {
+         ncores = #[2];
+      }
+   }
+   
    if(size(#) == 0)
    {
@@ -421 +461 @@
    }
    if(p == 2) { ERROR("no more primes"); }
-   for(i = 2; i <= n; i++)
-   {
-      p = prime(p-1);
-      while(!primeTest(I,p))
+   if(ncores == 1)
+   {
+      for(i = 2; i <= n; i++)
       {
          p = prime(p-1);
-         if(p == 2) { ERROR("no more primes"); }
-      }
-      L[size(L)+1] = p;
+         while(!primeTest(I,p))
+         {
+            p = prime(p-1);
+            if(p == 2) { ERROR("no more primes"); }
+         }
+         L[size(L)+1] = p;
+      }
+   }
+   else
+   {
+      int neededSize = size(L)+n-1;;
+      list parallelResults;
+      list arguments;
+      int neededPrimes = neededSize-size(L);
+      while(neededPrimes > 0)
+      {
+         arguments = list();
+         for(i = ((neededPrimes div ncores)+1-(neededPrimes%ncores == 0))
+            *ncores; i > 0; i--)
+         {
+            p = prime(p-1);
+            if(p == 2) { ERROR("no more primes"); }
+            arguments[i] = list("I", p);
+         }
+         parallelResults = parallelWaitAll("primeTest", arguments,
+            list(list(list(ncores))));
+         for(i = size(arguments); i > 0; i--)
+         {
+            if(parallelResults[i])
+            {
+               L[size(L)+1] = arguments[i][2];
+            }
+         }
+         neededPrimes = neededSize-size(L);
+      }
+      if(size(L) > neededSize)
+      {
+         L = L[1..neededSize];
+      }
    }
    return(L);
@@ -470 +545 @@
    ideal I = imap(R,I);
 
+   intvec opt = option(get);
    option(none);
    option(prompt);
@@ -504 +580 @@
 
    setring R;
+   option(set, opt);
    return(imap(newR,sI),imap(newR,T));
 }
@@ -537 +614 @@
          The standard basis computation modulo p does also vary depending on the
          integer variant, namely
-@*       - variant = 1/4: std(.,#[1]) resp. groebner,
-@*       - variant = 2/5: groebner,
-@*       - variant = 3/6: homog. - std(.,#[1]) resp. groebner - dehomog..
+@*       - variant = 1: std(.,#[1]) resp. groebner,
+@*       - variant = 2: groebner,
+@*       - variant = 3: homog. - std(.,#[1]) resp. groebner - dehomog.,
+@*       - variant = 4: fglm.
 EXAMPLE: example modpStd; shows an example
 "
@@ -552 +630 @@
    option(redSB);
 
-   int t = timer;
-   if((variant == 1) || (variant == 4))
+   if(variant == 1)
    {
       if(size(#) > 0)
@@ -565 +642 @@
    }
 
-   if((variant == 2) || (variant == 5))
+   if(variant == 2)
    {
       i = groebner(i);
    }
 
-   if((variant == 3) || (variant == 6))
+   if(variant == 3)
    {
       list rl = ringlist(@r);
@@ -607 +684 @@
       }
 
-      t = timer;
       i = subst(i, homvar, 1);
       i = simplify(i, 34);
@@ -615 +691 @@
       i = interred(i);
       kill HomR;
+   }
+   
+   if(variant == 4)
+   {
+      def R1 = changeord("dp");
+      setring R1;
+      ideal i = fetch(@r,i);
+      i = std(i);
+      setring @r;
+      i = fglm(R1,i);
    }
 
@@ -646 +732 @@
 RETURN:  a standard basis of I if no warning appears;
 NOTE:    The procedure computes a standard basis of I (over the rational
-         numbers) by using  modular methods. If a warning appears then the
-         result is a standard basis containing I and with high probability
-         a standard basis of I.
+         numbers) by using  modular methods.
          By default the procedure computes a standard basis of I for sure, but
          if the optional parameter #[2] = 0, it computes a standard basis of I
-         with high probability and a warning appears at the end.
+         with high probability.
          The procedure distinguishes between different variants for the standard
          basis computation in positive characteristic depending on the ordering
          of the basering, the parameter #[2] and if the ideal I is homogeneous.
-@*       - variant = 1, if I is homogeneous and exactness = 0,
-@*       - variant = 2, if I is not homogeneous, 1-block-ordering and
-                        exactness = 0,
+@*       - variant = 1, if I is homogeneous,
+@*       - variant = 2, if I is not homogeneous, 1-block-ordering,
 @*       - variant = 3, if I is not homogeneous, complicated ordering (lp or
-                        > 1 block) and exactness = 0,
-@*       - variant = 4, if I is homogeneous and exactness = 1,
-@*       - variant = 5, if I is not homogeneous, 1-block-ordering and
-                        exactness = 1,
-@*       - variant = 6, if I is not homogeneous, complicated ordering (lp or
-                        > 1 block) and exactness = 1.
+                        > 1 block),
+@*       - variant = 4, if I is not homogeneous, ordering lp, dim(I) = 0.
 EXAMPLE: example modStd; shows an example
 "
@@ -752 +831 @@
    if(printlevel >= 10)
    {
-      "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3);
+      "n1 = "+string(n1)+", n2 = "+string(n2)+", n3 = "+string(n3)
+       +", exactness = "+string(exactness);
    }
 
@@ -761 +841 @@
 
 //--------------------  Initialize the list of primes  -------------------------
-   intvec L = primeList(I,n2);
+   int tt = timer;
+   int rt = rtimer;
+   intvec L = primeList(I,n2,n1);
+   if(printlevel >= 10)
+   {
+      "CPU-time for primeList: "+string(timer-tt)+" seconds.";
+      "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
+   }
    L[5] = prime(random(an,en));
 
@@ -768 +855 @@
    int h = homog(I);
 
-   int tt = timer;
-   int rt = rtimer;
+   tt = timer;
+   rt = rtimer;
 
    if(!mixedTest())
@@ -775 +862 @@
       if(h)
       {
-         if(exactness == 0)
-         {
-            variant = 1;
-            if(printlevel >= 10) { "variant = 1"; }
-         }
-         if(exactness == 1)
-         {
-            variant = 4;
-            if(printlevel >= 10) { "variant = 4"; }
-         }
+         variant = 1;
+         if(printlevel >= 10) { "variant = 1"; }
+         
          rl[1] = L[5];
          def @r = ring(rl);
@@ -802 +882 @@
          if((find(ordstr_R0, "M") > 0) || (find(ordstr_R0, "a") > 0) || neg)
          {
-            if(exactness == 0)
-            {
-               variant = 2;
-               if(printlevel >= 10) { "variant = 2"; }
-            }
-            if(exactness == 1)
-            {
-               variant = 5;
-               if(printlevel >= 10) { "variant = 5"; }
-            }
+            variant = 2;
+            if(printlevel >= 10) { "variant = 2"; }
          }
          else
@@ -827 +899 @@
             if((order == "simple") || (size(rl) > 4))
             {
-               if(exactness == 0)
+               variant = 2;
+               if(printlevel >= 10) { "variant = 2"; }
+            }
+            else
+            {
+               rl[1] = L[5];
+               def @r = ring(rl);
+               setring @r;
+               
+               def @s = changeord("dp");
+               setring @s;
+               ideal I = std(fetch(R0,I));
+               if(dim(I) == 0)
                {
-                  variant = 2;
-                  if(printlevel >= 10) { "variant = 2"; }
+                  variant = 4;
+                  if(printlevel >= 10) { "variant = 4"; }
                }
-               if(exactness == 1)
-               {
-                  variant = 5;
-                  if(printlevel >= 10) { "variant = 5"; }
-               }
-            }
-            else
-            {
-               if(exactness == 0)
+               else
                {
                   variant = 3;
                   if(printlevel >= 10) { "variant = 3"; }
+                  
+                  int nvar@r = nvars(@r);
+                  intvec w;
+                  for(i = 1; i <= nvar@r; i++)
+                  {
+                     w[i] = deg(var(i));
+                  }
+                  w[nvar@r + 1] = 1;
+
+                  list hiRi = hilbRing(fetch(R0,I),w);
+                  intvec W = hiRi[2];
+                  @s = hiRi[1];
+                  setring @s;
+
+                  Id(1) = std(Id(1));
+                  intvec hi = hilb(Id(1), 1, W);
                }
-               if(exactness == 1)
-               {
-                  variant = 6;
-                  if(printlevel >= 10) { "variant = 6"; }
-               }
-
-               rl[1] = L[5];
-               def @r = ring(rl);
-               setring @r;
-               int nvar@r = nvars(@r);
-               intvec w;
-               for(i = 1; i <= nvar@r; i++)
-               {
-                  w[i] = deg(var(i));
-               }
-               w[nvar@r + 1] = 1;
-
-               list hiRi = hilbRing(fetch(R0,I),w);
-               intvec W = hiRi[2];
-               def @s = hiRi[1];
-               setring @s;
-
-               Id(1) = std(Id(1));
-               intvec hi = hilb(Id(1), 1, W);
-
+               
                setring R0;
                kill @r,@s;
@@ -971 +1039 @@
          link l(i) = "ssi:fork";
          open(l(i));
-         if((variant == 1) || (variant == 3) ||
-            (variant == 4) || (variant == 6))
+         if((variant == 1) || (variant == 3))
          {
             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
                                                   eval(variant), eval(hi))));
          }
-         if((variant == 2) || (variant == 5))
+         if((variant == 2) || (variant == 4))
          {
             write(l(i), quote(modpStd(I_for_fork, eval(L[i + 1]),
@@ -985 +1052 @@
 
       int t = timer;
-      if((variant == 1) || (variant == 3) || (variant == 4) || (variant == 6))
+      if((variant == 1) || (variant == 3))
       {
          P = modpStd(I_for_fork, L[1], variant, hi);
       }
-      if((variant == 2) || (variant == 5))
+      if((variant == 2) || (variant == 4))
       {
          P = modpStd(I_for_fork, L[1], variant);
@@ -1005 +1072 @@
 //--------------  Main standard basis computations in positive  ----------------
 //----------------------  characteristic start here  ---------------------------
+
+   list arguments_farey, results_farey;
 
    while(1)
@@ -1029 +1098 @@
                   if(j <= size(L))
                   {
-                     if((variant == 1) || (variant == 3) ||
-                        (variant == 4) || (variant == 6))
+                     if((variant == 1) || (variant == 3))
                      {
                         write(l(i), quote(modpStd(I_for_fork, eval(L[j]),
@@ -1036 +1104 @@
                         j++;
                      }
-                     if((variant == 2) || (variant == 5))
+                     if((variant == 2) || (variant == 4))
                      {
                         write(l(i), quote(modpStd(I_for_fork,
@@ -1062 +1130 @@
          while(j <= size(L))
          {
-            if((variant == 1) || (variant == 3) ||
-               (variant == 4) || (variant == 6))
+            if((variant == 1) || (variant == 3))
             {
                P = modpStd(I, L[j], variant, hi);
             }
-            if((variant == 2) || (variant == 5))
+            if((variant == 2) || (variant == 4))
             {
                P = modpStd(I, L[j], variant);
@@ -1095 +1162 @@
 //-------------------  Lift results to basering via farey  ---------------------
 
-      tt = timer;
+      tt = timer; rt = rtimer;
       N = T2[1];
       for(i = 2; i <= size(T2); i++) { N = N*T2[i]; }
       H = chinrem(T1,T2);
-      J = farey(H,N);
-      if(printlevel >= 10) { "Lifting-process takes "+string(timer - tt)
-                             +" seconds"; }
+      if(n1 == 1)
+      {
+         J = farey(H,N);
+      }
+      else
+      {
+         for(i = ncols(H); i > 0; i--)
+         {
+            arguments_farey[i] = list(ideal(H[i]), N);
+         }
+         results_farey = parallelWaitAll("farey", arguments_farey,
+                                         list(list(list(n1))));
+         for(i = ncols(H); i > 0; i--)
+         {
+            J[i] = results_farey[i][1];
+         }
+      }
+      if(printlevel >= 10)
+      {
+         "CPU-time for lifting-process is "+string(timer - tt)+" seconds.";
+         "Real-time for lifting-process is "+string(rtimer - rt)+" seconds.";
+      }
 
 //----------------  Test if we already have a standard basis of I --------------
 
       tt = timer; rt = rtimer;
-      if((variant == 1) || (variant == 3) || (variant == 4) || (variant == 6))
+      if((variant == 1) || (variant == 3))
       {
          pTest = pTestSB(I,J,L,variant,hi);
       }
-      if((variant == 2) || (variant == 5))
+      if((variant == 2) || (variant == 4))
       {
          pTest = pTestSB(I,J,L,variant);
@@ -1132 +1218 @@
 
          attrib(J,"isSB",1);
-         tt = timer; rt = rtimer;
-         sizeTest = 1 - isIncluded(I,J,n1);
-
-         if(printlevel >= 10)
-         {
-            "CPU-time for checking if I subset <G> is "
-            +string(timer - tt)+" seconds.";
-            "Real-time for checking if I subset <G> is "
-            +string(rtimer - rt)+" seconds.";
-         }
-
-         if(sizeTest == 0)
-         {
-            if((variant == 1) || (variant == 2) || (variant == 3))
-            {
-               "===========================================================";
-               "WARNING: Output might not be a standard basis of the input.";
-               "===========================================================";
-               option(set, opt);
-               if(n1 > 1) { kill I_for_fork; }
-               return(J);
-            }
-            if((variant == 4) || (variant == 5) || (variant == 6))
+         
+         if(exactness == 0)
+         {
+            option(set, opt);
+            if(n1 > 1) { kill I_for_fork; }
+            return(J);
+         }
+         
+         if(exactness == 1)
+         {
+            tt = timer; rt = rtimer;
+            sizeTest = 1 - isIncluded(I,J,n1);
+
+            if(printlevel >= 10)
+            {
+               "CPU-time for checking if I subset <G> is "
+               +string(timer - tt)+" seconds.";
+               "Real-time for checking if I subset <G> is "
+               +string(rtimer - rt)+" seconds.";
+            }
+
+            if(sizeTest == 0)
             {
                tt = timer; rt = rtimer;
@@ -1185 +1270 @@
 
       j = size(L) + 1;
-      L = primeList(I,n3,L);
+      tt = timer; rt = rtimer;
+      L = primeList(I,n3,L,n1);
+      if(printlevel >= 10)
+      {
+         "CPU-time for primeList: "+string(timer-tt)+" seconds.";
+         "Real-time for primeList: "+string(rtimer-rt)+" seconds.";
+      }
 
       if(n1 > 1)
@@ -1192 +1283 @@
          {
             open(l(i));
-            if((variant == 1) || (variant == 3) ||
-               (variant == 4) || (variant == 6))
+            if((variant == 1) || (variant == 3))
             {
                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
                                                      eval(variant), eval(hi))));
             }
-            if((variant == 2) || (variant == 5))
+            if((variant == 2) || (variant == 4))
             {
                write(l(i), quote(modpStd(I_for_fork, eval(L[j+i-1]),
@@ -1318 +1408 @@
    def S = ring(rl);
    setring S;
+   intvec opt = option(get);
    option(redSB);
    module Z,M,Z2;
@@ -1362 +1453 @@
                if(size(reduce(G3,testG1)) == 0)
                {
+                  option(set, opt);
                   return(G3);
                }

Singular/LIB/parallel.lib

@@ -3 +3 @@
 category="General purpose";
 info="
-LIBRARY:   parallel.lib  An Interface for Parallelization
+LIBRARY:   parallel.lib  Tools for Parallelization
 AUTHOR:    Andreas Steenpass, e-mail: steenpass@mathematik.uni-kl.de
+
+OVERVIEW:
+This library provides tools to do several computations in parallel. They
+are aimed at ordinary Singular users as well as authors of Singular
+libraries.
+@* Even without this library, it is possible to do execute self-defined
+Singular commands in parallel using @ref{links}, but the handling of
+such links can be quite tedious. With the pocedures described below,
+this can be done by one-line commands.
+@* There are many parallel 'skeletons' (i.e. ways in which parallel
+tasks rely upon and interact with each other). A few of them are already
+implemented. Future plans include an abstraction layer for modular
+techniques, 'worker farms', and parallel tests.
 
 SEE ALSO:  link, modstd_lib, assprimeszerodim_lib
@@ -26 +39 @@
 RETURN:  a list, containing the results of commands[i] applied to arg[i],
          i = 1, ..., size(commands).
-         @* The entries of the list commands must be strings.
-         @* The entries of the list args must be lists.
          @* The procedure waits for N jobs to finish.
-         @* An optional timeout in ms can be provided. Default is 0 which
+
+         @* OPTIONAL PARAMETERS:
+
+            An optional timeout in ms can be provided. Default is 0 which
             disables the timeout.
-         @* Supported linktypes are up to now \"ssi\" and \"mp\", see
+
+            Supported linktypes are up to now \"ssi\" and \"mp\", see
             @ref{Ssi links} and @ref{MP links}.
+
+            Servers:
          @* Each server is given by a list containing the address of the server,
             the number of cores to use on this server and the command to start
-            Singular. If the address is \"localhost\", the processes will
-            be generated on the same machine using forks. If the command to
-            start Singular is \"\" (the empty string), \"Singular\" will be
-            used. Default is @code{list(\"localhost\", system(\"cpu\"), \"\")}.
-            There are some obvious shortcuts for servers, e.g. \"myserver\" is
+            Singular.
+         @* If the address is \"localhost\", the processes will be generated on
+            the same machine using forks. If the command to start Singular is
+            \"\" (the empty string), \"Singular\" will be used.
+         @* Default is @code{list(\"localhost\", system(\"cpu\"), \"\")}.
+         @* There are some obvious shortcuts for servers, e.g. \"myserver\" is
             a shortcut for
             @code{list(\"myserver\", [nb. of cores on myserver], \"\")}, or 3
             for @code{list(\"localhost\", 3, \"\")}.
+
+            Memory limits:
          @* If an intvec maxmemory of size @code{size(commands)} is given, the
             i-th job will be killed if it uses more than maxmemory[i] MB of
             memory. If maxmemory[i] is 0, there will be no restraint for the
             i-th job. Default is @code{0:size(commands)}.
-NOTE:       The returned list may contain more than N results if several jobs
+NOTE:       The entries of the list commands must be strings.
+         @* The entries of the list args must be lists.
+         @* The returned list may contain more than N results if several jobs
             finished \"at the same time\". It may contain less than N results in
             the case of timeout or errors occurring.
@@ -368 +390 @@
     }
     write(l(i), quote(execute("result = "+eval(commands[k])
-                                    +"(currentargs[1..size(currentargs)]);")));
+      +"("+argsToString("currentargs", size(currentargs))+");")));
     assignment[i] = k;
     k++;
@@ -455 +477 @@
       }
       write(l(wait), quote(execute("def result = "+eval(commands[k])
-                                     +"(currentargs[1..size(currentargs)]);")));
+        +"("+argsToString("currentargs", size(currentargs))+");")));
       assignment[wait] = k;
       k++;
@@ -542 +564 @@
   ideal i = z8+z6+4z5+4z3+4z2+4, y-z2;
   ideal j = 3x3y+x3+xy3+y2z2, 2x3z-xy-xz3-y4-z2, 2x2yz-2xy2+xz2-y4;
-  list commands = list("std", "primdecGTZ", "primdecSY", "std", "primdecGTZ",
-                       "primdecSY");
+  list commands = list("std", "primdecGTZ", "primdecSY",
+                       "std", "primdecGTZ", "primdecSY");
   list args = list(list(i), list(i), list(i), list(j), list(j), list(j));
   parallelWaitN(commands, args, 3);
@@ -717 +739 @@
   return(i);
 }
+
+static proc argsToString(string name, int length)
+{
+  string arglist;
+  if(length > 0) {
+    arglist = name+"[1]";
+  }
+  int i;
+  for(i = 2; i <= length; i++) {
+    arglist = arglist+", "+name+"["+string(i)+"]";
+  }
+  return(arglist);
+}

Singular/LIB/realclassify.lib

@@ -9 +9 @@
 OVERVIEW:
    A library for classifying isolated hypersurface singularities over the reals
-   w.r.t. right
-   equivalence, based on the determinator of singularities by V.I. Arnold.
-   This library is based on classify.lib by Kai Krueger, but handles the real
-   case, while classify.lib does the complex classification.
+   w.r.t. right equivalence, based on the determinator of singularities by
+   V.I. Arnold. This library is based on classify.lib by Kai Krueger, but
+   handles the real case, while classify.lib does the complex classification.
+
+REFERENCES:
+Arnold, Varchenko, Gusein-Zade: Singularities of Differentiable Maps.
+Vol. 1: The classification of critical points caustics and wave fronts.
+Birkh\"auser, Boston 1985
+
+Greuel, Lossen, Shustin: Introduction to singularities and deformations.
+Springer, Berlin 2007
 
 PROCEDURES:
@@ -31 +38 @@
 RETURN:   A list containing (in this order)
           @* - the type of the singularity as a string,
-          @* - the normal form as well as
+          @* - the normal form,
           @* - the corank, the Milnor number, the inertia index and
                a bound for the determinacy as integers.
@@ -778 +785 @@
   "EXAMPLE:";
   echo = 2;
-  LIB "realclassify.lib";
   ring r = 0, (x,y,z), ds;
   poly f = (x2+3y-2z)^2+xyz-(x-y3+x2z3)^3;
@@ -1006 +1012 @@
   "EXAMPLE:";
   echo = 2;
-  LIB "realclassify.lib";
   ring r = 0, (x,y,z), ds;
   poly f = (x2+3y-2z)^2+xyz-(x-y3+x2z3)^3;
@@ -1053 +1058 @@
   "EXAMPLE:";
   echo = 2;
-  LIB "realclassify.lib";
   ring r = 0, (x,y), ds;
   poly f = x3+y4;
@@ -1145 +1149 @@
   "EXAMPLE:";
   echo = 2;
-  LIB "realclassify.lib";
   ring r = 0, (x,y), ds;
   poly f = x3+xy3;

factory/libfac/Makefile.am

@@ -48 +48 @@
 EXTRA_DIST = factor/class.cc \
       factor/test.cc test.cc testcs.cc header.tpl \
-      tests charset/tests bin \
+      charset/tests bin \
       ChangeLog 00README 
 

factory/libfac/charset/alg_factor.cc

@@ -2 +2 @@
 // emacs edit mode for this file is -*- C++ -*-
 ////////////////////////////////////////////////////////////
-////////////////////////////////////////////////////////////
+
 // FACTORY - Includes
 #include <factory.h>
@@ -18 +18 @@
 #include "alg_factor.h"
 
-void out_cf(char *s1,const CanonicalForm &f,char *s2);
+void out_cf(const char *s1,const CanonicalForm &f,const char *s2);
 
 #ifdef ALGFACTORDEBUG
@@ -80 +80 @@
 // replacement for factory's broken psr
 static CanonicalForm
-mypsr ( const CanonicalForm &rr, const CanonicalForm &vv, const Variable & x ){
+mypsr ( const CanonicalForm &rr, const CanonicalForm &vv, const Variable & x )
+{
   CanonicalForm r=rr, v=vv, l, test, lu, lv, t, retvalue;
   int dr, dv, d,n=0;
@@ -104 +105 @@
 // replacement for factory's broken resultant
 static CanonicalForm
-resultante( const CanonicalForm & f, const CanonicalForm& g, const Variable & v ){
+resultante( const CanonicalForm & f, const CanonicalForm& g, const Variable & v )
+{
   bool on_rational = isOn(SW_RATIONAL);
   On(SW_RATIONAL);
@@ -113 +115 @@
   if (!on_rational)  Off(SW_RATIONAL);
 
-return resultant(fz,gz,v);
+  return resultant(fz,gz,v);
 }
 
@@ -133 +135 @@
 sqrf_norm_sub( const CanonicalForm & f, const CanonicalForm & PPalpha,
            CFGenerator & myrandom, CanonicalForm & s,  CanonicalForm & g,
-           CanonicalForm & R){
+           CanonicalForm & R)
+{
   Variable y=PPalpha.mvar(),vf=f.mvar();
   CanonicalForm temp, Palpha=PPalpha, t;
@@ -147 +150 @@
 
   // Norm, resultante taken with respect to y
-  while ( !sqfreetest ){
+  while ( !sqfreetest )
+  {
     DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
     R = resultante(Palpha, g, y); R= R* bCommonDen(R);
@@ -160 +164 @@
       DEBOUTLN(CERR, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
     }
-    else{
+    else
+    {
       DEBOUTMSG(CERR, "Starting SqrFreeTest(R)!");
       // Look at SqrFreeTest!
@@ -169 +174 @@
       if (getAlgVar(R,X))
       {
-        if (R.isUnivariate())
           testlist=factorize( R, X );
-        else
-          testlist= Factorize(R, X, 0);
       }
       else
@@ -183 +185 @@
       DEBOUTLN(CERR, "SqrFreeTest(R)= ", sqfreetest);
     }
-    if ( ! sqfreetest ){
+    if ( ! sqfreetest )
+    {
       myrandom.next();
       DEBOUTLN(CERR, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
@@ -198 +201 @@
 sqrf_agnorm_sub( const CanonicalForm & f, const CanonicalForm & PPalpha,
            AlgExtGenerator & myrandom, CanonicalForm & s,  CanonicalForm & g,
-           CanonicalForm & R){
+           CanonicalForm & R)
+{
   Variable y=PPalpha.mvar(),vf=f.mvar();
   CanonicalForm temp, Palpha=PPalpha, t;
@@ -212 +216 @@
 
   // Norm, resultante taken with respect to y
-  while ( !sqfreetest ){
+  while ( !sqfreetest )
+  {
     DEBOUTLN(CERR, "sqrf_norm_sub: Palpha= ", Palpha);
     R = resultante(Palpha, g, y); R= R* bCommonDen(R);
@@ -225 +230 @@
       DEBOUTLN(CERR, "sqrf_norm_sub: sqfreetest= ", sqfreetest);
     }
-    else{
+    else
+    {
       DEBOUTMSG(CERR, "Starting SqrFreeTest(R)!");
       // Look at SqrFreeTest!
@@ -234 +240 @@
       if (getAlgVar(R,X))
       {
-        if (R.isUnivariate())
           testlist=factorize( R, X );
-        else
-          testlist= Factorize(R, X, 0);
       }
       else
@@ -248 +251 @@
       DEBOUTLN(CERR, "SqrFreeTest(R)= ", sqfreetest);
     }
-    if ( ! sqfreetest ){
+    if ( ! sqfreetest )
+    {
       myrandom.next();
       DEBOUTLN(CERR, "sqrf_norm_sub generated new myrandom item: ", myrandom.item());
@@ -264 +268 @@
 sqrf_norm( const CanonicalForm & f, const CanonicalForm & PPalpha,
            const Variable & Extension, CanonicalForm & s,  CanonicalForm & g,
-           CanonicalForm & R){
-
+           CanonicalForm & R)
+{
   DEBOUTLN(CERR, "sqrf_norm:      f= ", f);
   DEBOUTLN(CERR, "sqrf_norm: Palpha= ", PPalpha);
-  if ( getCharacteristic() == 0 ) {
+  if ( getCharacteristic() == 0 )
+  {
     IntGenerator myrandom;
     DEBOUTMSG(CERR, "sqrf_norm: no extension, char=0");
@@ -278 +283 @@
     DEBOUTLN(CERR, "sqrf_norm:      R= ", R);
   }
-  else if ( degree(Extension) > 0 ){ // working over Extensions
+  else if ( degree(Extension) > 0 ) // working over Extensions
+  {
     DEBOUTLN(CERR, "sqrf_norm: degree of extension is ", degree(Extension));
     AlgExtGenerator myrandom(Extension);
     sqrf_agnorm_sub(f,PPalpha, myrandom, s,g,R);
   }
-  else{
+  else
+  {
     FFGenerator myrandom;
     DEBOUTMSG(CERR, "sqrf_norm: degree of extension is 0");
@@ -296 +303 @@
   Variable x;
 
-  for ( VarlistIterator i=uord; i.hasItem(); i++){
+  for ( VarlistIterator i=uord; i.hasItem(); i++)
+  {
     x=i.getItem();
-    for ( CFListIterator j=Astar; j.hasItem(); j++ ){
+    for ( CFListIterator j=Astar; j.hasItem(); j++ )
+    {
       elem= j.getItem();
-      if ( degree(elem,x) > 0 ){ // x actually occures in Astar
+      if ( degree(elem,x) > 0 ) // x actually occures in Astar
+      {
         output.append(x);
         break;
@@ -312 +322 @@
 // Must be a power of p: i.e. y^{p^e}-x
 static int
-inseperable(const CFList & Astar){
+inseperable(const CFList & Astar)
+{
   CanonicalForm elem;
   int Counter= 1;
 
   if ( Astar.length() == 0 ) return 0;
-  for ( CFListIterator i=Astar; i.hasItem(); i++){
+  for ( CFListIterator i=Astar; i.hasItem(); i++)
+  {
     elem= i.getItem();
     if ( elem.deriv() == elem.genZero() ) return Counter;
@@ -327 +339 @@
 // calculate gcd of f and g in char=0
 static CanonicalForm
-gcd0( CanonicalForm f, CanonicalForm g ){
+gcd0( CanonicalForm f, CanonicalForm g )
+{
   int charac= getCharacteristic();
   int save=isOn(SW_RATIONAL);
@@ -333 +346 @@
   CanonicalForm ff= mapinto(f), gg= mapinto(g);
   CanonicalForm result= gcd(ff,gg);
-  setCharacteristic(charac); 
+  setCharacteristic(charac);
   if (save) On(SW_RATIONAL);
   return mapinto(result);
@@ -344 +357 @@
 // have enough elements to plug in.
 static int
-getextension( IntList & degreelist, int n){
+getextension( IntList & degreelist, int n)
+{
   int charac= getCharacteristic();
   setCharacteristic(0); // need it for k !
@@ -543 +557 @@
 
 static CFFList
-endler( const CanonicalForm & f, const CFList & AS, const Varlist & uord ){
+endler( const CanonicalForm & f, const CFList & AS, const Varlist & uord )
+{
   CanonicalForm F=f, g, q,r;
   CFFList Output;
@@ -551 +566 @@
   Variable vg;
 
-  for (i=as; i.hasItem(); i++){
+  for (i=as; i.hasItem(); i++)
+  {
     g= i.getItem();
-    if (g.deriv() == 0 ){
+    if (g.deriv() == 0 )
+    {
       DEBOUTLN(CERR, "Inseperable extension detected: ", g);
-      for (j=uord; j.hasItem(); j++){
+      for (j=uord; j.hasItem(); j++)
+      {
         if ( degree(g,j.getItem()) > 0 ) vg= j.getItem();
       }
@@ -568 +586 @@
       // Now transform all remaining polys in as:
       int x=0;
-      for (ii=i; ii.hasItem(); ii++){
-        if ( x != 0 ){
+      for (ii=i; ii.hasItem(); ii++)
+      {
+        if ( x != 0 )
+        {
           divrem(ii.getItem(), gg, q,r);
 //          CERR << ii.getItem() << " divided by " << gg << "\n";
@@ -595 +615 @@
 
   // Transform back:
-  for ( CFFListIterator k=factorlist; k.hasItem(); k++){
+  for ( CFFListIterator k=factorlist; k.hasItem(); k++)
+  {
     CanonicalForm factor= k.getItem().factor();
     ii=One;
-    for (i=Two; i.hasItem(); i++){
+    for (i=Two; i.hasItem(); i++)
+    {
       DEBOUTLN(CERR, "Mapping ", i.getItem());
       DEBOUTLN(CERR, "     to ", ii.getItem());
@@ -618 +640 @@
 //           no transcendentals, seperable and inseperable extensions
 CFFList
-newfactoras( const CanonicalForm & f, const CFList & as, int &success){
+newfactoras( const CanonicalForm & f, const CFList & as, int &success)
+{
   Variable vf=f.mvar();
   CFListIterator i;
@@ -751 +774 @@
 
 CFFList
-newcfactor(const CanonicalForm & f, const CFList & as, int & success ){
+newcfactor(const CanonicalForm & f, const CFList & as, int & success )
+{
   Off(SW_RATIONAL);
-  CFFList Output, output, Factors=Factorize(f); On(SW_RATIONAL);
+  CFFList Output, output, Factors=Factorize(f);
+  On(SW_RATIONAL);
   Factors.removeFirst();
 
@@ -760 +785 @@
 
   success=1;
-  for ( CFFListIterator i=Factors; i.hasItem(); i++ ){
+  for ( CFFListIterator i=Factors; i.hasItem(); i++ )
+  {
     output=newfactoras(i.getItem().factor(),as, success);
     for ( CFFListIterator j=output; j.hasItem(); j++)

factory/libfac/charset/charset.cc

@@ -493 +493 @@
     if ( degree(elem) > 1 ) // linear poly's are irreduzible
     {
-      qs = Factorize(elem);
+      qs = factorize(elem);
       // remove a constant
       if (qs.getFirst().factor().degree()==0) qs.removeFirst();

factory/libfac/configure

@@ -530 +530 @@
 libfac_name="\"Factorization and characteristic sets library\""
 
-libfac_version="3.1.3"
+libfac_version="3.1.5"
 cat >> confdefs.h <<EOF
 #define LIBFAC_VERSION "$libfac_version"
@@ -536 +536 @@
 
 
-libfac_date="\"March 2011\""
+libfac_date="\"July 2012\""
 cat >> confdefs.h <<EOF
 #define LIBFAC_DATE $libfac_date

factory/libfac/configure.in

@@ -15 +15 @@
 libfac_name="\"Factorization and characteristic sets library\""
 AC_SUBST(libfac_name)
-libfac_version="3.1.3"
+libfac_version="3.1.5"
 AC_DEFINE_UNQUOTED(LIBFAC_VERSION,"$libfac_version")
 AC_SUBST(libfac_version)
-libfac_date="\"March 2011\""
+libfac_date="\"July 2012\""
 AC_DEFINE_UNQUOTED(LIBFAC_DATE,$libfac_date)
 AC_SUBST(libfac_date)

factory/libfac/factor/Factor.cc

@@ -27 +27 @@
 
 #include "alg_factor.h"
-void out_cf(char *s1,const CanonicalForm &f,char *s2);
+void out_cf(const char *s1,const CanonicalForm &f,const char *s2);
 void out_cff(CFFList &L);
 
@@ -52 +52 @@
 * ( in factorize, alpha.level() must be < 0 )
 */
+static
 CFFList factorize2 ( const CanonicalForm & f,
                      const Variable & alpha, const CanonicalForm & mipo )
@@ -61 +62 @@
   else
   {
-    bool repl=(f.mvar() != alpha);
     //out_cf("f2 - factor:",f,"\n");
     //out_cf("f2 - ext:",alpha,"\n");
@@ -67 +67 @@
     Variable X=rootOf(mipo);
     CanonicalForm F=f;
-    if (repl) F=replacevar(f,alpha,X);
+    F=replacevar(f,alpha,X);
     //out_cf("call - factor:",F,"\n");
     //out_cf("call - ext:",X,"\n");
@@ -73 +73 @@
     CFFList L=factorize(F,X);
     CFFListIterator i=L;
-    if (repl)
     {
       CFFList Outputlist;
@@ -82 +81 @@
         i.getItem().exp()));
       }
+      //out_cff(Outputlist);
       return Outputlist;
     }
-    else return L;
   }
 }
@@ -393 +392 @@
 generate_mipo( int degree_of_Extension , const Variable & Extension ){
   FFRandom gen;
-  if ( degree(Extension) > 0 ) GFRandom gen;
-  else {
-    if ( degree(Extension) == 0 ) FFRandom gen;
-    else
-    {
-      factoryError("libfac: evaluate: Extension not inFF() or inGF() !");
-    }
-  }
+  if (degree (Extension) < 0)
+    factoryError("libfac: evaluate: Extension not inFF() or inGF() !");
   return find_irreducible( degree_of_Extension, gen, Variable(1) );
 }
@@ -465 +458 @@
 
 static int
-specializePoly(const CanonicalForm & f, Variable & Extension, int deg, SFormList & Substitutionlist, int i,int j){
+specializePoly(const CanonicalForm & f, Variable & Extension, int deg, SFormList & Substitutionlist, int i,int j)
+{
   Variable minpoly= Extension;
   int ok,extended= degree(Extension), working_over_extension;
@@ -474 +468 @@
   // First try:
   ok = try_specializePoly(f,minpoly,deg,Substitutionlist,i,j);
-  while ( ! ok ){ // we have to extend!
+  while ( ! ok ) // we have to extend!
+  {
+    SFormList origS=Substitutionlist;
     extended+= 1;
-    if ( ! working_over_extension ){
-      minpoly= rootOf(generate_mipo( extended,Extension ));
+    if ( ! working_over_extension )
+    {
+      if (!hasMipo(Extension))
+        minpoly= rootOf (generate_mipo (extended, Extension));
+      else
+      {
+        setReduce (Extension, false);
+        setMipo (minpoly, generate_mipo ( extended, Extension));
+        setReduce (Extension, true);
+      }
       Extension= minpoly;
       ok= try_specializePoly(f,minpoly,deg,Substitutionlist,i,j);
+      if (!ok)
+        Substitutionlist=origS;
     }
     else
@@ -804 +810 @@
 {
   //out_cf("Factorize ",F,"\n");
-  CFFList Outputlist,SqrFreeList,Intermediatelist,Outputlist2;
-  ListIterator<CFFactor> i,j;
-  CanonicalForm g=1,unit=1,r=1;
-  Variable minpoly; // dummy
-  int exp;
-  CFMap m;
+  CFFList Outputlist;
 
   // INTERRUPTHANDLER
@@ -831 +832 @@
     return Outputlist;
   }
+  CFFList SqrFreeList,Intermediatelist,Outputlist2;
+  ListIterator<CFFactor> i,j;
+  CanonicalForm g=1,unit=1,r=1;
+  Variable minpoly; // dummy
+  int exp;
+  CFMap m;
   TIMING_START(factorize_time);
   // search an "optimal" main variavble

factory/variable.cc

@@ -215 +215 @@
 }
 
-/*void setMipo ( const Variable & alpha, const CanonicalForm & mipo)
+void setMipo ( const Variable & alpha, const CanonicalForm & mipo)
 {
     ASSERT( alpha.level() < 0 && alpha.level() != LEVELBASE, "illegal extension" );
     algextensions[-alpha.level()]= ext_entry((InternalPoly*)(conv2mipo( mipo, alpha ).getval()), true );
-}*/
+}
 
 bool hasMipo( const Variable & alpha )
 {
-    ASSERT( alpha.level() < 0 && alpha.level() != LEVELBASE, "illegal extension" );
-    return ((algextensions!=NULL) && getReduce(alpha) );
+    ASSERT( alpha.level() < 0, "illegal extension" );
+    return (alpha.level() != LEVELBASE && (algextensions!=NULL) && getReduce(alpha) );
 }
 

factory/variable.h

@@ -78 +78 @@
 inline char name( const Variable & v ) { return v.name(); }
 
+void setReduce( const Variable & alpha, bool reduce );
+void setMipo ( const Variable & alpha, const CanonicalForm & mipo);
 CanonicalForm getMipo( const Variable & alpha, const Variable & x );
 bool hasMipo( const Variable & alpha );
@@ -93 +95 @@
 InternalPoly * getInternalMipo ( const Variable & alpha );
 bool getReduce( const Variable & alpha );
-void setReduce( const Variable & alpha, bool reduce );
 
 #endif /* ! INCL_VARIABLE_H */