Changeset 917fb5 – Singular

Singular/LIB/all.lib

-                      rce7ba6
+                      r917fb5
 // $Id: all.lib,v 1.17 1999-06-22 10:42:23 obachman Exp $
+// $Id: all.lib,v 1.18 1999-07-06 15:32:45 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: all.lib,v 1.17 1999-06-22 10:42:23 obachman Exp $";
+version="$Id: all.lib,v 1.18 1999-07-06 15:32:45 Singular Exp $";
 info="
 LIBRARY:  all.lib   Load all libraries
 …
   homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
   inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
   invar.lib     PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
+  invar.lib     PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
   latex.lib     PROCEDURES FOR TYPESET OF SINGULAROBJECTS IN LATEX2E
   matrix.lib    PROCEDURES FOR MATRIX OPERATIONS

Singular/LIB/deform.lib

-                      rce7ba6
+                      r917fb5
 // $Id: deform.lib,v 1.15 1999-07-06 11:32:46 obachman Exp $
+// $Id: deform.lib,v 1.16 1999-07-06 15:32:46 Singular Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
 //(bm, last modified 4/98)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: deform.lib,v 1.15 1999-07-06 11:32:46 obachman Exp $";
+version="$Id: deform.lib,v 1.16 1999-07-06 15:32:46 Singular Exp $";
 info="
 LIBRARY:  deform.lib       PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
 …
   br = my+"Sx";
   if (defined(`br`)) { kill `br`}
+  if(system("with","Namespaces")) {
+  if(system("with","Namespaces"))
+  {
     br = my+"Qx";
     if (defined(Top::`br`)) { kill Top::`br`;}

Singular/LIB/general.lib

-                      rce7ba6
+                      r917fb5
 // $Id: general.lib,v 1.14 1999-07-06 11:32:54 obachman Exp $
+// $Id: general.lib,v 1.15 1999-07-06 15:32:47 Singular Exp $
 //system("random",787422842);
 //GMG, last modified 18.6.99
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: general.lib,v 1.14 1999-07-06 11:32:54 obachman Exp $";
+version="$Id: general.lib,v 1.15 1999-07-06 15:32:47 Singular Exp $";
 info="
 LIBRARY:  general.lib   PROCEDURES OF GENERAL TYPE
 …
 EXAMPLE: example kmemory; shows an example
+"
+{
+{
    int n;
    int verb;
 …
      { verb=#[2]; }
+   }
   if ( verb != 0)
+  {

Singular/LIB/graphics.lib

-                      rce7ba6
+                      r917fb5
 // $Id: graphics.lib,v 1.3 1999-07-06 11:32:55 obachman Exp $
+// $Id: graphics.lib,v 1.4 1999-07-06 15:32:47 Singular Exp $
 //
 // author : Christian Gorzel email: gorzelc@math.uni-muenster.de
 //
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: graphics.lib,v 1.3 1999-07-06 11:32:55 obachman Exp $";
+version="$Id: graphics.lib,v 1.4 1999-07-06 15:32:47 Singular Exp $";
 info="
 LIBRARY: graphics.lib    PROCEDURES FOR GRAPHICS WITH MATHEMATICA
 …
  if (i>0)
  { suffix = filename[i,size(filename)-i+1];
+ { suffix = filename[i,size(filename)-i+1];
    name = ">" + filename[1,i-1]+ ".m";
+ }
  else { print("--Error: Suffix of filename incorrect"); return("");}
 // if (suffix ==".m") { cmd = "Display[\" " + filename + "\",% ]";}
  if (suffix ==".mps") { cmd = "Display[\" " + filename + "\",%] ";}
  if (suffix ==".ps") { cmd = "Display[\" ! psfix > " + filename + "\", %]";}
  if (suffix ==".eps")
                 { cmd = "Display[\" ! psfix -epsf > " + filename + "\", %]";}
+ if (suffix ==".mps") { cmd = "Display[\" " + filename + "\",%] ";}
+ if (suffix ==".ps") { cmd = "Display[\" ! psfix > " + filename + "\", %]";}
+ if (suffix ==".eps")
+                { cmd = "Display[\" ! psfix -epsf > " + filename + "\", %]";}
+ }
 …
  // active evalutation of the cell with SHIFT RETURN
+ // Hit RETURN to continue
+ pause;
+ pause("Hit RETURN to continue");
    // --------- space curves --------------
    I(1) = x3,-1/10x3+x2,x2;
 …
  // active evalutation of the cell with SHIFT RETURN
+ // Hit RETURN to continue
+ pause;
+ pause("Hit RETURN to continue");
    // --------- implicit curves ------------
    ring rr = 0,(x,y),ds;  export rr;
 …
  // active evalutation of the cell with SHIFT RETURN
+ // Hit RETURN to continue
+ pause;
+ pause("Hit RETURN to continue");
    // ----------- surfaces -------------------
    ideal J(1) = 3xy4 + 2xy2, x5y3 + x + y6,10x2;

Singular/LIB/hnoether.lib

-                      rce7ba6
+                      r917fb5
 // $Id: hnoether.lib,v 1.11 1999-07-06 11:32:56 obachman Exp $
+// $Id: hnoether.lib,v 1.12 1999-07-06 15:32:48 Singular Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
 // last change:           09.03.99
 …
 // This library is for Singular 1.2 or newer
 version="$Id: hnoether.lib,v 1.11 1999-07-06 11:32:56 obachman Exp $";
+version="$Id: hnoether.lib,v 1.12 1999-07-06 15:32:48 Singular Exp $";
 info="
 LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER DEVELOPMENT
 …
        "The given polynomial is in fact not squarefree.";
        "I'll continue with the radical.";
        pause;
+       pause("Hit RETURN to continue");
        f=test_sqr;
+      }
 …
      {"But if the polynomial contains a factor of the form g^"+string(p)+",";
       "this factor will be lost.";}
     pause;
+    pause("Hit RETURN to continue");
     f=test_sqr;
     nm = getnm(f);              // N,M haben sich veraendert
 …
   //   (the missing x in the matrix indicates that this line is not complete.
   //    It can only occur in the last line of the HNE, and normally does.)
+  hne[2]; pause;
+  hne[2];
+  pause("Hit RETURN to continue");
   param(hne);
   // returns the parametrization x(t)= -t14+O(t21), y(t)= -3t98+O(t105)
 …
  list hne_extended1=develop(f,6);
  list hne_extended2=develop(f,10);
  pause;
+ pause("Hit RETURN to continue");
                                    //   compare the different matrices ...
  print(hne[1]);
 …
   list hne=reddevelop(x14-3y2x11-y3x10-y2x9+3y4x8+y5x7+3y4x6+x5*(-y6+y5)-3y6x3-y7x2+y8);
   print(hne[1][1]); // finite HNE
+  print(extdevelop(hne[1],5)[1]); pause;
+  print(extdevelop(hne[1],5)[1]);
+  pause("Hit RETURN to continue");
   print(hne[2][1]); // HNE that can be extended
   list ehne=extdevelop(hne[2],5);
 …
   param(hne[2]);
   param(ehne);
+  param(extdevelop(ehne,7)); pause;
+  param(extdevelop(ehne,7));
+  pause("Hit RETURN to continue");
   //////////////////////////
   print(develop(x-y2-2y3-3y4)[1]);
 …
   displayInvariants(hne);
   kill HNEring,r;
   pause;
+  pause("Hit RETURN to continue");
   // a more interesting example:
   ring r = 32003,(x,y),dp;
 …
       if (testpol!=0) {
         "factorize not implemented in char (0,a)!";
+        "could not factorize:",charPoly(leitf,M,N); pause;
+        "could not factorize:",charPoly(leitf,M,N);
+        pause("Hit RETURN to continue");
+      }
  return(faktoren,(testpol==0)); // Test: faktoren==list() geht leider nicht

Singular/LIB/inout.lib

-                      rce7ba6
+                      r917fb5
 // $Id: inout.lib,v 1.8 1999-07-06 11:32:58 obachman Exp $
+// $Id: inout.lib,v 1.9 1999-07-06 15:32:49 Singular Exp $
 // system("random",787422842);
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: inout.lib,v 1.8 1999-07-06 11:32:58 obachman Exp $";
+version="$Id: inout.lib,v 1.9 1999-07-06 15:32:49 Singular Exp $";
 info="
 LIBRARY:  inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
 …
       int i;
       for( i=1; i<=size(#); i=i+1 ) { print(#[i]); }
       if( ALLprint==2 ) { pause; listvar(matrix); }
       if( ALLprint >0 ) { pause; }
+      if( ALLprint==2 ) { pause(); listvar(matrix); }
+      if( ALLprint >0 ) { pause(); }
+   }
    return();
 …
+         {
             "["+string(@ii)+"]:";
             tab(@li@+2),"//",id[@ii];
+            tab(@li@+2),"//",id[@ii];
+         }
+      }

Singular/LIB/invar.lib

-                      rce7ba6
+                      r917fb5
 // $Id: invar.lib,v 1.8 1999-07-06 11:32:59 obachman Exp $
+// $Id: invar.lib,v 1.9 1999-07-06 15:32:50 Singular Exp $
 ///////////////////////////////////////////////////////
 // invar.lib
 …
 //////////////////////////////////////////////////////
 version="$Id: invar.lib,v 1.8 1999-07-06 11:32:59 obachman Exp $";
+version="$Id: invar.lib,v 1.9 1999-07-06 15:32:50 Singular Exp $";
 info="
 LIBRARY: invar.lib PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
 …
      "                     ";
      karl;
-    // pause;
      "                     ";
+  }
 …
        "                                  ";
        karl;
-      // pause;
        "                                  ";
+    }

Singular/LIB/jordan.lib

-                      rce7ba6
+                      r917fb5
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: jordan.lib,v 1.14 1999-07-06 11:32:59 obachman Exp $";
+version="$Id: jordan.lib,v 1.15 1999-07-06 15:32:51 Singular Exp $";
 info="
 LIBRARY: jordan.lib  PROCEDURES TO COMPUTE THE JORDAN NORMAL FORM
 …
+      {
         for(j=ncols(eM0);j>=1;j--)
+        {
+        {
           if(deg(eM0[j])>1)
+          {
 …
+      {
         for(j=ncols(eM0);j>=1;j--)
+        {
+        {
           if(deg(eM0[j])>1)
+          {
 …
     print("//not enough entries in argument list");
     matrix J[1][0];
     return(J);
+    return(J);
+  }
   def eJ,bJ=jd[1..2];
 …
     print("//first entry in argument list not an ideal");
     matrix J[1][0];
     return(J);
+    return(J);
+  }
   if(typeof(bJ)!="list")
 …
     print("//second entry in argument list not a list");
     matrix J[1][0];
     return(J);
+    return(J);
+  }
   if(size(eJ)<size(bJ))

Singular/LIB/latex.lib

-                      rce7ba6
+                      r917fb5
 // $Id: latex.lib,v 1.7 1999-07-06 11:33:00 obachman Exp $
+// $Id: latex.lib,v 1.8 1999-07-06 15:32:52 Singular Exp $
 //                        1998/04/17
 // author : Christian Gorzel email: gorzelc@math.uni-muenster.de
 //
+//
 ///////////////////////////////////////////////////////////////////////////////
 …
  xdvi(s);             calls xdvi for dvi-file s
          (parameters in square brackets [] are optional)
 GLOBAL VARIABLES:
+GLOBAL VARIABLES:
   TeXwidth, TeXnofrac, TeXbrack, TeXproj, TeXaligned, TeXreplace, NoDollars
                   are used to control the typesetting
+                  are used to control the typesetting
     Call example texdemo; to become familiar with the features of latex.lib
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc closetex(string fname, list #)
+proc closetex(string fname, list #)
 "USAGE:   closetex(fname[,style]); fname,style = string
 RETURN:  nothing; writes a LaTeX2e closing line into file fname
 NOTE:    style overwrites the default setting latex2e; maybe latex,amstex,tex
          preceeding >> end ending \".tex\" may miss in fname;
+NOTE:    style overwrites the default setting latex2e; maybe latex,amstex,tex
+         preceeding >> end ending \".tex\" may miss in fname;
          overwriting an existing file is not possible
 EXAMPLE: example closetex; shows an example
+"
+{
   string default = "latex2e";
+  string default = "latex2e";
   string s;
   int i = 1;
 …
   if (size(#)) { default = #[1];}
   if (default=="latex2e" or default == "latex")
+  if (default=="latex2e" or default == "latex")
    {  s = "\\end{document}"; flag = 1;}
   if (default=="amstex") {s = "\\enddocument"; flag = 1;}
   if (default=="tex") {s = "\\bye"; flag = 1;}
   if (not(flag)) { s = "";}
   if (size(fname))
+  if (not(flag)) { s = "";}
+  if (size(fname))
+  {
    while (fname[i]==">"){i++;}
    fname = fname[i,size(fname)-i+1];
    if (size(fname)>=4)               // check if filename is ending with ".tex"
    { if(fname[size(fname)-3,4]!=".tex") {fname = fname +".tex"; }
 …
    else {fname = fname + ".tex";}
    write(fname, s);
    write(fname," - Thanks latex.lib and Singular - ");
+  }
   else {return(s);}
+   write(fname," - Thanks latex.lib and Singular - ");
+  }
+  else {return(s);}
+}
 example
 …
 "USAGE:   tex(fname[,style]); fname,style = string
 RETURN:  nothing; calls latex2e for compiling the file fname
 NOTE:    style overwrites the default setting latex2e; maybe latex,amstex,tex
          ending ".tex" may miss in fname
+NOTE:    style overwrites the default setting latex2e; maybe latex,amstex,tex
+         ending ".tex" may miss in fname
 EXAMPLE: example tex; shows an example
+"
+{
+{
   string default = "latex2e";
   int retval;
+  int retval;
   int i=1;
 …
    while (fname[i]==">"){i++;}
    fname = fname[i,size(fname)-i+1];
    if (size(fname)>=4)               // check if filename is ending with ".tex"
    { if(fname[size(fname)-3,4]!=".tex") {fname = fname +".tex"; }
 …
    else {fname = fname + ".tex";}
    "calling ",default, " for :",fname,newline;
    retval = system("sh",default + " " +  fname);
+  }
 …
   tex("exp002","tex");
   echo = 0;
+  print("the created files will be deleted after pressing <RETURN> ");
+  pause;
+  pause("the created files will be deleted after pressing <RETURN>");
   echo = 2;
   system("sh","rm -i exp00?.*");
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc opentex(string fname, list #)
+proc opentex(string fname, list #)
 "USAGE:   opentex(fname[,style]); fname,style = string
 RETURN:  nothing; writes as LaTeX2e header into a new file fname
 NOTE:    suffix .tex may miss in fname
          style overwrites the default setting latex2e; may be latex,amstex,tex
+         style overwrites the default setting latex2e; may be latex,amstex,tex
 EXAMPLE: example opentex; shows an example
+"
+{
+{
   string default = "latex2e";
   string s;
 …
   if (size(#)) { default = #[1];}
   if (default == "latex2e")          // the default  latex2e header
   { s =
+  if (default == "latex2e")          // the default  latex2e header
+  { s =
       "\\documentclass[12pt]{article}" + newline +
    //   "\\usepackage{fullpage,amsmath,amscd,amsthm,amssymb,amsxtra,latexsym,epsfig}" + newline +
       "\\usepackage{amsmath,amssymb}" + newline +
       "\\parindent=0pt" + newline +
       "\\newcommand{\\C}{{\\Bbb C}}" + newline +
       "\\newcommand{\\F}{{\\Bbb F}}" + newline +
+      "\\parindent=0pt" + newline +
+      "\\newcommand{\\C}{{\\Bbb C}}" + newline +
+      "\\newcommand{\\F}{{\\Bbb F}}" + newline +
       "\\newcommand{\\N}{{\\Bbb N}}" + newline +
    // "\\newcommand{\\P}{{\\Bbb P}}" + newline +
       "\\newcommand{\\Q}{{\\Bbb Q}}" + newline +
+      "\\newcommand{\\Q}{{\\Bbb Q}}" + newline +
       "\\newcommand{\\R}{{\\Bbb R}}" + newline +
       "\\newcommand{\\T}{{\\Bbb T}}" + newline +
 …
+  }
   if (default == "latex")
   { s =
+  { s =
       "\\documentstyle[12pt,amstex]{article}" + newline +
       "\\parindent=0pt" + newline +
       "\\newcommand{\\C}{{\\Bbb C}}" + newline +
       "\\newcommand{\\F}{{\\Bbb F}}" + newline +
+      "\\newcommand{\\C}{{\\Bbb C}}" + newline +
+      "\\newcommand{\\F}{{\\Bbb F}}" + newline +
       "\\newcommand{\\N}{{\\Bbb N}}" + newline +
    // "\\newcommand{\\P}{{\\Bbb P}}" + newline +
       "\\newcommand{\\Q}{{\\Bbb Q}}" + newline +
+      "\\newcommand{\\Q}{{\\Bbb Q}}" + newline +
       "\\newcommand{\\R}{{\\Bbb R}}" + newline +
       "\\newcommand{\\T}{{\\Bbb T}}" + newline +
 …
       "\\begin{document}";
     flag = 1;
+  }
   if (default == "amstex")
   { s =
+  }
+  if (default == "amstex")
+  { s =
      "\\documentstyle{amsppt} " + newline + newline +
      "\\document";
     flag = 1;
+  }
   if (default == "tex")
   { s =
      "";
+    flag = 1;
+  }
+  if (default == "tex")
+  { s =
+     "";
     flag = 1;
+  }
 …
   if (not(flag)) { s = "";}
   if (size(fname))
+  if (size(fname))
+  {
    while (fname[i]==">"){i++;}
 …
    write(fname,s);
+  }
   else {return(s);}
+  else {return(s);}
+}
 example
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc texdemo(list #)
+proc texdemo(list #)
 "USAGE:   texdemo();
 RETURN:  nothing; generates automatically a LaTeX2e file called: texlibdemo.tex
          explaining the  features of latex.lib and its gloabl variables
 NOTE:    this proc takes a minutes
+NOTE:    this proc takes a minutes
 EXAMPLE: example texdemo; executes the generation
+"
 …
   string fname = "texlibdemo";
   if (size(#))
   { if (typeof(#[1])=="int") {TeXdemostart = #[1];}
+  if (size(#))
+  { if (typeof(#[1])=="int") {TeXdemostart = #[1];}
+  }
   system("random",TeXdemostart);
   if (size(#) ==2)
   { if (typeof(#[2]) == "string") { fname = #[2];}
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc texfactorize(string fname, poly f, list #)
+proc texfactorize(string fname, poly f, list #)
 "USAGE:   opentex(fname,f); fname = string; f = poly
 RETURN:  string, the poly as as product of its irreducible factors
                  in TeX-typesetting if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding >> end ending \".tex\" may miss in fname
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding >> end ending \".tex\" may miss in fname
 EXAMPLE: example texfactorize; shows an example
+"
 …
   else { D = ""; }
   TW = defined(TeXwidth);
   if (TW) {Tw = TeXwidth; TeXwidth = -1;}
+  if (TW) {Tw = TeXwidth; TeXwidth = -1;}
   else {int TeXwidth = -1; export TeXwidth;}
 …
     if(size(g)>1 or (size(g)==1 and k>1))
     { t = "(" + texpoly("",l[1][i]) + ")";}
     else { t =  texpoly("",l[1][i]);}
+    else { t =  texpoly("",l[1][i]);}
     if (l[2][i]>1)
     { t = t+"^{" +string(l[2][i]) + "}";}
 …
    if (TW) {TeXwidth = Tw;}
+  }
   if(size(fname))
+  if(size(fname))
   { i=1;
     while (fname[i]==">"){i++;}
 …
   minpoly = a2 +a +3;
   poly f = (a24x5 + x3)*a2x6*(x+1)^2;
   f;
+  f;
   texfactorize("",f);
+}
 …
 RETURN:  string, the map m from @r1 to @r2 preeceded by its name if m = string
                  in TeX-typesetting if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding >> end ending \".tex\" may miss in fname
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding >> end ending \".tex\" may miss in fname
 EXAMPLE: example texmap; shows an example
+"
+{
+{
   int saveDollars= defined(NoDollars);
   int TX = defined(TeXwidth);
 …
   { int i;
     for(i=1;i<=size(TeXreplace);i++)
+    for(i=1;i<=size(TeXreplace);i++)
     { if (TeXreplace[i][1]==s) {s= TeXreplace[i][2]; break;}}
     return(s);
+  }
 // --- store all actual informations
   if(TX) { Tw = TeXwidth; TeXwidth = -1;}
 …
   t = t + texpoly("",@J[1]);
   for (i=2;i<=n; i++)
   {if(defined(TeXaligned))
+  {if(defined(TeXaligned))
    { t = t + vrg + texpoly("",@J[i]); }
    else { t = t + "\\\\" + newline + texpoly("",@J[i]);}
 …
   else {return(s);}
+}
 example
+example
 { "EXAMPLE:"; echo = 2;
   string fname = "tldemo";
 …
   texmap("",phi,r1,r2,"\\C");
   kill r1,r2,TeXreplace,TeXaligned;
+}
+}
 ///////////////////////////////////////////////////////////////////////////////
 proc texname(string fname, string s)
+proc texname(string fname, string s)
 "USAGE:   texname(fname,s);  fname,s = string
 RETURN:  the string s if fname == the empty string
          otherwise append s to file fname.tex; return nothing
 NOTE:    preceeding >> end ending \".tex\" may miss in fname
+         otherwise append s to file fname.tex; return nothing
+NOTE:    preceeding >> end ending \".tex\" may miss in fname
 EXAMPLE: example texname; shows an example
+"
 …
   if (s[i]=="[") { anf = i+1;
    while(s[i]!="]"){i++;}                    // matrices and vectors
     st = st + "_{" + s[anf,i-anf] + "}"; n = n+ 5*(i-anf); i++;
+    st = st + "_{" + s[anf,i-anf] + "}"; n = n+ 5*(i-anf); i++;
   // besser: while s[i]<> nwline : scan forward: end, return
+  }
 …
   n = n+5*(i-anf);
   anf =i;            // the next text in ( , ) as exponent
   if (op) { if (s[i]== ","){anf = anf+1;}
+  if (op) { if (s[i]== ","){anf = anf+1;}
    while(s[i] !=")"){ i++;}
    if (i<>anf){st = st + "^{" + s[anf,i-anf] + "}"; n = n +5*(i-anf);}
 …
 "USAGE:   texobj(fname,l); fname = string,l = list of Singular dataypes
 RETURN:  string, the objects in TeX-typesetting if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding ">>" end ending ".tex" may miss in fname;
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding ">>" end ending ".tex" may miss in fname;
 EXAMPLE: example texobj; shows an example
+"
 …
  string D,DA,DE = "$","\\begin{equation*}" + newline,
                      "\\end{equation*}"+ newline;
  string OB,CB = "(",")";
+ string OB,CB = "(",")";
  if (defined(TeXbrack))
  {// if (TeXbrack=="(") {OB = "("; CB = ")";}
 …
  proc absterm(poly f)
  { int k;
    for (k=1; k<=nvars(basering); k++)
    { f = subst(f,var(k),0); }
 …
  if (size(#)==1)
  { if (typeof(#[1])=="int" or typeof(#[1])=="intvec" or typeof(#[1])=="vector"
+ { if (typeof(#[1])=="int" or typeof(#[1])=="intvec" or typeof(#[1])=="vector"
    or typeof(#[1])=="number" or defined(TeXaligned)) { DA = D; DE = D; } }
 …
  for (k=1; k<=size(#); k++)
  { def obj = #[k];
    if (typeof(obj) == "string")
+   if (typeof(obj) == "string")
    { if (defined(`obj`))
      { if (typeof(`obj`)=="ideal")
+     { if (typeof(`obj`)=="ideal")
        { Iname = obj; def e = `obj`;
          kill obj; def obj = e; kill e;}
 …
+   }
    if (typeof(obj) == "int") { s = s + "  " + string(obj) + "  ";}
    if (typeof(obj) == "intvec")
+   if (typeof(obj) == "intvec")
    { s = s + "  (";
      for(j=1; j<size(obj);j++) { s = s + string(obj[j]) + sep;}
 …
+   }
    if (typeof(obj) == "number" )
+   if (typeof(obj) == "number" )
    { s = s + texpoly("",obj) + newline;
+   }
 …
+   }
    if (typeof(obj) == "vector")
+   if (typeof(obj) == "vector")
    { if (obj==0) { s = s  + "0" ;}
      else
 …
+    }
    if (typeof(obj) == "ideal")
+   if (typeof(obj) == "ideal")
    { if (size(Iname))   // verwende hier align
      { if (Tw==0) {TeXwidth = -1;}
 …
       //  { untereinander }
       // else { hintereinander }
       //
       //
       //  s = s + Iname + "=" + texpoly("",obj,",");
+      //
+      //
+      //  s = s + Iname + "=" + texpoly("",obj,",");
       //  siehe ebenso noch einmal am Ende : ! (TeXwidth <> 0 !? )
        s =  s + "\\begin{array}{rcl}" + newline;
        for (i=1;i<=size(matrix(obj));i++)
        { s =  s + Iname+ "_{" + string(i) + "} & = & "
+       { s =  s + Iname+ "_{" + string(i) + "} & = & "
                + texpoly("",obj[i]);
          if (i<size(matrix(obj))){ s = s  + "\\\\" + newline;}
 …
        Iname ="";
+     }
      else
+     {
       if (TeXwidth==0)
+     else
+     {
+      if (TeXwidth==0)
       { TeXwidth = -1;
         obj= simplify(obj,2);
 …
+        }
         else   // linear
         { s = s +
+        { s = s +
    "\\begin{array}{*{" + string(2*nvars(basering)-1) + "}{c}cr}" + newline;
            for(j=1; j<=size(obj);j++)
            { h = absterm(obj[j]);
+           for(j=1; j<=size(obj);j++)
+           { h = absterm(obj[j]);
              ineq = attrib(obj[j],"ineq");
              if(!(size(ineq))) { ineq = "=" ; }
 …
                 { if (t[1]!="-" and t[1]!= " " and nc ){sg = "+";}
                   if  (t[1]=="-") { sg = "-"; nc =1; t=t[2,size(t)-1];}
                   if (t==" ") {sg ="";}
+                  if (t==" ") {sg ="";}
                   l = l + " & " + sg + " & " + t;
+                }
 …
      if (defined(TeXaligned))
      { s = s + texpoly("",obj,",");
+     }
+     }
      else
      { s = s + newline + "\\begin{array}{c}" + newline +
                texpoly("",obj,", \\\\" + newline) +
+               texpoly("",obj,", \\\\" + newline) +
                 newline + "\\end{array}" + newline;
+     }
     s = s + "\\right" + CB;
     } // end TeXwidth <> 0
+    } // end TeXwidth <> 0
    }  // not Iname
 // s;
+  }
    if (typeof(obj) == "module")
+   if (typeof(obj) == "module")
    { M = matrix(obj);
      if (Tw ==0 or Tw > 9) { TeXwidth = -1;}
 …
      if (!(defined(TeXaligned)))
      {  // Naechste Zeile nicht notwendig !
      // s = s + "\\begin{array}{*{"+ string(ncols(M)) + "}{c}}" + newline;
       for(j=1;j<=ncols(M);j++)
+     // s = s + "\\begin{array}{*{"+ string(ncols(M)) + "}{c}}" + newline;
+      for(j=1;j<=ncols(M);j++)
       { l = "\\left" + OB + newline + "\\begin{array}{c}" + newline;
         l = l + texpoly("",ideal(M[1..nrows(M),j]), " \\\\" + newline)
 …
+     }
      else    // TeXaligned
+     {
       for(j=1;j<=ncols(M);j++)
+     {
+      for(j=1;j<=ncols(M);j++)
       { s = s + "\\left" + OB + newline +
            texpoly("",ideal(M[1..nrows(M),j]),",") + newline + "\\right" + CB;
 …
      l = "";
    //  M = transpose(obj);
      s = s + "\\left" + OB + newline +
+     s = s + "\\left" + OB + newline +
              "\\begin{array}{*{"+ string(ncols(obj)) + "}{c}" + "}"+ newline;
      for(i=1;i<=nrows(obj);i++)
 …
+     }
      l = l + newline;
      s = s + l + "\\end{array}" + newline +
+     s = s + l + "\\end{array}" + newline +
                  "\\right" + CB + newline;
     TeXwidth = Tw;
+  }
    if (typeof(obj) == "intmat")
    { nr,nc = nrows(obj),ncols(obj);
      l = "";
      l =  "\\left" + OB + newline +
+     l =  "\\left" + OB + newline +
           "\\begin{array}{*{"+ string(nc) + "}{r}}"+ newline;
      for(i=1;i<=nr;i++)
      { for(j=1;j<=nc;j++)
+     { for(j=1;j<=nc;j++)
        { l = l + string(obj[i,j]);
          if (j <nc ) { l = l + " & ";}
 …
+       }
+     }
      l = l + newline + "\\end{array}" + newline +
+     l = l + newline + "\\end{array}" + newline +
              "\\right" + CB + newline;
     s = s + l;
+    s = s + l;
+  }
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc texproc(string fname,string pname)
+proc texproc(string fname,string pname)
 "USAGE:   opentex(fname,pname); fname,pname = string
 RETURN:  string, the proc in a verbatim environment in TeX-typesetting
+RETURN:  string, the proc in a verbatim environment in TeX-typesetting
                  if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding >> end ending \".tex\" may miss in fname;
 CAUTION: texproc cannot applied on itself correctly
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding >> end ending \".tex\" may miss in fname;
+CAUTION: texproc cannot applied on itself correctly
 EXAMPLE: example texproc; shows an example
+"
 …
     { if(fname[size(fname)-3,4]!=".tex") {fname = fname +".tex"; }
+    }
     else {fname = fname + ".tex";}
+    else {fname = fname + ".tex";}
     write(fname,s);
+  }
   else{return(s);}
+  else{return(s);}
+}
 example
 …
+  }
   export exp;
   texproc("","exp");
+  texproc("","exp");
+}
 ///////////////////////////////////////////////////////////////////////////////
 proc texring(string fname, def r, list #)
+proc texring(string fname, def r, list #)
 "USAGE:   texring(fname, r[,l]); fname = string; r = ring;
          l=list of strings : controls the symbol for
          coefficient field etc. see example texdemo();
+         coefficient field etc. see example texdemo();
 RETURN:  string, the ring in TeX-typesetting if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding >> end ending \".tex\" may miss in fname;
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding >> end ending \".tex\" may miss in fname;
 EXAMPLE: example texring; shows an example
+"
+{
+{
   int i,galT,flag,mipo,nopar,Dollars,TB,TA;
   string ob,cb,cf,en,s,t,savebrack; //opening bracket, closing br, coef.field
 …
   proc tvar(intvec v)
+  {
+  {
     int i,j,ldots;
     string s;
     j = 1;
     s = texpoly("",var(1));
     if (nvars(basering)==1) { return(s);}
     if (nvars(basering)==2) { return(s + "," + texpoly("",var(2)));}
 …
         ldots =1;
+      }
       if (i== v[j])
+      if (i== v[j])
       { s = s + "," + texpoly("",var(i));
         ldots =0;
 …
   if (size(#))
   { if (typeof(#[1])=="list") { # = #[1];}
+  }
+  }
   for (i=1;i<=size(#);i++)
   { flag =0;
 …
    s = s + texpoly("",par(npars(r))) + ")";
   }                               // parameters done
   if (!(galT) and mipo and minpoly!=0)
+  if (!(galT) and mipo and minpoly!=0)
   { s = s + "/" + list(parsp(string(minpoly),0))[1];}
   s = s + ob;
 …
   if (typeof(r)=="qring")
   { ideal @I = ideal(r);
     if (defined(TeXbrack))
+    if (defined(TeXbrack))
+    {
       TB =1; savebrack = TeXbrack;
+      TB =1; savebrack = TeXbrack;
       if (TeXbrack!= "<" and TeXbrack!="(") { TeXbrack = "<";}
+    }
 …
+  }
   if (Dollars)
+  if (Dollars)
   { kill NoDollars;
     s =  "$" + s + "$";
 …
+  }
   else{return(s);}
+}
+}
 example
 { "EXAMPLE:"; echo=2;
   ring r0 = 0,(x,y,z),dp;       // short varnames polynomial ordering
   texring("",r0);
   ring r7 =0,(x(0..2)),ds;      // char =7, long varnames
+  ring r7 =0,(x(0..2)),ds;      // char =7, long varnames
   texring("",r7);
   ring r1 = 0,(x1,x2,y1,y2),wp(1,2,3,4);
 …
   texring("",rr);
   ring r;
   texring("",r);
+  texring("",r);
   ring rabc =(0,t1,t2,t3),(x,y),dp;  // parameters
   texring("",rabc);
 …
   texring("",ralg,"mipo");
   ring r49=(49,a),x,dp;              // Galoisfield
   texring("",r49);
+  texring("",r49);
   setring r0;
   ideal i = x2-z,xy2+1;
 …
   intvec v = 5,6;
   texring("",rxy,v);
   texring("",r0,"C","{");
+  texring("",r0,"C","{");
   texring("",ralg,"k");
   texring("",r7,"^G");
 …
 proc rmx(string fname)
 "USAGE:   rmx(fname); fname = string
 RETURN:  nothing; removes .log and .aux files associated to file <fname>
+RETURN:  nothing; removes .log and .aux files associated to file <fname>
          removes tex and xdvi file too, if suffix \".tex\" or \".dvi\" is given
 NOTE:    if fname ends by .dvi or .tex
          fname.dvi or fname.dvi and fname.tex will be deleted, too
+NOTE:    if fname ends by .dvi or .tex
+         fname.dvi or fname.dvi and fname.tex will be deleted, too
 EXAMPLE: example rmx; shows an example
+"
+{
   int i,suffix= 1,0;
   int retval;
+  int retval;
   if (size(fname))
 …
      if (fname[size(fname)-3,4]==".dvi") { suffix = 1; }
      if (suffix) { fname = fname[1,size(fname)-4]; }
+   }
+   }
    retval = system("sh","rm " + fname + ".aux");
    retval = system("sh","rm " + fname + ".log");
 …
   {" -- Need a filename ";
     return();
+  }
+  }
+}
 example
 …
   rmx("exp002.tex");  // removes aux, log, dvi and tex file of exp002
   echo = 0;
+  print("remaining files will be deleted after pressing <RETURN> ");
+  pause;
+  pause("remaining files will be deleted after pressing <RETURN>");
   echo = 2;
   system("sh","rm -i exp00?.*");
 …
   int i=1;
   int retval;
   string default = "xdvi";
+  string default = "xdvi";
   if (size(#)) {default = string(#[1]);}
   if (size(fname))
+  {
 …
    if (size(fname)>=4)
    { if(fname[size(fname)-3,4]==".tex") {fname = fname[1,size(fname)-4];}}
    "calling ",default, " for :",fname,newline;
+   "calling ",default, " for :",fname,newline;
    retval = system("sh",default + " " +  fname + " &");
+  }
 …
   xdvi("exp001");
   echo = 0;
+  print("the created files will be deleted after pressing <RETURN> ");
+  pause;
+  pause("the created files will be deleted after pressing <RETURN>");
   echo = 2;
   system("sh","rm -i exp00?.*");
+  system("sh","rm -i exp00?.*");
+}
 ///////////////////////////////////////////////////////////////////////////////
 …
 "USAGE:   texpoly(fname,p[,l]); fname = string; p = poly,ideal; l formation str
 RETURN:  string, the objects in TeX-typesetting if fname == empty string;
          otherwise append this to file fname.tex; return nothing
 NOTE:    preceeding ">>" end ending ".tex" may miss in fname;
+         otherwise append this to file fname.tex; return nothing
+NOTE:    preceeding ">>" end ending ".tex" may miss in fname;
 EXAMPLE: example texpoly; shows an example
+"
+{
+{
   def @r = basering;
 …
   string sign,cfmt,pt,s,bg,t,monomt,  lnbreak;
   string sep = newline;
   int i,b,b2,n, msz,linesz, count,k;
+  int i,b,b2,n, msz,linesz, count,k;
   int realT, parT, galT;
   int C = 2 + defined(TeXdisplay);
 …
   if (typeof(p)  == "ring" or typeof(p) == "qring")
   { " -- Call  texring  instead "; return();}
   if (find(notvalid,typeof(p)))
+  if (find(notvalid,typeof(p)))
   { " -- Call  texobj  instead "; return();}
   if (typeof(p)  == "map")
 …
   proc parsr(string s)                     // parse real
   { string t;
     if (s=="      Inf") { return("\\infty",3);}
+  { string t;
+    if (s=="      Inf") { return("\\infty",3);}
     if (s=="     -Inf") { return("\\-infty",6);}
     if (s[7]=="-"){t ="-";}
     if (s[8]<>"0"){t = t + s[8];}
     if (s[9]<>"0" or s[8]<>"0"){t = t + s[9];}
     if (size(t))
+    if (size(t))
     { if (t=="1") {return(s[1,5]+"*10",21);}
       if (size(t)>1) {return(s[1,5]+"*10^{"+t+"}",21+2*size(t));}
 …
   { int i,j = 1,1;
     string t;
     if (short)
     { t =s[1];
+    { t =s[1];
      if(size(s)>1) {return(t+"^{" + s[2,size(s)-1] + "}",3+2*(size(s)-1));}
      else{return(t,5);}
+     else{return(t,5);}
+    }
     else
     { return(parselong(s+"!"));}
+  }
   if (defined(TeXdisplay)) { bg = "& ";}
   if (!(defined(TeXwidth))) { int TeXwidth = -1; export TeXwidth;}
 …
 // -- Type check
  if (typeof(p)=="string")
   { if(defined(`p`))
     { pt = p + " = ";
       p = `p`;
+    { pt = p + " = ";
+      p = `p`;
+    }
+  }
   if (typeof(p)=="poly" or typeof(p)=="number") {I = p;}
   if (typeof(p)=="ideal")
+  if (typeof(p)=="ideal")
   { I = p;
     if(size(#)){ sep = #[1];}
+  }
   if (I==0)
+  if (I==0)
   { if (!(defined(NoDollars))){return("$0$");}
     else {return("0");}
+  }
 // -- Type check ende
 //---------------------
+// -- Type check ende
+//---------------------
 //------- set flags: --------------------------------------------------------
   if (size(#))
   { if (typeof(#[1])=="int") { linesz = #[1];}
 …
   { t = charstr(@r)[1,i-1];
     galT = (t <> string(char(@r)));  // the char is not the same as the ...
+  }
+  }
   i = 0;
 //------- parse the polynom
   pt = bg;
  for(k=1;k<=size(matrix(I));k++)
  { i = 0; linesz = 0; count =0;
    sign ="";
+   sign ="";
    f = I[k];
    if (f==0) { pt = pt + "0";}
 …
 // ------ tex the coefficient
     monom = lead(f);
     f = f - monom;
+    monom = lead(f);
+    f = f - monom;
     cfm = leadcoef(monom);
     if (cfm*1 != 0) { monom = monom/cfm;} // the normalized monom
     s = string(monom) + "!";              // add a terminating sign
     cfmt = "";
     if (defined(TeXreplace)) { short =0;}  // this is essential
     cfmt = string(cfm);
 …
      if (b) {b++;}
      n = size(cfmt);
      if (!(parT) and  !(realT) and !(galT))
      { if( !(b2) or defined(TeXnofrac))
+     if (!(parT) and  !(realT) and !(galT))
+     { if( !(b2) or defined(TeXnofrac))
        { monomt = cfmt; msz = 3*size(monomt);}
        else
 …
 // -- now parse the monom
     if (monom <> 1)
     { i = 1;
+    { i = 1;
       if(short)
       { while(s[i]<>"!")
         { monomt = monomt + s[i]; i++;
+        { monomt = monomt + s[i]; i++;
           b = i;
           msz = msz + 3; // it was a single lettered var
 …
+      }
+    }
 …
    if (TeXwidth > 10 and (linesz + msz > 3*TeXwidth) and linesz)
    { pt = pt + lnbreak + bg;
      linesz = msz;
+   { pt = pt + lnbreak + bg;
+     linesz = msz;
+   }
    else { linesz = linesz + msz; }  // 3 for sign
+   else { linesz = linesz + msz; }  // 3 for sign
     pt = pt + sign + monomt;
    sign = "+";
 …
+   }
   else {return(pt);}
+}
+}
 example
 { "EXAMPLE:"; echo =2;
 …
   texpoly("",f);
   texpoly("",2x2y23z);
   ring rr= real,(x,y),dp;
 …
   f;
   texpoly("",f);
+}
+}
 static proc parsp(string cfmt, int b)
 …
 // sec parameter to see if in parsp a fraction follows
 { int i,j =1,-1;
   int b,k,jj,mz;                         // begin and end
+  int b,k,jj,mz;                         // begin and end
   int saveshort=short;
             string t,c,vn,nom,denom,sg;
 …
  if(system("with","Namespaces")) { exportto(Current,splt); }
  else { export splt; }
 // string fname = "texlibdemo.tex";
  string nl = newline;
 …
  Singular in \\LaTeX \\ text.
  Most of the examples in this document are generated
  randomly by Singular itself and passed through the procs from
  \\verb|latex.lib|. Consequently,
+ randomly by Singular itself and passed through the procs from
+ \\verb|latex.lib|. Consequently,
  every document does not show merely how the \\verb|latex.lib| works
  but looks differently in large parts.");
 …
 ev);
 write(fname,"A flag means in the following that a variable with the indicated
+write(fname,"A flag means in the following that a variable with the indicated
 name has to be defined. Usually it is from type \\verb|int|.");
 …
   TeXreplace    : list, entries twoelemented list for replacing symbols
   NoDollars     : (int) flag, suppresses surrounding \\$ signs
 " +
 ev);
 …
 "> ring r0=0,(x,y,z),dp;                       texring(fname,r0);
 > poly g = -x2y +2y13z +1; g;                 texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
 …
 write(fname,
 bv +
 "> f = f/280;
+"> f = f/280;
 > texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
 …
  if(system("with","Namespaces")) { exportto(Current, r1); }
  else { export r1; }
  poly g = -2*x1 +x4 -1;
+ poly g = -2*x1 +x4 -1;
  poly f = randompoly(5,25,25); f; export f;
 write(fname,
 …
 "> ring r1=7,(x1,x2,x3,x4),Ds;                 texring(fname,r1);
 > poly g =  -2*x1 +x4 -1; g;                  texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,r1);             write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " +nl);
  ring r2=0,(x(1..5),y(1..2)),(ds(5),dp(2));
  poly g = -y(1)*x(5) +y(1)*x(2); g;
+ poly g = -y(1)*x(5) +y(1)*x(2); g;
  poly f = randompoly(5,25,25); f;
 write(fname,
 …
 "> ring r2=0,(x(1..5),y(1..2)),(ds(5),dp(2));  texring(fname,r2);
 > poly g = -y(1)*x(5) +y(1)*x(2); g;          texpoly(fname,g);"  +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
 ev
 );
+ splt(string(f)) + nl2 +
+ev
+);
   texring(fname,r2);             write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
  if(system("with","Namespaces")) { exportto(Current, r3); }
  else { export r3; }
  poly g = -x_1*x_2 + 2*x_2*x_3 + x_1*x_3; g;
+ poly g = -x_1*x_2 + 2*x_2*x_3 + x_1*x_3; g;
  poly f = randompoly(5,25,25); f;            export f;
 write(fname,
 …
 "> ring r3=0,(x_1,x_2,x_3),wp(3,2,1);          texring(fname,r3);
 > poly g = -x_1*x_2 + 2*x_2*x_3 + x_1*x_3; g; texpoly(fname,g);"  +nl +
   string(g) + nl +
+  string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,r3);             write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " A ring with real coefficients and matrix ordering.
 " +nl);
  ring rr =real,(x,y),M(1,2,3,4);
  poly g = -1.2e-10*x + y +1;
+ ring rr =real,(x,y),M(1,2,3,4);
+ poly g = -1.2e-10*x + y +1;
  poly f = randompoly(5,25,25); f;
 write(fname,
 …
 "> ring rr =real,(x,y),M(1,2,3,4);             texring(fname,rr);
 > poly g = -1.2e-10*x + y +1; g;              texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,rr);             write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " A ring in characteristic 0 and indexed parameters.
 " +nl);
  ring r0t=(0,s,t),(x,y),dp;
+ ring r0t=(0,s,t),(x,y),dp;
  if(system("with","Namespaces")) { exportto(Current, r0t); }
  else { export r0t; }
  poly g = 8*(-s+2t)/(st+t3)*x + t2*x -1; g;
+ poly g = 8*(-s+2t)/(st+t3)*x + t2*x -1; g;
  poly f = randompoly(5,25,25); f;  export f;
 write(fname,
 …
 "> ring r0t=(0,s,t),(x,y),dp;                  texring(fname,r0t);
 > poly g = 8*(-s+2t)/(st+t3)*x + t2*x -1; g;  texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,r0t);            write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " A ring in characteristic 11 and indexed parameters.
 " +nl);
  ring rt=(11003,t1,t2,t3),(X,Y),dp;
  poly g = 8*(-t1+t2)/(t1+t3)*X + t2*Y -1; g;
+ ring rt=(11003,t1,t2,t3),(X,Y),dp;
+ poly g = 8*(-t1+t2)/(t1+t3)*X + t2*Y -1; g;
  poly f = randompoly(5,25,25); f;
 write(fname,
 …
 "> ring rt=(11003,t1,t2,t3),(X,Y),dp;             texring(fname,rt);
 > poly g = 8*(-t1+t2)/(t1+t3)*X + t2*Y -1; g; texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,rt);             write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " A ring over an algebraic extension in char 7.
 " +nl);
  ring ralg = (7,a),x,dp;
  minpoly = a2-a+3;
  poly g = -(2a13 +a)*x2 + a2*x -a +1; g;
+ ring ralg = (7,a),x,dp;
+ minpoly = a2-a+3;
+ poly g = -(2a13 +a)*x2 + a2*x -a +1; g;
  poly f = randompoly(5,25,25); f;
 write(fname,
 bv +
 "> ring ralg = (7,a),x,dp;
+"> ring ralg = (7,a),x,dp;
 > minpoly = a2-a+3;                           texring(fname,ralg);
 > poly g = -(2a13 +a)*x2 + a2*x -a +1; g;    texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,ralg);           write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 // -8-------- the same ring a in 7 ralg, defined with gftables -- F_49 -------
 write(fname,
 " A ring defined with \\verb|gftables|, the same as \\verb|ralg| before, but
+" A ring defined with \\verb|gftables|, the same as \\verb|ralg| before, but
 with primitive element in the Galoisfield $\\F_{49}$." +nl);
  ring r49 =(49,a),x,dp;
  if(system("with","Namespaces")) { exportto(Current, r49); }
  else { export r49; }
  poly g = -(2a13 +a)*x2 + a2*x -a +1; g;  export g;
+ poly g = -(2a13 +a)*x2 + a2*x -a +1; g;  export g;
  poly f = randompoly(5,25,25); f;
 write(fname,
 …
 "> ring r49 =(49,a),x,dp;                     texring(fname,r49);
 > poly g = -(2a13 +a)*x2 + a2*x -a +1; g;    texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;           texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,r49);            write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " +nl);
  ring ri=(0,i),(x,y,z),ls;
  minpoly = i2 +1;
  poly g = -(i+1)*x +2i2y2 +i +x; g;
+ minpoly = i2 +1;
+ poly g = -(i+1)*x +2i2y2 +i +x; g;
  poly f = randompoly(5,25,25); f;
 write(fname,
 …
 > minpoly = i2 +1;                            texring(fname,ri);
 > poly g = -(i+1)*x +2i2y2 +i +x; g;          texpoly(fname,g);" +nl +
  string(g) + nl +
+ string(g) + nl +
 "> poly f = randompoly(5,25,25); f;            texpoly(fname,f);" +nl +
  splt(string(f)) + nl2 +
+ splt(string(f)) + nl2 +
 ev
 );
+);
   texring(fname,ri);              write(fname,lb);
   texpoly(fname,g);              write(fname,lb);
+  texpoly(fname,g);              write(fname,lb);
   texpoly(fname,f);              write(fname,lb);
 write(fname,"\\Line");
 …
 " +nl);
  setring r0;
  ideal I = x2-y,y+z2, xy;
+ ideal I = x2-y,y+z2, xy;
  I = std(I);
 string sI = string(I);
 …
 > string(I);" + nl +
 splt(sI) + nl +
 "> qring qr = I;                   texring(fname,qr);" +
+"> qring qr = I;                   texring(fname,qr);" +
 ev
 );
+);
   texring(fname,qr);              write(fname,lb);
 …
 // changing the brackets
 write(fname,"If the displayed  and defaulted brackets for the ring are not
+write(fname,"If the displayed  and defaulted brackets for the ring are not
 the rigth one,
 correct brackets my be passed over to \\verb|texring|",nl,
 …
 write(fname,
 bv +
 "> texring(fname,rr,\"{{\");" + nl +
+"> texring(fname,rr,\"{{\");" + nl +
 ev
 );
+);
 texring(fname,rr,"{{");
 …
 write(fname,
 bv +
 "> texring(fname,r2,\"[\");" + nl +
+"> texring(fname,r2,\"[\");" + nl +
 ev
 );
+);
 texring(fname,r2,"[");
 …
 write(fname,nl2);
 write(fname,nl2,"The brackets around the ideal in a quotientring can be
 changed  with the global variable \\verb|TeXbrack| (see the section
+write(fname,nl2,"The brackets around the ideal in a quotientring can be
+changed  with the global variable \\verb|TeXbrack| (see the section
 {\\tt ideal}).",nl);
 …
 bv +
 "> string TeXbrack = \"<\";
 > texring(fname,qr);
+> texring(fname,qr);
 > kill TeXbrack;" + nl +
 ev
 );
+);
 string TeXbrack = "<"; export TeXbrack;
 …
 write(fname,
 bv +
 "> texring(fname,r3,\"\\\\C\");" + nl +
+"> texring(fname,r3,\"\\\\C\");" + nl +
 ev
 );
+);
 texring(fname,r3,"\\C");
 …
 write(fname,nl2, "naechster abschnitt stimmt nicht"+lb,nl2);
 write(fname,"Predefined and accepted values here are
+write(fname,"Predefined and accepted values here are
 \\verb|\"\\\\C\"|, \\verb|\"\\\\R\"|,
  \\verb|\"\\\\C\"|, \\verb|\"k\"|, \\verb|\"K\"|, \\verb|\"R\"|.");
 write(fname,"The latter are useful to print a ring whose coefficientfield is
+write(fname,"The latter are useful to print a ring whose coefficientfield is
 defined by an algebraic extension. Now the parameters will omitted completely.
 ");
 write(fname,"The user may specify then the field in more detail."+lb,nl2);
+write(fname,"The user may specify then the field in more detail."+lb,nl2);
 write(fname,"Any correct letter in \\LaTeX \\ notation may be used to describe
 the coefficientfield. If the letter is k, K or R it  forces \\verb|texring|
+the coefficientfield. If the letter is k, K or R it  forces \\verb|texring|
 not to print the parameters. This will be useful for a ring described by an
 algebraic extension",nl2);
 …
 write(fname,
 bv +
 "> texring(fname,ralg,\"k\");" + nl +
+"> texring(fname,ralg,\"k\");" + nl +
 ev
 );
+);
 texring(fname, ralg,"k");
 // texobj(fname,"with k = ");
 …
 write(fname,
 bv +
 "> texring(fname,ralg,\"mipo\");" + nl +
+"> texring(fname,ralg,\"mipo\");" + nl +
 ev
 );
+);
 texring(fname, ralg,"mipo");
 …
 "> intvec v = 5,6;
 > texring(fname,r2,v);
 > kill v;" + nl +
+> kill v;" + nl +
 ev
 );
+);
 intvec v = 5,6;
 …
 write(fname,
 bv +
 "> texring(fname,r1,1);" + nl +
+"> texring(fname,r1,1);" + nl +
 ev
 );
+);
 texring(fname,r1,1);
 …
 write(fname,
 bv +
 "> texring(fname,r0,\"^G\");" + nl +
+"> texring(fname,r0,\"^G\");" + nl +
 ev
 );
+);
 texring(fname, r0,"^G");
 write(fname,nl2,"All these arguments may be passed over in any order as
 optional arguments, but it may give a rather nonsense result if too much of
+write(fname,nl2,"All these arguments may be passed over in any order as
+optional arguments, but it may give a rather nonsense result if too much of
 them  are used at the same time",nl);
 write(fname,
 bv +
 "> texring(fname,r3,\"\\\\R\",1,\"{{\",\"^G\");" + nl +
+"> texring(fname,r3,\"\\\\R\",1,\"{{\",\"^G\");" + nl +
 ev
 );
+);
 texring(fname, r3,"\\R",1,"<<","^G");
 …
+  }
   else { texdemopart=2; }
  "Continuing Part2 of " + fname + nl;
 …
 write(fname,"The command \\verb|texfactorize| calls internally the Singular
 command \\verb|factorize| and returns the product of the irreducible factors.
 at the present it is not possible to pass the optional arguments of
+at the present it is not possible to pass the optional arguments of
 \\verb|factorize| through \\verb|texfactorize|."+lb);
 …
 // TeXreplace
 // ---------------------------------------------
 write(fname,"The global variable \\verb|TeXreplace| must be a list
+write(fname,"The global variable \\verb|TeXreplace| must be a list
 whose entries are twoelemented lists again; wherby the first entry is the
 word which should be replaced and second is the replacing word."  +
 "This is may be applied to replace variablenames, but holds  also for texname
+"This is may be applied to replace variablenames, but holds  also for texname
 anmd texmap" + lb +
 "It is most useful to write the greece letters correctly. Notice that it
 is necesarry to write
 a double backslash \\verb|\\\\\ | at the beginning of
+a double backslash \\verb|\\\\\ | at the beginning of
 a \\TeX \\ symbol." + lb);
 …
 write(fname,"If \\verb|TeXreplace| is defined, the translation into \\TeX  code
 runs significantly slower, because every polynomial will be compiled in the
+runs significantly slower, because every polynomial will be compiled in the
 \\verb|non short| mode."+ lb );
 …
 //linebreaking   TeXwdith
 //-----------------------------------------------------------------------
 write(fname,"The global variable \\verb|TeXwidth| controls the wrapping of
+write(fname,"The global variable \\verb|TeXwidth| controls the wrapping of
 polynomials; possible values are:" + lb);
 …
 " -1 & \\text{no linebreaking} \\\\ ",
 "  0 & \\text{print the polynom as equation} f=0 \\\\ ",
 " 1,\\ldots,5 & \\text{ the first n termes followed by the sign of the next
+" 1,\\ldots,5 & \\text{ the first n termes followed by the sign of the next
 term} \\\\ ",
 " > 5 & \\text{wrapping after n letters corresponding x} ",
 …
 "\\]",nl);
 write(fname,"Notice that two letters like x counts as three subscripts or
+write(fname,"Notice that two letters like x counts as three subscripts or
 exponents",nl);
 …
 write(fname,"\\verb|TeXwidth| is the only global variable which will be defined
 automatically from Singular. Its default value is -1
+automatically from Singular. Its default value is -1
 i.e. wrapping is set off."+ lb);
 …
 //write(fname,nl2,"\\Line",nl);
 write(fname,"As seen there are two possibilities to tex a polynomial. The
+write(fname,"As seen there are two possibilities to tex a polynomial. The
 command \\verb|texpoly| is the most basic one and sets the polynomials in
 textmode. Notice that it counts the length of the terms convenientely." + lb +
 …
 bv +
 "> setring r3;
 > texpoly(fname,f/180);" + nl +
+> texpoly(fname,f/180);" + nl +
 ev);
 setring r3;
 texpoly(fname,f/180);
+texpoly(fname,f/180);
 write(fname,nl2, "Now the same again with \\verb|texobj| "+ lb,nl);
 …
 write(fname,"Some explaination how it works: if \\verb|texobj| is called for
 a polynomial, then it defines a global variable \\verb|TeXdisp| which forces
 \\verb|texpoly| to count fraction with space corresponding
+\\verb|texpoly| to count fraction with space corresponding
 the displaymode."+lb,nl2);
 …
 ring r;
+ring r;
 ideal I = 3xz5+x2y3-3z,7xz5+y3z+x-z,-xyz2+4yz+2x;
 …
  ideal I = -x(1) + 2*x(3) + x(5),x(2) -x(4) +2*x(5) -1,8*x(1) +x(4) +2;
  TeXwidth = 0;
 write(fname,
 bv +
 "> ring r5 = 0,x(1..5),dp ;
+ TeXwidth = 0;
+write(fname,
+bv +
+"> ring r5 = 0,x(1..5),dp ;
 > ideal I = -x(1) + 2*x(3) + x(5),x(2) -x(4) +2*x(5) -1,8*x(1) +x(4) +2;
 > string(I);" + nl +
 splt(string(I)) + nl2 +
 "> TeXwidth = 0;
+splt(string(I)) + nl2 +
+"> TeXwidth = 0;
 > texobj(fname,I);" +
 //> TeXwidth = 0;" +
 ev
 );
+);
  texobj(fname,I);
 // TeXwidth = -1;
  setring r;
  ideal J;
 …
 write(fname,
 bv +
 "> texobj(fname,J);" +
+"> texobj(fname,J);" +
 ev
 );
+);
  texobj(fname,J);
 //% TeXwidth = 0; TeXbrackets
 …
 ev);
 setring r;
+setring r;
 ideal I = 3xz5+x2y3-3z,7xz5+y3z+x-z,-xyz2+4yz+2x;
 if(system("with","Namespaces")) { exportto(Current, r, I); }
 …
 // int TeXwidth =-1;
 write(fname,bv +
 "> ring r1=0,(x,y,z),dp;
+"> ring r1=0,(x,y,z),dp;
 > ring r2=0,(u,v),dp;
 > map phi = r1,u2,uv -v,v2;
 …
 write(fname,"\\item",nl);
 write(fname,"If the map will be called by its name \\verb|texmap| can in
+write(fname,"If the map will be called by its name \\verb|texmap| can in
 combination with \\verb|TeXreplace| print the name of the map." + lb ,nl);
 …
 "> list TeXreplace;
 > TeXreplace[1] = list(\"phi\",\"\\\\phi\");
 > texmap(fname,\"phi\",r1,r2);" + nl +
+> texmap(fname,\"phi\",r1,r2);" + nl +
 ev);
 …
 write(fname,"\\item",nl);
 write(fname,nl2,"The addtional arguments for \\verb|rings| may be passed over
+write(fname,nl2,"The addtional arguments for \\verb|rings| may be passed over
 in \\verb|texmap|.",nl);
 write(fname,"In the following form the arguments are valid for both
+write(fname,"In the following form the arguments are valid for both
 \\verb|rings|.",nl);
 …
 texobj(fname,H);
 // probiere auch V = 0 bei texobj aus
+// probiere auch V = 0 bei texobj aus
 matrix M = H;
 …
 //------------------------------------------------------------------------
 write(fname,"All the features for \\verb|poly| and the features for
+write(fname,"All the features for \\verb|poly| and the features for
 \\verb|intmat| or \\verb|intvec| hold here, too.");
 …
 write(fname,bv +
 "> TeXwidth = 1;",
 "> texobj(fname,H);",
+"> texobj(fname,H);",
 "> TeXwidth = -1;",
 ev );
 TeXwidth = 1;
 texobj(fname,H);
+texobj(fname,H);
 TeXwidth = -1;
 …
 write(fname,bv +
 "> int TeXnofrac;",
+"> int TeXnofrac;",
 "> texobj(fname,M);",
 "> kill TeXnofrac;",
 …
 > v;" + nl +
 string(v) + nl +
 "> nrows(v);" + nl +
+"> nrows(v);" + nl +
 string(nrows(v)) + nl +
 "texobj(fname,v);" + nl2 +
 …
 "> intmat m[3][4] = -1,3,5,2,-2,8,6,0,2,5,8,7;" + nl +
 "> m;" + nl +
 string(m) + nl +
+string(m) + nl +
 "> texobj(fname,m);" + nl2 +
 ev );
 …
 "> intmat mat[3][3] = 1,2,3,4,5,6,7,8,9;" + nl +
 "> string TeXbrack = \"|\";" + nl +
 "> texobj(fname,mat,\"=\",det(mat)); " + nl2 +
+"> texobj(fname,mat,\"=\",det(mat)); " + nl2 +
 ev );
 …
 //write(fname,"The proc \\verb|texname| is used to write indexed names in a
+//write(fname,"The proc \\verb|texname| is used to write indexed names in a
 //correct way"+lb,nl);
 …
  proc cleantexdemo()
+ {
+ {
   kill fname,nl,nl2,lb,bv,ev;
   return();

Singular/LIB/mondromy.lib

-                      rce7ba6
+                      r917fb5
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: mondromy.lib,v 1.6 1999-07-06 11:33:02 obachman Exp $";
+version="$Id: mondromy.lib,v 1.7 1999-07-06 15:32:53 Singular Exp $";
 info="
 LIBRARY: mondromy.lib  PROCEDURES TO COMPUTE THE MONODROMY OF A SINGULARITY
 …
+    }
+  }
   return(m);
+  return(m);
+}
 ///////////////////////////////////////////////////////////////////////////////
 …
          If U is not a sqaure matrix, the list is empty.
          If U is a sqaure matrix, then the first entry is the determinant of U.
          If U is a square matrix and the determinant of U not zero,
+         If U is a square matrix and the determinant of U not zero,
          then the second entry is the adjoint matrix of U.
 DISPLAY: The procedure displays comments if printlevel>=1.
 …
 proc jacoblift(poly f)
 "USAGE:   jacoblift(f); f poly
 ASSUME:  The polynomial f in a series ring (local ordering) defines
+ASSUME:  The polynomial f in a series ring (local ordering) defines
          an isolated hypersurface singularity.
 RETURN:  The procedure returns a list with entries kappa, xi, u of type
+RETURN:  The procedure returns a list with entries kappa, xi, u of type
          int, vector, poly such that kappa is minimal with f^kappa in jacob(f),
          u is a unit, and u*f^kappa=(matrix(jacob(f))*xi)[1,1].
 …
   for(i=1;i<=size(e);i++)
+  {
     for(j,p=nvars(basering),0;j>=1;j--)
+    for(j,p=nvars(basering),0;j>=1;j--)
+    {
       q=jet(e[i]*xi[j],N);
 …
 proc monodromy(poly f, list #)
 "USAGE:   monodromy(f[,opt]); f poly, opt int
 ASSUME:  The polynomial f in a series ring (local ordering) defines
+ASSUME:  The polynomial f in a series ring (local ordering) defines
          an isolated hypersurface singularity.
 RETURN:  The procedure returns a residue matrix M of the meromorphic
          Gauss-Manin connection of the singularity defined by f
          or an empty matrix if the assumptions are not fulfilled.
          If opt=0 (default), exp(2*pi*i*M) is a monodromy matrix of f,
          else, only the characteristic polynomial of exp(2*pi*i*M) coincides
+RETURN:  The procedure returns a residue matrix M of the meromorphic
+         Gauss-Manin connection of the singularity defined by f
+         or an empty matrix if the assumptions are not fulfilled.
+         If opt=0 (default), exp(2*pi*i*M) is a monodromy matrix of f,
+         else, only the characteristic polynomial of exp(2*pi*i*M) coincides
          with the characteristic polynomial of the monodromy of f.
 THEORY:  The procedure uses an algorithm by Brieskorn (See E. Brieskorn,
          manuscipta math. 2 (1970), 103-161) to compute a connection matrix of
          the meromorphic Gauss-Manin connection up to arbitrarily high order,
          and an algorithm of Gerard and Levelt (See R. Gerard, A.H.M. Levelt,
          Ann. Inst. Fourier, Grenoble 23,1 (1973), pp. 157-195) to transform
+THEORY:  The procedure uses an algorithm by Brieskorn (See E. Brieskorn,
+         manuscipta math. 2 (1970), 103-161) to compute a connection matrix of
+         the meromorphic Gauss-Manin connection up to arbitrarily high order,
+         and an algorithm of Gerard and Levelt (See R. Gerard, A.H.M. Levelt,
+         Ann. Inst. Fourier, Grenoble 23,1 (1973), pp. 157-195) to transform
          it to a simple pole.
 DISPLAY: The procedure displays more comments for higher printlevel.
 …
       return();
+    }
+  }
 …
 proc H''basis(poly f)
 "USAGE:   H''basis(f); f poly
 ASSUME:  The polynomial f in a series ring (local ordering) defines
+ASSUME:  The polynomial f in a series ring (local ordering) defines
          an isolated hypersurface singularity.
 RETURN:  The procedure returns a list of representatives of a C{f}-basis of the

Singular/LIB/noethernormal.lib

-                      rce7ba6
+                      r917fb5
 // $Id: noethernormal.lib,v 1.2 1999-07-06 11:33:03 obachman Exp $
+// $Id: noethernormal.lib,v 1.3 1999-07-06 15:32:53 Singular Exp $
 //(GP, last modified 15.08.98)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: noethernormal.lib,v 1.2 1999-07-06 11:33:03 obachman Exp $";
+version="$Id: noethernormal.lib,v 1.3 1999-07-06 15:32:53 Singular Exp $";
 info="
 LIBRARY:  noetherNormal.lib    PROCEDURE FOR NOETHERNORMALIZATION
 …
+{
    intvec v,w;
    int j;
+   int j;
    for(j=1;j<=size(i);j++)
+   {
 …
 RETURN:  1 if R---->basering/I is finite and 0 else
 EXAMPLE: mapIsFinite; shows an example
+"
+"
+{
   int n=nvars(R);
   def S=basering;
   setring R;
   ideal jj=maxideal(1);
   setring S;
   ideal jj=phi(jj);
   def T=S+R;
   setring T;
+  setring T;
   changeord("@rr","lp");
 //  ideal j=imap(S,phi(jj));
   ideal j=imap(S,jj);
   int i;
   for(i=1;i<=nvars(S);i++)
 …
    ideal i= xy;
    map phi=r,(xy)^3+x2+z,y2-1,z3;
    mapIsFinite(r,phi,i);
+}

Singular/LIB/normal.lib

-                      rce7ba6
+                      r917fb5
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: normal.lib,v 1.15 1999-07-06 11:33:04 obachman Exp $";
+version="$Id: normal.lib,v 1.16 1999-07-06 15:32:54 Singular Exp $";
 info="
 LIBRARY: normal.lib     PROCEDURES FOR NORMALIZATION
 …
  normal(I);             computes the normalization of basering/I
  extraweight(R);        intvec of variable weights of ring R
  HomJJ(L);              presentation of End_R(J) as affine ring, L a list
+ HomJJ(L);              presentation of End_R(J) as affine ring, L a list
 ";
 …
    intvec rw,rw1;
    list L;
    y = printlevel-voice+2;  // y=printlevel (default: y=0)
  def P = basering;
 …
 //---------- computation of p*Hom(J,J) as R-ideal -----------------------------
    if ( y>=1 )
+   {
+   {
      "// compute p*Hom(rad(J),rad(J)) = p*J:J, p a non-zerodivisor";
      "//   p is equal to:"; "";
      p;
      "";
+     "";
+   }
 …
    if ( y>=1 )
    { "// the module p*Hom(rad(J),rad(J)) = p*J:J, p a non-zerodivisor";
       "// p"; p;
       "// f=p*J:J";f;
 …
          endphi;
          "   ";
          pause;
+         pause();
          newline;
+      }
 …
+   {
       "// R is not equal to Hom(rad(J),rad(J)), we have to try again";
       pause;
+      pause();
       newline;
+   }
 …
       "   ";
       interred(Quad);
       pause;
+      pause();
       newline;
+   }
 …
       endphi;
       "   ";
       pause;
+      pause();
       newline;
+   }
 …
          (which is sometimes more efficient)
 RETURN:  a list of rings (say nor), in each ring nor[i] are two ideals
          norid, normap such that the product of the nor[i]/norid is the
+         norid, normap such that the product of the nor[i]/norid is the
          normalization of basering/id and normap is the map from basering/id
          to nor[i]/norid
 …
       result = normalizationPrimes(prim[1],maxideal(1));
       sr = string(size(result));
       dbprint(y+1,"
 // 'normal' created a list of "+sr+" ring(s).
 …
       dbprint(y+1,"
 // 'normal' created a list of "+sr+" ring(s).
+// 'normal' created a list of "+sr+" ring(s).
 // To see the rings, type (if the name of your list is nor):
      show( nor);
+     show( nor);
 // To access the 1-st ring and map (and similair for the others), type:
      def R = nor[1]; setring R;  norid; normap;
+     def R = nor[1]; setring R;  norid; normap;
 // R/norid is the 1-st ring of the normalization and
 // normap the map from the original basering to R/norid");
 …
+{
    int y = printlevel-voice+2;  // y=printlevel (default: y=0)
    if(y>=1)
+   {
 …
      i;  "";
      basering;  "";
      pause;
+     pause();
      newline;
+   }

Singular/LIB/paramet.lib

-                      rce7ba6
+                      r917fb5
 // $Id: paramet.lib,v 1.4 1999-07-06 11:33:06 obachman Exp $
+// $Id: paramet.lib,v 1.5 1999-07-06 15:32:55 Singular Exp $
 // author : Thomas Keilen email: keilen@mathematik.uni-kl.de
 // last change:           07.08.98
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: paramet.lib,v 1.4 1999-07-06 11:33:06 obachman Exp $";
+version="$Id: paramet.lib,v 1.5 1999-07-06 15:32:55 Singular Exp $";
 info="
 LIBRARY:  paramet.lib   PROCEDURES FOR PARAMETRIZATION OF PRIMARY
+LIBRARY:  paramet.lib   PROCEDURES FOR PARAMETRIZATION OF PRIMARY
                         DECOMPOSITION, ETC.
 PROCEDURES:
  parametrize(I);       parametrizes a prime ideal if possible via the
+ parametrize(I);       parametrizes a prime ideal if possible via the
                        normalization
  parametrizepd(I);     calculates the primary decomp. and parametrizes
+ parametrizepd(I);     calculates the primary decomp. and parametrizes
                        the components
  parametrizesing(f);   parametrize an isolated plane curve singularity
 …
 proc parametrize(ideal I)
 "USAGE:  parametrize(); I ideal in an arbitrary number of variables,
          whose radical is prime, in a ring with global ordering
+         whose radical is prime, in a ring with global ordering
 RETURN:  a list containing the parametrization ideal resp. the original ideal,
          the number of variables needed for the parametrization resp. 0, and
 resp. 0 depending on whether the parametrization was successful
+resp. 0 depending on whether the parametrization was successful
          or not
 NOTE:    if successful, the basering is changed to the parametrization ring;
          the result will be incorrect, if the parametrization needs more than
+         the result will be incorrect, if the parametrization needs more than
          two variables
 EXAMPLE: example parametrize; shows an example
 …
    list nor=normal(newI);
    def N=nor[1];
    ring PR=0,(s,t),dp;
+   ring PR=0,(s,t),dp;
    setring N;
    // If the ideal is zero dimensional, the procedure works as well in good cases.
 …
      ideal para=p(normap);
      export para;
      // The i-th list component contains the parametrization, the
+     // The i-th list component contains the parametrization, the
      // number of necessary variables, and the information, if
      // the parametrization was successful.
 …
      keepring(PR);
+   }
    else
+   else
+   {
      list param=I,0,0;
 …
+}
 example
 { "EXAMPLE:";echo = 2;
+{ "EXAMPLE:";echo = 2;
   ring RING=0,(x,y,z),dp;
   ideal I=z2-y2x2+x3;
 …
          resp. 0, and 1 resp. 0 depending on whether the parametrization
          of the component was successful or not
 NOTE:    the basering will be changed to PR=0,(s,t),dp
+NOTE:    the basering will be changed to PR=0,(s,t),dp
          the result will be incorrect, if the parametrization needs more than two
          variables
 …
  for (int ii=1; ii<=size(primary); ii=ii+1)
+   {
      no=normal(std(primary[ii][2]));
+     no=normal(std(primary[ii][2]));
      nor[ii]=no[1];
      def N=nor[ii];
      setring N;
      int d=dim(std(norid));
      // Test if the normalization is K, K[s] or K[s,t]. Then give back the parametrization.
+     // Test if the normalization is K, K[s] or K[s,t]. Then give back the parametrization.
      if (size(norid)==0)
+     {
 …
        setring BAS;
+     }
      else
+     else
+     {
        setring PR;
 …
+   }
  export nor;
  setring PR;
+ setring PR;
  export PR;
  keepring PR;
 …
+}
 example
 { "EXAMPLE:";echo = 2;
+{ "EXAMPLE:";echo = 2;
   ring RING=0,(x,y,z),dp;
   ideal I=(x2-y2z2+z3)*(x2-z2-z3),(x2-y2z2+z3)*yz;
 …
 "USAGE:  parametrizesing(); f a polynomial in two variables with ordering ls or ds
 RETURN:  a list containing the parametrizations of the different branches of the
          singularity at the origin resp. 0, if f was not of the desired kind
+         singularity at the origin resp. 0, if f was not of the desired kind
 NOTE:    if successful, the basering is changed to ring 0,(x,y),ls;
 EXAMPLE: example parametrizesing; shows an example
 …
+}
 example
 { "EXAMPLE:";echo = 2;
+{ "EXAMPLE:";echo = 2;
   ring RING=0,(x,y),ls;
   poly f=(x^2-y^3)*(x^2-y^2-y^3);
 …
 /// Examples for parametrizepd
 /// Example 1
+/// Example 1
 ring r=0,(x,y,z),dp;
 ideal i=y2z5-x2y2z2+y2z4-z6-z5+x4-x2z2,-y3z3+yz4+x2yz;

Singular/LIB/poly.lib

-                      rce7ba6
+                      r917fb5
 // $Id: poly.lib,v 1.15 1999-07-06 11:33:07 obachman Exp $
+// $Id: poly.lib,v 1.16 1999-07-06 15:32:55 Singular Exp $
 //system("random",787422842);
 //(GMG, last modified 22.06.96)
 …
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: poly.lib,v 1.15 1999-07-06 11:33:07 obachman Exp $";
+version="$Id: poly.lib,v 1.16 1999-07-06 15:32:55 Singular Exp $";
 info="
 LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
 …
 proc katsura
 "USAGE: katsura([n]): n integer
 RETURN: katsura(n) : n-th katsura ideal of
                       (1) newly created and set ring (32003, x(0..n), dp), if
+RETURN: katsura(n) : n-th katsura ideal of
+                      (1) newly created and set ring (32003, x(0..n), dp), if
                           nvars(basering) < n
                       (2) basering, if nvars(basering) >= n
 …
     n = nvars(basering) -1;
+  }
   ideal s;
   int i, j;

Singular/LIB/primdec.lib

-                      rce7ba6
+                      r917fb5
 // $Id: primdec.lib,v 1.37 1999-07-06 11:33:09 obachman Exp $
+// $Id: primdec.lib,v 1.38 1999-07-06 15:32:56 Singular Exp $
 ////////////////////////////////////////////////////////////////////////////////
 // primdec.lib                                                                //
 …
 ////////////////////////////////////////////////////////////////////////////////
 version="$Id: primdec.lib,v 1.37 1999-07-06 11:33:09 obachman Exp $";
+version="$Id: primdec.lib,v 1.38 1999-07-06 15:32:56 Singular Exp $";
 info="
 LIBRARY: primdec.lib PROCEDURE FOR PRIMARY DECOMPOSITION
 …
       act;
       keep;
       pause;
+      pause();
       p;
       q;
       pause;
+      pause();
+   }
+}
 …
+     {
 //@pr[j];
 //pause;
+//pause();
         @res[j]=decomp(@pr[j],2);
 //       @res[j]=decomp(@pr[j],2,@pr[j],ser);

Singular/LIB/solve.lib

-                      rce7ba6
+                      r917fb5
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: solve.lib,v 1.8 1999-07-06 11:33:13 obachman Exp $";
+version="$Id: solve.lib,v 1.9 1999-07-06 15:32:57 Singular Exp $";
 info="
 LIBRARY: solve.lib     PROCEDURES TO SOLVE POLYNOMIAL SYSTEMS
 …
          l>0: defines precision of fractional part if ground field is Q
          m=0,1,2: number of iterations for approximation of roots (default=2)
 ASSUME:  i is a zerodimensional ideal with
          nvars(basering) = ncols(i) = number of vars actually occuring in i
+ASSUME:  i is a zerodimensional ideal with
+         nvars(basering) = ncols(i) = number of vars actually occuring in i
 RETURN:  list of all (complex) roots of the polynomial system i = 0,
          of type number if the ground field is the complex numbers,
 …
   int prec=30;
   if ( size(#) >= 1 )
+    {
       typ= #[1];
       if ( typ < 0 || typ > 1 )
+        {
+          ERROR("Valid values for second parameter k are:
 : use sparse Resultant (default)
 : use Macaulay Resultant");
+        }
+    }
   if ( size(#) >= 2 )
+    {
       prec= #[2];
       if ( prec == 0 ) { prec = 30; }
       if ( prec < 0 )
+        {
           ERROR("Third parameter l must be positive!");
+        }
+    }
   if ( size(#) >= 3 )
+    {
       polish= #[3];
       if ( polish < 0 || polish > 2 )
+        {
+          ERROR("Valid values for fourth parameter m are:
 ,1,2: number of iterations for approximation of roots");
+        }
+    }
   if ( size(#) > 3 )
+    {
       ERROR("only three parameters allowed!");
+    }
+  if ( size(#) >= 1 )
+  {
+    typ= #[1];
+    if ( typ < 0 || typ > 1 )
+    {
+      ERROR("Valid values for second parameter k are:
+: use sparse Resultant (default)
+: use Macaulay Resultant");
+    }
+  }
+  if ( size(#) >= 2 )
+  {
+    prec= #[2];
+    if ( prec == 0 ) { prec = 30; }
+    if ( prec < 0 )
+    {
+      ERROR("Third parameter l must be positive!");
+    }
+  }
+  if ( size(#) >= 3 )
+  {
+    polish= #[3];
+    if ( polish < 0 || polish > 2 )
+    {
+      ERROR("Valid values for fourth parameter m are:
+,1,2: number of iterations for approximation of roots");
+    }
+  }
+  if ( size(#) > 3 )
+  {
+    ERROR("only three parameters allowed!");
+  }
   int digits= system("setFloatDigits",prec);
   return(uressolve(gls,typ,polish));
+}
 example
 …
   // result is a list (x,y)-coordinates as strings
   pause;
   // now with complex coefficient field, precision is 10 digits
+  pause();
+  // now with complex coefficient field, precision is 10 digits
   ring rsc= (real,10,I),(x,y),lp;
   ideal i = (2+3*I)*x2 + (0.35+I*45.0e-2)*y2 - 8, x2 + xy + (42.7)*y2;
 …
   int prec=30;
   if ( size(#) >= 1 )
+    {
       prec= #[1];
       if ( prec == 0 ) { prec = 30; }
       if ( prec < 0 )
+        {
           ERROR("Fisrt parameter must be positive!");
+        }
+    }
   if ( size(#) >= 2 )
+    {
       polish= #[2];
       if ( polish < 0 || polish > 2 )
+        {
+          ERROR("Valid values for third parameter are:
 ,1,2: number of iterations for approximation of roots");
+        }
+    }
   if ( size(#) > 2 )
+    {
       ERROR("only two parameters allowed!");
+    }
+  if ( size(#) >= 1 )
+  {
+    prec= #[1];
+    if ( prec == 0 ) { prec = 30; }
+    if ( prec < 0 )
+    {
+      ERROR("Fisrt parameter must be positive!");
+    }
+  }
+  if ( size(#) >= 2 )
+  {
+    polish= #[2];
+    if ( polish < 0 || polish > 2 )
+    {
+      ERROR("Valid values for third parameter are:
+,1,2: number of iterations for approximation of roots");
+    }
+  }
+  if ( size(#) > 2 )
+  {
+    ERROR("only two parameters allowed!");
+  }
   int digits= system("setFloatDigits",prec);
   return(laguerre(f,polish));
+}
 example
 …
   laguerre_solve(f);
   pause;
+  pause();
   // Now with 10 digits precision:
   laguerre_solve(f,10);
   pause;
+  pause();
   // Now with complex coefficients, precision is 20 digits:
   ring rsc= (real,20,I),x,lp;
 …
          k=1: resultant matrix of Macaulay (k=0 is default)
 ASSUME:  nvars(basering) = ncols(i)-1 = number of vars actually occuring in i,
          for k=1 i must be homogeneous
 RETURN:  module representing the multipolynomial resultant matrix
+         for k=1 i must be homogeneous
+RETURN:  module representing the multipolynomial resultant matrix
 EXAMPLE: example mp_res_mat; shows an example
+"
 …
   int typ=2;
   if ( size(#) == 1 )
+    {
       typ= #[1];
       if ( typ < 0 || typ > 1 )
+        {
           ERROR("Valid values for third parameter are:
 : sparse resultant (default)
 : Macaulay resultant");
+        }
+    }
   if ( size(#) > 1 )
+    {
       ERROR("only two parameters allowed!");
+    }
+  if ( size(#) == 1 )
+  {
+    typ= #[1];
+    if ( typ < 0 || typ > 1 )
+    {
+      ERROR("Valid values for third parameter are:
+: sparse resultant (default)
+: Macaulay resultant");
+    }
+  }
+  if ( size(#) > 1 )
+  {
+    ERROR("only two parameters allowed!");
+  }
   return(mpresmat(i,typ));
+}
 example
 …
   det(m);
   pause;
+  pause();
   // compute resultant matrix (Macaulay resultant matrix)
   ring rdq= (0,u0,u1,u2),(x0,x1,x2),lp;
 …
   det(m);
   pause;
+  pause();
   // compute numerical sparse resultant matrix
   setring rsq;
 …
 ASSUME:  ground field K is the rational numbers,
          p and v consist of numbers of the ground filed K, p must have
          n elements, v must have N=(d+1)^n elements where n=nvars(basering)
          and d=deg(f) (f is the unknown polynomial in K[x1,...,xn])
+         n elements, v must have N=(d+1)^n elements where n=nvars(basering)
+         and d=deg(f) (f is the unknown polynomial in K[x1,...,xn])
 COMPUTE: polynomial f with values given by v at points p1,..,pN derived from p;
          more precisely: consider p as point in K^n and v as N elements in K,
 …
+}
 ///////////////////////////////////////////////////////////////////////////////

Singular/LIB/solver.lib

-                      rce7ba6
+                      r917fb5
 // $Id: solver.lib,v 1.2 1999-07-06 11:33:14 obachman Exp $
+// $Id: solver.lib,v 1.3 1999-07-06 15:32:58 Singular Exp $
 ////////////////////////////////////////////////////////////////////////////////
 // solver.lib                                                                //
 …
 ////////////////////////////////////////////////////////////////////////////////
 version="$Id: solver.lib,v 1.2 1999-07-06 11:33:14 obachman Exp $";
+version="$Id: solver.lib,v 1.3 1999-07-06 15:32:58 Singular Exp $";
 info="
 LIBRARY: solver.lib: PROCEDURES FOR SOLVING ZERO-DIMENSIONAL ALGEBRAIC SYSTEMS
 …
             p[i] = subst(p[i],var(j),a[j]);
             for (k = n; k >= n-i+1; k--)
+            {
+            {
                 J[i,k] = subst(J[i,k],var(j),a[j]);
+            }
 …
             return();
+        }
         // solve linear equations
         hh = -p[i];

Singular/LIB/spcurve.lib

-                      rce7ba6
+                      r917fb5
 // $Id: spcurve.lib,v 1.2 1999-07-06 11:33:14 obachman Exp $
+// $Id: spcurve.lib,v 1.3 1999-07-06 15:32:58 Singular Exp $
 // (anne, last modified 20.7.98)
 /////////////////////////////////////////////////////////////////////////////
 version="$Id: spcurve.lib,v 1.2 1999-07-06 11:33:14 obachman Exp $";
+version="$Id: spcurve.lib,v 1.3 1999-07-06 15:32:58 Singular Exp $";
 info="
 LIBRARY: spcurve.lib    PROCEDURES FOR CM CODIMENSION 2 SINGULARITIES
 …
  kod_ker(M,a);           kernel of the Kodaira-Spencer map using eliminate
  kod_noelim(M);          kernel of the Kodaira-Spencer map (weighted
                          elimination)
+                         elimination)
 ";
 LIB "elim.lib";
 LIB "homolog.lib";
 …
 proc isCMcod2(ideal kurve)
 USAGE:   isCMcod2(i);
+USAGE:   isCMcod2(i);
          where i is an ideal
 RETURN:  presentation matrix of i, if i is Cohen-Macaulay of codimension2
 …
   list kurveres=mres(kurve,0);
   matrix M=kurveres[2];
   if ((size(kurveres)>3) &&
          ((size(kurveres[3])>1) ||
+  if ((size(kurveres)>3) &&
+         ((size(kurveres[3])>1) ||
           ((size(kurveres[3])<=1) && (kurveres[3][1,1]!=0))))
+  {
 …
 proc CMtype(ideal kurve)
 USAGE:   CMtype(i);
+USAGE:   CMtype(i);
          where i is an ideal, Cohen-Macaulay of codimension 2
 RETURN:  Cohen-Macaulay type of i (integer)
+RETURN:  Cohen-Macaulay type of i (integer)
          (-1, if i is not Cohen-Macaulay of codimension 2)
 EXAMPLE: example CMtype; shows an example
 …
   kurveres=mres(kurve,0);
   if (size(kurveres)>3)
+  {
+  {
     dbprint(p,"//not Cohen-Macaulay, codim 2");
     return(gt);
 …
 proc matrixT1(matrix M ,int n)
 USAGE:   matrixT1(M,n);
          where M is a presentation matrix of an ideal,
+USAGE:   matrixT1(M,n);
+         where M is a presentation matrix of an ideal,
          Cohen-Macaulay of codimension 2
          and n determines the number of variables used as variables, not as
          parameters ( variables are assumed to precede parameters in the
          definition of the basering )
 RETURN:  T1 of i as a quotient of the module of matrices of the same
+         definition of the basering )
+RETURN:  T1 of i as a quotient of the module of matrices of the same
          size as M with polynomial entries
 EXAMPLE: example matrixT1; shows an example
 …
     dbprint(p,"//not a k x (k+1) matrix");
     return("ERROR");
+  }
+  }
 //---------------------------------------------------------------------------
 // Construct the denominator - step by step
 …
+  }
 //---------------------------------------------------------------------------
 // step 4: so is L*M
+// step 4: so is L*M
 //---------------------------------------------------------------------------
   for( i=1; i <= (gt+1); i++)
 …
   matrix Mtemp[gt*(gt+1)][1];
   for( i=1; i<=tau; i++)
+  {
+  {
     Mtemp=t1erz[i];
     N=N+A(i)*transpose(Mtemp);
 …
   int i;
   ideal sem=std(kurve);
   ideal semdiff;
+  ideal semdiff;
   ideal J2;
   int ncol=ncols(matrix(sem));
 …
 USAGE:   qhmatrix(M);
          where M is a matrix with polynomial entries of size k x (k+1)
 RETURN:  list consisting of an integer vector containing the weights of
+RETURN:  list consisting of an integer vector containing the weights of
          the variables of the basering and an integer matrix giving the
          weights of the entries
          integer vector and integer matrix both contain only 0, if the
          matrix is not quasihomogeneous, i.e. does not allow row and
+         matrix is not quasihomogeneous, i.e. does not allow row and
          column weights
 EXAMPLE: example qhmatrix; shows an example
 …
     dbprint(p,"//not a k x (k+1) matrix");
     return("ERROR");
+  }
+  }
   ideal m=minor(M,nr);
 //---------------------------------------------------------------------------
 …
+      {
         if(M[i,j]==0)
+        {
+        {
           comprow=0;
           break;
 …
 //---------------------------------------------------------------------------
 // get the weights of the comprow'th row or use emergency exit
 //---------------------------------------------------------------------------
+//---------------------------------------------------------------------------
   if(comprow==0)
+  {
 …
+  {
     if ( i==comprow )
+    {
+    {
 // this row should not be tested against itself
       donttest=1;
 …
 proc relweight(matrix N, intmat W, intvec a)
 USAGE:   relweight(N,W);
          where N is a non-zero matrix with polynomial entries, W is a
+         where N is a non-zero matrix with polynomial entries, W is a
          matrix with integer entries of the same size and the entries
          of a give the weight of the variables of the basering
 …
          ring rneu=char(basering),(var(1),..,var(nvars(basering)),
                     T(1),..,T(k),(dp nvars(basering),dp k);
          a presentation matrix describing the deformation given by the
+         a presentation matrix describing the deformation given by the
          generators of T1 of non-negative weight is returned as the first
          list element, followed by the weight vector for the new variables
 …
+  }
   kill i;
   if (defined(jj))
+  if (defined(jj))
+  {
     if (jj==-1)
 …
   matrix Mtemp[gt*(gt+1)][1];
   for( i=1; i<=pw; i++)
+  {
+  {
     mtemp=erz1[i];
     Mtemp=mtemp;
 …
           ker[i]=lead(ker[i]);
+      }
+    }
+    }
     kill testlead;
+  }
+  }
   ker=eliminate(interred(ker),p);
   option(set,optvec);
 …
   matrix M=imap(rt,M);
   int ne=size(M);
   intvec iv=1..ne;
+  intvec iv=1..ne;
   list l=matrixT1(M,3);
   if (dim(std(l[2])) != 0)
 …
+    }
+  }
   ringre="ring re=" + charstr(r) +",(e(1.." + string(ne) + "),"+ varstr(basering)
                         + "),ws(" + string((-1)*intvec(wl[2])) + ","
+  ringre="ring re=" + charstr(r) +",(e(1.." + string(ne) + "),"+ varstr(basering)
+                        + "),ws(" + string((-1)*intvec(wl[2])) + ","
                         + string(wl[1]) + ");";
   execute ringre;
 …
+  }
   ideal templ=lead(t1perts);
   for(int j=1;j<=nv;j++)
+  for(int j=1;j<=nv;j++)
+  {
     templ=subst(templ,T(j),0);
 …
+  }
 //--------------------------------------------------------------------------
 // multiply by the initial ring variables to shift the generators with
+// multiply by the initial ring variables to shift the generators with
 // leading term divisible by some T(i) and reduce afterwards
 //--------------------------------------------------------------------------
   attrib(mx,"isSB",1); // This is obviously no SB, but we have to reduce by
+  attrib(mx,"isSB",1); // This is obviously no SB, but we have to reduce by
                        // it and setting isSB suppresses error messages
   noether=noet[size(noet)];
 …
   ovar=var(1);
   for(i=2;i<=ne;i++)
+  {
+  {
     ovar=ovar,var(i);
+  }
 …
            gen(i) will correspond to var(vpos[i])
 NOTE:      this procedure should be used in the following situation:
            one wants to pass to a ring with new variables which stand
            for the generators of the module and consider the module as
+           one wants to pass to a ring with new variables which stand
+           for the generators of the module and consider the module as
            an ideal
 RETURN:    ideal i in which each gen(i) from the module is replaced by
            var(vpos[i]) and all monomials var(vpos[i])*var(vpos[j]) have
+           var(vpos[i]) and all monomials var(vpos[i])*var(vpos[j]) have
            been added to the generating set of i
 EXAMPLE:   example mod2id; shows an example
 …
+  }
 //----------------------------------------------------------------------
 // define the desired ideal
+// define the desired ideal
 //----------------------------------------------------------------------
   ideal ret=vars^2,varm*M;
 …
   intvec iv=2,1;
   mod2id(mo,iv);
+}
+}
 ////////////////////////////////////////////////////////////////////////
 static
 …
 NOTE:      * use this procedure only makes sense if the ideal contains
              all var(vpos[i])*var(vpos[j]) as monomial generators and
              all other generators are linear combinations of the
+             all other generators are linear combinations of the
              var(vpos[i]) over the ring in the other variables
            * this is the inverse procedure to mod2id
 RETURN:    module corresponding to the ideal by replacing var(vpos[i]) by
            gen(i) and omitting all generators var(vpos[i])*var(vpos[j])
+           gen(i) and omitting all generators var(vpos[i])*var(vpos[j])
 EXAMPLE:   example id2mod; shows an example;
+{
 //---------------------------------------------------------------------
 // Initialization
+// Initialization
 //---------------------------------------------------------------------
   int n=size(i);
 …
           sm ideal in a ring r with n + s variables,
           e.g. x_1,..,x_n and t_1,..,t_s
           mon ideal with monomial generators (not divisible by
+          mon ideal with monomial generators (not divisible by
           one of the t_i) such that sm is contained in the module
           k[t_1,..,t_s]*mon
           iv intvec listing the variables which are supposed to be used
           as x_i
 RETURN:   interreduced system of generators of sm seen as a submodule
+RETURN:   interreduced system of generators of sm seen as a submodule
           of k[t_1,..,t_s]*mon
 EXAMPLE:  example subrInterred; shows an example

Singular/LIB/standard.lib

-                      rce7ba6
+                      r917fb5
 // $Id: standard.lib,v 1.35 1999-07-06 11:33:15 obachman Exp $
+// $Id: standard.lib,v 1.36 1999-07-06 15:32:59 Singular Exp $
 //////////////////////////////////////////////////////////////////////////////
 version="$Id: standard.lib,v 1.35 1999-07-06 11:33:15 obachman Exp $";
+version="$Id: standard.lib,v 1.36 1999-07-06 15:32:59 Singular Exp $";
 info="
 LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
 …
  fprintf(link,fmt,..) writes formatted string to link
  printf(fmt,...)      displays formatted string
+ pause([prompt])      pause in the computation till user input
 ";
 …
+}
 example
+{
+  "EXAMPLE: "; echo = 2;
+{ "EXAMPLE: "; echo = 2;
   ring r = 0, (a,b,c,d), lp;
   option(prot);
 …
+}
 example
+{
+{ "EXAMPLE:"; echo=2;
   ring r=0,(x,y,z),dp;
   module m=[1,y],[0,x+z];
 …
+}
 example
+{
+{ "EXAMPLE:"; echo=2;
   ring r=0,(x,y,z),dp;
   module m=[1,y],[0,x+z];
 …
+}
 example
+{
+{ "EXAMPLE:"; echo=2;
   ring r=0,(x,y,z),dp;
   module m=[1,y],[0,x+z];
 …
+proc pause(list #)
+"USAGE:    pause([ prompt ])  prompt string
+RETURN:   none
+PURPOSE: pause in the computation till user input
+EXAMPLE : example pause; shows an example
+"
+{
+  string pr="pause>";
+  if (size(#)!=0)
+  {
+    pr=#[1];
+  }
+  pr=read("",pr);
+}
+example
+{ "EXAMPLE:"; echo=2;
+  pause("press <return> to continue");
+  pause();
+}

Singular/LIB/surf.lib

-                      rce7ba6
+                      r917fb5
 // $Id: surf.lib,v 1.4 1999-07-06 11:33:16 obachman Exp $
+// $Id: surf.lib,v 1.5 1999-07-06 15:33:00 Singular Exp $
 //
 // author : Hans Schoenemann
 //
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: surf.lib,v 1.4 1999-07-06 11:33:16 obachman Exp $";
+version="$Id: surf.lib,v 1.5 1999-07-06 15:33:00 Singular Exp $";
 info="
 LIBRARY: surf.lib    PROCEDURES FOR GRAPHICS WITH SURF (by Stephan Endrass)
 …
 "USAGE:   plot(I);  I ideal
 RETURN:
 NOTE:
+NOTE:
 EXAMPLE: example plot; shows an example
+"
 …
    plot(I);
    ideal J = x1^2-x1-x2^3;
    plot(J);
+   plot(J);
    ring rr1 = 0,(x,y,z),dp;
    ideal I(1) = 2x2-1/2x3 +1-y+1;
    plot(I(1));
    ideal I(2) = x3-x-y;
+   ideal I(2) = x3-x-y;
    plot(I(2));
 …
   plot(logo);
    // --------- implicit curves ------------
    // implicit curves
 …
    poly f = (x-y)*(x2+y);
    plot(f,1);
+   plot(f,1);
    ideal J = jacob(f);
    J;
 …
    ideal J(2) = x^2*y^2+x^2*z^2+y^2*z^2-17*x*y*z;
    plot(J(2));
   plot(x*(x2-y2)+z2);

Singular/LIB/tst.lib

-                      rce7ba6
+                      r917fb5
 // $Id: tst.lib,v 1.13 1999-07-06 11:33:17 obachman Exp $
+// $Id: tst.lib,v 1.14 1999-07-06 15:33:00 Singular Exp $
 //(obachman, last modified 6/30/98)
 /////////////////////////////////////////////////////////////////////////////
 version="$Id: tst.lib,v 1.13 1999-07-06 11:33:17 obachman Exp $";
+version="$Id: tst.lib,v 1.14 1999-07-06 15:33:00 Singular Exp $";
 info="
 LIBRARY:  tst.lib      PROCEDURES FOR RUNNING AUTOMATIC TST TESTS
 …
  tst_init()             writes some identification data to GetTstStatusFile()
  tst_status([any])      writes status info to to GetTstStatusFile()
  tst_groebnerTest(ideal i)
                         tests groebner command
  tst_stdEqual(ideal i1, ideal i2)
+ tst_groebnerTest(ideal i)
+                        tests groebner command
+ tst_stdEqual(ideal i1, ideal i2)
                         test whether two std's are \"equal\"
 ";
 …
 "USAGE:    tst_ignore(any,[keyword], [link])
             any     -- valid argument to string()
             keyword -- an arbitrary string
+            keyword -- an arbitrary string
             link    -- a link which can be written to
 RETURN:   none; writes string(any) to link (or stdout, if no link given),
           prepending prefix \"// tst_ignore:\", or
+          prepending prefix \"// tst_ignore:\", or
                             \"// tst_ignore:keyword hostname:\",
                             if keyword was given.
 …
     return ("tst_status.out");
+  }
   else
+  else
+  {
     return (tst_status_file);
+  }
+}
 static proc tst_status_out (def prefix, def what, list #)
+{
   string outstring;
   outstring = string(prefix) + " >> " + string(what);
   if (size(#) > 0)
+  {
     outstring = outstring + " :: " +
+    outstring = outstring + " :: " +
       tst_system("hostname", 1) + ":" + string(#[1]);
+  }
   write(":a " + GetTstStatusFile(), outstring);
+}
 proc tst_status (list #)
 "USAGE:   tst_status([any])
 RETURN:   none; writes to stdout the current memory usage and used time
           since last call to tst_status(), if no argument is given, or,
+          since last call to tst_status(), if no argument is given, or,
           since start-up of Singular, if an argument is given.
 NOTE:     Should be used regularly within tst files to enable automatic
+NOTE:     Should be used regularly within tst files to enable automatic
           tracking of memory and time performance.
 EXAMPLE: example tst_status; shows example
 …
       tst_status_counter++;
+    }
     tst_status_out(tst_status_counter, "tst_memory_0", memory(0));
     tst_status_out(tst_status_counter, "tst_memory_1", memory(1));
 …
+}
 proc tst_init()
 "USAGE:   tst_init()
 …
 , otherwise
         Two std's are \"equal\" here, if their redSB's are element-wise equal,
         and if they reduce each other to zero, and if their leading ideals
+        and if they reduce each other to zero, and if their leading ideals
         are equal
         On success, times of std - groebner is written with tst_ignore, and
         times are added to global variables tst_std_time and
         tst_groebner_time. If v given, and <= 0, short ideal
+        times are added to global variables tst_std_time and
+        tst_groebner_time. If v given, and <= 0, short ideal
         characteristic is printed, if v > 0, ideals are printed.
         On failure, Error message and ideals are printed.
 …
   ideal si = std(i);
   st = timer - st;
   int gt = timer;
   ideal gi = groebner(i);
 …
+}
 //
 // A routine which test for equality of "std-bases"
 //
+//
 proc tst_stdEqual(ideal i1, ideal i2)
 "USAGE: tst_stdEqual(i1, i2)  ideal i1, i2
 …
 , otherwise
        Two std's are \"equal\" here, if their redSB's are element-wise equal,
        and if they reduce each other to zero, and if their leading ideals
+       and if they reduce each other to zero, and if their leading ideals
        are equal
        On failure, error message is printed.
 …
   intvec opts = option(get);
   option(redSB);
   ideal ri1 = simplify(interred(i1), 1);
   ideal ri2 = simplify(interred(i2), 1);
   option(set, opts);
 …
+    {
       poly p1, p2;
       ideal si1 = simplify(i1, 7);
       ideal si2 = simplify(i2, 7);
       if (size(si1) == size(si2))
+      {
 …
+}

Singular/febase.cc

-                      rce7ba6
+                      r917fb5
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 /* $Id: febase.cc,v 1.73 1999-05-01 15:30:44 obachman Exp $ */
+/* $Id: febase.cc,v 1.74 1999-07-06 15:32:43 Singular Exp $ */
 /*
 * ABSTRACT: i/o system
 …
+    {
       lines = 0;
+      fePause();
+      fputs("pause>\n",stderr);
+      uchar c = fgetc(stdin);
+    }
     else
 …
   int ls = strlen(s);
   if (ls == 0) return;
   char* ns;
   int l = strlen(sprint);
   ns = (char*) AllocL((l + ls + 1)*sizeof(char));
   if (l > 0) strcpy(ns, sprint);
   strcpy(&(ns[l]), s);
   FreeL(sprint);
 …
     return;
+  }
   if (feOut) /* do not print when option --no-out was given */
+  {
 #ifdef macintosh
     char c;
 …
       ns = (char*) AllocL(sizeof(char)*(ls + l + 256));
       if (l > 0)  strcpy(ns, sprint);
 #ifdef HAVE_VSNPRINTF
       l = vsnprintf(&(ns[l]), ls+255, fmt, ap);
 …
+}
-void fePause()
+{
-#ifdef HAVE_TCL
-  if(!tclmode)
-#endif
+  {
-    mflush();
-#ifndef macintosh
-    fputs("pause>",stderr);
-#else
-    fputs("pause>\n",stderr);
-#endif
-    uchar c = fgetc(stdin);
-    if (((c == '\003') || (c == 'C')) || (c == 'c'))
+    {
-      m2_end(4);
+    }
+  }
+}
 void monitor(char* s, int mode)
+{

Singular/febase.h

-                      rce7ba6
+                      r917fb5
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 /* $Id: febase.h,v 1.28 1999-04-17 14:58:46 obachman Exp $ */
+/* $Id: febase.h,v 1.29 1999-07-06 15:32:44 Singular Exp $ */
 /*
 * ABSTRACT: basic i/o
 …
 FILE *  feFopen(char *path, char *mode, char *where=NULL, int useWerror=FALSE);
-void    fePause(void);
 #ifndef __MWERKS__
 #ifdef HAVE_TCL

Singular/scanner.l

-                      rce7ba6
+                      r917fb5
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 /* $Id: scanner.l,v 1.16 1999-04-15 17:28:06 Singular Exp $ */
+/* $Id: scanner.l,v 1.17 1999-07-06 15:32:44 Singular Exp $ */
 #include <stdio.h>
 #include <string.h>
 …
                            yy_noeof=0;
+                         }
-pause[ \t\n]*[\.;]       { fePause(); }
 while                    { prompt_char='.';
                            blocknest = 0; yy_noeof = noeof_brace; BEGIN(brace);

Context Navigation

Changeset 917fb5 in git

Legend:

Singular/LIB/all.lib

Singular/LIB/deform.lib

Singular/LIB/general.lib

Singular/LIB/graphics.lib

Singular/LIB/hnoether.lib

Singular/LIB/inout.lib

Singular/LIB/invar.lib

Singular/LIB/jordan.lib

Singular/LIB/latex.lib

Singular/LIB/mondromy.lib

Singular/LIB/noethernormal.lib

Singular/LIB/normal.lib

Singular/LIB/paramet.lib

Singular/LIB/poly.lib

Singular/LIB/primdec.lib

Singular/LIB/solve.lib

Singular/LIB/solver.lib

Singular/LIB/spcurve.lib

Singular/LIB/standard.lib

Singular/LIB/surf.lib

Singular/LIB/tst.lib

Singular/febase.cc

Singular/febase.h

Singular/scanner.l

Download in other formats: