Changeset 7f3ad4 in git

Timestamp:

Jan 14, 2009, 5:07:05 PM (14 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '828514cf6e480e4bafc26df99217bf2a1ed1ef45')

Children:

0721816437af5ddabc83aa203a12d9b58b42a33c

Parents:

95edd5641377e851d4a1d4e986853687991d0895

Message:

*hannes: format


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

Location:

Singular/LIB

Files:

• bfct.lib (modified) (37 diffs)
• classify.lib (modified) (3 diffs)
• compregb.lib (modified) (3 diffs)
• decodegb.lib (modified) (113 diffs)
• discretize.lib (modified) (4 diffs)
• dmod.lib (modified) (6 diffs)
• dmodapp.lib (modified) (15 diffs)
• elim.lib (modified) (13 diffs)
• findifs.lib (modified) (6 diffs)
• freegb.lib (modified) (9 diffs)
• general.lib (modified) (3 diffs)
• jacobson.lib (modified) (54 diffs)
• latex.lib (modified) (4 diffs)
• matrix.lib (modified) (19 diffs)
• nchomolog.lib (modified) (9 diffs)
• nctools.lib (modified) (22 diffs)
• polymake.lib (modified) (76 diffs)
• powers.lib (modified) (3 diffs)
• ratgb.lib (modified) (2 diffs)
• ringgb.lib (modified) (1 diff)
• surfex.lib (modified) (2 diffs)
• teachstd.lib (modified) (3 diffs)
• tropical.lib (modified) (266 diffs)

Singular/LIB/bfct.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: bfct.lib,v 1.10 2009-01-12 19:31:23 Singular Exp $";
+version="$Id: bfct.lib,v 1.11 2009-01-14 16:07:03 Singular Exp $";
 category="Noncommutative";
 info="
@@ -35 +35 @@
 AUXILIARY PROCEDURES:
 
-allPositive(v);  checks whether all entries of an intvec are positive 
+allPositive(v);  checks whether all entries of an intvec are positive
 scalarProd(v,w); computes the standard scalar product of two intvecs
 vec2poly(v[,i]); constructs an univariate poly with given coefficients
@@ -79 +79 @@
 EXAMPLE: example gradedWeyl; shows examples
 NOTE:    u[i] is the weight of x(i), v[i] the weight of D(i).
-@*       u+v has to be a non-negative intvec. 
+@*       u+v has to be a non-negative intvec.
 "
 {
@@ -88 +88 @@
   {
     ERROR("weight vectors have wrong dimension");
-  } 
+  }
   intvec uv,gr;
   uv = u+v;
@@ -97 +97 @@
       if (uv[i]==0)
       {
-        gr[i] = 0;
+        gr[i] = 0;
       }
       else
       {
-        gr[i] = 1;
+        gr[i] = 1;
       }
     }
@@ -114 +114 @@
   for (i=1; i<=n; i++)
   {
-    if (gr[i] == 1)  
+    if (gr[i] == 1)
     {
        l2[n+i] = "xi("+string(i)+")";
@@ -231 +231 @@
 RETURN:  ideal/list, linear reductum (over field) of f by elements from I
 PURPOSE: reduce a poly only by linear reductions (no monomial multiplications)
-NOTE:    If s<>0, a list consisting of the reduced ideal and the coefficient 
+NOTE:    If s<>0, a list consisting of the reduced ideal and the coefficient
 @*       vectors of the used reductions given as module is returned.
 @*       Otherwise (and by default), only the reduced ideal is returned.
@@ -255 +255 @@
       if (typeof(#[2])=="int" || typeof(#[2])=="number")
       {
-        redtail = #[2];
+        redtail = #[2];
       }
     }
@@ -273 +273 @@
       for (i=1; i<=sI; i++)
       {
-        if (I[i] == 0)
-        {
-          j++;
-          J[j] = 0;
-          ordJ[j] = -1;
-          M[j] = gen(i);
-        }
-        else
-        {
-          M[i+sZeros-j] = gen(lJ[2][i-j]+j);
-        }
+        if (I[i] == 0)
+        {
+          j++;
+          J[j] = 0;
+          ordJ[j] = -1;
+          M[j] = gen(i);
+        }
+        else
+        {
+          M[i+sZeros-j] = gen(lJ[2][i-j]+j);
+        }
       }
     }
@@ -290 +290 @@
       for (i=1; i<=sZeros; i++)
       {
-        J[i] = 0;
-        ordJ[i] = -1;
+        J[i] = 0;
+        ordJ[i] = -1;
       }
     }
@@ -327 +327 @@
       for (j=sZeros+1; j<i; j++)
       {
-        if (lm == 0) { break; }
-        if (ordlm > maxordJ) { break; }
-        if (ordlm == ordJ[j])
-        {           
-          if (lm > maxlmJ) { break; }
-          if (lm == lmJ[j])
-          {
-            dbprint(ppl,"reducing " + string(redpoly));
-            dbprint(ppl," with " + string(J[j]));
-            c = leadcoef(redpoly)/leadcoef(J[j]);
-            redpoly = redpoly - c*J[j];
-            dbprint(ppl," to " + string(redpoly));
-            lm = leadmonom(redpoly);
-            ordlm = ord(lm);
-            if (remembercoeffs <> 0) { M[i] = M[i] - c * M[j]; }
-            reduction = 1;
-          }
-        }
+        if (lm == 0) { break; }
+        if (ordlm > maxordJ) { break; }
+        if (ordlm == ordJ[j])
+        {
+          if (lm > maxlmJ) { break; }
+          if (lm == lmJ[j])
+          {
+            dbprint(ppl,"reducing " + string(redpoly));
+            dbprint(ppl," with " + string(J[j]));
+            c = leadcoef(redpoly)/leadcoef(J[j]);
+            redpoly = redpoly - c*J[j];
+            dbprint(ppl," to " + string(redpoly));
+            lm = leadmonom(redpoly);
+            ordlm = ord(lm);
+            if (remembercoeffs <> 0) { M[i] = M[i] - c * M[j]; }
+            reduction = 1;
+          }
+        }
       }
     }
@@ -354 +354 @@
     lmJ = insertGenerator(lmJ,lm,j);
     ordJ = insertGenerator(ordJ,poly(ordlm),j);
-    if (remembercoeffs <> 0) 
+    if (remembercoeffs <> 0)
     {
       v = M[i];
@@ -373 +373 @@
       for (j=i+1; j<=sI; j++)
       {
-        for (k=2; k<=size(J[j]); k++) // run over all terms in J[j]
-        {
-          if (ordJ[i] == ord(J[j][k]))
-          {    
-            if (lm == normalize(J[j][k]))
-            {
-              c = leadcoef(J[j][k])/leadcoef(J[i]);
-              dbprint(ppl,"reducing " + string(J[j]));
-              dbprint(ppl," with " + string(J[i]));
-              J[j] = J[j] - c*J[i];
-              dbprint(ppl," to " + string(J[j]));
-              if (remembercoeffs <> 0) { M[j] = M[j] - c * M[i]; }
-            }
-          }
-        }
+        for (k=2; k<=size(J[j]); k++) // run over all terms in J[j]
+        {
+          if (ordJ[i] == ord(J[j][k]))
+          {
+            if (lm == normalize(J[j][k]))
+            {
+              c = leadcoef(J[j][k])/leadcoef(J[i]);
+              dbprint(ppl,"reducing " + string(J[j]));
+              dbprint(ppl," with " + string(J[i]));
+              J[j] = J[j] - c*J[i];
+              dbprint(ppl," to " + string(J[j]));
+              if (remembercoeffs <> 0) { M[j] = M[j] - c * M[i]; }
+            }
+          }
+        }
       }
     }
@@ -410 +410 @@
 RETURN:  poly/list, linear reductum (over field) of f by elements from I
 PURPOSE: reduce a poly only by linear reductions (no monomial multiplications)
-NOTE:    If s<>0, a list consisting of the reduced poly and the coefficient 
+NOTE:    If s<>0, a list consisting of the reduced poly and the coefficient
 @*       vector of the used reductions is returned, otherwise (and by default)
 @*       only reduced poly is returned.
@@ -433 +433 @@
       if (typeof(#[2])=="int" || typeof(#[2])=="number")
       {
-        redtail = #[2];
+        redtail = #[2];
       }
       if (size(#)>2)
       {
-        if (typeof(#[3])=="int" || typeof(#[3])=="number")
+        if (typeof(#[3])=="int" || typeof(#[3])=="number")
         {
-          prepareideal = #[3];
-        }
+          prepareideal = #[3];
+        }
       }
     }
@@ -469 +469 @@
       for (i=1; i<=sI; i++)
       {
-        M[i] = gen(i);
+        M[i] = gen(i);
       }
     }
@@ -495 +495 @@
       if (ordf == ordI[i])
       {
-        if (lm == lmI[i])
-        {
-          c = leadcoef(f)/lcI[i];
-          f = f - c*I[i];
-          lm = leadmonom(f);
-          ordf = ord(lm);
-          if (remembercoeffs <> 0)
-          {
-            v = v - c * M[i];
-          }
-        }
+        if (lm == lmI[i])
+        {
+          c = leadcoef(f)/lcI[i];
+          f = f - c*I[i];
+          lm = leadmonom(f);
+          ordf = ord(lm);
+          if (remembercoeffs <> 0)
+          {
+            v = v - c * M[i];
+          }
+        }
       }
     }
@@ -518 +518 @@
       for (j=1; j<=size(f); j++)
       {
-        if (ord(f[j]) == ordI[i])
-        {
-          if (normalize(f[j]) == lmI[i])
-          {
-            c = leadcoef(f[j])/lcI[i];
-            f = f - c*I[i];
-            dbprint(ppl,"reducing poly to ",f);
-            if (remembercoeffs <> 0)
-            {
-              v = v - c * M[i];
-            }
-          }
-        }
+        if (ord(f[j]) == ordI[i])
+        {
+          if (normalize(f[j]) == lmI[i])
+          {
+            c = leadcoef(f[j])/lcI[i];
+            f = f - c*I[i];
+            dbprint(ppl,"reducing poly to ",f);
+            if (remembercoeffs <> 0)
+            {
+              v = v - c * M[i];
+            }
+          }
+        }
       }
     }
@@ -556 +556 @@
   f = x3 + y2 + x2 + y + x;
   I = x3 - y3, y3 - x2, x3 - y2, x2 - y, y2-x;
-  list l = linReduce(f, I, 1); 
+  list l = linReduce(f, I, 1);
   l;
   module M = I;
@@ -601 +601 @@
       if (p <> 0)
       {
-        whichengine = 1;
+        whichengine = 1;
       }
     }
@@ -668 +668 @@
 proc pIntersect (poly s, ideal I)
 "USAGE:  pIntersect(f, I);  f a poly, I an ideal
-RETURN:  vector, coefficient vector of the monic polynomial 
+RETURN:  vector, coefficient vector of the monic polynomial
 PURPOSE: compute the intersection of ideal I with the subalgebra K[f]
 ASSUME:  I is given as Groebner basis.
@@ -712 +712 @@
       if (degs[j] == 0)
       {
-        if (degI[i][j] <> 0)
-        {
-          break;
-        }
+        if (degI[i][j] <> 0)
+        {
+          break;
+        }
       }
       if (j == n)
       {
-        k++;
-        possdegbounds[k] = Max(degI[i]);
+        k++;
+        possdegbounds[k] = Max(degI[i]);
       }
     }
@@ -749 +749 @@
       if (tobracket==0) // todo bug in bracket?
       {
-        toNF = 0;
+        toNF = 0;
       }
       else
       {
-        toNF = bracket(tobracket,secNF);
+        toNF = bracket(tobracket,secNF);
       }
       newNF = NF(toNF+oldNF*secNF,I);  // = NF(s^i,I)
@@ -802 +802 @@
     v = v + m[j,1]*gen(j);
   }
-  setring save; 
+  setring save;
   v = imap(@R,v);
   kill @R;
@@ -864 +864 @@
       if (size(#)>2)
       {
-        if (typeof(#[3])=="int" || typeof(#[3])=="number")
-        {
-          modengine = int(#[3]);
-        }
+        if (typeof(#[3])=="int" || typeof(#[3])=="number")
+        {
+          modengine = int(#[3]);
+        }
       }
     }
@@ -909 +909 @@
       if (tobracket!=0)
       {
-        toNF = bracket(tobracket,NI[2]) + NI[i]*NI[2];
+        toNF = bracket(tobracket,NI[2]) + NI[i]*NI[2];
       }
       else
       {
-        toNF = NI[i]*NI[2];
+        toNF = NI[i]*NI[2];
       }
       newNF =  NF(toNF,I);
@@ -927 +927 @@
       if (v!=0) // there is a modular solution
       {
-        dbprint(ppl,"got solution in char ",solveincharp," of degree " ,i);
-        setring save;
-        v = linSyzSolve(NI,whichengine);
-        if (v==0)
-        {
-          break;
-        }
+        dbprint(ppl,"got solution in char ",solveincharp," of degree " ,i);
+        setring save;
+        v = linSyzSolve(NI,whichengine);
+        if (v==0)
+        {
+          break;
+        }
       }
       else // no modular solution
       {
-        setring save;
-        v = 0;
+        setring save;
+        v = 0;
       }
     }
@@ -965 +965 @@
       {
         dbprint(ppl,"linSyzSolve: got solution!");
-        // "got solution!";
+        // "got solution!";
         break;
       }
@@ -1015 +1015 @@
       if (typeof(#[2])=="int" || typeof(#[2])=="number")
       {
-        ringvar = int(#[2]);
+        ringvar = int(#[2]);
       }
     }
@@ -1121 +1121 @@
       while (b == 0)
       {
-        dbprint(ppl,"number of run in the loop: "+string(i));
-        int q = prime(random(lb,ub));
-        if (findFirst(usedprimes,q)==0) // if q was not already used
+        dbprint(ppl,"number of run in the loop: "+string(i));
+        int q = prime(random(lb,ub));
+        if (findFirst(usedprimes,q)==0) // if q was not already used
         {
-          usedprimes = usedprimes,q;
-          dbprint(ppl,"used prime is: "+string(q));
-          b = pIntersectSyz(s,J,q,whichengine,modengine);
-        }
-        i++;
-      }
-    }
-    else // pIntersectSyz::non-modular 
+          usedprimes = usedprimes,q;
+          dbprint(ppl,"used prime is: "+string(q));
+          b = pIntersectSyz(s,J,q,whichengine,modengine);
+        }
+        i++;
+      }
+    }
+    else // pIntersectSyz::non-modular
     {
       b = pIntersectSyz(s,J,0,whichengine);
@@ -1158 +1158 @@
 RETURN:  list of ideal and intvec
 PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
-@*       for the hypersurface defined by f. 
+@*       for the hypersurface defined by f.
 ASSUME:  The basering is a commutative polynomial ring in char 0.
-BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm 
+BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm
 @*       by Masayuki Noro and then a system of linear equations is solved by linear reductions.
-NOTE:    In the output list, the ideal contains all the roots 
+NOTE:    In the output list, the ideal contains all the roots
 @*       and the intvec their multiplicities.
 @*       If s<>0, @code{std} is used for GB computations,
-@*       otherwise, and by default, @code{slimgb} is used. 
+@*       otherwise, and by default, @code{slimgb} is used.
 @*       If t<>0, a matrix ordering is used for Groebner basis computations,
 @*       otherwise, and by default, a block ordering is used.
-@*       If v is a positive weight vector, v is used for homogenization computations, 
+@*       If v is a positive weight vector, v is used for homogenization computations,
 @*       otherwise and by default, no weights are used.
 DISPLAY: If printlevel=1, progress debug messages will be printed,
@@ -1199 +1199 @@
       if (size(#)>2)
       {
-        if (typeof(#[3])=="intvec" && size(#[3])==n && allPositive(#[3])==1)
+        if (typeof(#[3])=="intvec" && size(#[3])==n && allPositive(#[3])==1)
         {
-          u0 = #[3];
-        }
+          u0 = #[3];
+        }
       }
     }
@@ -1222 +1222 @@
 "USAGE:  bfctSyz(f [,r,s,t,u,v]);  f a poly, r,s,t,u optional ints, v an optional intvec
 RETURN:  list of ideal and intvec
-PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) 
+PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
 @*       for the hypersurface defined by f
 ASSUME:  The basering is a commutative polynomial ring in char 0.
-BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm 
+BACKGROUND: In this proc, the initial Malgrange ideal is computed according to the algorithm
 @*       by Masayuki Noro and then a system of linear equations is solved by computing syzygies.
-NOTE:    In the output list, the ideal contains all the roots 
+NOTE:    In the output list, the ideal contains all the roots
 @*       and the intvec their multiplicities.
-@*       If r<>0, @code{std} is used for GB computations in characteristic 0, 
-@*       otherwise, and by default, @code{slimgb} is used. 
-@*       If s<>0, a matrix ordering is used for GB computations, otherwise, 
+@*       If r<>0, @code{std} is used for GB computations in characteristic 0,
+@*       otherwise, and by default, @code{slimgb} is used.
+@*       If s<>0, a matrix ordering is used for GB computations, otherwise,
 @*       and by default, a block ordering is used.
-@*       If t<>0, the computation of the intersection is solely performed over 
+@*       If t<>0, the computation of the intersection is solely performed over
 @*       charasteristic 0, otherwise and by default, a modular method is used.
-@*       If u<>0 and by default, @code{std} is used for GB computations in 
-@*       characteristic >0, otherwise, @code{slimgb} is used. 
-@*       If v is a positive weight vector, v is used for homogenization 
+@*       If u<>0 and by default, @code{std} is used for GB computations in
+@*       characteristic >0, otherwise, @code{slimgb} is used.
+@*       If v is a positive weight vector, v is used for homogenization
 @*       computations, otherwise and by default, no weights are used.
 DISPLAY: If printlevel=1, progress debug messages will be printed,
@@ -1275 +1275 @@
         if (typeof(#[3])=="int" || typeof(#[3])=="number")
         {
-          pIntersectchar = int(#[3]);
-        }
-        if (size(#)>3)
+          pIntersectchar = int(#[3]);
+        }
+        if (size(#)>3)
         {
-          if (typeof(#[4])=="int" || typeof(#[4])=="number")
+          if (typeof(#[4])=="int" || typeof(#[4])=="number")
           {
-            modengine = int(#[4]);
-          }
-          if (size(#)>4)
-          {
-            if (typeof(#[5])=="intvec" && size(#[5])==n && allPositive(#[5])==1)
-            {
-              u0 = #[5];
-            }
-          }
-        }
+            modengine = int(#[4]);
+          }
+          if (size(#)>4)
+          {
+            if (typeof(#[5])=="intvec" && size(#[5])==n && allPositive(#[5])==1)
+            {
+              u0 = #[5];
+            }
+          }
+        }
       }
     }
@@ -1315 +1315 @@
 BACKGROUND:  In this proc, the initial ideal of I is computed according to the algorithm by
 @*       Masayuki Noro and then a system of linear equations is solved by linear reductions.
-NOTE:    In the output list, the ideal contains all the roots 
+NOTE:    In the output list, the ideal contains all the roots
 @*       and the intvec their multiplicities.
 @*       If s<>0, @code{std} is used for GB computations in characteristic 0,
-@*       otherwise, and by default, @code{slimgb} is used. 
+@*       otherwise, and by default, @code{slimgb} is used.
 @*       If t<>0, a matrix ordering is used for GB computations, otherwise,
 @*       and by default, a block ordering is used.
@@ -1374 +1374 @@
 "USAGE:  bfctOneGB(f [,s,t]);  f a poly, s,t optional ints
 RETURN:  list of ideal and intvec
-PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) for the 
+PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) for the
 @*       hypersurface defined by f, using only one GB computation
 ASSUME:  The basering is a commutative polynomial ring in char 0.
-BACKGROUND: In this proc, the initial Malgrange ideal is computed based on the 
+BACKGROUND: In this proc, the initial Malgrange ideal is computed based on the
 @*       algorithm by Masayuki Noro and combined with an elimination ordering.
-NOTE:    In the output list, the ideal contains all the roots 
+NOTE:    In the output list, the ideal contains all the roots
 @*       and the intvec their multiplicities.
 @*       If s<>0, @code{std} is used for the GB computation, otherwise,
-@*       and by default, @code{slimgb} is used. 
+@*       and by default, @code{slimgb} is used.
 @*       If t<>0, a matrix ordering is used for GB computations,
 @*       otherwise, and by default, a block ordering is used.
@@ -1492 +1492 @@
 "USAGE:  bfctAnn(f [,r]);  f a poly, r an optional int
 RETURN:  list of ideal and intvec
-PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s) 
+PURPOSE: computes the roots of the Bernstein-Sato polynomial b(s)
 @*       for the hypersurface defined by f
 ASSUME:  The basering is a commutative polynomial ring in char 0.
 BACKGROUND: In this proc, ann(f^s) is computed and then a system of linear
 @*       equations is solved by linear reductions.
-NOTE:    In the output list, the ideal contains all the roots 
+NOTE:    In the output list, the ideal contains all the roots
 @*       and the intvec their multiplicities.
 @*       If r<>0, @code{std} is used for GB computations,
-@*       otherwise, and by default, @code{slimgb} is used. 
+@*       otherwise, and by default, @code{slimgb} is used.
 DISPLAY: If printlevel=1, progress debug messages will be printed,
 @*       if printlevel>=2, all the debug messages will be printed.

Singular/LIB/classify.lib

@@ -1 +1 @@
 // KK,GMG last modified: 17.12.00
 ///////////////////////////////////////////////////////////////////////////////
-version  = "$Id: classify.lib,v 1.54 2008-12-08 14:24:41 dreyer Exp $";
+version  = "$Id: classify.lib,v 1.55 2009-01-14 16:07:03 Singular Exp $";
 category="Singularities";
 info="
@@ -1474 +1474 @@
 
   s = s +" has 4-jet equal to zero. (F47), mu="+string(Mu);
-  
+
   s; // +"  ("+SG_Typ+")";
   s = "No further classification available.";
@@ -2222 +2222 @@
   list v;
 
-  if(sg[1]==1 && sg[2]==0 && sg[3]==1) { 
-      v=HKclass7_teil_1(sg, SG_Typ, cnt); 
+  if(sg[1]==1 && sg[2]==0 && sg[3]==1) {
+      v=HKclass7_teil_1(sg, SG_Typ, cnt);
   }
   else {

Singular/LIB/compregb.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: compregb.lib,v 1.2 2007-06-20 15:39:44 Singular Exp $";
+version="$Id: compregb.lib,v 1.3 2009-01-14 16:07:03 Singular Exp $";
 category="General purpose";
 info="
@@ -79 +79 @@
       for (j = 1; j <= size(CoefLsub); j ++)
       {
-        if (CoefLsub[j] > 1)
+        if (CoefLsub[j] > 1)
         {
-          CoefL = insert(CoefL, CoefLsub[j]);
-        }
+          CoefL = insert(CoefL, CoefLsub[j]);
+        }
       }
     }
@@ -94 +94 @@
       if (Coef == CoefL[j])
       {
-        CoefL = delete(CoefL, j);
-        j --;
+        CoefL = delete(CoefL, j);
+        j --;
       }
     }

Singular/LIB/decodegb.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: decodegb.lib,v 1.8 2008-10-22 13:31:48 bulygin Exp $";
+version="$Id: decodegb.lib,v 1.9 2009-01-14 16:07:03 Singular Exp $";
 category="Coding theory";
 info="
 LIBRARY: decodegb.lib         Decoding and min distance of linear codes with GB
-AUTHOR:  Stanislav Bulygin,   bulygin@mathematik.uni-kl.de                     
+AUTHOR:  Stanislav Bulygin,   bulygin@mathematik.uni-kl.de
 
 OVERVIEW:
  In this library we generate several systems used for decoding cyclic codes and
- finding their minimum distance. Namely, we work with the Cooper's philosophy 
- and generalized Newton identities. The original method of quadratic equations 
- is worked out here as well. We also (for comparison) enable to work with the 
- system of Fitzgerald-Lax. We provide some auxiliary functions for further 
- manipulations and decoding. For an overview of the methods mentioned above @ref{Decoding codes with GB} 
- For the vanishing ideal computation the algorithm of Farr and Gao is 
+ finding their minimum distance. Namely, we work with the Cooper's philosophy
+ and generalized Newton identities. The original method of quadratic equations
+ is worked out here as well. We also (for comparison) enable to work with the
+ system of Fitzgerald-Lax. We provide some auxiliary functions for further
+ manipulations and decoding. For an overview of the methods mentioned above @ref{Decoding codes with GB}
+ For the vanishing ideal computation the algorithm of Farr and Gao is
  implemented.
 
-MAIN PROCEDURES: 
+MAIN PROCEDURES:
  sysCRHT(..);        generates the CRHT-ideal as in Cooper's philosophy
  sysCRHTMindist(..); CRHT-ideal to find the minimum distance in the binary case
@@ -29 +29 @@
  genMDSMat(n,a);     generates an MDS (actually an RS) matrix
  mindist(check);     computes the minimum distance of a code
- decode(rec);        decoding of a word using the system of quadratic equations 
+ decode(rec);        decoding of a word using the system of quadratic equations
  decodeRandom(..); a procedure for manipulation with random codes
  decodeCode(..);   a procedure for manipulation with the given code
@@ -35 +35 @@
  sysFL(..);          generates the Fitzgerald-Lax system
  decodeRandomFL(..); manipulation with random codes via Fitzgerald-Lax
- 
-
-KEYWORDS:  Cyclic code; Linear code; Decoding; 
+
+
+KEYWORDS:  Cyclic code; Linear code; Decoding;
            Minimum distance; Groebner bases
 ";
@@ -76 +76 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// the polynomial for Sala's restrictions 
+// the polynomial for Sala's restrictions
 static proc p_poly(int n, int a, int b)
 {
@@ -92 +92 @@
 "USAGE:   sysCRHT(n,defset,e,q,m,[k]); n,e,q,m,k int, defset list of int's
 @format
-         - n length of the cyclic code, 
+         - n length of the cyclic code,
          - defset is a list representing the defining set,
-         - e the error-correcting capacity, 
+         - e the error-correcting capacity,
          - q field size
-         - m degree extension of the splitting field, 
-         - if k>0 additional equations representing the fact that every two 
+         - m degree extension of the splitting field,
+         - if k>0 additional equations representing the fact that every two
          error positions are either different or at least one of them is zero
 @end format
-RETURN: the ring to work with the CRHT-ideal (with Sala's additions), 
+RETURN: the ring to work with the CRHT-ideal (with Sala's additions),
         containig an ideal with name 'crht'
-THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs 
-         the corresponding Cooper-Reed-Heleseth-Truong ideal 'crht'. With its 
+THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs
+         the corresponding Cooper-Reed-Heleseth-Truong ideal 'crht'. With its
          help one can solve the decoding problem. For basics of the method @ref{Cooper philosophy}.
 SEE ALSO: sysNewton, sysBin
@@ -109 +109 @@
 "
 {
-  int r=size(defset);  
+  int r=size(defset);
   ring @crht=(q,a),(Y(e..1),Z(1..e),X(r..1)),lp;
   ideal crht;
@@ -115 +115 @@
   poly sum;
   int k;
-  if ( size(#) > 0) 
-  { 
-    k = #[1]; 
-  }
-  
+  if ( size(#) > 0)
+  {
+    k = #[1];
+  }
+
   //---------------------- add check equations --------------------------
   for (i=1; i<=r; i++)
@@ -130 +130 @@
     crht[i]=sum-X(i);
   }
-  
+
   //--------------------- field equations on syndromes ------------------
   for (i=1; i<=r; i++)
@@ -136 +136 @@
     crht=crht,X(i)^(q^m)-X(i);
   }
-  
+
   //------ restrictions on error-locations: n-th roots of unity ----------
   for (i=1; i<=e; i++)
@@ -142 +142 @@
     crht=crht,Z(i)^(n+1)-Z(i);
   }
-  
+
   for (i=1; i<=e; i++)
   {
     crht=crht,Y(i)^(q-1)-1;
-  }  
-  
+  }
+
   //--------- add Sala's additional conditions if necessary --------------
   if ( k > 0 )
-  
+
   {
     for (i=1; i<=e; i++)
@@ -159 +159 @@
       }
     }
-  }  
-  export crht;  
-  return(@crht);    
-} 
+  }
+  export crht;
+  return(@crht);
+}
 example
 { "EXAMPLE:"; echo=2;
@@ -168 +168 @@
   intvec v = option(get);
 
-  list defset=1,3;           // defining set  
+  list defset=1,3;           // defining set
   int n=15;                  // length
   int e=2;                   // error-correcting capacity
@@ -174 +174 @@
   int m=4;                   // degree extension of the splitting field
   int sala=1;                // indicator to add additional equations
-    
-  def A=sysCRHT(n,defset,e,q,m); 
+
+  def A=sysCRHT(n,defset,e,q,m);
   setring A;
   A;                         // shows the ring we are working in
-  print(crht);               // the CRHT-ideal 
+  print(crht);               // the CRHT-ideal
   option(redSB);
   ideal red_crht=std(crht);  // reduced Groebner basis
   print(red_crht);
-  
+
   //============================
-  A=sysCRHT(n,defset,e,q,m,sala); 
-  setring A;  
+  A=sysCRHT(n,defset,e,q,m,sala);
+  setring A;
   print(crht);                // CRHT-ideal with additional equations from Sala
   option(redSB);
   ideal red_crht=std(crht);   // reduced Groebner basis
-  print(red_crht);            
+  print(red_crht);
   red_crht[5];                // general error-locator polynomial for this code
   option(set,v);
@@ -198 +198 @@
 
 proc sysCRHTMindist (int n, list defset, int w)
-"USAGE:  sysCRHTMindist(n,defset,w);  n,w are int, defset is list of int's  
+"USAGE:  sysCRHTMindist(n,defset,w);  n,w are int, defset is list of int's
 @format
-        - n length of the cyclic code, 
+        - n length of the cyclic code,
         - defset is a list representing the defining set,
         - w is a candidate for the minimum distance
 @end format
-RETURN:  the ring to work with the Sala's ideal for the minimum distance 
+RETURN:  the ring to work with the Sala's ideal for the minimum distance
          containing the ideal with name 'crht_md'
-THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs 
-         the corresponding Cooper-Reed-Heleseth-Truong ideal 'crht_md'. With 
-         its help one can find minimum distance of the code in the binary 
+THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs
+         the corresponding Cooper-Reed-Heleseth-Truong ideal 'crht_md'. With
+         its help one can find minimum distance of the code in the binary
          case. For basics of the method @ref{Cooper philosophy}.
 EXAMPLE: example sysCRHTMindist; shows an example
 "
 {
-  int r=size(defset);  
+  int r=size(defset);
   ring @crht_md=2,Z(1..w),lp;
   ideal crht_md;
   int i,j;
   poly sum;
-  
+
   //------------ add check equations --------------
   for (i=1; i<=r; i++)
@@ -228 +228 @@
     }
     crht_md[i]=sum;
-  }  
-  
-  
+  }
+
+
   //----------- locations are n-th roots of unity ------------
   for (i=1; i<=w; i++)
   {
     crht_md=crht_md,Z(i)^n-1;
-  }  
-  
+  }
+
   //------------ adding conditions on locations being different ------------
   for (i=1; i<=w; i++)
@@ -245 +245 @@
     }
   }
-    
-  export crht_md;  
-  return(@crht_md);    
-} 
+
+  export crht_md;
+  return(@crht_md);
+}
 example
 {
@@ -254 +254 @@
   intvec v = option(get);
   // binary cyclic [15,7,5] code with defining set (1,3)
-  
-  list defset=1,3;             // defining set  
-  int n=15;                    // length 
-  int d=5;                     // candidate for the minimum distance  
-      
-  def A=sysCRHTMindist(n,defset,d); 
+
+  list defset=1,3;             // defining set
+  int n=15;                    // length
+  int d=5;                     // candidate for the minimum distance
+
+  def A=sysCRHTMindist(n,defset,d);
   setring A;
   A;                           // shows the ring we are working in
   print(crht_md);              // the Sala's ideal for mindist
   option(redSB);
-  ideal red_crht_md=std(crht_md);     
+  ideal red_crht_md=std(crht_md);
   print(red_crht_md);          // reduced Groebner basis
-  
+
   option(set,v);
 }
@@ -281 +281 @@
 
 proc sysNewton (int n, list defset, int t, int q, int m, list #)
-"USAGE:   sysNewton (n,defset,t,q,m,[tr]); n,t,q,m,tr int, defset list int's 
+"USAGE:   sysNewton (n,defset,t,q,m,[tr]); n,t,q,m,tr int, defset list int's
 @format
-         - n is length, 
+         - n is length,
          - defset is the defining set,
-         - t is the number of errors, 
-         - q is basefield size, 
+         - t is the number of errors,
+         - q is basefield size,
          - m is degree extension of the splitting field,
-         - if tr>0 it indicates that Newton identities in triangular 
+         - if tr>0 it indicates that Newton identities in triangular
            form should be constructed
 @end format
-RETURN:  the ring to work with the generalized Newton identities (in 
+RETURN:  the ring to work with the generalized Newton identities (in
          triangular form if applicable) containing the ideal with name 'newton'
-THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs 
-         the corresponding ideal 'newton' with the generalized Newton 
-         identities. With its help one can solve the decoding problem. For 
+THEORY:  Based on 'defset' of the given cyclic code, the procedure constructs
+         the corresponding ideal 'newton' with the generalized Newton
+         identities. With its help one can solve the decoding problem. For
          basics of the method @ref{Cooper philosophy}.
 SEE ALSO: sysCRHT, sysBin
 EXAMPLE:  example sysNewton; shows an example
 "
-{  
+{
  string s="ring @newton=("+string(q)+",a),(";
  int i,j;
  int flag;
  int tr;
- 
+
  if (size(#)>0)
  {
   tr=#[1];
  }
- 
+
  for (i=n; i>=1; i--)
  {
@@ -319 +319 @@
     {
       flag=0;
-      break;      
+      break;
     }
   }
@@ -332 +332 @@
   s=s+"S("+string(defset[i])+"),";
  }
- s=s+"S("+string(defset[1])+")),lp;"; 
-  
+ s=s+"S("+string(defset[1])+")),lp;";
+
  execute(s);
- 
- ideal newton; 
+
+ ideal newton;
  poly sum;
- 
- 
+
+
  //------------ generate generalized Newton identities ----------
  if (tr)
@@ -353 +353 @@
   }
  } else
- { 
+ {
   for (i=1; i<=t; i++)
   {
@@ -372 +372 @@
   }
   newton=newton,S(t+i)+sum;
- } 
- 
+ }
+
  //----------- add field equations on sigma's --------------
  for (i=1; i<=t; i++)
@@ -379 +379 @@
   newton=newton,sigma(i)^(q^m)-sigma(i);
  }
- 
+
  //----------- add conjugacy relations ------------------
  for (i=1; i<=n; i++)
@@ -387 +387 @@
  newton=simplify(newton,2);
  export newton;
- return(@newton); 
-} 
-example 
+ return(@newton);
+}
+example
 {
      "EXAMPLE:";  echo = 2;
-     // Newton identities for a binary 3-error-correcting cyclic code of 
+     // Newton identities for a binary 3-error-correcting cyclic code of
      //length 31 with defining set (1,5,7)
-     
+
      int n=31;          // length
      list defset=1,5,7; //defining set
@@ -401 +401 @@
      int m=5;           // degree extension of the splitting field
      int tr=1;          // indicator of triangular form of Newton identities
-     
-     
+
+
      def A=sysNewton(n,defset,t,q,m);
      setring A;
      A;                 // shows the ring we are working in
      print(newton);     // generalized Newton identities
-     
+
      //===============================
      A=sysNewton(n,defset,t,q,m,tr);
-     setring A;     
+     setring A;
      print(newton);     // generalized Newton identities in triangular form
 }
 
 ///////////////////////////////////////////////////////////////////////////////
-// forms a list of special combinations needed for computation of Waring's 
+// forms a list of special combinations needed for computation of Waring's
 //function
 static proc combinations_sum (int m, int n)
@@ -438 +438 @@
    count++;
   }
-  if (flag) 
+  if (flag)
   {
    for (j=2; j<=m; j++)
@@ -444 +444 @@
     interm[i][j]=interm[i][j] div j;
    }
-   result[size(result)+1]=interm[i];  
+   result[size(result)+1]=interm[i];
   }
  }
@@ -470 +470 @@
 "USAGE:    sysBin (v,Q,n,[odd]);  v,n,odd are int, Q is list of int's
 @format
-          - v a number if errors, 
-          - Q is a generating set of the code, 
-          - n the length, 
-          - odd is an additional parameter: if  
-           set to 1, then the generating set is enlarged by odd elements, 
+          - v a number if errors,
+          - Q is a generating set of the code,
+          - n the length,
+          - odd is an additional parameter: if
+           set to 1, then the generating set is enlarged by odd elements,
            which are 2^(some power)*(some elment in the gen.set) mod n
 @end format
 RETURN:    the ring with the resulting system called 'bin'
-THEORY:  Based on Q of the given cyclic code, the procedure constructs 
-         the corresponding ideal 'bin' with the use of Waring function. 
-         With its help one can solve the decoding problem. 
+THEORY:  Based on Q of the given cyclic code, the procedure constructs
+         the corresponding ideal 'bin' with the use of Waring function.
+         With its help one can solve the decoding problem.
          For basics of the method @ref{Generalized Newton identities}.
 SEE ALSO: sysNewton, sysCRHT
@@ -527 +527 @@
   Q_update=Q;
  }
- 
- //---- form polynomials for the Bin system via Waring's function ---------  
+
+ //---- form polynomials for the Bin system via Waring's function ---------
  for (i=1; i<=size(Q_update); i++)
  {
@@ -541 +541 @@
    }
    count1=0;
-   for (j=2; j<=upper-1; j++) 
+   for (j=2; j<=upper-1; j++)
    {
     count1=count1+exp_count(j,2);
@@ -564 +564 @@
    sum_=sum_+coef_*mon;
   }
-  result=result,S(Q_update[i])-sum_;  
+  result=result,S(Q_update[i])-sum_;
  }
  ideal bin=simplify(result,2);
  export bin;
  return(r);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
@@ -592 +592 @@
  if (ncols(x)!=nrows(g)) {print("ERRORencode2!");}
  return(x*g);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
@@ -603 +603 @@
                     0,0,0,1,1,1,0;
      //encode x with the generator matrix g
-     print(encode(x,g)); 
+     print(encode(x,g));
 }
 
@@ -616 +616 @@
  if (nrows(c)>1) {print("ERRORsyndrome1!");}
  if (ncols(c)!=ncols(h)) {print("ERRORsyndrome2!");}
- return(h*transpose(c));  
-} 
-example 
+ return(h*transpose(c));
+}
+example
 {
      "EXAMPLE:";  echo = 2;
@@ -636 +636 @@
      print(syndrome(check,c));
      c[1,3]=1;
-     //now c is a codeword 
+     //now c is a codeword
      print(syndrome(check,c));
 }
@@ -657 +657 @@
 "USAGE:   sysQE(check,y,t,[fieldeq,formal]);check,y matrix;t,fieldeq,formal int
 @format
-        - check is the check matrix of the code   
-        - y is a received word, 
-        - t the number of errors to be corrected, 
-        - if fieldeq=1, then field equations are added, 
-        - if formal=0, field equations on (known) syndrome variables 
-          are not added, in order to add them (note that the exponent should 
+        - check is the check matrix of the code
+        - y is a received word,
+        - t the number of errors to be corrected,
+        - if fieldeq=1, then field equations are added,
+        - if formal=0, field equations on (known) syndrome variables
+          are not added, in order to add them (note that the exponent should
           be as a number of elements in the INITIAL alphabet) one
           needs to set formal>0 for the exponent
 @end format
 RETURN:   the ring to work with together with the resulting system called 'qe'
-THEORY:  Based on 'check' of the given linear code, the procedure constructs 
+THEORY:  Based on 'check' of the given linear code, the procedure constructs
          the corresponding ideal that gives an opportunity to compute
          unknown syndrome of the received word y. Further
-         one is able to solve the decoding problem. 
+         one is able to solve the decoding problem.
          For basics of the method @ref{Decoding method based on quadratic equations}.
 SEE ALSO: sysFL
@@ -686 +686 @@
   formal=#[2];
  }
- 
- def br=basering; 
+
+ def br=basering;
  list rl=ringlist(br);
- 
+
  int red=nrows(check);
  int n=ncols(check);
  int q=rl[1][1];
- 
+
  if (formal==0)
- { 
+ {
   ring work=(q,a),(V(1..t),U(1..n)),dp;
  } else
@@ -701 +701 @@
   ring work=(q,a),(V(1..t),U(1..n),s(1..red)),(dp(t),lp(n),dp(red));
  }
- 
+
  matrix check=imap(br,check);
  matrix y=imap(br,y);
- 
+
  matrix h_full=genMDSMat(n,a);
  matrix h=submat(h_full,1..red,1..n);
  if (nrows(y)!=1) {print("ERROR1Pell");}
  if (ncols(y)!=n) {print("ERROR2Pell");}
-  
+
  ideal result;
- 
+
  list c;
  list a;
@@ -722 +722 @@
   c[i]=tmp;
  }
- 
+
  int tim=rtimer;
  matrix transf=inverse(transpose(h_full));
-  
+
  //------ expression matrix of check vectors w.r.t. the MDS basis -----------
  tim=rtimer;
@@ -733 +733 @@
   a[i]=transf*a[i];
  }
- 
+
  //----------- compute the structure constants ------------------------
  tim=rtimer;
- matrix te[n][1]; 
+ matrix te[n][1];
  for (i=1; i<=n; i++)
  {
@@ -742 +742 @@
   {
    if ((j<i)&&(i<=t+1)) {c[i][j]=c[j][i];}
-   else 
+   else
    {
-    if (i+j<=n+1) 
+    if (i+j<=n+1)
     {
      c[i][j]=te;
-     c[i][j][i+j-1,1]=1; 
+     c[i][j][i+j-1,1]=1;
     }
     else
@@ -753 +753 @@
      c[i][j]=star(h_full,i,j);
      c[i][j]=transf*c[i][j];
-    }   
+    }
    }
   }
  }
- 
- 
- tim=rtimer; 
+
+
+ tim=rtimer;
  if (formal==0)
  {
@@ -798 +798 @@
      result=result,V(j)^q-V(j);
   }
- } 
- 
+ }
+
  //----- form the quadratic equations according to the theory -----------
  for (i=1; i<=n; i++)
@@ -819 +819 @@
   }
   result=result,sum1-sum3;
- } 
- 
+ }
+
  result=simplify(result,2);
- 
+
  ideal qe=result;
  export qe;
- return(work); 
-} 
-example 
+ return(work);
+}
+example
 {
      "EXAMPLE:";  echo = 2;
      intvec v = option(get);
-     
+
      //correct 2 errors in [7,3] 8-ary code RS code
      int t=2; int q=8; int n=7; int redun=4;
@@ -840 +840 @@
      matrix x[1][3]=0,0,1,0;
      matrix y[1][7]=encode(x,g);
-     
+
      //disturb with 2 errors
-     matrix rec[1][7]=errorInsert(y,list(2,4),list(1,a)); 
-     
+     matrix rec[1][7]=errorInsert(y,list(2,4),list(1,a));
+
      //generate the system
      def A=sysQE(h,rec,t);
      setring A;
      print(qe);
-     
+
      //let us decode
      option(redSB);
      ideal sys_qe=std(qe);
-     print(sys_qe);     
-     
+     print(sys_qe);
+
      option(set,v);
 }
@@ -862 +862 @@
 "USAGE:  errorInsert(y,pos,val); y is matrix, pos,val list of int's
 @format
-        - y is a (code) word, 
-        - pos = positions where errors occured, 
+        - y is a (code) word,
+        - pos = positions where errors occured,
         - val = their corresponding values
 @end format
@@ -877 +877 @@
  }
  return(result);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
@@ -890 +890 @@
      matrix y[1][7]=encode(x,g);
      print(y);
-     
+
      //disturb with 2 errors
      matrix rec[1][7]=errorInsert(y,list(2,4),list(1,a));
@@ -902 +902 @@
 "USAGE:    errorRand(y, num, e); y matrix, num,e int
 @format
-          - y is a (code) word, 
-          - num is the number of errors, 
+          - y is a (code) word,
+          - num is the number of errors,
           - e is an extension degree (if one wants values to be from GF(p^e))
 @end format
@@ -926 +926 @@
    }
    if (flag) {pos[i]=temp;break;}
-  } 
- }
- 
+  }
+ }
+
  for (i=1; i<=num; i++)
  {
   flag=1;
   while(flag)
-  {   
-   tempnum=randomvector(1,e);   
-   if (tempnum!=0) {flag=0;}   
-  }
-  val[i]=tempnum; 
- }
-  
+  {
+   tempnum=randomvector(1,e);
+   if (tempnum!=0) {flag=0;}
+  }
+  val[i]=tempnum;
+ }
+
  for (i=1; i<=size(pos); i++)
  {
@@ -945 +945 @@
  }
  return(result);
-} 
-example 
+}
+example
 {
   "EXAMPLE:";  echo = 2;
@@ -957 +957 @@
      matrix x[1][3]=0,0,1,0;
      matrix y[1][7]=encode(x,g);
-     
+
      //disturb with 2 random errors
      matrix rec[1][7]=errorRand(y,2,3);
      print(rec);
-     print(rec-y);     
+     print(rec-y);
 }
 
@@ -969 +969 @@
 "USAGE:    randomCheck(m, n, e); m,n,e are int
 @format
-          - m x n are dimensions of the matrix, 
+          - m x n are dimensions of the matrix,
           - e is an extension degree (if one wants values to be from GF(p^e))
 @end format
@@ -986 +986 @@
   {
    rand[i,j]=temp[j,1];
-  } 
+  }
  }
  result=concat(rand,unitmat(m));
  return(result);
-} 
-example 
-{
-  "EXAMPLE:";  echo = 2;     
+}
+example
+{
+  "EXAMPLE:";  echo = 2;
      int redun=5; int n=15;
      ring r=2,x,dp;
-     
+
      //generate random check matrix for a [15,5] binary code
      matrix h=randomCheck(redun,n,1);
      print(h);
-     
+
      //corresponding generator matrix
      matrix g=dual_code(h);
-     print(g);     
+     print(g);
 }
 
@@ -1011 +1011 @@
 "USAGE:   genMDSMat(n, a); n is int, a is number
 @format
-        - n x n are dimensions of the MDS matrix, 
+        - n x n are dimensions of the MDS matrix,
         - a is a primitive element of the field.
-@end format    
-NOTE:   An MDS matrix is constructed in the following way. We take a to be a 
-        generator of the multiplicative group of the field. Then we construct 
+@end format
+NOTE:   An MDS matrix is constructed in the following way. We take a to be a
+        generator of the multiplicative group of the field. Then we construct
         the Vandermonde matrix with this a.
-ASSUME:   extension field should already be defined 
+ASSUME:   extension field should already be defined
 RETURN:   a matrix with the MDS property
-EXAMPLE:  example genMDSMat; shows an example  
+EXAMPLE:  example genMDSMat; shows an example
 "
 {
@@ -1029 +1029 @@
   {
    result[j+1,i+1]=(a^i)^j;
-  } 
+  }
  }
  return(result);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
      int q=16; int n=15;
      ring r=(q,a),x,dp;
-     
+
      //generate an MDS (Vandermonde) matrix
      matrix h_full=genMDSMat(n,a);
-     print(h_full);     
+     print(h_full);
 }
 
@@ -1050 +1050 @@
 "USAGE:  mindist (check, q); check matrix, q int
 @format
-        - check is a check matrix, 
+        - check is a check matrix,
         - q is the field size
 @end format
-RETURN:  minimum distance of the code together with the time needed for its 
+RETURN:  minimum distance of the code together with the time needed for its
          calculation
-EXAMPLE: example mindist; shows an example 
+EXAMPLE: example mindist; shows an example
 "
 {
@@ -1061 +1061 @@
 
  int n=ncols(check); int redun=nrows(check); int t=redun+1;
- 
- def br=basering; 
- list rl=ringlist(br); 
+
+ def br=basering;
+ list rl=ringlist(br);
  int q=rl[1][1];
- 
- ring work=(q,a),(V(1..t),U(1..n)),dp;  
- matrix check=imap(br,check); 
- 
+
+ ring work=(q,a),(V(1..t),U(1..n)),dp;
+ matrix check=imap(br,check);
+
  ideal temp;
  int count=1;
@@ -1074 +1074 @@
  int flag2;
  int i, tim, timsolve;
- matrix z[1][n]; 
+ matrix z[1][n];
  option(redSB);
  def A=sysQE(check,z,count);
 
- //proceed with solving the system w.r.t zero vector until some solutions 
+ //proceed with solving the system w.r.t zero vector until some solutions
  //are found
  while (flag)
@@ -1087 +1087 @@
     tim=rtimer;
     temp=std(temp);
-    timsolve=timsolve+rtimer-tim;  
+    timsolve=timsolve+rtimer-tim;
     flag2=1;
     setring work;
-    temp=imap(A,temp);    
+    temp=imap(A,temp);
     for (i=1; i<=n; i++)
     {
-      if 
-        (temp[i]!=U(n-i+1)) 
+      if
+        (temp[i]!=U(n-i+1))
         {
           flag2=0;
         }
     }
-    if (!flag2) 
+    if (!flag2)
     {
       flag=0;
     }
-    else 
+    else
     {
       count++;
     }
  }
- list result=list(count,timsolve); 
- 
+ list result=list(count,timsolve);
+
  option(set,vopt);
- return(result); 
-} 
-example 
+ return(result);
+}
+example
 {
      "EXAMPLE:";  echo = 2;
-     //determine a minimum distance for a [7,3] binary code 
-     int q=8; int n=7; int redun=4; int t=redun+1; 
-     ring r=(q,a),x,dp;     
-               
+     //determine a minimum distance for a [7,3] binary code
+     int q=8; int n=7; int redun=4; int t=redun+1;
+     ring r=(q,a),x,dp;
+
      //generate random check matrix
      matrix h=randomCheck(redun,n,1);
      print(h);
-     list l=mindist(h);     
-     print(l[1]);  
-     //time for the comutation in secs   
-     print(l[2]);     
+     list l=mindist(h);
+     print(l[1]);
+     //time for the comutation in secs
+     print(l[2]);
 }
 
@@ -1135 +1135 @@
 @format
           - check is the check matrix of the code,
-          - rec is a received word, 
+          - rec is a received word,
           - t is an upper bound for the number of errors one wants to correct
 @end format
-ASSUME:   Errors in rec should be correctable, otherwise the output is 
+ASSUME:   Errors in rec should be correctable, otherwise the output is
           unpredictable
 RETURN:   a codeword that is closest to rec
-EXAMPLE:  example decode; shows an example 
+EXAMPLE:  example decode; shows an example
 "
 {
- intvec vopt = option(get); 
- 
+ intvec vopt = option(get);
+
  def br=basering;
- int n=ncols(check); 
- 
- int count=1; 
+ int n=ncols(check);
+
+ int count=1;
  def A=sysQE(check,rec,count);
  while(1)
  {
   A=sysQE(check,rec,count);
-  setring A;     
+  setring A;
   matrix h_full=genMDSMat(n,a);
   matrix rec=imap(br,rec);
   option(redSB);
-  ideal qe_red=std(qe);   
+  ideal qe_red=std(qe);
   if (qe_red[1]!=1)
   {
     break;
   }
-  else 
+  else
   {
     count++;
@@ -1169 +1169 @@
   setring br;
  }
- 
- setring A; 
-     
+
+ setring A;
+
  //obtain a codeword
  //this works only if our code is indeed can correct these errors
@@ -1178 +1178 @@
  {
   syn[i,1]=-qe_red[n-i+1]+lead(qe_red[n-i+1]);
- }   
- 
- matrix real_syn=inverse(h_full)*syn;  
+ }
+
+ matrix real_syn=inverse(h_full)*syn;
  setring br;
  matrix real_syn=imap(A,real_syn);
- 
+
  option(set,vopt);
- return(rec-transpose(real_syn));     
-} 
-example 
-{
-     "EXAMPLE:";  echo = 2;     
-     //correct 1 error in [15,7] binary code 
+ return(rec-transpose(real_syn));
+}
+example
+{
+     "EXAMPLE:";  echo = 2;
+     //correct 1 error in [15,7] binary code
      int t=1; int q=16; int n=15; int redun=10;
-     ring r=(q,a),x,dp;     
-             
+     ring r=(q,a),x,dp;
+
      //generate random check matrix
-     matrix h=randomCheck(redun,n,1);     
+     matrix h=randomCheck(redun,n,1);
      matrix g=dual_code(h);
      matrix x[1][n-redun]=0,0,1,0,1,0,1;
      matrix y[1][n]=encode(x,g);
      print(y);
-     
+
      // find out the minimum distance of the code
      list l=mindist(h);
-     
+
      //disturb with errors
      "Correct ",(l[1]-1) div 2," errors";
      matrix rec[1][n]=errorRand(y,(l[1]-1) div 2,1);
-     print(rec);     
-     
+     print(rec);
+
      //let us decode
      matrix dec_word=decode(h,rec);
-     print(dec_word);     
+     print(dec_word);
 }
 
@@ -1221 +1221 @@
 @format
           - redun is a redundabcy of a (random) code,
-          - q is the field size, 
+          - q is the field size,
           - ncodes is the number of random codes to be processed,
           - ntrials is the number of received vectors per code to be corrected
-          - If e is given it sets the correction capacity explicitly. It 
+          - If e is given it sets the correction capacity explicitly. It
           should be used in case one expects some lower bound,
-          otherwise the procedure tries to compute the real minimum distance 
+          otherwise the procedure tries to compute the real minimum distance
           to find out the error-correction capacity
 @end format
-RETURN:    nothing; 
-EXAMPLE:   example decodeRandom; shows an example 
+RETURN:    nothing;
+EXAMPLE:   example decodeRandom; shows an example
 "
 {
@@ -1248 +1248 @@
  option(redSB);
  def br=basering;
- matrix h_full=genMDSMat(n,a); 
+ matrix h_full=genMDSMat(n,a);
  matrix z[1][ncols(h_full)];
 
@@ -1268 +1268 @@
      dist=tmp[1];
      printf("d= %p",dist);
-     t=(dist-1) div 2; 
-  }     
-  tim2=rtimer;  
+     t=(dist-1) div 2;
+  }
+  tim2=rtimer;
   tim3=rtimer;
 
@@ -1279 +1279 @@
   ideal sys2,sys3;
   matrix h=imap(br,h);
-  matrix g=dual_code(h);  
+  matrix g=dual_code(h);
   ideal sys=qe;
   print("The system is generated");
-  timdec3=timdec3+rtimer-tim3;  
+  timdec3=timdec3+rtimer-tim3;
 
   //------ modify the template according to every received word --------------
   for (j=1; j<=ntrials; j++)
   {
-   word=randomvector(n-redun,1);   
+   word=randomvector(n-redun,1);
    y=encode(transpose(word),g);
-   rec=errorRand(y,t,1);   
-   sys2=add_synd(rec,h,redun,sys); 
-  
+   rec=errorRand(y,t,1);
+   sys2=add_synd(rec,h,redun,sys);
+
    tim=rtimer;
-   sys3=std(sys2);   
-   timdec=timdec+rtimer-tim;   
-  } 
+   sys3=std(sys2);
+   timdec=timdec+rtimer-tim;
+  }
   timdec2=timdec2+rtimer-tim2;
   kill A;
   option(set,vopt);
- } 
+ }
  printf("Time for mindist: %p", timdist);
  printf("Time for GB in mindist: %p", timdist);
  printf("Time for decoding: %p", timdec2);
  printf("Time for GB in decoding: %p", timdec);
- printf("Time for sysQE in decoding: %p", timdec3); 
-} 
-example 
+ printf("Time for sysQE in decoding: %p", timdec3);
+}
+example
 {
      "EXAMPLE:";  echo = 2;
      int q=32; int n=25; int redun=n-11; int t=redun+1;
      ring r=(q,a),x,dp;
-     
+
      // correct 2 errors in 5 random binary codes, 50 trials each
-     decodeRandom(n,redun,5,50,2); 
+     decodeRandom(n,redun,5,50,2);
 }
 
@@ -1320 +1320 @@
 
 proc decodeCode(matrix check, int ntrials, list #)
-"USAGE:     decodeCode(check, ntrials, [e]); check matrix, ntrials,e int 
-@format            
-           - check is a check matrix for the code, 
-           - ntrials is the number of received vectors per code to be 
+"USAGE:     decodeCode(check, ntrials, [e]); check matrix, ntrials,e int
+@format
+           - check is a check matrix for the code,
+           - ntrials is the number of received vectors per code to be
            corrected.
-           - If e is given it sets the correction capacity explicitly. It 
+           - If e is given it sets the correction capacity explicitly. It
            should be used in case one expects some lower bound,
-           otherwise the procedure tries to compute the real minimum distance 
+           otherwise the procedure tries to compute the real minimum distance
            to find out the error-correction capacity
 @end format
-RETURN:     nothing;  
-EXAMPLE:    example decodeCode; shows an example 
+RETURN:     nothing;
+EXAMPLE:    example decodeCode; shows an example
 "
 {
@@ -1351 +1351 @@
  option(redSB);
  def br=basering;
- matrix h_full=genMDSMat(n,a); 
+ matrix h_full=genMDSMat(n,a);
  matrix z[1][ncols(h_full)];
  setring br;
@@ -1369 +1369 @@
    dist=tmp[1];
    printf("d= %p",dist);
-   t=(dist-1) div 2; 
- }     
- tim2=rtimer;  
+   t=(dist-1) div 2;
+ }
+ tim2=rtimer;
  tim3=rtimer;
 
@@ -1380 +1380 @@
  ideal sys2,sys3;
  matrix h=imap(br,h);
- matrix g=dual_code(h);  
+ matrix g=dual_code(h);
  ideal sys=qe;
  print("The system is generated");
- timdec3=timdec3+rtimer-tim3; 
-
- //--- modify the template according to every received word --------------- 
+ timdec3=timdec3+rtimer-tim3;
+
+ //--- modify the template according to every received word ---------------
  for (j=1; j<=ntrials; j++)
  {
-   word=randomvector(n-redun,1);   
+   word=randomvector(n-redun,1);
    y=encode(transpose(word),g);
-   rec=errorRand(y,t,1);   
-   sys2=add_synd(rec,h,redun,sys); 
-   
+   rec=errorRand(y,t,1);
+   sys2=add_synd(rec,h,redun,sys);
+
    tim=rtimer;
-   sys3=std(sys2);   
-   timdec=timdec+rtimer-tim;   
- } 
- timdec2=timdec2+rtimer-tim2;  
-  
+   sys3=std(sys2);
+   timdec=timdec+rtimer-tim;
+ }
+ timdec2=timdec2+rtimer-tim2;
+
  printf("Time for mindist: %p", timdist);
  printf("Time for GB in mindist: %p", timdist);
  printf("Time for decoding: %p", timdec2);
  printf("Time for GB in decoding: %p", timdec);
- printf("Time for sysQE in decoding: %p", timdec3); 
- 
+ printf("Time for sysQE in decoding: %p", timdec3);
+
  option(set,vopt);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
@@ -1413 +1413 @@
      ring r=(q,a),x,dp;
      matrix check=randomCheck(redun,n,1);
-     
-     // correct 2 errors in using the code above, 50 trials 
-     decodeCode(check,50,2); 
+
+     // correct 2 errors in using the code above, 50 trials
+     decodeCode(check,50,2);
 }
 
@@ -1426 +1426 @@
      matrix s[redun][1]=syndrome(check,rec);
      for (int i=1; i<=redun; i++)
-     
-     {
-          result[i]=result[i]-s[i,1];          
+
+     {
+          result[i]=result[i]-s[i,1];
      }
      return(result);
@@ -1448 +1448 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// return index of an element in the ideal where it does not vanish at the 
+// return index of an element in the ideal where it does not vanish at the
 //given point
 static proc find_index (ideal G, matrix p)
@@ -1488 +1488 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// check whether given polynomial is divisible by some leading monomial of the 
+// check whether given polynomial is divisible by some leading monomial of the
 //ideal
 static proc divisible (poly m, ideal G)
@@ -1494 +1494 @@
      for (int i=1; i<=size(G); i++)
      {
-          if (m/leadmonom(G[i])!=0) {return(1);}          
+          if (m/leadmonom(G[i])!=0) {return(1);}
      }
      return(0);
@@ -1503 +1503 @@
 proc vanishId (list points)
 "USAGE:  vanishId (points); point is a list of matrices
-        'points' is a list of points for which the vanishing ideal is to be 
-        constructed        
+        'points' is a list of points for which the vanishing ideal is to be
+        constructed
 RETURN:  Vanishing ideal corresponding to the given set of points
-EXAMPLE: example vanishId; shows an example 
+EXAMPLE: example vanishId; shows an example
 "
 {
      int m=size(points[1]);
      int n=size(points);
-     
+
      ideal G=1;
      int i,k,j;
@@ -1519 +1519 @@
      //------------- proceed according to Farr-Gao algorithm ----------------
      for (k=1; k<=n; k++)
-     {          
+     {
           i=find_index(G,points[k]);
-          cur=G[i];          
+          cur=G[i];
           for(j=i+1; j<=size(G); j++)
           {
@@ -1529 +1529 @@
           temp=ideal2list(G);
           temp=delete(temp,i);
-          G=list2ideal(temp);          
+          G=list2ideal(temp);
           for (j=1; j<=m; j++)
           {
@@ -1535 +1535 @@
                {
                     attrib(G,"isSB",1);
-                    h=NF((x(j)-points[k][j,1])*cur,G);                    
+                    h=NF((x(j)-points[k][j,1])*cur,G);
                     temp=ideal2list(G);
                     temp=insert(temp,h);
                     G=list2ideal(temp);
-                    G=sort(G)[1];     
+                    G=sort(G)[1];
                }
           }
@@ -1545 +1545 @@
      attrib(G,"isSB",1);
      return(G);
-} 
-example 
+}
+example
 {
      "EXAMPLE:";  echo = 2;
       ring r=3,(x(1..3)),dp;
-     
+
      //generate all 3-vectors over GF(3)
      list points=pointsGen(3,1);
-     
+
      list points2=convPoints(points);
-     
+
      //grasps the first 11 points
      list p=graspList(points2,1,11);
      print(p);
-     
+
      //construct the vanishing ideal
      ideal id=vanishId(p);
@@ -1566 +1566 @@
 
 ///////////////////////////////////////////////////////////////////////////////
-// construct the list of all vectors of length m with elements in p^e, where p 
+// construct the list of all vectors of length m with elements in p^e, where p
 //is characteristics
 proc pointsGen (int m, int e)
@@ -1588 +1588 @@
           count++;
           for (j=1; j<=charac^(e)-1; j++)
-          {               
+          {
                result[count][m]=a^j;
                count++;
@@ -1594 +1594 @@
           return(result);
      }
-     list prev=pointsGen(m-1,e);     
+     list prev=pointsGen(m-1,e);
      for (i=1; i<=size(prev); i++)
      {
@@ -1609 +1609 @@
      return(result);
      }
-     
+
      if (e==1)
      {
@@ -1616 +1616 @@
      int i,j;
      list l=ringlist(basering);
-     int charac=l[1][1];     
+     int charac=l[1][1];
      list tmp;
      for (i=1; i<=charac^m; i++)
@@ -1625 +1625 @@
      {
           for (j=0; j<=charac-1; j++)
-          {               
+          {
                result[count][m]=number(j);
                count++;
@@ -1631 +1631 @@
           return(result);
      }
-     list prev=pointsGen(m-1,e);     
+     list prev=pointsGen(m-1,e);
      for (i=1; i<=size(prev); i++)
      {
@@ -1643 +1643 @@
      return(result);
      }
-     
+
 }
 
@@ -1688 +1688 @@
 {
      poly prod=1;
-     list rl=ringlist(basering);     
+     list rl=ringlist(basering);
      int charac=rl[1][1];
      int l;
@@ -1730 +1730 @@
 "USAGE:    sysFL (check,y,t,e,s); check,y matrix, t,e,s int
 @format
-          - check is a check matrix of the code, 
-          - y is a received word, 
+          - check is a check matrix of the code,
+          - y is a received word,
           - t the number of errors to correct,
-          - e is the extension degree, 
+          - e is the extension degree,
           - s is the dimension of the point for the vanishing ideal
 @end format
 RETURN:  the system of Fitzgerald-Lax for the given decoding problem
-THEORY:  Based on 'check' of the given linear code, the procedure constructs 
+THEORY:  Based on 'check' of the given linear code, the procedure constructs
          the corresponding ideal constructed with a generalization of
          Cooper's philosophy. For basics of the method @ref{Fitzgerald-Lax method}.
@@ -1744 +1744 @@
 "
 {
-     list rl=ringlist(basering);        
-     int charac=rl[1][1];     
+     list rl=ringlist(basering);
+     int charac=rl[1][1];
      int n=ncols(check);
-     int m=nrows(check);          
+     int m=nrows(check);
      list points=pointsGen(s,e);
      list points2=convPoints(points);
-     list p=graspList(points2,1,n);     
-     ideal id=vanishId(p,e);      
-     ideal funcs=gener_funcs(check,p,e,id,s);          
-     
+     list p=graspList(points2,1,n);
+     ideal id=vanishId(p,e);
+     ideal funcs=gener_funcs(check,p,e,id,s);
+
      ideal result;
      poly temp;
      int i,j,k;
-     
+
      //--------------- add vanishing realtions ---------------------
      for (i=1; i<=t; i++)
-     {          
+     {
           for (j=1; j<=size(id); j++)
           {
-               temp=id[j];               
+               temp=id[j];
                for (k=1; k<=s; k++)
                {
                     temp=subst(temp,x(k),x_var(i,k,s));
-               }               
+               }
                result=result,temp;
           }
-     }          
-     
+     }
+
      //--------------- add field equations --------------------
      for (i=1; i<=t; i++)
@@ -1784 +1784 @@
           result=result,e(i)^(charac^e-1)-1;
      }
-     
+
      result=simplify(result,8);
-     
+
      //--------------- add check realtions --------------------
      poly sum;
-     matrix syn[m][1]=syndrome(check,y);          
+     matrix syn[m][1]=syndrome(check,y);
      for (i=1; i<=size(funcs); i++)
-     {          
+     {
           sum=0;
           for (j=1; j<=t; j++)
@@ -1800 +1800 @@
                     temp=subst(temp,x(k),x_var(j,k,s));
                }
-               sum=sum+temp*e(j);         
+               sum=sum+temp*e(j);
           }
           result=result,sum-syn[i,1];
      }
-     
+
      result=simplify(result,2);
-     
+
      points=points2;
-     export points;     
+     export points;
      return(result);
-} 
+}
 example
 {
      "EXAMPLE:";  echo = 2;
      intvec vopt = option(get);
-     
+
      list l=FLpreprocess(3,1,11,2,"");
      def r=l[1];
      setring r;
-     int s_work=l[2];     
-     
+     int s_work=l[2];
+
      //the check matrix of [11,6,5] ternary code
      matrix h[5][11]=1,0,0,0,0,1,1,1,-1,-1,0,
@@ -1833 +1833 @@
      matrix rec[1][11]=errorInsert(y,list(2,4),list(1,-1));
 
-     //the Fitzgerald-Lax system     
+     //the Fitzgerald-Lax system
      ideal sys=sysFL(h,rec,2,1,s_work);
      print(sys);
      option(redSB);
      ideal red_sys=std(sys);
-     red_sys; 
+     red_sys;
      // read the solutions from this redGB
      // the points are (0,0,1) and (0,1,0) with error values 1 and -1 resp.
      // use list points to find error positions;
      points;
-     
+
      option(set,vopt);
 }
@@ -1856 +1856 @@
      {
           s++;
-     }     
+     }
      list var_ord;
      int i,j;
@@ -1874 +1874 @@
                count++;
           }
-     }     
-     
+     }
+
      list rl;
      list tmp;
-     
+
      if (e>1)
      {
@@ -1886 +1886 @@
           rl[1][2][1]=string("a");
           rl[1][3]=tmp;
-          rl[1][3][1]=tmp;          
+          rl[1][3][1]=tmp;
           rl[1][3][1][1]=string("lp");
           rl[1][3][1][2]=1;
@@ -1893 +1893 @@
           rl[1]=p;
      }
-     
+
      rl[2]=var_ord;
-     
+
      rl[3]=tmp;
-     rl[3][1]=tmp;     
+     rl[3][1]=tmp;
      rl[3][1][1]=string("lp");
      intvec v=1;
@@ -1904 +1904 @@
           v=v,1;
      }
-     rl[3][1][2]=v; 
+     rl[3][1][2]=v;
      rl[3][2]=tmp;
-     rl[3][2][1]=string("C");    
+     rl[3][2][1]=string("C");
      rl[3][2][2]=intvec(0);
-     
-     rl[4]=ideal(0);     
-     
+
+     rl[4]=ideal(0);
+
      def r2=ring(rl);
      setring r2;
-     list l=ringlist(r2);     
+     list l=ringlist(r2);
      if (e>1)
      {
-          execute(string("poly f="+minp));     
-          ideal id=f;     
+          execute(string("poly f="+minp));
+          ideal id=f;
           l[1][4]=id;
      }
-     
+
      def r=ring(l);
-     setring r;      
-     
+     setring r;
+
      return(list(r,s));
 }
@@ -1930 +1930 @@
 // imitating two indeces
 static proc x_var (int i, int j, int s)
-{     
+{
      return(x1(s*(i-1)+j));
 }
@@ -1937 +1937 @@
 // random vector of length n with entries from p^e, p the characteristic
 static proc randomvector(int n, int e)
-{     
+{
     int i;
     matrix result[n][1];
@@ -1944 +1944 @@
         result[i,1]=asElement(random_prime_vector(e));
     }
-    return(result);        
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// "convert" representation of an element from the field extension from vector 
+    return(result);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// "convert" representation of an element from the field extension from vector
 //to an elelemnt
 static proc asElement(list l)
@@ -1955 +1955 @@
   int i;
   number w=1;
-  if (size(l)>1) {w=par(1);}  
+  if (size(l)>1) {w=par(1);}
   for (i=0; i<=size(l)-1; i++)
   {
@@ -1966 +1966 @@
 // random vector of length n with entries from p, p the characteristic
 static proc random_prime_vector (int n)
-{  
+{
   list rl=ringlist(basering);
   int i, charac;
@@ -1972 +1972 @@
   {
     if (rl[1][1] mod i ==0)
-    {      
+    {
       break;
     }
   }
-  charac=i;  
-  
+  charac=i;
+
   list l;
-  
+
   for (i=1; i<=n; i++)
   {
@@ -1990 +1990 @@
 
 proc decodeRandomFL(int n, int redun, int p, int e, int t, int ncodes, int ntrials, string minpol)
-"USAGE:    decodeRandomFL(redun,p,e,n,t,ncodes,ntrials,minpol); 
+"USAGE:    decodeRandomFL(redun,p,e,n,t,ncodes,ntrials,minpol);
 @format
-          - n is length of codes generated, redun = redundancy of codes 
-          generated, 
-          - p is characteristics, 
-          - e is the extension degree, 
-          - t is the number of errors to correct, 
+          - n is length of codes generated, redun = redundancy of codes
+          generated,
+          - p is characteristics,
+          - e is the extension degree,
+          - t is the number of errors to correct,
           - ncodes is the number of random codes to be processed,
           - ntrials is the number of received vectors per code to be corrected,
-          - minpol: due to some pecularities of SINGULAR one needs to provide 
+          - minpol: due to some pecularities of SINGULAR one needs to provide
           minimal polynomial for the extension explicitly
 @end format
@@ -2008 +2008 @@
  intvec vopt = option(get);
 
- list l=FLpreprocess(p,e,n,t,minpol); 
- 
+ list l=FLpreprocess(p,e,n,t,minpol);
+
  def r=l[1];
- int s_work=l[2]; 
+ int s_work=l[2];
  export(s_work);
  setring r;
- 
+
  int i,j;
  matrix h, g, word, y, rec;
  int dist, tim, tim2, tim3, timdist, timdec, timdist2, timdec2, timdec3;
  ideal sys, sys2, sys3;
- list tmp; 
-
- option(redSB); 
- matrix z[1][n]; 
- 
+ list tmp;
+
+ option(redSB);
+ matrix z[1][n];
+
  for (i=1; i<=ncodes; i++)
  {
-     h=randomCheck(redun,n,e);            
+     h=randomCheck(redun,n,e);
      g=dual_code(h);
-     tim2=rtimer;       
+     tim2=rtimer;
      tim3=rtimer;
 
-     //---------------- generate the template system -----------------------  
-     sys=sysFL(h,z,t,e,s_work);     
+     //---------------- generate the template system -----------------------
+     sys=sysFL(h,z,t,e,s_work);
      timdec3=timdec3+rtimer-tim3;
-   
+
      //------ modifying the template according to the received word ---------
      for (j=1; j<=ntrials; j++)
@@ -2041 +2041 @@
           y=encode(transpose(word),g);
           rec=errorRand(y,t,e);
-          sys2=LF_add_synd(rec,h,sys);   
+          sys2=LF_add_synd(rec,h,sys);
           tim=rtimer;
           sys3=std(sys2);
           timdec=timdec+rtimer-tim;
-     }            
+     }
      timdec2=timdec2+rtimer-tim2;
- } 
- 
+ }
+
  printf("Time for decoding: %p", timdec2);
  printf("Time for GB in decoding: %p", timdec);
- printf("Time for generating Fitzgerald-Lax system during decoding: %p", timdec3); 
- 
+ printf("Time for generating Fitzgerald-Lax system during decoding: %p", timdec3);
+
  option(set,vopt);
-} 
+}
 example
 {
      "EXAMPLE:";  echo = 2;
-     
-     // correcting one error for one random binary code of length 25, 
+
+     // correcting one error for one random binary code of length 25,
      //redundancy 14; 300 words are processed
      decodeRandomFL(25,14,2,1,1,1,300,"");
@@ -2084 +2084 @@
 
 "EXAMPLE:";  echo = 2;
-int q=128; int n=120; int redun=n-30; 
+int q=128; int n=120; int redun=n-30;
 ring r=(q,a),x,dp;
 decodeRandom(n,redun,1,1,6);
 
-int q=128; int n=120; int redun=n-20; 
+int q=128; int n=120; int redun=n-20;
 ring r=(q,a),x,dp;
 decodeRandom(n,redun,1,1,9);
@@ -2106 +2106 @@
 
 "EXAMPLE:";  echo = 2;
-int q=128; int n=120; int redun=n-40; 
+int q=128; int n=120; int redun=n-40;
 ring r=(q,a),x,dp;
 decodeRandom(n,redun,1,1,6);
@@ -2119 +2119 @@
 decodeRandom(n,redun,1,1,24);
 
-int q=256; int n=150; int redun=n-10; 
+int q=256; int n=150; int redun=n-10;
 ring r=(q,a),x,dp;
 decodeRandom(n,redun,1,1,26);
@@ -2156 +2156 @@
 setring A;
 print(qe);
-ideal red_qe=stdfglm(qe); 
+ideal red_qe=stdfglm(qe);
 
 */

Singular/LIB/discretize.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: discretize.lib,v 1.4 2009-01-07 16:11:35 Singular Exp $";
+version="$Id: discretize.lib,v 1.5 2009-01-14 16:07:04 Singular Exp $";
 category="Applications";
 info="
@@ -108 +108 @@
 RETURN:  string
 PURPOSE: replaces in 's' all the substrings 'what' with substring 'with'
-NOTE: 
+NOTE:
 EXAMPLE: example replace; shows examples
 "{
@@ -419 +419 @@
       if ( (sout[i]=="+") || (sout[i]=="-") )
       {
-        NisPoly = 1;
+        NisPoly = 1;
       }
     }
@@ -709 +709 @@
  " ideal I = decoef(p,dt);";
  " difpoly2tex(I,L);";
- difpoly2tex(I,L); // the nodal form of the scheme in TeX 
+ difpoly2tex(I,L); // the nodal form of the scheme in TeX
  "* Preparations for the semi-factorized form: ";
  poly pi1 = subst(I[2],B,0);

Singular/LIB/dmod.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: dmod.lib,v 1.33 2008-12-23 21:39:31 levandov Exp $";
+version="$Id: dmod.lib,v 1.34 2009-01-14 16:07:04 Singular Exp $";
 category="Noncommutative";
 info="
@@ -1285 +1285 @@
   {
     bs[i-1] = P[1][i]; bs[i-1] = subst(bs[i-1],s,-s-1);
-    m[i-1]  = P[2][i]; 
+    m[i-1]  = P[2][i];
   }
   int sP = minIntRoot(bs,1);
@@ -1465 +1465 @@
   dbprint(ppl,"// -2-1- the ring @R3 i.e. K[s] is ready");
   ideal K3 = imap(@R2,K2);
-  poly p = K3[1]; 
+  poly p = K3[1];
   p = s*p; // mult with the lost (s+1) factor
   dbprint(ppl,"// -2-2- factorization");
@@ -1480 +1480 @@
   {
     bs[i-1] = P[1][i]; bs[i-1] = subst(bs[i-1],s,-s-1);
-    m[i-1]  = P[2][i]; 
+    m[i-1]  = P[2][i];
   }
   int sP = minIntRoot(bs,1);
@@ -1923 +1923 @@
       if ( leadmonom(K[i,2]) == 1)
       {
-        t = K[i,1];
-        n = leadcoef(K[i,2]);
-        t = t/n;
-        //        J = J, K[i][2];
-        break;
+        t = K[i,1];
+        n = leadcoef(K[i,2]);
+        t = t/n;
+        //        J = J, K[i][2];
+        break;
       }
     }
@@ -3561 +3561 @@
   kill s;
   kill NName;
-  tmp[1]      = "C"; 
+  tmp[1]      = "C";
   Lord[2]     = tmp;  tmp = 0;
   L[3]        = Lord;

Singular/LIB/dmodapp.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: dmodapp.lib,v 1.15 2009-01-12 19:31:23 Singular Exp $";
+version="$Id: dmodapp.lib,v 1.16 2009-01-14 16:07:04 Singular Exp $";
 category="Noncommutative";
 info="
@@ -9 +9 @@
 GUIDE: Let R = K[x1,..xN] and D be the Weyl algebra in variables x1,..xN,d1,..dN.
 In this library there are the following procedures for algebraic D-modules:
-@* - localization of a holonomic module D/I with respect to a mult. closed set 
+@* - localization of a holonomic module D/I with respect to a mult. closed set
 of all powers of a given polynomial F from R. Our aim is to compute an ideal L
-in D, such that D/L is a presentation of a localized module. Such L always exists, since 
-such localizations are known to be holonomic and thus cyclic modules. 
+in D, such that D/L is a presentation of a localized module. Such L always exists, since
+such localizations are known to be holonomic and thus cyclic modules.
 The procedures for the localization are DLoc, SDLoc and DLoc0.
 
@@ -423 +423 @@
   {
     return(I);
-  }  
+  }
   int j,i,s,m;
   list l;
@@ -442 +442 @@
       else
       {
-        if (s > m)
-        {
-          m = s;
-          g = l[i][2];
-        }
+        if (s > m)
+        {
+          m = s;
+          g = l[i][2];
+        }
       }
     }
@@ -587 +587 @@
 
 
-proc appelF1() 
+proc appelF1()
 "USAGE:  appelF1();
 RETURN:  ring
@@ -613 +613 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,x,dp;
-  def A = appelF1(); 
+  def A = appelF1();
   setring A;
   IAppel1;
@@ -643 +643 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,x,dp;
-  def A = appelF2(); 
+  def A = appelF2();
   setring A;
   IAppel2;
 }
 
-proc appelF4() 
+proc appelF4()
 "USAGE:  appelF4();
 RETURN:  ring
@@ -673 +673 @@
   "EXAMPLE:"; echo = 2;
   ring r = 0,x,dp;
-  def A = appelF4(); 
+  def A = appelF4();
   setring A;
   IAppel4;
@@ -716 +716 @@
 PURPOSE: check whether the ideal I is F-saturated
 NOTE:    1 is returned if I is F-saturated, otherwise 0 is returned.
-@*   we check indeed that Ker(D --F--> D/I) is (0) 
+@*   we check indeed that Ker(D --F--> D/I) is (0)
 EXAMPLE: example isFsat; shows examples
 "
@@ -1332 +1332 @@
   LD;
   // Now, compare with the output of Macaulay2:
-  ideal tst = 3*x*Dx + 2*y*Dy + 1, y^3*Dy^2 - x^2*Dy^2 + 6*y^2*Dy + 6*y, 
-9*y^2*Dx^2*Dy - 4*y*Dy^3 + 27*y*Dx^2 + 2*Dy^2, 9*y^3*Dx^2 - 4*y^2*Dy^2 + 10*y*Dy -10; 
+  ideal tst = 3*x*Dx + 2*y*Dy + 1, y^3*Dy^2 - x^2*Dy^2 + 6*y^2*Dy + 6*y,
+9*y^2*Dx^2*Dy - 4*y*Dy^3 + 27*y*Dx^2 + 2*Dy^2, 9*y^3*Dx^2 - 4*y^2*Dy^2 + 10*y*Dy -10;
  option(redSB); option(redTail);
  LD = groebner(LD);
@@ -1405 +1405 @@
 }
 
-/* DIFFERENT EXAMPLES 
+/* DIFFERENT EXAMPLES
 
 //static proc exCusp()
@@ -1504 +1504 @@
 */
 
-proc engine(ideal I, int i) 
+proc engine(ideal I, int i)
 "USAGE:  engine(I,i);  I an ideal, i an int
 RETURN:  ideal
@@ -1527 +1527 @@
   return(J);
 }
-example 
+example
 {
   "EXAMPLE:"; echo = 2;
@@ -1562 +1562 @@
     else
     {
-      if (inp1 == "ideal") 
+      if (inp1 == "ideal")
       {
-        ERROR("second argument has to be a poly if first argument is an ideal");
+        ERROR("second argument has to be a poly if first argument is an ideal");
       }
       else { vector f = #[2]; }
@@ -1579 +1579 @@
       if (k<=0)
       {
-        ERROR("third argument has to be positive");
+        ERROR("third argument has to be positive");
       }
     }

Singular/LIB/elim.lib

@@ -1 @@
-// $Id: elim.lib,v 1.25 2008-11-13 10:50:17 Singular Exp $
-///////////////////////////////////////////////////////////////////////////////
-version="$Id: elim.lib,v 1.25 2008-11-13 10:50:17 Singular Exp $";
+// $Id: elim.lib,v 1.26 2009-01-14 16:07:04 Singular Exp $
+///////////////////////////////////////////////////////////////////////////////
+version="$Id: elim.lib,v 1.26 2009-01-14 16:07:04 Singular Exp $";
 category="Commutative Algebra";
 info="
@@ -186 +186 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc elimRing ( poly vars, list #)
-"USAGE:   elimRing(vars [,w]); vars = product of variables to be eliminated 
+"USAGE:   elimRing(vars [,w]); vars = product of variables to be eliminated
          (type poly), w = intvec (specifying weights for all variables)
-RETURN:  a ring, say R, s.t. the monomial ordering of R has 2 blocks. 
+RETURN:  a ring, say R, s.t. the monomial ordering of R has 2 blocks.
          The first block corresponds to the (given) variables to be eliminated
-         and has ordering dp if these variables have weight all 1; if w is 
-         given or if not all variables in vars have weight 1 the ordering is 
-         wp(w1) where w1 is the intvec of weights of the variables to be 
-         eliminated. 
-         The second block corresponds to variables not to be eliminated. 
-@*       If the first variable not to be eliminated is global (i.e. > 1), 
-         resp. local (i.e. < 1), the second block has ordering dp, resp. ds, 
-         (or wp(w2), resp. ws(w2), where w2 is the intvec of weights of the 
+         and has ordering dp if these variables have weight all 1; if w is
+         given or if not all variables in vars have weight 1 the ordering is
+         wp(w1) where w1 is the intvec of weights of the variables to be
+         eliminated.
+         The second block corresponds to variables not to be eliminated.
+@*       If the first variable not to be eliminated is global (i.e. > 1),
+         resp. local (i.e. < 1), the second block has ordering dp, resp. ds,
+         (or wp(w2), resp. ws(w2), where w2 is the intvec of weights of the
          variables not to be eliminated).
-@*       If the basering is a quotient ring P/Q, then R a quotient ring 
+@*       If the basering is a quotient ring P/Q, then R a quotient ring
          with Q replaced by a standard basis of Q w.r.t. the new ordering
-         (parameters are not touched). 
+         (parameters are not touched).
 NOTE:    The ordering in R is an elimination ordering for the variables
          appearing in vars.
-PURPOSE: Prepare a ring for eliminating vars from an ideal/moduel by 
-         computing a standard basis in R with a fast monomial ordering. 
+PURPOSE: Prepare a ring for eliminating vars from an ideal/moduel by
+         computing a standard basis in R with a fast monomial ordering.
          This procedure is used by the procedure elim.
 EXAMPLE: example elimRing; shows an example
@@ -219 +219 @@
   {
     if ( typeof(#[1]) == "intvec" )
-    {  
+    {
        @w = #[1];              //take the given weights
     }
@@ -236 +236 @@
   {
      if( vars/var(ii)==0 )    //treat variables not to be eliminated
-     { 
+     {
         w2 = w2,@w[ii];
         v2 = v2+list(string(var(ii)));
@@ -244 +244 @@
          }
      }
-     else 
+     else
      {
         w1 = w1,@w[ii];
@@ -263 +263 @@
 
   w1 = w1[2..size(w1)];
-  w2 = w2[2..size(w2)]; 
+  w2 = w2[2..size(w2)];
 
   //--- put variables to be eliminated in front:
-  BRlist[2] = v1 + v2;  
-             
+  BRlist[2] = v1 + v2;
+
   //--- create a block ordering with two blocks and weights:
   int nblock = size(BRlist[3]);      //number of blocks
@@ -318 +318 @@
   }
 
-  def eRing = ring(quotientList(BRlist)); 
+  def eRing = ring(quotientList(BRlist));
   return (eRing);
 }
@@ -327 +327 @@
    intvec w = 1,1,3,4,5;
    elimRing(yu,w);
- 
+
    ring S =  (0,a),(x,y,z,u,v),ws(1,2,3,4,5);
    minpoly = a2+1;
    qring T = std(ideal(x+y2+v3,(x+v)^2));
-   def Q = elimRing(yv);  
+   def Q = elimRing(yv);
    setring Q; Q;
 }
@@ -337 +337 @@
 
 proc elim (id, list #)
-"USAGE:   elim(id,arg[,\"withWeights\"]);  id ideal/module, arg can be either 
-        an intvec vor a product p of variables (type poly) 
-RETURN: ideal/module obtained from id by eliminating either the variables 
-        with indices appearing in v or the variables appearing in p. 
+"USAGE:   elim(id,arg[,\"withWeights\"]);  id ideal/module, arg can be either
+        an intvec vor a product p of variables (type poly)
+RETURN: ideal/module obtained from id by eliminating either the variables
+        with indices appearing in v or the variables appearing in p.
         Works also in a qring.
 METHOD: elim uses elimRing to create a ring with block ordering with two
-        blocks where the first block contains the variables to be eliminated 
+        blocks where the first block contains the variables to be eliminated
         and then uses groebner. If the variables in the basering have weights
         these weights are used in elimRing.
-@*      If a string \"withWeigts\" as second, optional argument is given, 
-        Singular computes weights for the variables to make the input as 
+@*      If a string \"withWeigts\" as second, optional argument is given,
+        Singular computes weights for the variables to make the input as
         homogeneous as possible.
 @*      The method is different from that used by eliminate and elim1;
         in some examples elim can be significantly faster.
-NOTE:   No special monomial ordering is required, i.e. the ordering can be 
-        local or mixed. The result is a SB with respect to the ordering of 
-        the second block used by elimRing. E.g. if the first var not to be 
-        eliminated is global, resp. local, this ordering is dp, resp. ds 
-        (or wp, resp. ws, with the given weights for these variables). 
-        If printlevel > 0 the ring for which the output is a SB is shown. 
+NOTE:   No special monomial ordering is required, i.e. the ordering can be
+        local or mixed. The result is a SB with respect to the ordering of
+        the second block used by elimRing. E.g. if the first var not to be
+        eliminated is global, resp. local, this ordering is dp, resp. ds
+        (or wp, resp. ws, with the given weights for these variables).
+        If printlevel > 0 the ring for which the output is a SB is shown.
 SEE ALSO: eliminate, elim1
 EXAMPLE: example elim; shows an example
 "
-{  
+{
   if (size(#) == 0)
   {
@@ -369 +369 @@
 //-------------------------------- check input -------------------------------
   poly vars;
-  int ii; 
+  int ii;
   if (size(#) > 0)
   {
     if ( typeof(#[1]) == "poly" )
-    {  
+    {
       vars = #[1];
     }
     if ( typeof(#[1]) == "intvec")
-    {  
+    {
       vars=1;
-      for( ii=1; ii<=size(#[1]); ii++ ) 
-      {  
-        vars=vars*var(#[1][ii]); 
+      for( ii=1; ii<=size(#[1]); ii++ )
+      {
+        vars=vars*var(#[1][ii]);
       }
     }
@@ -388 +388 @@
   {
     if ( typeof(#[2]) == "string" )
-    {  
+    {
        if ( #[2] == "withWeights" )
-       { 
+       {
          intvec @w = weight(id);
        }
@@ -411 +411 @@
   id = groebner(id);
   id = nselect(id,1..size(ringlist(ER)[3][1][2]));
-  if ( pr > 0 ) 
-  { 
+  if ( pr > 0 )
+  {
      "// result is a SB in the following ring:";
      ER;
@@ -424 +424 @@
    ideal i=x-u,y-u2,w-u3,v-x+y3;
    elim(i,3..4);
-   elim(i,uv); 
+   elim(i,uv);
    int p = printlevel;
    printlevel = 2;

Singular/LIB/findifs.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: findifs.lib,v 1.3 2009-01-07 16:11:35 Singular Exp $";
+version="$Id: findifs.lib,v 1.4 2009-01-14 16:07:04 Singular Exp $";
 category="Applications";
 info="
@@ -6 +6 @@
 AUTHORS: Viktor Levandovskyy,     levandov@risc.uni-linz.ac.at
 
-THEORY: We provide the presentation of difference operators in a polynomial, 
-        semi-factorized and a nodal form. Running @code{findifs_example();} 
-        will show how we generate finite difference schemes of linear PDE's 
+THEORY: We provide the presentation of difference operators in a polynomial,
+        semi-factorized and a nodal form. Running @code{findifs_example();}
+        will show how we generate finite difference schemes of linear PDE's
         from given approximations.
 
@@ -67 +67 @@
 RETURN:  string
 PURPOSE: converts special characters to TeX in s
-NOTE: the convention is the following: 
-      'Tx' goes to 'T_x', 
+NOTE: the convention is the following:
+      'Tx' goes to 'T_x',
       'dx' to '\\tri x' (the same for dt, dy, dz),
       'theta', 'ro', 'A', 'V' are converted to greek letters.
@@ -114 +114 @@
 RETURN:  string
 PURPOSE: replaces in 's' all the substrings 'what' with substring 'with'
-NOTE: 
+NOTE:
 EXAMPLE: example replace; shows examples
 "{
@@ -425 +425 @@
       if ( (sout[i]=="+") || (sout[i]=="-") )
       {
-        NisPoly = 1;
+        NisPoly = 1;
       }
     }
@@ -722 +722 @@
  " ideal I = decoef(p,dt);";
  " difpoly2tex(I,L);";
- difpoly2tex(I,L); // the nodal form of the scheme in TeX 
+ difpoly2tex(I,L); // the nodal form of the scheme in TeX
  "* Preparations for the semi-factorized form: ";
  poly pi1 = subst(I[2],B,0);

Singular/LIB/freegb.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: freegb.lib,v 1.14 2009-01-14 15:48:37 Singular Exp $";
+version="$Id: freegb.lib,v 1.15 2009-01-14 16:07:04 Singular Exp $";
 category="Noncommutative";
 info="
@@ -10 +10 @@
 freegbasis(L, int n);   compute two-sided Groebner basis of ideal, encoded via L, up to degree n
 
-AUXILIARY PROCEDURES: 
+AUXILIARY PROCEDURES:
 
 lp2lstr(K, s);      convert letter-place ideal to a list of modules
@@ -310 +310 @@
 "USAGE:  isVar(p);  poly p
 RETURN:  int
-PURPOSE: checks whether p is a power of a single variable from the basering. 
+PURPOSE: checks whether p is a power of a single variable from the basering.
 @* Returns the exponent or 0 is p is not a power of  a single variable.
 EXAMPLE: example isVar; shows examples
@@ -913 +913 @@
 }
 
-/* EXAMPLES: 
+/* EXAMPLES:
 
 //static proc ex_shift()
@@ -1065 +1065 @@
 }
 
-// END COMMENTED EXAMPLES 
+// END COMMENTED EXAMPLES
 
 */
@@ -1531 +1531 @@
   // Adem rels modulo 2 are interesting
 
-//static 
+//static
 proc stringpoly2lplace(string s)
 {
@@ -1706 +1706 @@
 }
 
-//static 
+//static
 proc sent2lplace(string s)
 {
@@ -2102 +2102 @@
 {
   "EXAMPLE:"; echo = 2;
-  intmat A[3][3] =  
+  intmat A[3][3] =
     2, -1, 0,
     -1, 2, -3,
@@ -2345 +2345 @@
 }
 
-/* EXAMPLES AGAIN: 
+/* EXAMPLES AGAIN:
 //static proc get_ls3nilp()
 {

Singular/LIB/general.lib

@@ -3 +3 @@
 //eric, added absValue 11.04.2002
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: general.lib,v 1.58 2008-12-12 11:26:34 Singular Exp $";
+version="$Id: general.lib,v 1.59 2009-01-14 16:07:04 Singular Exp $";
 category="General purpose";
 info="
@@ -197 +197 @@
    binomial(200,100);"";                 //type bigint
    int n,k = 200,100;
-   bigint b1 = binomial(n,k);            
+   bigint b1 = binomial(n,k);
    ring r = 0,x,dp;
    poly b2 = coeffs((x+1)^n,x)[k+1,1];  //coefficient of x^k in (x+1)^n
@@ -1088 +1088 @@
           def watchdog_rneu=basering;
           setring rsave;
-          if (!defined(result))
-          {
-            def result=fetch(watchdog_rneu,result);
-          }
+          if (!defined(result))
+          {
+            def result=fetch(watchdog_rneu,result);
+          }
         }
         if(defined(watchdog_interrupt))

Singular/LIB/jacobson.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: jacobson.lib,v 1.7 2009-01-07 16:11:37 Singular Exp $";
+version="$Id: jacobson.lib,v 1.8 2009-01-14 16:07:04 Singular Exp $";
 category="System and Control Theory";
 info="
@@ -6 +6 @@
 AUTHOR: Kristina Schindelar,     Kristina.Schindelar@math.rwth-aachen.de
 
-THEORY: We work over a ring R, that is a principal ideal domain. 
+THEORY: We work over a ring R, that is a principal ideal domain.
 @*   If R is commutative, we suppose R to be a polynomial ring in one variable.
-@* If R is non-commutative, we suppose R to be in two variables, say x and d. 
+@* If R is non-commutative, we suppose R to be in two variables, say x and d.
 @* We treat then the basering as principal ideal ring with d a polynomial
-@* variable and x an invertible one. That is, we work in the Ore localization of R 
-@* with respect to the mult. closed set S = K[x] without 0. 
+@* variable and x an invertible one. That is, we work in the Ore localization of R
+@* with respect to the mult. closed set S = K[x] without 0.
 @* Note, that in computations no division by x will actually happen.
-@*   Given a rectangular matrix M over R, one can compute unimodular (that is invertible) 
-@* square matrices U and V, such that U*M*V=D is a diagonal matrix. 
+@*   Given a rectangular matrix M over R, one can compute unimodular (that is invertible)
+@* square matrices U and V, such that U*M*V=D is a diagonal matrix.
 @*   Depending on the ring, the diagonal entries of D have certain properties.
 
-REFERENCES: 
+REFERENCES:
 @* N. Jacobson, 'The theory of rings', AMS, 1943.
 @* Manuel Avelino Insua Hermo, 'Varias perspectives sobre las bases de Groebner: Forma normal de Smith, Algorithme de Berlekamp y algebras de Leibniz'. PhD thesis, Universidad de Santiago de Compostela, 2005.
@@ -35 +35 @@
 "USAGE: smith(M[, eng1, eng2]);  M matrix, eng1 and eng2 are optional integers
 RETURN: matrix or list
-ASSUME: The current ring is assumed to be the commutative polynomial ring in 
+ASSUME: The current ring is assumed to be the commutative polynomial ring in
         one variable
 PURPOSE: compute the Smith Normal Form of M with transformation matrices (optionally)
-NOTE: If the optional integer eng1 is non-zero, returns the list {U,D,V}, 
+NOTE: If the optional integer eng1 is non-zero, returns the list {U,D,V},
 where U*M*V = D and the diagonal field entries of D are not normalized.
 @*    Otherwise only the matrix D, that is the Smith Normal Form of M, is returned.
@@ -48 +48 @@
 EXAMPLE: example smith; shows examples
 "
-{ 
+{
   def R = basering;
   // check assume: R must be a polynomial ring in 1 variable
@@ -70 +70 @@
   {
   BASIS=#[2];
-  } 
+  }
   else{BASIS=0;}
- 
+
 
   int ROW=ncols(MA);
@@ -100 +100 @@
   if(eng==1)
   {
-    list rueckLI=diagonal_with_trafo(R,MA,BASIS); 
+    list rueckLI=diagonal_with_trafo(R,MA,BASIS);
     list rueckLII=divisibility(rueckLI[2]);
     matrix CON=divideByContent(rueckLII[2]);
@@ -108 +108 @@
   else
   {
-    matrix rueckm=diagonal_without_trafo(R,MA,BASIS); 
+    matrix rueckm=diagonal_without_trafo(R,MA,BASIS);
     list rueckL=divisibility(rueckm);
     matrix CON=divideByContent(rueckm);
@@ -152 +152 @@
   if(k==0){adrow++;}
   }
-   
+
     m=transpose(m);
     for(i=1;i<=adrow;i++){m=m,0;}
@@ -181 +181 @@
 
     int s,st,p,ff;
-    
+
     module LT,TSTD;
     module STD=transpose(m);
@@ -189 +189 @@
     matrix END;
     matrix ENDSTD;
-    matrix STDFIN; 
-    STDFIN=STD; 
+    matrix STDFIN;
+    STDFIN=STD;
     list COMPARE=STDFIN;
 
@@ -200 +200 @@
       {
         STD_EX=EXL,transpose(STD);
-      } 
-      else 
+      }
+      else
       {
         STD_EX=EXR,transpose(STD);
       }
-        dbprint(ppl,"Computing Groebner basis: start");
-        dbprint(ppl-1,STD);
+        dbprint(ppl,"Computing Groebner basis: start");
+        dbprint(ppl-1,STD);
       STD=engine(STD,BASIS);
-        dbprint(ppl,"Computing Groebner basis: finished");
-        dbprint(ppl-1,STD);
+        dbprint(ppl,"Computing Groebner basis: finished");
+        dbprint(ppl-1,STD);
 
       if(flag mod 2==1){s=ROW; st=COL;}else{s=COL; st=ROW;}
-        dbprint(ppl,"Computing Groebner basis for transformation matrix: start");
-        dbprint(ppl-1,STD_EX);
+        dbprint(ppl,"Computing Groebner basis for transformation matrix: start");
+        dbprint(ppl-1,STD_EX);
       STD_EX=transpose(STD_EX);
       STD_EX=engine(STD_EX,BASIS);
-        dbprint(ppl,"Computing Groebner basis for transformation matrix: finished");
-        dbprint(ppl-1,STD_EX);
+        dbprint(ppl,"Computing Groebner basis for transformation matrix: finished");
+        dbprint(ppl-1,STD_EX);
 
       //////// split STD_EX in STD and the transformation matrix
@@ -241 +241 @@
 
       ////////////////////// compute the transformation matrices
-      
+
       if (flag mod 2 ==1)
-      { 
+      {
         TrafoL=transpose(LT)*TrafoL;
       }
-      else 
-      { 
+      else
+      {
         TrafoR=TrafoR*LT;
       }
 
 
-      STDFIN=STD; 
+      STDFIN=STD;
       /////////////////////////////////// check if the D-th row is finished ///////////////////////////////////
       COMPARE=insert(COMPARE,STDFIN);
-        if(size(COMPARE)>=3)
-       {   
+             if(size(COMPARE)>=3)
+       {
         if(STD==COMPARE[3]){finish=1;}
        }
@@ -268 +268 @@
 
    if (flag mod 2!=0) { STD=transpose(STD); }
-   
-   
+
+
    //zero colums to the end
     matrix STDMM=STD;
@@ -278 +278 @@
       for(i=1; i<=ncols(STDMM); i++)
       {
-        ff=0; 
+        ff=0;
         for(j=1; j<=nrows(STDMM); j++)
         {
@@ -291 +291 @@
     int fehlposc=fehlpos;
     module SORT;
-    for(i=1; i<=fehlpos; i++) 
+    for(i=1; i<=fehlpos; i++)
     {
       SORT=gen(2);
       for (j=3;j<=ROW;j++)
-      { 
+      {
         SORT=SORT,gen(j);
       }
@@ -308 +308 @@
     fehlpos=0;
     while( size(transpose(STD))+fehlpos-ncols(STDMM) < 0)
-    { 
+    {
       for(i=1; i<=ncols(STDMM); i++)
       {
@@ -319 +319 @@
     int fehlposr=fehlpos;
 
-    for(i=1; i<=fehlpos; i++) 
+    for(i=1; i<=fehlpos; i++)
     {
       SORT=gen(2);
@@ -328 +328 @@
       TrafoL=SORT*TrafoL;
     }
-     
+
     setring R;
     map MAPinv=r,var(1);
@@ -338 +338 @@
     matrix STDM=STD;
 
-    //Test 
+    //Test
     if(TrafoLM*m*TrafoRM!=STDM){ return(0); }
-    
+
     list RUECK=TrafoRM;
     RUECK=insert(RUECK,STDM);
@@ -393 +393 @@
       for(j=i+1; j<=Sort; j++)
       {
-        GCDL=UNITL;
-        GCDR=UNITR;
-        G=gcd(STDM[i,i],STDM[j,j]);
-        ideal Z=STDM[i,i],STDM[j,j];
-        matrix T=lift(Z,G);
-        GCDL[i,i]=T[1,1];
-        GCDL[i,j]=T[2,1];
-        GCDL[j,i]=-STDM[j,j]/G;
-        GCDL[j,j]=STDM[i,i]/G;
-        GCDR[i,j]=T[2,1]*STDM[j,j]/G;
-        GCDR[j,j]=T[2,1]*STDM[j,j]/G-1;
-        GCDR[j,i]=1;
-        STDM=GCDL*STDM*GCDR;
-        TrafoLM=GCDL*TrafoLM;
-        TrafoRM=TrafoRM*GCDR;
+        GCDL=UNITL;
+        GCDR=UNITR;
+        G=gcd(STDM[i,i],STDM[j,j]);
+        ideal Z=STDM[i,i],STDM[j,j];
+        matrix T=lift(Z,G);
+        GCDL[i,i]=T[1,1];
+        GCDL[i,j]=T[2,1];
+        GCDL[j,i]=-STDM[j,j]/G;
+        GCDL[j,j]=STDM[i,i]/G;
+        GCDR[i,j]=T[2,1]*STDM[j,j]/G;
+        GCDR[j,j]=T[2,1]*STDM[j,j]/G-1;
+        GCDR[j,i]=1;
+        STDM=GCDL*STDM*GCDR;
+        TrafoLM=GCDL*TrafoLM;
+        TrafoRM=TrafoRM*GCDR;
       }
     }
@@ -418 +418 @@
 static proc diagonal_without_trafo( R, matrix MA, int B)
 {
-  int ppl = printlevel-voice+2;  
+  int ppl = printlevel-voice+2;
 
   int BASIS=B;
@@ -452 +452 @@
     int finish=0;
     matrix STDFIN;
-    STDFIN=STD; 
+    STDFIN=STD;
     list COMPARE=STDFIN;
 
@@ -463 +463 @@
       dbprint(ppl,"Computing Groebner basis: finished");
       dbprint(ppl-1,STD);
-      STDFIN=STD; 
+      STDFIN=STD;
       /////////////////////////////////// check if the D-th row is finished ///////////////////////////////////
       COMPARE=insert(COMPARE,STDFIN);
-        if(size(COMPARE)>=3)
-       {   
+             if(size(COMPARE)>=3)
+       {
         if(STD==COMPARE[3]){finish=1;}
-       }     
-        ////////////////////////////////// change to the opposite module
-
-        TSTD=transpose(STD);
-        STD=TSTD;
-        flag++;
+       }
+        ////////////////////////////////// change to the opposite module
+
+        TSTD=transpose(STD);
+        STD=TSTD;
+        flag++;
         dbprint(ppl,"Finished one while cycle");
     }
@@ -485 +485 @@
       for(i=1; i<=ncols(STDMM); i++)
       {
-        ff=0; 
+        ff=0;
         for(j=1; j<=nrows(STDMM); j++)
         {
@@ -498 +498 @@
    int fehlposc=fehlpos;
     module SORT;
-    for(i=1; i<=fehlpos; i++) 
+    for(i=1; i<=fehlpos; i++)
     {
       SORT=gen(2);
       for (j=3;j<=ROW;j++)
-      { 
+      {
         SORT=SORT,gen(j);
       }
@@ -514 +514 @@
     fehlpos=0;
     while( size(transpose(STD))+fehlpos-ncols(STDMM) < 0)
-    { 
+    {
       for(i=1; i<=ncols(STDMM); i++)
       {
@@ -525 +525 @@
     int fehlposr=fehlpos;
 
-    for(i=1; i<=fehlpos; i++) 
+    for(i=1; i<=fehlpos; i++)
     {
       SORT=gen(2);
@@ -533 +533 @@
       STD=SORT*STD;
     }
-    
+
    //add zero rows or columns
 
@@ -573 +573 @@
 proc jacobson(matrix MA, list #)
  "USAGE:  jacobson(M, eng);  M matrix, eng an optional int
-RETURN: list 
+RETURN: list
 ASSUME: Basering is a noncommutative ring in two variables.
 PURPOSE: compute a weak Jacobson Normal Form of M over a noncommutative ring
@@ -585 +585 @@
 EXAMPLE: example jacobson; shows examples
 "
-{ 
+{
   def R = basering;
   // check assume: R must be a polynomial ring in 2 variables
@@ -626 +626 @@
   def r=ring(RINGLIST);
   setring r;
-  
+
   //fix the required ordering
   map MAP=R,var(1),var(2);
@@ -638 +638 @@
   module m=TRIANGLE[2];
 
-  //back to the ring 
+  //back to the ring
   setring R;
   map MAPR=r,var(1),var(2);
@@ -646 +646 @@
   module TR=MAPR(TrafoR);
   matrix CON=divideByContent(MAA);
- 
+
 list RUECK=CON*TL, CON*MAA, TR;
 return(RUECK);
 }
 example
-{ 
+{
   "EXAMPLE:"; echo = 2;
   ring r = 0,(x,d),Dp;
@@ -663 +663 @@
   def R2 = nc_algebra(1,s);   setring R2; // the 1st shift algebra
   matrix m[2][2] = s,x,0,s; print(m); // matrix of the same for as above
-  list J = jacobson(m); 
+  list J = jacobson(m);
   print(J[2]); // a Jacobson Form D, quite different from above
   print(J[1]*m*J[3] - J[2]); // check that U*M*V = D
@@ -670 +670 @@
 static proc triangle( matrix MA, int B)
 {
- int ppl = printlevel-voice+2; 
+ int ppl = printlevel-voice+2;
 
   map inv=ncdetection();
@@ -713 +713 @@
     module STD_EX,LT,TSTD, L, Trafo;
 
-    
-    
+
+
     module STD=transpose(m);
     int finish=0;
@@ -734 +734 @@
       dbprint(ppl-1,STD);
       if(flag mod 2==1){s=ROW; st=COL;}else{s=COL; st=ROW;}
- 
+
       STD_EX=transpose(STD_EX);
       dbprint(ppl,"Computing Groebner basis for transformation matrix: start");
@@ -745 +745 @@
       COM_EX=1;
       for(i=2; i<=size(STD); i++)
-         { COM=COM[1..size(COM)],i; COM_EX=COM_EX[1..size(COM_EX)],i; } 
-      nz=size(STD_EX)-size(STD); 
-
-      //zero rows in the begining 
+         { COM=COM[1..size(COM)],i; COM_EX=COM_EX[1..size(COM_EX)],i; }
+      nz=size(STD_EX)-size(STD);
+
+      //zero rows in the begining
 
        if(size(STD)!=size(STD_EX) )
@@ -756 +756 @@
            COM_EX=0,COM_EX[1..size(COM_EX)];
          }
-       }  
-
-        
-        
-      
+       }
+
+
+
+
        for(i=nz+1; i<=size(STD_EX); i++ )
-        {if( leadcoef(STD[i-nz])!=leadcoef(STD_EX[i]) )   {STD[i-nz]=leadcoef(STD_EX[i])*STD[i-nz];}
-        }
-
-        //assign the zero rows in STD_EX
+        {if( leadcoef(STD[i-nz])!=leadcoef(STD_EX[i]) )          {STD[i-nz]=leadcoef(STD_EX[i])*STD[i-nz];}
+        }
+
+        //assign the zero rows in STD_EX
 
        for (j=2; j<=nz; j++)
        {
-        p=0;
+        p=0;
         i=1;
         while(STD_EX[j-1][i]==0){i++;};
@@ -780 +780 @@
         if (k==p){ COM_EX[j]=-1; }
        }
-     
+
       //assign the zero rows in STD
       for (j=2; j<=size(STD); j++)
        {
-        i=size(transpose(STD));
+        i=size(transpose(STD));
         while(STD[j-1][i]==0){i--;}
         p=i;
@@ -796 +796 @@
         if(COM[j]<0){COM=delete(COM,j);}
         }
-     
+
       for(i=1; i<=size(COM_EX); i++)
         {ff=0;
@@ -819 +819 @@
        LT=L[1];
 
-      
+
        for(i=2; i<=s+st; i++)
         {
@@ -838 +838 @@
 
       ////////////////////// compute the transformation matrices
-      
+
        if (flag mod 2 ==1)
-        { 
+        {
          TrafoL=transpose(LT)*TrafoL;
         }
-       else 
-        { 
+       else
+        {
          TrafoR=TrafoR*involution(LT,inv);
         }
@@ -851 +851 @@
       ///////////////////////// check whether the alg termined /////////////////
       if(size(COMPARE)>=3)
-       {   
+       {
         if(STD==COMPARE[3]){finish=1;}
-       }       
+       }
        ////////////////////////////////// change to the opposite module
        TSTD=transpose(STD);
@@ -861 +861 @@
     }
 
-if (flag mod 2 ==0){ STD = involution(STD,inv);} else { STD = transpose(STD);  } 
- 
+if (flag mod 2 ==0){ STD = involution(STD,inv);} else { STD = transpose(STD);  }
+
     list REVERSE=TrafoL,STD,TrafoR;
     return(REVERSE);
@@ -877 +877 @@
     if(leadcoef(M[i])!=0){CON=CON+leadcoef(M[i])*gen(k); k++;}
    }
-poly con=content(CON); 
+poly con=content(CON);
 matrix TL=1/con*freemodule(nrows(M));
 return(TL);
@@ -888 +888 @@
 
 //static proc Ex_One_wheeled_bicycle()
-{ 
+{
 ring RA=(0,m), D, lp;
 matrix bicycle[2][3]=(1+m)*D^2, D^2, 1, D^2, D^2-1, 0;
@@ -897 +897 @@
 
 
-//static proc Ex_RLC-circuit() 
+//static proc Ex_RLC-circuit()
 {
 ring RA=(0,m,R1,R2,L,C), D, lp;
@@ -946 +946 @@
 /*
 
-//static proc Ex_compare_output_with_maple_package_JanetOre()  
-{  
+//static proc Ex_compare_output_with_maple_package_JanetOre()
+{
     ring w = 0,(x,d),Dp;
     def W=nc_algebra(1,1);
     setring W;
-    matrix m[3][3]=[d2,d+1,0],[d+1,0,d3-x2*d],[2d+1, d3+d2, d2]; 
+    matrix m[3][3]=[d2,d+1,0],[d+1,0,d3-x2*d],[2d+1, d3+d2, d2];
     list J=jacobson(m,0);
-    print(J[1]*m*J[3]); 
+    print(J[1]*m*J[3]);
     print(J[2]);
     print(J[1]);
@@ -965 +965 @@
     def W=nc_algebra(1,s);
     setring W;
-    matrix m[3][3]=[s^2,s+1,0],[s+1,0,s^3-x^2*s],[2*s+1, s^3+s^2, s^2]; 
+    matrix m[3][3]=[s^2,s+1,0],[s+1,0,s^3-x^2*s],[2*s+1, s^3+s^2, s^2];
     list J=jacobson(m,0);
-    print(J[1]*m*J[3]); 
+    print(J[1]*m*J[3]);
     print(J[2]);
     print(J[1]);
@@ -975 +975 @@
 
 //static proc Ex_cyclic()
-{   
+{
     ring w = 0,(x,d),Dp;
     def W=nc_algebra(1,1);
@@ -981 +981 @@
     matrix m[3][3]=d,0,0,x*d+1,d,0,0,x*d,d;
     list J=jacobson(m,0);
-    print(J[1]*m*J[3]); 
+    print(J[1]*m*J[3]);
     print(J[2]);
     print(J[1]);
@@ -995 +995 @@
     matrix m[3][3]=s,0,0,x*s+1,s,0,0,x*s,s;
     list J=jacobson(m,0);
-    print(J[1]*m*J[3]); 
+    print(J[1]*m*J[3]);
     print(J[2]);
     print(J[1]);
@@ -1010 +1010 @@
     matrix m[3][3]=s,0,0,x*s+s,s,0,0,x*s,s;
     list J=jacobson(m,0);
-    print(J[1]*m*J[3]); 
+    print(J[1]*m*J[3]);
     print(J[2]);
     print(J[1]);

Singular/LIB/latex.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: latex.lib,v 1.29 2007-06-20 22:30:41 levandov Exp $";
+version="$Id: latex.lib,v 1.30 2009-01-14 16:07:05 Singular Exp $";
 category="Visualization";
 info="
@@ -677 +677 @@
  if (size(#)==1)
  { if (typeof(#[1])=="int" or typeof(#[1])=="intvec" or typeof(#[1])=="vector"
-    or typeof(#[1])=="number" or typeof(#[1])=="bigint" or defined(TeXaligned)) 
-   { DA = D; DE = D; } 
+    or typeof(#[1])=="number" or typeof(#[1])=="bigint" or defined(TeXaligned))
+   { DA = D; DE = D; }
 }
 
@@ -696 +696 @@
     else {s = s + obj + newline;}
    }
-   if (typeof(obj) == "int" or typeof(#[1])=="bigint") 
+   if (typeof(obj) == "int" or typeof(#[1])=="bigint")
    { s = s + "  " + string(obj) + "  ";}
 
@@ -1594 +1594 @@
   //if(defined(TeXreplace)){ short =0;}   // hier ueberfluessig 31.5.07
   if (short)
-  { j = 0;  // 31.5.07  
+  { j = 0;  // 31.5.07
     while(s[i]<>"!")
     { b=i; if (s[i]=="+" or s[i]=="-") {j++;}  // 31.5.07

Singular/LIB/matrix.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: matrix.lib,v 1.45 2008-12-08 14:31:46 motsak Exp $";
+version="$Id: matrix.lib,v 1.46 2009-01-14 16:07:05 Singular Exp $";
 category="Linear Algebra";
 info="
@@ -30 +30 @@
  rowred(A[,any]);       reduction of matrix A with elementary row-operations
  colred(A[,any]);       reduction of matrix A with elementary col-operations
- linear_relations(E);   find linear relations between homogeneous vectors 
+ linear_relations(E);   find linear relations between homogeneous vectors
  rm_unitrow(A);         remove unit rows and associated columns of A
  rm_unitcol(A);         remove unit columns and associated rows of A
@@ -37 +37 @@
  exteriorBasis(n,k[,s]); basis of k-th exterior power of n-dim v.space
  symmetricPower(A,k);   k-th symmetric power of a module/matrix A
- exteriorPower(A,k);    k-th exterior power of a module/matrix A 
+ exteriorPower(A,k);    k-th exterior power of a module/matrix A
           (parameters in square brackets [] are optional)
 ";
@@ -910 +910 @@
 "USAGE:   linear_relations(M);
          M: a module
-ASSUME:  All non-zero entries of M are homogeneous polynomials of the same 
-         positife degree. The base field must be an exact field (not real 
+ASSUME:  All non-zero entries of M are homogeneous polynomials of the same
+         positife degree. The base field must be an exact field (not real
          or complex).
          It is not checked whether these assumptions hold.
@@ -957 +957 @@
   pmat(REL);
   pmat(M*REL);
-}  
+}
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1078 +1078 @@
 proc symmetricBasis(int n, int k, list #)
 "USAGE:    symmetricBasis(n, k[,s]); n int, k int, s string
-RETURN:   ring, poynomial ring containing the ideal \"symBasis\", 
+RETURN:   ring, poynomial ring containing the ideal \"symBasis\",
           being a basis of the k-th symmetric power of an n-dim vector space.
-NOTE:     The output polynomial ring has characteristics 0 and n variables 
+NOTE:     The output polynomial ring has characteristics 0 and n variables
           named \"S(i)\", where the base variable name S is either given by the
           optional string argument(which must not contain brackets) or equal to
@@ -1099 +1099 @@
     if( (find(S, "(") + find(S, ")")) > 0 )
     {
-      ERROR("Wrong optional argument: must be a string without brackets"); 
+      ERROR("Wrong optional argument: must be a string without brackets");
     }
   }
@@ -1117 +1117 @@
 
 // basis of the 3-rd symmetricPower of a 4-dim vector space:
-def R = symmetricBasis(4, 3, "@e"); setring R; 
+def R = symmetricBasis(4, 3, "@e"); setring R;
 R;  // container ring:
 symBasis; // symmetric basis:
@@ -1126 +1126 @@
 proc exteriorBasis(int n, int k, list #)
 "USAGE:    exteriorBasis(n, k[,s]); n int, k int, s string
-RETURN:   qring, an exterior algebra containing the ideal \"extBasis\", 
+RETURN:   qring, an exterior algebra containing the ideal \"extBasis\",
           being a basis of the k-th exterior power of an n-dim vector space.
-NOTE:     The output polynomial ring has characteristics 0 and n variables 
+NOTE:     The output polynomial ring has characteristics 0 and n variables
           named \"S(i)\", where the base variable name S is either given by the
           optional string argument(which must not contain brackets) or equal to
@@ -1147 +1147 @@
     if( (find(S, "(") + find(S, ")")) > 0 )
     {
-      ERROR("Wrong optional argument: must be a string without brackets"); 
+      ERROR("Wrong optional argument: must be a string without brackets");
     }
   }
@@ -1165 +1165 @@
 { "EXAMPLE:"; echo = 2;
 // basis of the 3-rd symmetricPower of a 4-dim vector space:
-def r = exteriorBasis(4, 3, "@e"); setring r; 
+def r = exteriorBasis(4, 3, "@e"); setring r;
 r; // container ring:
 extBasis; // exterior basis:
@@ -1194 +1194 @@
       rings Tn is source- and Tm is image-ring with bases
           resp. Ink and Imk.
-      M = max dim of Image, N - dim. of source      
+      M = max dim of Image, N - dim. of source
 SEE ALSO: symmetricPower, exteriorPower"
 {
@@ -1206 +1206 @@
 
 //------------------------- compute matrix of single images ------------------
-  def Rm = save + Tm;  setring Rm; 
+  def Rm = save + Tm;  setring Rm;
   dbprint(p-2, "Temporary Working Ring", Rm);
 
@@ -1228 +1228 @@
 //------------------------- compute image ---------------------
   // apply S^k(A): Tn -> Rm  to Source basis vectors Ink:
-  map TMap = Tn, B; 
-
-  ideal C = NF(TMap(Ink), std(0)); 
+  map TMap = Tn, B;
+
+  ideal C = NF(TMap(Ink), std(0));
   dbprint(p-1, "Image Matrix: ", C);
 
@@ -1273 +1273 @@
 "USAGE:    symmetricPower(A, k); A module, k int
 RETURN:   module: the k-th symmetric power of A
-NOTE:     the chosen bases and most of intermediate data will be shown if 
+NOTE:     the chosen bases and most of intermediate data will be shown if
           printlevel is big enough
 SEE ALSO: exteriorPower
@@ -1303 +1303 @@
 
 //------------------------- compute and return S^k(A) in chosen bases --
-  setring save;  
+  setring save;
 
   return(mapPower(p, A, k, Tn, Tm));
@@ -1332 +1332 @@
 "USAGE:    exteriorPower(A, k); A module, k int
 RETURN:   module: the k-th exterior power of A
-NOTE:     the chosen bases and most of intermediate data will be shown if 
+NOTE:     the chosen bases and most of intermediate data will be shown if
           printlevel is big enough. Last rows will be invisible if zero.
 SEE ALSO: symmetricPower
@@ -1366 +1366 @@
 example
 { "EXAMPLE:"; echo = 2;
-  ring r = (0),(a, b, c, d, e, f), dp; 
+  ring r = (0),(a, b, c, d, e, f), dp;
   r; "base ring:";
 
-  module B = a*gen(1) + c*gen(2) + e*gen(3), 
-             b*gen(1) + d*gen(2) + f*gen(3), 
+  module B = a*gen(1) + c*gen(2) + e*gen(3),
+             b*gen(1) + d*gen(2) + f*gen(3),
                         e*gen(1) + f*gen(3);
 
   print(B);
-  print(exteriorPower(B, 2)); 
-  print(exteriorPower(B, 3)); 
+  print(exteriorPower(B, 2));
+  print(exteriorPower(B, 3));
 
   def g = SuperCommutative(); setring g; g;
@@ -1384 +1384 @@
   print(exteriorPower(A, 2));
 
-  module B = a*gen(1) + c*gen(2) + e*gen(3), 
-             b*gen(1) + d*gen(2) + f*gen(3), 
+  module B = a*gen(1) + c*gen(2) + e*gen(3),
+             b*gen(1) + d*gen(2) + f*gen(3),
                         e*gen(1) + f*gen(3);
   print(B);

Singular/LIB/nchomolog.lib

@@ -1 @@
-version="$Id: nchomolog.lib,v 1.8 2008-08-07 21:15:02 levandov Exp $";
+version="$Id: nchomolog.lib,v 1.9 2009-01-14 16:07:05 Singular Exp $";
 category="Noncommutative";
 info="
@@ -168 +168 @@
   ring A=0,(x,t,dx,dt),dp;
   def W = Weyl(); setring W;
-  matrix M[2][2] = 
+  matrix M[2][2] =
     dt,  dx,
     t*dx,x*dt;
@@ -226 +226 @@
 "{
   if (i==0)
-  { 
+  {
     return(ncHom_R(Ps)); // the rest is not needed
   }
@@ -512 +512 @@
   // assumed to be basering
   // returns the difference between M and Ext^n_D(Ext^n_D(M,D),D)
-  def save = basering; 
+  def save = basering;
   setring save;
   module Md = ncExt_R(n,M); // right module
@@ -537 +537 @@
   ring R   = 0,(x,y),dp;
   poly F   = x3-y2;
-  def A    = annfs(F); 
+  def A    = annfs(F);
   setring A;
   dmodualtest(LD,2);
@@ -544 +544 @@
 
 proc dmodoublext(module M, list #)
-"USAGE:   dmodoublext(M [,i]);  M module, i optional int 
+"USAGE:   dmodoublext(M [,i]);  M module, i optional int
 COMPUTE:  a presentation of Ext^i(Ext^i(M,D),D); for basering D
 RETURN:   left module
@@ -553 +553 @@
 {
   // assume: basering is a Weyl algebra?
-  def save = basering; 
+  def save = basering;
   setring save;
   // if a list is nonempty and contains an integer N, n = N; otherwise n = nvars/2
@@ -572 +572 @@
     n = nvars(save); n = n div 2;
   }
-  // returns Ext^i_D(Ext^i_D(M,D),D), that is 
+  // returns Ext^i_D(Ext^i_D(M,D),D), that is
   // computes the "dual" of the "dual" of a d-mod M (for n = nvars/2)
   module Md = ncExt_R(n,M); // right module
@@ -602 +602 @@
   ring R   = 0,(x,y),dp;
   poly F   = x3-y2;
-  def A    = annfs(F); 
+  def A    = annfs(F);
   setring A;
   dmodoublext(LD);

Singular/LIB/nctools.lib

@@ -1 +1 @@
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: nctools.lib,v 1.39 2008-04-23 14:06:10 motsak Exp $";
+version="$Id: nctools.lib,v 1.40 2009-01-14 16:07:05 Singular Exp $";
 category="Noncommutative";
 info="
@@ -156 +156 @@
     execute (newringstring);
     def lnewring=imap(r,lr);
-    return( nc_algebra(lnewring[1],lnewring[2]) ); 
+    return( nc_algebra(lnewring[1],lnewring[2]) );
   }
   else
@@ -491 +491 @@
   D[1,3]=2*x;
   D[2,3]=-2*y;
-  def S = nc_algebra(1,D); setring S; 
+  def S = nc_algebra(1,D); setring S;
   S; // this is U(sl_2)
   poly c = 4*x*y+z^2-2*z;
@@ -595 +595 @@
   matrix D[3][3];
   D[1,2]=x; D[1,3]=z;
-  def S = nc_algebra(C,D); setring S; 
+  def S = nc_algebra(C,D); setring S;
   S;
   ideal j=ndcond(); // the silent version
@@ -664 +664 @@
   "EXAMPLE:";echo=2;
   ring A1=0,(x(1..2),d(1..2)),dp;
-  def S=Weyl();  
+  def S=Weyl();
   setring S;  S;
   kill A1,S;
@@ -722 +722 @@
 RETURN:  qring
 PURPOSE:  create the super-commutative algebra (as a GR-algebra) 'over' a basering,
-NOTE: activate this qring with the \"setring\" command. 
+NOTE: activate this qring with the \"setring\" command.
 NOTE: if b==e then the resulting ring is commutative unles 'flag' is given and non-zero.
 THEORY: given a basering, this procedure introduces the anticommutative relations x(j)x(i)=-x(i)x(j) for all e>=j>i>=b,
@@ -732 +732 @@
 // NOTE: as a side effect the basering will be changed (if not in a commutative case) to bo the ground G-algebra (without factor).
   int fprot = (find(option(),"prot") != 0);
-  
+
   string rname=nameof(basering);
-  
+
   if ( rname == "basering") // i.e. no ring has been set yet
   {
@@ -742 +742 @@
 
   def saveRing = basering;
-  
+
   int N = nvars(saveRing);
   int b = 1;
   int e = N;
   int flag = 0;
-  
+
   ideal Q = 0;
 
@@ -756 +756 @@
       ERROR("The argument 'b' must be an integer!");
       return();
-    }    
+    }
     b = #[1];
 
@@ -763 +763 @@
       ERROR("The argument 'b' must within [1..nvars(basering)]!");
       return();
-    }    
-    
+    }
+
   }
 
@@ -781 +781 @@
       return();
     }
-    
+
     if(e < b)
     {
@@ -798 +798 @@
     Q = #[3];
   }
-  
+
   if(size(#)>3)
   {
@@ -809 +809 @@
   }
 
-  int iSavedDegBoung = degBound; 
+  int iSavedDegBoung = degBound;
 
   if( (b == e) && (flag == 0) ) // commutative ring!!!
@@ -817 +817 @@
       print("Warning: (b==e) means that the resulting ring will be commutative!");
     }
-    
+
     degBound=0;
     Q = std(Q + (var(b)^2));
     degBound = iSavedDegBoung;
-    
+
     qring @EA = Q; // and it will be internally commutative as well!!!
-        
-    return(@EA);    
+
+    return(@EA);
   }
 
 /*
-  // Singular'(H.S.) politics: no ring copies! 
+  // Singular'(H.S.) politics: no ring copies!
   // in future nc_algebra() should return a new ring!!!
   list CurrRing = ringlist(basering);
@@ -841 +841 @@
       print("Warning: (char == 2) means that the resulting ring will be commutative!");
     }
-    
+
     int j = ncols(Q) + 1;
-    
+
     for ( int i=e; i>=b; i--, j++ )
     {
       Q[j] = var(i)^2;
     }
-    
-    degBound=0;    
+
+    degBound=0;
     Q = std(Q);
     degBound = iSavedDegBoung;
-    
+
     qring @EA = Q; // and it will be internally commutative as well!!!
-    return(@EA);      
-  }
-  
+    return(@EA);
+  }
+
 
   int i, j;
-  
+
   if( (b == 1) && (e == N) ) // just an exterior algebra?
-  {  
+  {
     def S = nc_algebra(-1, 0); // define ground G-algebra!
-    setring S;  
+    setring S;
   } else
   {
     matrix @E = UpOneMatrix(N);
-  
+
     for ( i = b; i < e; i++ )
     {
@@ -880 +880 @@
 
   ideal @Q = fetch(saveRing, Q);
-  
+
   j = ncols(@Q) + 1;
 
@@ -894 +894 @@
   }
 
-  degBound=0;    
+  degBound=0;
   @Q = twostd(@Q); // must be computed within the ground G-algebra => problems with local orderings!
   degBound = iSavedDegBoung;
-  
+
   qring @EA = @Q;
 
@@ -945 +945 @@
     return("SCA rings are factors by (at least) squares!"); // no squares in the factor ideal!
   }
-  
+
   list L = ringlist(saveRing);
 
@@ -960 +960 @@
       {
         if( (fprot == 1) and (i > 1) )
-        {          
+        {
           print("Warning: the SCA representation of the current commutative factor ring may be ambiguous!");
         }
-                      
+
         return( list(i, i) ); // this is not unique in this case! there may be other squares in the factor ideal!
       }
-    }    
+    }
 
     return("The current commutative ring is not SCA! (Wrong quotient ideal)"); // no squares in the factor ideal!
@@ -991 +991 @@
         if(i < b)
         {
-          b = i;        
+          b = i;
         }
 
         if(j > e)
         {
-          e = j;        
+          e = j;
         }
       } else
@@ -1020 +1020 @@
       {
         if( (fprot == 1) and (i > 1) )
-        {          
+        {
           print("Warning: the SCA representation of the current factor ring may be ambiguous!");
         }
-                      
+
         return( list(i, i) ); // this is not unique in this case! there may be other squares in the factor ideal!
       }
@@ -1183 +1183 @@
 
   def S = nc_algebra(E,0); setring S; S;
-  
+
   if(IsSCA())
     { "Alternating variables: [", AltVarStart(), ",", AltVarEnd(), "]."; }

Singular/LIB/polymake.lib

@@ -1 @@
-version="$Id: polymake.lib,v 1.9 2008-08-29 15:16:49 keilen Exp $";
+version="$Id: polymake.lib,v 1.10 2009-01-14 16:07:05 Singular Exp $";
 category="Tropical Geometry";
 info="
@@ -7 +7 @@
 WARNING:
      Most procedures will not work unless polymake or topcom is installed and
-     if so, they will only work with the operating system LINUX! 
+     if so, they will only work with the operating system LINUX!
      For more detailed information see IMPORTANT NOTE respectively consult the
      help string of the procedures.
 
 IMPORTANT NOTE:
-     Even though this is a Singular library for computing polytopes and fans such 
-     as the Newton polytope or the Groebner fan of a polynomial, most of the hard 
-     computations are NOT done by Singular but by the program 
+     Even though this is a Singular library for computing polytopes and fans such
+     as the Newton polytope or the Groebner fan of a polynomial, most of the hard
+     computations are NOT done by Singular but by the program
 @*   -  polymake by Ewgenij Gawrilow, TU Berlin and Michael Joswig, TU Darmstadt
-@*      (see http://www.math.tu-berlin.de/polymake/),  
+@*      (see http://www.math.tu-berlin.de/polymake/),
 @*   respectively (only in the procedure triangularions) by the program
 @*   -  topcom by Joerg Rambau, Universitaet Bayreuth
 @*      (see http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM);
-@*   this library should rather be seen as an interface which allows to use a (very limited) 
-     number of options which polymake respectively topcom offers to compute with polytopes 
-     and fans and to make the results available in Singular for further computations; 
+@*   this library should rather be seen as an interface which allows to use a (very limited)
+     number of options which polymake respectively topcom offers to compute with polytopes
+     and fans and to make the results available in Singular for further computations;
      moreover, the user familiar with Singular does not have to learn the syntax of polymake
      or topcom, if the options offered here are sufficient for his purposes.
@@ -35 +35 @@
      groebnerFan(poly)                 computes the Groebner fan of a polynomial
      intmatToPolymake(intmat,string)   transforms an integer matrix into polymake format
-     polymakeToIntmat(string,string)   transforms polymake output into an integer matrix 
+     polymakeToIntmat(string,string)   transforms polymake output into an integer matrix
 
 PROCEDURES USING TOPCOM:
@@ -59 +59 @@
 
 KEYWORDS:    polytope; fan; secondary fan; secondary polytope; polymake;
-             Newton polytope; Groebner fan 
+             Newton polytope; Groebner fan
 
 ";
@@ -99 +99 @@
 RETURN:  list, L with four entries
 @*            L[1] : an integer matrix whose rows are the coordinates of vertices
-                     of the polytope 
+                     of the polytope
 @*            L[2] : the dimension of the polytope
 @*            L[3] : a list whose ith entry explains to which vertices the ith vertex
@@ -109 +109 @@
                      i.e. the smallest affine space containing the polytope
 NOTE: -  for its computations the procedure calls the program polymake by Ewgenij Gawrilow,
-         TU Berlin and Michael Joswig, TU Darmstadt; it therefore is necessary that 
+         TU Berlin and Michael Joswig, TU Darmstadt; it therefore is necessary that
          this program is installed in order to use this procedure;
          see http://www.math.tu-berlin.de/polymake/
@@ -117 +117 @@
          in polymake format; if you wish to use this for further computations with polymake,
          you have to use the procedure polymakeKeepTmpFiles in before
-@*    -  moreover, the procedure creates the file /tmp/polytope.output which it deletes 
+@*    -  moreover, the procedure creates the file /tmp/polytope.output which it deletes
          again before ending
 @*    -  it is possible to give as an optional second argument as string which then will be
@@ -191 +191 @@
       }
     }
-  }  
+  }
   newveg=newveg[1,size(newveg)-1];
   execute("list nveg="+newveg+";");
@@ -226 +226 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice points of the unit square in the plane 
+   // the lattice points of the unit square in the plane
    list points=intvec(0,0),intvec(0,1),intvec(1,0),intvec(1,1);
    // the secondary polytope of this lattice point configuration is computed
@@ -266 +266 @@
 @*    -  the procedure creates the file  /tmp/newtonPolytope.polymake which contains the polytope
          in polymake format and which can be used for further computations with polymake
-@*    -  moreover, the procedure creates the file /tmp/newtonPolytope.output which it deletes 
+@*    -  moreover, the procedure creates the file /tmp/newtonPolytope.output which it deletes
          again before ending
 @*    -  it is possible to give as an optional second argument as string which then will be
@@ -303 +303 @@
    np[2];
    // np[3] contains information how the vertices are connected to each other,
-   // e.g. the first vertex (number 0) is connected to the second, third and 
+   // e.g. the first vertex (number 0) is connected to the second, third and
    //      fourth vertex
    np[3][1];
@@ -313 +313 @@
    np[1];
    // its dimension is
-   np[2];   
-   // the Newton polytope is contained in the affine space given 
+   np[2];
+   // the Newton polytope is contained in the affine space given
    //     by the equations
    np[4]*M;
@@ -348 +348 @@
 "USAGE:  normalFan (vert,aff,graph,rays,[,#]);   vert,aff intmat,  graph list, rays int, # string
 ASSUME:  - vert is an integer matrix whose rows are the coordinate of the vertices of
-           a convex lattice polygon; 
+           a convex lattice polygon;
 @*       - aff describes the affine hull of this polytope, i.e.
-           the smallest affine space containing it, in the following sense: 
-           denote by n the number of columns of vert, then multiply aff by (1,x(1),...,x(n)) 
+           the smallest affine space containing it, in the following sense:
+           denote by n the number of columns of vert, then multiply aff by (1,x(1),...,x(n))
            and set the resulting terms to zero in order to get the equations for the affine hull;
 @*       - the ith entry of graph is an integer vector describing to which vertices
@@ -357 +357 @@
            connected to vert[k];
 @*       - the integer rays is either one (if the extreme rays should be computed) or zero (otherwise)
-RETURN:  list, the ith entry of L[1] contains information about the cone in the normal fan 
-               dual to the ith vertex of the polytope 
+RETURN:  list, the ith entry of L[1] contains information about the cone in the normal fan
+               dual to the ith vertex of the polytope
 @*             L[1][i][1] = integer matrix representing the inequalities which describe the
                             cone dual to the ith vertex
@@ -370 +370 @@
            TU Berlin and Michael Joswig, so it only works if polymake is installed;
            see http://www.math.tu-berlin.de/polymake/
-@*       - in the optional argument # it is possible to hand over other names for the 
+@*       - in the optional argument # it is possible to hand over other names for the
            variables to be used -- be carful, the format must be correct and that is
            not tested, e.g. if you want the variable names to be u00,u10,u01,u11
@@ -378 +378 @@
   list ineq; // stores the inequalities of the cones
   int i,j,k;
-  // we work over the following ring  
+  // we work over the following ring
   execute("ring ineqring=0,x(1.."+string(ncols(vertices))+"),lp;");
   string greatersign=">";
@@ -403 +403 @@
   for (i=1;i<=nrows(vertices);i++)
   {
-    // first we produce for each vertex in the polytope 
+    // first we produce for each vertex in the polytope
     // the inequalities describing the dual cone in the normal fan
     list pp;  // contain strings representing the inequalities describing the normal cone
@@ -489 +489 @@
   }
   // get the linearity space
-  return(list(ineq,linearity)); 
+  return(list(ineq,linearity));
 }
 example
@@ -516 +516 @@
 proc groebnerFan (poly f,list #)
 "USAGE:  groebnerFan(f[,#]);  f poly, # string
-RETURN:  list, the ith entry of L[1] contains information about the ith cone in the Groebner fan 
+RETURN:  list, the ith entry of L[1] contains information about the ith cone in the Groebner fan
                dual to the ith vertex in the Newton polytope of the f
-@*             L[1][i][1] = integer matrix representing the inequalities which describe the cone         
+@*             L[1][i][1] = integer matrix representing the inequalities which describe the cone
 @*             L[1][i][2] = a list which contains the inequalities represented by L[1][i][1]
                             as a list of strings
 @*             L[1][i][3] = an interger matrix whose rows are the extreme rays of the cone
 @*             L[2] = is an integer matrix whose rows span the linearity space of the fan,
-                      i.e. the linear space which is contained in each cone               
+                      i.e. the linear space which is contained in each cone
 @*             L[3] = the Newton polytope of f in the format of the procedure newtonPolytope
 @*             L[4] = integer matrix where each row represents the exponet vector of one monomial
@@ -533 +533 @@
            TU Berlin and Michael Joswig, so it only works if polymake is installed;
            see http://www.math.tu-berlin.de/polymake/
-@*       - the procedure creates the file  /tmp/newtonPolytope.polymake which contains the 
-           Newton polytope of f in polymake format and which can be used for further 
+@*       - the procedure creates the file  /tmp/newtonPolytope.polymake which contains the
+           Newton polytope of f in polymake format and which can be used for further
            computations with polymake
 @*       - it is possible to give as an optional second argument as string which then will be
@@ -605 +605 @@
 ASSUME:  - M is an integer matrix which should be transformed into polymake format;
 @*       - art is one of the following strings:
-@*         + 'rays'   : indicating that a first column of 0's should be added 
-@*         + 'points' : indicating that a first column of 1's should be added 
+@*         + 'rays'   : indicating that a first column of 0's should be added
+@*         + 'points' : indicating that a first column of 1's should be added
 RETURN:  string, the matrix is transformed in a string and a first column has been added
 EXAMPLE: example intmatToPolymake;   shows an example"
@@ -614 +614 @@
     string anf="0 ";
   }
-  else 
+  else
   {
     string anf="1 ";
@@ -654 +654 @@
                  where each row has been multiplied with the lowest common multiple of the
                  denominators of its entries so as to be an integer matrix; moreover,
-                 if art=='affine', then the first column is omitted since we only want affine 
+                 if art=='affine', then the first column is omitted since we only want affine
                  coordinates
 EXAMPLE: example polymakeToIntmat;   shows an example"
@@ -666 +666 @@
     pm=stringdelete(pm,1);
   }
-  pm=stringdelete(pm,1);  
+  pm=stringdelete(pm,1);
   // find out how many entries each vector has, namely one more than 'spaces' in a row
   int i=1;
@@ -681 +681 @@
   // if we want to have affine coordinates
   if (art=="affine")
-  {    
+  {
     s--; // then there is one column less
     // and the entry of the first column (in the first row) has to be removed
@@ -720 +720 @@
       if (pm[i]==" ")
       {
-        pm[i]=",";      
+        pm[i]=",";
       }
     }
@@ -730 +730 @@
   }
   // since the matrix could be over the rationals, we need a ring with rational coefficients
-  ring zwischering=0,x,lp;    
+  ring zwischering=0,x,lp;
   // create the matrix with the elements of pm as entries
   execute("matrix mm["+string(z)+"]["+string(s)+"]="+pm+";");
@@ -780 +780 @@
 "USAGE:  triangulations(polygon); list polygon
 ASSUME:  polygon is a list of integer vectors of the same size representing the affine
-         coordinates of the lattice points 
+         coordinates of the lattice points
 PURPOSE: the procedure considers the marked polytope given as the convex hull of
          the lattice points and with these lattice points as markings; it then
-         computes all possible triangulations of this marked polytope 
+         computes all possible triangulations of this marked polytope
 RETURN:  list, each entry corresponds to one triangulation and the ith entry is
                itself a list of integer vectors of size three, where each integer
@@ -790 +790 @@
 NOTE:  - the procedure calls for its computations the program points2triangs
          from the program topcom by Joerg Rambau, Universitaet Bayreuth; it
-         therefore is necessary that this program is installed in order to use this 
+         therefore is necessary that this program is installed in order to use this
          procedure; see
 @*       http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM
@@ -799 +799 @@
          you have to use the procedure polymakeKeepTmpFiles in before
 @*     - note that an integer i in an integer vector representing a triangle refers to
-         the ith lattice point, i.e. polygon[i]; this convention is different from 
+         the ith lattice point, i.e. polygon[i]; this convention is different from
          TOPCOM's convention, where i would refer to the i-1st lattice point
 EXAMPLE: example triangulations;   shows an example"
 {
   int i,j;
-  // prepare the input for points2triangs by writing the input polygon in the 
+  // prepare the input for points2triangs by writing the input polygon in the
   // necessary format
   string spi="[";
@@ -847 +847 @@
       }
       else
-      {        
+      {
         np2t=np2t+p2t[i];
       }
@@ -859 +859 @@
   {
     if (np2t[size(np2t)]!=";")
-    {      
+    {
       np2t=np2t+p2t[size(p2t)-1]+p2t[size(p2t)];
     }
@@ -881 +881 @@
           np2t=np2t+"))";
           i++;
-        }     
+        }
         else
         {
@@ -919 +919 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice points of the unit square in the plane 
+   // the lattice points of the unit square in the plane
    list polygon=intvec(0,0),intvec(0,1),intvec(1,0),intvec(1,1);
    // the triangulations of this lattice point configuration are computed
@@ -935 +935 @@
 PURPOSE: the procedure considers the marked polytope given as the convex hull of
          the lattice points and with these lattice points as markings; it then
-         computes the lattice points of the secondary polytope given by this 
+         computes the lattice points of the secondary polytope given by this
          marked polytope which correspond to the triangulations computed by
          the procedure triangulations
 RETURN:  list, say L, such that:
-@*             L[1] = intmat, each row gives the affine coordinates of a lattice point 
+@*             L[1] = intmat, each row gives the affine coordinates of a lattice point
                       in the secondary polytope given by the marked
                       polytope corresponding to polygon
 @*             L[2] = the list of corresponding triangulations
-NOTE:    if the triangluations are not handed over as optional argument the procedure calls 
+NOTE:    if the triangluations are not handed over as optional argument the procedure calls
          for its computation of these triangulations the program points2triangs
          from the program topcom by Joerg Rambau, Universitaet Bayreuth; it
-         therefore is necessary that this program is installed in order to use this 
+         therefore is necessary that this program is installed in order to use this
          procedure; see
 @*       http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM
@@ -995 +995 @@
     secpoly[i,1..size(polygon)]=vertex;
   }
-  return(list(secpoly,triangs));          
+  return(list(secpoly,triangs));
 }
 example
@@ -1024 +1024 @@
 PURPOSE: the procedure considers the marked polytope given as the convex hull of
          the lattice points and with these lattice points as markings; it then
-         computes the lattice points of the secondary polytope given by this 
+         computes the lattice points of the secondary polytope given by this
          marked polytope which correspond to the triangulations computed by
          the procedure triangulations
-RETURN:  list, the ith entry of L[1] contains information about the ith cone in the 
+RETURN:  list, the ith entry of L[1] contains information about the ith cone in the
                secondary fan of the polygon, i.e. the cone dual to the ith vertex of the
                secondary polytope
@@ -1039 +1039 @@
                       i.e. the linear space which is contained in each cone
 @*             L[3] = the secondary polytope in the format of the procedure polymakePolytope
-@*             L[4] = the list of triangulations corresponding to the vertices 
+@*             L[4] = the list of triangulations corresponding to the vertices
                       of the secondary polytope
 NOTE:    - the procedure calls for its computation polymake by Ewgenij Gawrilow,
            TU Berlin and Michael Joswig, so it only works if polymake is installed;
            see http://www.math.tu-berlin.de/polymake/
-@*       - in the optional argument # it is possible to hand over other names for the 
+@*       - in the optional argument # it is possible to hand over other names for the
            variables to be used -- be carful, the format must be correct and that is
            not tested, e.g. if you want the variable names to be u00,u10,u01,u11
            then you must hand over the string u11,u10,u01,u11
-@*       - if the triangluations are not handed over as optional argument the procedure calls 
+@*       - if the triangluations are not handed over as optional argument the procedure calls
            for its computation of these triangulations the program points2triangs
            from the program topcom by Joerg Rambau, Universitaet Bayreuth; it
-           therefore is necessary that this program is installed in order to use this 
+           therefore is necessary that this program is installed in order to use this
            procedure; see
 @*         http://www.uni-bayreuth.de/departments/wirtschaftsmathematik/rambau/TOPCOM
@@ -1143 +1143 @@
    // interior is a lattice point in the interior of this lattice polygon
    intvec interior=1,1;
-   // compute the general cycle length of a cycle of the corresponding cycle 
+   // compute the general cycle length of a cycle of the corresponding cycle
    // in the dual tropical curve, note that (0,1) and (2,1) do not contribute
    cycleLength(boundary,interior);
@@ -1162 +1162 @@
 @*                       L[2][i][j][1] = intvec, the coordinates of the jth lattice point on that facet
 @*                       L[2][i][j][2] = int, the position of L[2][i][j][1] in markings
-@*             L[3]    : represents the interior lattice points of the polygon 
+@*             L[3]    : represents the interior lattice points of the polygon
 @*                       L[3][i][1] = intvec, the coordinates of the ith interior point
 @*                       L[3][i][2] = int, the position of L[3][i][1] in markings
@@ -1247 +1247 @@
     }
     vert[3][i]=list(vert[3][i],j);
-  }  
+  }
   return(vert);
 }
@@ -1254 +1254 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3) 
+   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3)
    // with all integer points as markings
    list polygon=intvec(1,1),intvec(3,0),intvec(2,0),intvec(1,0),
@@ -1272 +1272 @@
 proc eta (list triang,list polygon)
 "USAGE:  eta(triang,polygon);  triang, polygon list
-ASSUME:  polygon has the format of the output of splitPolygon, i.e. it is a list with three 
+ASSUME:  polygon has the format of the output of splitPolygon, i.e. it is a list with three
          entries describing a convex lattice polygon in the following way:
 @*       polygon[1] : is a list of lists; for each i the entry polygon[1][i][1] is a lattice point which is
@@ -1289 +1289 @@
          polygon described by polygon; if an entry of triang is the vector (i,j,k) then the triangle
          is build by the vertices with indices i, j and k
-RETURN:  intvec, the integer vector eta describing that vertex of the Newton polytope discriminant 
-                 of the polygone whose dual cone in the Groebner fan contains the cone of the 
+RETURN:  intvec, the integer vector eta describing that vertex of the Newton polytope discriminant
+                 of the polygone whose dual cone in the Groebner fan contains the cone of the
                  secondary fan of the polygon corresponding to the given triangulation
-NOTE:    for a better description of eta see either Gelfand, Kapranov, Zelevinski: Discriminants, 
+NOTE:    for a better description of eta see either Gelfand, Kapranov, Zelevinski: Discriminants,
          Resultants and multidimensional Determinants. Chapter 10.
 EXAMPLE: example eta;   shows an example"
@@ -1359 +1359 @@
       if ((polygon[1][j][2]==triang[k][1]) or (polygon[1][j][2]==triang[k][2]) or (polygon[1][j][2]==triang[k][3]))
       {
-        // ... if so, add the area of the triangle to etaij 
+        // ... if so, add the area of the triangle to etaij
         etaij=etaij+triangarea[k];
-        // then check if that triangle has a facet which is contained in one of the 
+        // then check if that triangle has a facet which is contained in one of the
         // two facets of the polygon which are adjecent to the given vertex ...
         // these two facets are seiten[j] and seiten[j+1]
@@ -1393 +1393 @@
   {
     for (j=1;j<=size(polygon[2][i]);j++)
-    {      
+    {
       // initialise etaij
       etaij=0;
@@ -1404 +1404 @@
         if ((polygon[2][i][j][2]==triang[k][1]) or (polygon[2][i][j][2]==triang[k][2]) or (polygon[2][i][j][2]==triang[k][3]))
         {
-          // ... if so, add the area of the triangle to etaij 
+          // ... if so, add the area of the triangle to etaij
           etaij=etaij+triangarea[k];
-          // then check if that triangle has a facet which is contained in the 
+          // then check if that triangle has a facet which is contained in the
           // facet of the polygon which contains the lattice point in question,
           // this is the facet seiten[i+1];
@@ -1414 +1414 @@
             // ... and for each lattice point in the triangle ...
             for (m=1;m<=size(triang[k]);m++)
-            {            
+            {
               // ... if they coincide and are not the vertex itself ...
               if ((seiten[i+1][l][2]==triang[k][m]) and (seiten[i+1][l][2]!=polygon[2][i][j][2]))
@@ -1451 +1451 @@
       if ((polygon[3][j][2]==triang[k][1]) or (polygon[3][j][2]==triang[k][2]) or (polygon[3][j][2]==triang[k][3]))
       {
-        // ... if so, add the area of the triangle to etaij 
+        // ... if so, add the area of the triangle to etaij
         etaij=etaij+triangarea[k];
       }
@@ -1464 +1464 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3) 
+   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3)
    // with all integer points as markings
    list polygon=intvec(1,1),intvec(3,0),intvec(2,0),intvec(1,0),
@@ -1471 +1471 @@
    // split the polygon in its vertices, its facets and its interior points
    list sp=splitPolygon(polygon);
-   // define a triangulation by connecting the only interior point 
+   // define a triangulation by connecting the only interior point
    //        with the vertices
    list triang=intvec(1,2,5),intvec(1,5,10),intvec(1,5,10);
@@ -1477 +1477 @@
    eta(triang,sp);
 }
- 
+
 proc findOrientedBoundary (list polygon)
 "USAGE:      findOrientedBoundary(polygon); polygon list
@@ -1517 +1517 @@
     //   compute their pairwise angles and their lengths
     for (i=1;i<=size(polygon)-1;i++)
-    {      
+    {
       for (j=i+1;j<=size(polygon);j++)
       {
@@ -1541 +1541 @@
     polygon=sortlistbyintvec(polygon,abstand);
     return(list(polygon,endpoints));
-  }  
+  }
   ///////////////////////////////////////////////////////////////
   list orderedvertices;  // stores the vertices in an ordered way
@@ -1551 +1551 @@
   intvec startvertex=polygon[1]; // keep the starting vertex to test, when the end is reached
   int endtest;                    // is set to one, when the end is reached
-  int startvertexfound;// is 1, once for some testvertex a candidate for the next vertex has been found 
+  int startvertexfound;// is 1, once for some testvertex a candidate for the next vertex has been found
   polygon=delete(polygon,1);    // delete the testvertex
   intvec v,w;
@@ -1577 +1577 @@
       // therefore find a vertex in the interior as candidate; but always testing against
       // the starting vertex, this can not happen
-      comparevertices[size(comparevertices)+1]=startvertex; 
+      comparevertices[size(comparevertices)+1]=startvertex;
       for (j=1;(j<=size(comparevertices)) and (d<=0);j++)
       {
@@ -1591 +1591 @@
     }
     if (size(naechste)>0) // then a candidate for the next vertex has been found
-    {      
+    {
       startvertexfound=1; // at least once a candidate has been found
       naechste=sortlist(naechste,3);  //we order the candidates according to their distance from testvertex;
@@ -1607 +1607 @@
       }
     }
-    else // that means either that the vertex was inside the polygon, 
+    else // that means either that the vertex was inside the polygon,
     {    // or that we have reached the last vertex on the boundary of the polytope
       if (startvertexfound==0) // the vertex was in the interior; we delete it and start all over again
-      {        
-        orderedvertices[1]=polygon[1]; 
-        minimisedorderedvertices[1]=polygon[1]; 
+      {
+        orderedvertices[1]=polygon[1];
+        minimisedorderedvertices[1]=polygon[1];
         testvertex=polygon[1];
         startvertex=polygon[1];
@@ -1673 +1673 @@
              computes all marked points in points which ly on the boundary of that polygon, ordered
              clockwise
-RETURN:      list, of integer vectors which are the coordinates of the lattice points on 
+RETURN:      list, of integer vectors which are the coordinates of the lattice points on
                    the boundary of the above mentioned polygon P, if this polygon is not the
-                   empty set (that would be the case if points[pt] is not a vertex of any  
+                   empty set (that would be the case if points[pt] is not a vertex of any
                    triangle in the triangulation); otherwise return the empty list
 EXAMPLE:     example cyclePoints;   shows an example"
@@ -1723 +1723 @@
    "EXAMPLE:";
    echo=2;
-   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3) 
+   // the lattice polygon spanned by the points (0,0), (3,0) and (0,3)
    // with all integer points as markings
    list points=intvec(1,1),intvec(3,0),intvec(2,0),intvec(1,0),
                intvec(0,0),intvec(2,1),intvec(0,1),intvec(1,2),
                intvec(0,2),intvec(0,3);
-   // define a triangulation 
+   // define a triangulation
    list triang=intvec(1,2,5),intvec(1,5,7),intvec(1,7,9),intvec(8,9,10),
                intvec(1,8,9),intvec(1,2,8);
@@ -1765 +1765 @@
 proc picksFormula (list polygon)
 "USAGE:  picksFormula(polygon);   polygon list
-ASSUME:  polygon is a list of integer vectors in the plane and consider their convex hull C 
-RETURN:  list, L of three integersthe 
+ASSUME:  polygon is a list of integer vectors in the plane and consider their convex hull C
+RETURN:  list, L of three integersthe
 @*             L[1] : the lattice area of C, i.e. twice the Euclidean area
 @*             L[2] : the number of lattice points on the boundary of C
@@ -1815 +1815 @@
 proc ellipticNF (list polygon)
 "USAGE:  ellipticNF(polygon);   polygon list
-ASSUME:  polygon is a list of integer vectors in the plane such that their convex hull C 
+ASSUME:  polygon is a list of integer vectors in the plane such that their convex hull C
          has precisely one interior lattice point; i.e. C is the Newton polygon of an
          elliptic curve
 PURPOSE: compute the normal form of the polygon with respect to the unimodular affine
-         transformations T=A*x+v; there are sixteen different normal forms 
+         transformations T=A*x+v; there are sixteen different normal forms
          (see e.g. Bjorn Poonen, Fernando Rodriguez-Villegas: Lattice Polygons and
                    the number 12.  Amer. Math. Monthly  107  (2000),  no. 3, 238--250.)
@@ -1952 +1952 @@
     M=pg[max],1,pg[max+1],1,pg[max+2],1;
     // the orientation of the polygon matters
-    A=pg[max-1]-pg[max],pg[max+1]-pg[max];    
+    A=pg[max-1]-pg[max],pg[max+1]-pg[max];
     if (det(A)==4)
     {
@@ -2001 +2001 @@
     {
       max++;
-    }    
+    }
     M=pg[max],1,pg[max+1],1,pg[max+2],1;
     N=0,1,1,1,2,1,2,1,1;
@@ -2064 +2064 @@
    // the vertices of the normal form are
    nf[1];
-   // it has been transformed by the unimodular affine transformation A*x+v 
+   // it has been transformed by the unimodular affine transformation A*x+v
    // with matrix A
    nf[2];
@@ -2079 +2079 @@
 "USAGE:  ellipticNFDB(n[,#]);   n int, # list
 ASSUME:  n is an intger between 1 and 16
-PURPOSE: this is a database storing the 16 normal forms of planar polygons with 
+PURPOSE: this is a database storing the 16 normal forms of planar polygons with
          precisely one interior point up to unimodular affine transformations
 @*       (see e.g. Bjorn Poonen, Fernando Rodriguez-Villegas: Lattice Polygons and
                    the number 12.  Amer. Math. Monthly  107  (2000),  no. 3, 238--250.)
 RETURN:  list, L such that
-@*             L[1] : list whose entries are the vertices of the nth normal form 
-@*             L[2] : list whose entries are all the lattice points of the nth normal form 
+@*             L[1] : list whose entries are the vertices of the nth normal form
+@*             L[2] : list whose entries are all the lattice points of the nth normal form
 @*             L[3] : only present if the optional parameter # is present, and then
-                      it is a polynomial in the variables (x,y) whose Newton polygon 
+                      it is a polynomial in the variables (x,y) whose Newton polygon
                       is the nth normal form
 NOTE:    the optional parameter is only allowed if the basering has the variables x and y
@@ -2139 +2139 @@
 proc polymakeKeepTmpFiles (int i)
 "USAGE:  polymakeKeepTmpFiles(int i);   i int
-PURPOSE: some procedures create files in the directory /tmp which are used for 
+PURPOSE: some procedures create files in the directory /tmp which are used for
          computations with polymake respectively topcom; these will be removed
          when the corresponding procedure is left; however, it might be desireable
@@ -2184 +2184 @@
 static proc scalarproduct (intvec w,intvec v)
 "USAGE:      scalarproduct(w,v); w,v intvec
-ASSUME:      w and v are integer vectors of the same length 
+ASSUME:      w and v are integer vectors of the same length
 RETURN:      int, the scalarproduct of v and w
 NOTE:        the procedure is called by findOrientedBoundary"
@@ -2231 +2231 @@
   {
     int m=nrows(M);
-    
+
   }
   else
@@ -2289 +2289 @@
   {
     return("");
-    
+
   }
   if (i==1)
@@ -2399 +2399 @@
         k++;
       }
-      else 
+      else
       {
         stop=1;
@@ -2442 +2442 @@
         k++;
       }
-      else 
+      else
       {
         stop=1;
@@ -2491 +2491 @@
 static proc polygonToCoordinates (list points)
 "USAGE:      polygonToCoordinates(points);   points list
-ASSUME:      points is a list of integer vectors each of size two describing the 
+ASSUME:      points is a list of integer vectors each of size two describing the
              marked points of a convex lattice polygon like the output of polygonDB
-RETURN:      list, the first entry is a string representing the coordinates corresponding 
+RETURN:      list, the first entry is a string representing the coordinates corresponding
                    to the latticpoints seperated by commata
                    the second entry is a list where the ith entry is a string representing
@@ -2528 +2528 @@
   }
   size(etavectors);
-  
+
   for (i=size(etavectors);i>=2;i--)
   {
@@ -2563 +2563 @@
     }
     return(list(etavectors,string(ad)));
-    
-    
-  }
-  
+
+
+  }
+
   return(etavectors);
 }
@@ -2599 +2599 @@
 }
 
-*/ 
+*/

Singular/LIB/powers.lib

@@ -1 +1 @@
 // version string automatically expanded by CVS
-version="$Id: powers.lib,v 1.3 2008-06-26 13:17:43 motsak Exp $";
+version="$Id: powers.lib,v 1.4 2009-01-14 16:07:05 Singular Exp $";
 category="Linear algebra";
 
@@ -15 +15 @@
     exteriorBasis(int, int)        return a basis of a k-th exterior power
     exteriorPower(module,int)      return k-th exterior power of a matrix
-       
+
 ";
-    
+
 
 LIB "general.lib"; // for sort
@@ -81 +81 @@
     p = char(basering);
   }
-    
+
   ring S = (p), (e(1..n)), dp;
   def T = SuperCommutative(); setring T;

Singular/LIB/ratgb.lib

@@ -1 +1 @@
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: ratgb.lib,v 1.12 2008-02-26 23:36:12 levandov Exp $";
+version="$Id: ratgb.lib,v 1.13 2009-01-14 16:07:05 Singular Exp $";
 category="Noncommutative";
 info="
@@ -14 +14 @@
 LIB "poly.lib";
 
-//static 
+//static