Changeset d2b2a7 for Singular/LIB – Singular

Singular/LIB/classify.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: classify.lib,v 1.22 1998-04-22 09:13:07 krueger Exp $
 ///////////////////////////////////////////////////////////////////////////////
 version  =       "$Id: classify.lib,v 1.22 1998-04-22 09:13:07 krueger Exp $";
+// $Id: classify.lib,v 1.23 1998-05-05 11:55:20 krueger Exp $
+///////////////////////////////////////////////////////////////////////////////
+version  =       "$Id: classify.lib,v 1.23 1998-05-05 11:55:20 krueger Exp $";
 info="
 LIBRARY:  classify.lib  PROCEDURES FOR THE ARNOLD-CLASSIFIER OF SINGULARITIES
 …
 proc classify (poly f_in)
 USAGE:    classify(f);  f=poly
+"USAGE:    classify(f);  f=poly
 COMPUTE:  normal form and singularity type of f with respect to right
           equivalence, as given in the book "Singularities of
           differentiables maps, Volume I" by V.I. Arnold, S.M. Gusein-Zade,
+          equivalence, as given in the book \"Singularities of
+          differentiables maps, Volume I\" by V.I. Arnold, S.M. Gusein-Zade,
           A.N. Varchenko
 RETURN:   normal form of f, of type poly
 REMARK:   This version of classify is only alpha. Please send bugs and
           comments to: "Kai Krueger" <krueger@mathematik.uni-kl.de>
+          comments to: \"Kai Krueger\" <krueger@mathematik.uni-kl.de>
           Be sure to have at least Singular version 0.9.3, better 1.0.1
           Updates can be found under:
 …
           with @, hence there should be no name conflicts
 EXAMPLE:  example classify; shows an example
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc tschirnhaus (poly f, poly x)
+USAGE:    tschirnhaus();
+"USAGE:    tschirnhaus();
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc morsesplit(poly f)
+"
 USAGE:    morsesplit(f);        f=poly
 RETURN:   Normal form of f in M^3 after application of the splitting lemma
 COMPUTE:  apply the splitting lemma (generalized Morse lemma) to f
 EXAMPLE:  example morsesplit; shows an example
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
+proc quickclass(poly f);
+proc quickclass(poly f)
+"
 USAGE:    quickclass(f);         f=poly
 RETURN:   Normal form of f in Arnold's list
 …
           no coordinate change is needed (see also proc 'milnorcode').
 EXAMPLE:  example quickclass; shows an example
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc milnorcode (poly f, list #)
 USAGE:    milnorcode(f[,e]); f=poly, e=int
+"USAGE:    milnorcode(f[,e]); f=poly, e=int
 RETURN:   intvec, coding the Hilbert function of the e-th Milnor algebra
           of f, i.e. of basering/(jacob(f)^e) (default e=1), according
           to proc Hcode
 EXAMPLE:  example milnorcode; shows an example
+"
+{
   int  e=1;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc Hcode (intvec v)
 USAGE:    Hcode(v); v=intvec
+"USAGE:    Hcode(v); v=intvec
 RETURN:   intvec, coding v according to the number of successive
           repetitions of an entry
 EXAMPLE:  example Hcode; shows an example.
+"
+{
   int    col, len, i, cur, cnt, maxcoef, nlen;
 …
 static
 proc parity  (int e)
+USAGE:    parity()
+"USAGE:    parity()
+"
+{
   int r = e/2;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc singularity(string typ, list #)
 USAGE:    singularity(t, l); t=string (name of singularity),
+"USAGE:    singularity(t, l); t=string (name of singularity),
           l=list of integers (index/indices of singularity)
 COMPUTE:  get the Singularity named by type t from the database.
 …
           index (indices) l
 EXAMPLE:  example singularity; shows an example
+"
+{
   poly a1, a2, a3, a4, f;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc RandomPolyK (int M, string Typ)
+USAGE:    RandomPolyK(M, Typ)
+"USAGE:    RandomPolyK(M, Typ)
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc debug_log (int level, list #)
 USAGE:    debug_log(level,li); level=int, li=comma separated "message" list
 COMPUTE:  print "messages" if level>=@DeBug.
+"USAGE:    debug_log(level,li); level=int, li=comma separated \"message\" list
+COMPUTE:  print \"messages\" if level>=@DeBug.
           useful for user-defined trace messages.
 EXAMPLE:  example debug_log; shows an example
 SEE ALSO: init_debug();
+"
+{
    int len = size(#);
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc init_debug(list #)
 USAGE:    init_debug([level]);  level=int
+"USAGE:    init_debug([level]);  level=int
 COMPUTE:  Set the global variable @DeBug to level. The variable @DeBug is
           used by the function debug_log(level, list of strings) to know
 …
           range from 0 to 10, higher values of n give more information.
 EXAMPLE:  example init_debug; shows an example
+"
+{
   int newDebug=0;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc basicinvariants(poly f)
 USAGE:    basicinvariants(f);   f = poly
+"USAGE:    basicinvariants(f);   f = poly
 COMPUTE:  Compute basic invariants of f: an upper bound d for the
           determinacy, the milnor number mu and the corank c of f
 RETURN:   intvec: d, mu, c
 EXAMPLE:  example basicinvariants; shows an example
+"
+{
   intvec v;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc corank(poly f)
 USAGE:    corank(f);   f=poly
+"USAGE:    corank(f);   f=poly
 RETURN:   the corank of the Hessian matrix of f, of type int
 REMARK:   corank(f) is the number of variables occuring in the residual
           singulartity after applying 'morsesplit' to f
 EXAMPLE:  example corank; shows an example
+"
+{
   matrix M = jacob(jacob(jet(f,2)));
 …
 static
 proc GetRf (poly fi, int n)
+USAGE:    GetRf();
+"USAGE:    GetRf();
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 static
 proc DecodeNormalFormString (string S_in)
+USAGE:    DecodeNormalFormString
+"USAGE:    DecodeNormalFormString
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc A_L
 USAGE:    A_L(f);         f=poly
           A_L("name");    type=string
+"USAGE:    A_L(f);         f=poly
+          A_L(\"name\");    type=string
 COMPUTE:  the normal form in Arnold's list of the singularity given either
           by a polynomial f or by its name.
 RETURN:   A_L(f): compute via 'milnorcode' the class of f and
           return the normal form of f found in the database.
           A_L("name"): Get the normal form from the database for
+          A_L(\"name\"): Get the normal form from the database for
           the singularity given by its name.
 EXAMPLE:  example A_L; shows an example
+"
+{
   // if trace/debug mode not set, do it!
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc normalform(string s_in)
 USAGE:    normalform(s);  s=string
+"USAGE:    normalform(s);  s=string
 RETURN:   Arnold's normal form of singularity with name s
 EXAMPLE:  example normalform; shows an example.
+"
+{
   string Typ;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc swap
 USAGE:    swap(a,b);
+"USAGE:    swap(a,b);
 RETURN:   b,a if b,a is the input (any type)
+"
+{
   return(#[2],#[1]);
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc Setring(int c, string name)
+USAGE:
+"USAGE:
+"
+{
   string s="ring "+name+"=0,(x(1.."+ string(c) +")),(c,ds);";
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc internalfunctions
 USAGE:   internalfunctions();
+"USAGE:   internalfunctions();
 RETURN:  nothing, display names of internal procedures of classify.lib
 EXAMPLE: no example
+"
 { "   Internal functions for the classification using Arnold's method,";
  "   the function numbers correspond to numbers in Arnold's classifier:";

Singular/LIB/deform.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: deform.lib,v 1.9 1998-05-03 14:09:50 obachman Exp $
+// $Id: deform.lib,v 1.10 1998-05-05 11:55:22 krueger Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
 //(bm, last modified 4/98)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: deform.lib,v 1.9 1998-05-03 14:09:50 obachman Exp $";
+version="$Id: deform.lib,v 1.10 1998-05-05 11:55:22 krueger Exp $";
 info="
 LIBRARY:  deform.lib       PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc versal (ideal Fo,list #)
 USAGE:   versal(Fo[,d,any]); Fo=ideal, d=int, any=list
+"USAGE:   versal(Fo[,d,any]); Fo=ideal, d=int, any=list
 COMUPTE: miniversal deformation of Fo up to degree d (default d=100),
 CREATE:  Rings (exported):
          'my'Px = extending the basering Po by new variables given by "A,B,.."
+         'my'Px = extending the basering Po by new variables given by \"A,B,..\"
                   (deformation parameters), returns as basering,
                   the new variables come before the old ones,
                   the ordering is the product between "ls" and "ord(Po)",
+                  the ordering is the product between \"ls\" and \"ord(Po)\",
          'my'Qx = Px/Fo extending Qo=Po/Fo,
          'my'So = being the embedding-ring of the versal base space,
          'my'Ox = Px/Js extending So/Js.   (default my="")
+         'my'Ox = Px/Js extending So/Js.   (default my=\"\")
       Matrices (in Px, exported):
          Js  = giving the versal base space (obstructions),
 …
       If d is defined (!=0), it computes up to degree d.
       If 'any' is defined and any[1] is no string, interactive version.
       Otherwise 'any' gives predefined strings: "my","param","order","out"
       ("my" prefix-string, "param" is a letter (e.g. "A")  for the name of
       first parameter or (e.g. "A(") for index parameter variables, "order"
       ordering string for ring extension), "out" name of output-file).
+      Otherwise 'any' gives predefined strings: \"my\",\"param\",\"order\",\"out\"
+      (\"my\" prefix-string, \"param\" is a letter (e.g. \"A\")  for the name of
+      first parameter or (e.g. \"A(\") for index parameter variables, \"order\"
+      ordering string for ring extension), \"out\" name of output-file).
 NOTE:   printlevel < 0        no output at all,
         printlevel >=0,1,2,.. informs you, what is going on;
         this proc uses 'execute'.
 EXAMPLE:example versal; shows an example
+"
+{
 //------- prepare -------------------------------------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc mod_versal(matrix Mo, ideal I, list #)
+"
 USAGE:   mod_versal(Mo,I[,d,any]); I=ideal, M=module, d=int, any =list
 COMUPTE: miniversal deformation of coker(Mo) over Qo=Po/Io, Po=basering;
 …
                    (deformation parameters),
                    the new variables come before the old ones,
                    the ordering is the product between "my_ord" and "ord(Po)",
+                   the ordering is the product between \"my_ord\" and \"ord(Po)\",
          'my'Qx  = Px/Io extending Qo (returns as basering),
          'my'Ox  = Px/(Io+Js) ring of the versal deformation of coker(Ms),
          'my'So  = embedding-ring of the versal base space.  (default 'my'="")
+         'my'So  = embedding-ring of the versal base space.  (default 'my'=\"\")
       Matrices (in Qx, exported):
          Js  = giving the versal base space (obstructions),
 …
       If d is defined (!=0), it computes up to degree d.
       If 'any' is defined and any[1] is no string, interactive version.
       Otherwise 'any' gives predefined strings:"my","param","order","out"
       ("my" prefix-string, "param" is a letter (e.g. "A")  for the name of
       first parameter or (e.g. "A(") for index parameter variables, "ord"
       ordering string for ringextension), "out" name of output-file).
+      Otherwise 'any' gives predefined strings:\"my\",\"param\",\"order\",\"out\"
+      (\"my\" prefix-string, \"param\" is a letter (e.g. \"A\")  for the name of
+      first parameter or (e.g. \"A(\") for index parameter variables, \"ord\"
+      ordering string for ringextension), \"out\" name of output-file).
 NOTE:   printlevel < 0        no output at all,
         printlevel >=0,1,2,.. informs you, what is going on,
         this proc uses 'execute'.
 EXAMPLE:example mod_versal; shows an example
+"
+{
 //------- prepare -------------------------------------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc kill_rings(list #)
 USAGE: kill_rings([string]);
+"USAGE: kill_rings([string]);
 Sub-procedure: kills exported rings of 'versal' and
                'mod_versal' with prefix 'string'
+"
+{
   string my,br;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc compute_ext(matrix Mo,int p)
+"
 Sub-procedure: obtain Ext1 and Ext2 and other objects used by mod_versal
+"
+{
    int    l,f0,f1,f2,f3,e1,e2,ok_ann;
 …
 //////////////////////////////////////////////////////////////////////////////
 proc get_rings(ideal Io,int e1,int switch, list #)
+"
 Sub-procedure: creating ring-extensions
+"
+{
    def Po = basering;
 …
+}
 //////////////////////////////////////////////////////////////////////////////
 proc get_inf_def(list #);
+proc get_inf_def(list #)
+"
 Sub-procedure: compute infinitesimal family of a module and its syzygies
                from a kbase of Ext1 and its lifts
+"
+{
   matrix Ms  = #[1];
 …
 //////////////////////////////////////////////////////////////////////////////
 proc lift_rel_kb (module N, module M, list #)
+"
 USAGE   lift_rel_kb(N,M[,kbaseM,p]);
 ASSUME  [p a monomial ] or the product of all variables
 …
         i.e. kbaseM*A = reduce(N,std(M))
 EXAMPLE example lift_rel_kb;  shows examples
+"
+{
   poly p = product(maxideal(1));
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc lift_kbase (N, M)
 USAGE:   lift_kbase(N,M); N,M=poly/ideal/vector/module
+"USAGE:   lift_kbase(N,M); N,M=poly/ideal/vector/module
 RETURN:  matrix A, coefficient matrix expressing N as linear combination of
          k-basis of M. Let the k-basis have k elements and size(N)=c columns.
 …
          block of the ordering is c or C
 EXAMPLE: example lift_kbase; shows an example
+"
+{
   return(lift_rel_kb(N,M));
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc interact1 ()
+"
 Sub_procedure: asking for and reading your input-strings
+"
+{
  string my = "@";
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc interact2 (matrix A, intvec col_vec, list #)
+"
 Sub-procedure: asking for and reading your input
+"
+{
   module B,C;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc negative_part(intvec iv)
+"
 RETURNS intvec of indices of jv having negative entries (or iv, if non)
+"
+{
    intvec jv;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc find_ord(matrix A, intvec w_vec)
+"
 Sub-proc: return martix ord(a_ij) with respect to weight_vec, or
 if A non-qh
+"
+{
   int @r = nrows(A);
 …
 //////////////////////////////////////////////////////////////////////////////////
 proc homog_test(intvec w_vec, matrix Mo, matrix A)
+"
 Sub proc: return relative weight string of columnes of A with respect
           to the given w_vec and to Mo, or "" if not qh
+          to the given w_vec and to Mo, or \"\" if not qh
     NOTE: * means weight is not determined
+"
+{
   int k,l;
 …
 //////////////////////////////////////////////////////////////////////////////////
 proc homog_t(intvec d_vec, matrix Fo, matrix A)
+"
 Sub-procedure: Computing relative (with respect to flatten(Fo)) weight_vec
                of columnes of A (return zero if Fo or A not qh)
+"
+{
    Fo = matrix(Fo,nrows(A),1);

Singular/LIB/elim.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: elim.lib,v 1.3 1998-04-03 22:47:00 krueger Exp $
+// $Id: elim.lib,v 1.4 1998-05-05 11:55:22 krueger Exp $
 // system("random",787422842);
 // (GMG, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: elim.lib,v 1.3 1998-04-03 22:47:00 krueger Exp $";
+version="$Id: elim.lib,v 1.4 1998-05-05 11:55:22 krueger Exp $";
 info="
 LIBRARY:  elim.lib      PROCEDURES FOR ELIMINATIOM, SATURATION AND BLOWING UP
 …
 proc blowup0 (ideal j,list #)
 USAGE:   blowup0(j[,s1,s2]); j ideal, s1,s2 nonempty strings
+"USAGE:   blowup0(j[,s1,s2]); j ideal, s1,s2 nonempty strings
 CREATE:  Create a presentation of the blowup ring of j
 RETURN:  no return value
 NOTE:    s1 and s2 are used to give names to the blownup ring and the blownup
          ideal (default: s1="j", s2="A")
          Assume R = char,x(1..n),ord is the basering of j, and s1="j", s2="A"
+         ideal (default: s1=\"j\", s2=\"A\")
+         Assume R = char,x(1..n),ord is the basering of j, and s1=\"j\", s2=\"A\"
          then the procedure creates a new ring with name Bl_jR
          (equal to R[A,B,...])
 …
          with k=ncols(j) new variables A,B,... and ordering wp(d1..dk) if j is
          homogeneous with deg(j[i])=di resp. dp otherwise for these vars.
          If k>26 or size(s2)>1, say s2="A()", the new vars are A(1),...,A(k).
+         If k>26 or size(s2)>1, say s2=\"A()\", the new vars are A(1),...,A(k).
          Let j_ be the kernel of the ring map Bl_jR -> R defined by A(i)->j[i],
          x(i)->x(i), then the quotient ring Bl_jR/j_ is the blowup ring of j
 …
 DISPLAY: printlevel >=0: explain created objects (default)
 EXAMPLE: example blowup0; shows examples
+{
+"{
    string bsr = nameof(basering);
    def br = basering;
 …
 proc elim (id, int n, int m)
 USAGE:   elim(id,n,m);  id ideal/module, n,m integers
+"USAGE:   elim(id,n,m);  id ideal/module, n,m integers
 RETURNS: ideal/module obtained from id by eliminating variables n..m
 NOTE:    no special monomial ordering is required, result is a SB with
 …
          This proc uses 'execute' or calls a procedure using 'execute'.
 EXAMPLE: example elim; shows examples
+"
+{
 //---- get variables to be eliminated and create string for new ordering ------
 …
 proc elim1 (id, poly vars)
 USAGE:   elim1(id,poly); id ideal/module, poly=product of vars to be eliminated
+"USAGE:   elim1(id,poly); id ideal/module, poly=product of vars to be eliminated
 RETURN:  ideal/module obtained from id by eliminating vars occuring in poly
 NOTE:    no special monomial ordering is required, result is a SB with
 …
          This proc uses 'execute' or calls a procedure using 'execute'.
 EXAMPLE: example elim1; shows examples
+"
+{
 //---- get variables to be eliminated and create string for new ordering ------
 …
 proc nselect (id, int n, list#)
 USAGE:   nselect(id,n[,m]); id a module or ideal, n, m integers
+"USAGE:   nselect(id,n[,m]); id a module or ideal, n, m integers
 RETURN:  generators of id not containing the variable n [up to m]
 EXAMPLE: example nselect; shows examples
+{
+"{
    int j,k;
    if( size(#)==0 ) { #[1]=n; }
 …
 proc sat (id, ideal j)
 USAGE:   sat(id,j);  id=ideal/module, j=ideal
+"USAGE:   sat(id,j);  id=ideal/module, j=ideal
 RETURN:  list of an ideal/module [1] and an integer [2]:
          [1] = saturation of id with respect to j (= union_(k=1...) of id:j^k)
 …
 DISPLAY: saturation exponent during computation if printlevel >=1
 EXAMPLE: example sat; shows an example
+{
+"{
    int ii,kk;
    def i=id;
 …
 proc select (id, int n, list#)
 USAGE:   select(id,n[,m]); id ideal/module, n, m integers
+"USAGE:   select(id,n[,m]); id ideal/module, n, m integers
 RETURN:  generators of id containing the variable n [up to m]
 EXAMPLE: example select; shows examples
+{
+"{
    if( size(#)==0 ) { #[1]=n; }
    int j,k;

Singular/LIB/factor.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: factor.lib,v 1.4 1998-04-03 22:47:01 krueger Exp $
+// $Id: factor.lib,v 1.5 1998-05-05 11:55:23 krueger Exp $
 //(RS)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: factor.lib,v 1.4 1998-04-03 22:47:01 krueger Exp $";
+version="$Id: factor.lib,v 1.5 1998-05-05 11:55:23 krueger Exp $";
 info="
 LIBRARY:  factor.lib    PROCEDURES FOR CALLING THE REDUCE FACTORIZER
 …
 proc delete_dollar ( string s )
 USAGE:   delete_dollar(s);  s = string
+"USAGE:   delete_dollar(s);  s = string
 RETURN:  string, with '$' replaced by ' '
 EXAMPLE: example delete_dollar; shows an example
+"
+{
    while( s[size(s)]=="$" and size(s)!=1 ) { s=s[1,size(s)-1]; }
 …
 proc reduce_factor ( poly f )
 USAGE:   reduce_factor(f);  f = poly
+"USAGE:   reduce_factor(f);  f = poly
 RETURN:  list, the factors of f
 NOTE:    due to a limitation of REDUCE, multivariate polynomials can only
 …
              This proc runs under UNIX only
 EXAMPLE: example reduce_factor; shows an example
+"
+{
   string pid = string( system( "pid" ) );

Singular/LIB/fastsolv.lib

-                      r4996f52
+                      rd2b2a7
 //
 version="$Id: fastsolv.lib,v 1.2 1998-04-03 22:47:01 krueger Exp $";
+version="$Id: fastsolv.lib,v 1.3 1998-05-05 11:55:24 krueger Exp $";
 info="";
 …
 proc Tsimplify
 USAGE:    simplify(id,n);  id ideal, n integer
+"USAGE:    simplify(id,n);  id ideal, n integer
 RETURNS:  list of two ideals the first containing the simplified
           elements, the second the variables which already have
 …
           n+1,... is not supported
 EXAMPLE:  example simplify; shows an example
+"
+{
   def bsr=basering;
 …
 proc simplifyInBadRings
 USAGE:    simplify(id,n);  id ideal, n product of the variables
+"USAGE:    simplify(id,n);  id ideal, n product of the variables
           to be eliminated later
 RETURNS:  list of two ideals the first containing the simplified
 …
           been eliminated
 EXAMPLE:  example simplify; shows an example
+"
+{
   int @i,@j;
 …
 proc fastElim
 USAGE:    fastelim(id,v);  id ideal, v Product of variables to
+"USAGE:    fastelim(id,v);  id ideal, v Product of variables to
           be eliminated.
 RETURNS:  list of two ideals the first containing the simplified
 …
           been eliminated
 EXAMPLE:  example fastElim; shows an example.
+{
+"{
    string @oldgnir = nameof(basering);  // Namen des alten Baserings merken
    string @varnames;
 …
 proc valvars
+"
 USAGE:    valvars(id, [n1, [m, [n2]]]); id (poly|ideal|vector|module);
                                         m monom; n1,n2 int
 …
           contains more monomials than that of y.
 EXAMPLE:  example valvars; shows an example
+"
+{
   int     @order1, @order2,     // order of vars not to elim resp. to elim

Singular/LIB/finvar.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: finvar.lib,v 1.9 1998-05-03 11:57:37 obachman Exp $
+// $Id: finvar.lib,v 1.10 1998-05-05 11:55:25 krueger Exp $
 // author: Agnes Eileen Heydtmann, email:agnes@math.uni-sb.de
 // last change: 3.5.98
 //////////////////////////////////////////////////////////////////////////////
 version="$Id: finvar.lib,v 1.9 1998-05-03 11:57:37 obachman Exp $"
+version="$Id: finvar.lib,v 1.10 1998-05-05 11:55:25 krueger Exp $"
 info="
 LIBRARY:  finvar.lib       LIBRARY TO CALCULATE INVARIANT RINGS & MORE
 …
 proc cyclotomic (int i)
 USAGE:   cyclotomic(i);
+"USAGE:   cyclotomic(i);
          i: an <int> > 0
 RETURNS: the i-th cyclotomic polynomial (type <poly>) as one in the first ring
 …
 THEORY:  x^i-1 is divided by the j-th cyclotomic polynomial where j takes on the
          value of proper divisors of i
+"
 { if (i<=0)
   { "ERROR:   the input should be > 0.";
 …
 proc group_reynolds (list #)
 USAGE:   group_reynolds(G1,G2,...[,v]);
+"USAGE:   group_reynolds(G1,G2,...[,v]);
          G1,G2,...: nxn <matrices> generating a finite matrix group, v: an
          optional <int>
 …
          the Reynolds operator is made up is generated. They are stored in the
          rows of the first return value.
+"
 { int ch=char(basering);               // the existance of the Reynolds operator
                                        // is dependent on the characteristic of
 …
 proc molien (list #)
 USAGE:   molien(G1,G2,...[,ringname,lcm,flags]);
+"USAGE:   molien(G1,G2,...[,ringname,lcm,flags]);
          G1,G2,...: nxn <matrices> generating a finite matrix group, ringname:
          a <string> giving a name for a new ring of characteristic 0 for the
 …
          enumerator and denominator of the expanded version where common factors
          have been canceled.
+"
 { def br=basering;                     // the Molien series depends on the
   int ch=char(br);                     // characteristic of the coefficient
 …
 proc reynolds_molien (list #)
 USAGE:   reynolds_molien(G1,G2,...[,ringname,flags]);
+"USAGE:   reynolds_molien(G1,G2,...[,ringname,flags]);
          G1,G2,...: nxn <matrices> generating a finite matrix group, ringname:
          a <string> giving a name for a new ring of characteristic 0 for the
 …
          modular case). The returned matrix gives enumerator and denominator of
          the expanded version where common factors have been canceled.
+"
 { def br=basering;                     // the Molien series depends on the
   int ch=char(br);                     // characteristic of the coefficient
 …
 proc partial_molien (matrix M, int n, list #)
 USAGE:   partial_molien(M,n[,p]);
+"USAGE:   partial_molien(M,n[,p]);
          M: a 1x2 <matrix>, n: an <int> indicating  number of terms in the
          expansion, p: an optional <poly>
 …
             (a1-b1)x+b1(a1-b1)x^2+...
 EXAMPLE: example partial_molien; shows an example
+"
 { poly A(2);                           // A(2) will contain the return value of
                                        // the intermediate result
 …
 proc evaluate_reynolds (matrix REY, ideal I)
 USAGE:   evaluate_reynolds(REY,I);
+"USAGE:   evaluate_reynolds(REY,I);
          REY: a <matrix> representing the Reynolds operator, I: an arbitrary
          <ideal>
 …
 THEORY:  REY has been constructed in such a way that each row serves as a ring
          mapping of which the Reynolds operator is made up.
+"
 { def br=basering;
   int n=nvars(br);
 …
 proc invariant_basis (int g,list #)
 USAGE:   invariant_basis(g,G1,G2,...);
+"USAGE:   invariant_basis(g,G1,G2,...);
          g: an <int> indicating of which degree (>0) the homogeneous basis
          shoud be, G1,G2,...: <matrices> generating a finite matrix group
 …
          system of linear equations is created. It is solved by computing
          syzygies.
+"
 { if (g<=0)
   { "ERROR:   the first parameter should be > 0";
 …
 proc invariant_basis_reynolds (matrix REY,int d,list #)
 USAGE:   invariant_basis_reynolds(REY,d[,flags]);
+"USAGE:   invariant_basis_reynolds(REY,d[,flags]);
          REY: a <matrix> representing the Reynolds operator, d: an <int>
          indicating of which degree (>0) the homogeneous basis shoud be, flags:
 …
          operator. A linearly independent set is generated with the help of
          minbase.
+"
+{
  //---------------------- checking that the input is ok -----------------------
 …
 proc primary_char0 (matrix REY,matrix M,list #)
 USAGE:   primary_char0(REY,M[,v]);
+"USAGE:   primary_char0(REY,M[,v]);
          REY: a <matrix> representing the Reynolds operator, M: a 1x2 <matrix>
          representing the Molien series, v: an optional <int>
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC).
+"
 { degBound=0;
   if (char(basering)<>0)
 …
 proc primary_charp (matrix REY,string ring_name,list #)
 USAGE:   primary_charp(REY,ringname[,v]);
+"USAGE:   primary_charp(REY,ringname[,v]);
          REY: a <matrix> representing the Reynolds operator, ringname: a
          <string> giving the name of a ring where the Molien series is stored,
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC).
+"
 { degBound=0;
 // ---------------- checking input and setting verbose mode -------------------
 …
 proc primary_char0_no_molien (matrix REY, list #)
 USAGE:   primary_char0_no_molien(REY[,v]);
+"USAGE:   primary_char0_no_molien(REY[,v]);
          REY: a <matrix> representing the Reynolds operator, v: an optional
          <int>
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC).
+"
 { degBound=0;
  //-------------- checking input and setting verbose mode ---------------------
 …
 proc primary_charp_no_molien (matrix REY, list #)
 USAGE:   primary_charp_no_molien(REY[,v]);
+"USAGE:   primary_charp_no_molien(REY[,v]);
          REY: a <matrix> representing the Reynolds operator, v: an optional
          <int>
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC).
+"
 { degBound=0;
  //----------------- checking input and setting verbose mode ------------------
 …
 proc primary_charp_without (list #)
 USAGE:   primary_charp_without(G1,G2,...[,v]);
+"USAGE:   primary_charp_without(G1,G2,...[,v]);
          G1,G2,...: <matrices> generating a finite matrix group, v: an optional
          <int>
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC). No Reynolds
          operator or Molien series is used.
+"
 { degBound=0;
  //--------------------- checking input and setting verbose mode --------------
 …
 proc primary_invariants (list #)
 USAGE:   primary_invariants(G1,G2,...[,flags]);
+"USAGE:   primary_invariants(G1,G2,...[,flags]);
          G1,G2,...: <matrices> generating a finite matrix group, flags: an
          optional <intvec> with three entries, if the first one equals 0 (also
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC).
+"
+{
  // ----------------- checking input and setting flags ------------------------
 …
 proc primary_char0_random (matrix REY,matrix M,int max,list #)
 USAGE:   primary_char0_random(REY,M,r[,v]);
+"USAGE:   primary_char0_random(REY,M,r[,v]);
          REY: a <matrix> representing the Reynolds operator, M: a 1x2 <matrix>
          representing the Molien series, r: an <int> where -|r| to |r| is the
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC).
+"
 { degBound=0;
   if (char(basering)<>0)
 …
 proc primary_charp_random (matrix REY,string ring_name,int max,list #)
 USAGE:   primary_charp_random(REY,ringname,r[,v]);
+"USAGE:   primary_charp_random(REY,ringname,r[,v]);
          REY: a <matrix> representing the Reynolds operator, ringname: a
          <string> giving the name of a ring where the Molien series is stored,
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC).
+"
 { degBound=0;
  // ---------------- checking input and setting verbose mode ------------------
 …
 proc primary_char0_no_molien_random (matrix REY, int max, list #)
 USAGE:   primary_char0_no_molien_random(REY,r[,v]);
+"USAGE:   primary_char0_no_molien_random(REY,r[,v]);
          REY: a <matrix> representing the Reynolds operator, r: an <int> where
          -|r| to |r| is the range of coefficients of the random combinations of
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC).
+"
 { degBound=0;
  //-------------- checking input and setting verbose mode ---------------------
 …
 proc primary_charp_no_molien_random (matrix REY, int max, list #)
 USAGE:   primary_charp_no_molien_random(REY,r[,v]);
+"USAGE:   primary_charp_no_molien_random(REY,r[,v]);
          REY: a <matrix> representing the Reynolds operator, r: an <int> where
          -|r| to |r| is the range of coefficients of the random combinations of
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC).
+"
 { degBound=0;
  //----------------- checking input and setting verbose mode ------------------
 …
 proc primary_charp_without_random (list #)
 USAGE:   primary_charp_without_random(G1,G2,...,r[,v]);
+"USAGE:   primary_charp_without_random(G1,G2,...,r[,v]);
          G1,G2,...: <matrices> generating a finite matrix group, r: an <int>
          where -|r| to |r| is the range of coefficients of the random
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC). No Reynolds operator or Molien series is used.
+"
 { degBound=0;
  //--------------------- checking input and setting verbose mode --------------
 …
 proc primary_invariants_random (list #)
 USAGE:   primary_invariants_random(G1,G2,...,r[,flags]);
+"USAGE:   primary_invariants_random(G1,G2,...,r[,flags]);
          G1,G2,...: <matrices> generating a finite matrix group, r: an <int>
          where -|r| to |r| is the range of coefficients of the random
 …
          linear combinations are chosen as primary invariants that lower the
          dimension of the ideal generated by the previously found invariants
          (see paper "Generating a Noetherian Normalization of the Invariant Ring
          of a Finite Group" by Decker, Heydtmann, Schreyer (1997) to appear in
+         (see paper \"Generating a Noetherian Normalization of the Invariant Ring
+         of a Finite Group\" by Decker, Heydtmann, Schreyer (1997) to appear in
          JSC).
+"
+{
  // ----------------- checking input and setting flags ------------------------
 …
 proc power_products(intvec deg_vec,int d)
 USAGE:   power_products(dv,d);
+"USAGE:   power_products(dv,d);
          dv: an <intvec> giving the degrees of homogeneous polynomials, d: the
          degree of the desired power products
 …
          of the powers is then homogeneous of degree d.
 EXAMPLE: example power_products; gives an example
+"
 { ring R=0,x,dp;
   if (d<=0)
 …
 proc secondary_char0 (matrix P, matrix REY, matrix M, list #)
 USAGE:   secondary_char0(P,REY,M[,v]);
+"USAGE:   secondary_char0(P,REY,M[,v]);
          P: a 1xn <matrix> with primary invariants, REY: a gxn <matrix>
          representing the Reynolds operator, M: a 1x2 <matrix> giving enumerator
 …
          to invariants with the Reynolds operator and using these images or
          their power products such that they are linearly independent modulo the
+         primary invariants (see paper "Some Algorithms in Invariant Theory of
+         Finite Groups" by Kemper and Steel (1997)).
+         primary invariants (see paper \"Some Algorithms in Invariant Theory of
+         Finite Groups\" by Kemper and Steel (1997)).
+"
 { def br=basering;
   degBound=0;
 …
 proc secondary_charp (matrix P, matrix REY, string ring_name, list #)
 USAGE:   secondary_charp(P,REY,ringname[,v]);
+"USAGE:   secondary_charp(P,REY,ringname[,v]);
          P: a 1xn <matrix> with primary invariants, REY: a gxn <matrix>
          representing the Reynolds operator, ringname: a <string> giving the
 …
          to invariants with the Reynolds operator and using these images or
          their power products such that they are linearly independent modulo the
+         primary invariants (see paper "Some Algorithms in Invariant Theory of
+         Finite Groups" by Kemper and Steel (1997)).
+         primary invariants (see paper \"Some Algorithms in Invariant Theory of
+         Finite Groups\" by Kemper and Steel (1997)).
+"
 { def br=basering;
   degBound=0;
 …
 proc secondary_no_molien (matrix P, matrix REY, list #)
 USAGE:   secondary_no_molien(P,REY[,deg_vec,v]);
+"USAGE:   secondary_no_molien(P,REY[,deg_vec,v]);
          P: a 1xn <matrix> with primary invariants, REY: a gxn <matrix>
          representing the Reynolds operator, deg_vec: an optional <intvec>
 …
          to invariants with the Reynolds operator and using these images as
          candidates for secondary invariants.
+"
 { int i;
   degBound=0;
 …
 proc secondary_with_irreducible_ones_no_molien (matrix P, matrix REY, list #)
 USAGE:   secondary_with_irreducible_ones_no_molien(P,REY[,v]);
+"USAGE:   secondary_with_irreducible_ones_no_molien(P,REY[,v]);
          P: a 1xn <matrix> with primary invariants, REY: a gxn <matrix>
          representing the Reynolds operator, v: an optional <int>
 …
          to invariants with the Reynolds operator and using these images or
          their power products such that they are linearly independent modulo the
+         primary invariants (see paper "Some Algorithms in Invariant Theory of
+         Finite Groups" by Kemper and Steel (1997)).
+         primary invariants (see paper \"Some Algorithms in Invariant Theory of
+         Finite Groups\" by Kemper and Steel (1997)).
+"
 { int i;
   degBound=0;
 …
 proc secondary_not_cohen_macaulay (matrix P, list #)
 USAGE:   secondary_not_cohen_macaulay(P,G1,G2,...[,v]);
+"USAGE:   secondary_not_cohen_macaulay(P,G1,G2,...[,v]);
          P: a 1xn <matrix> with primary invariants, G1,G2,...: nxn <matrices>
          generating a finite matrix group, v: an optional <int>
 …
 DISPLAY: information if v does not equal 0
 EXAMPLE: example secondary_not_cohen_macaulay; shows an example
 THEORY:  The secondary invariants are generated following "Generating Invariant
          Rings of Finite Groups over Arbitrary Fields" by Kemper (1996, to
+THEORY:  The secondary invariants are generated following \"Generating Invariant
+         Rings of Finite Groups over Arbitrary Fields\" by Kemper (1996, to
          appear in JSC).
+"
 { int i, j;
   degBound=0;
 …
 proc invariant_ring (list #)
 USAGE:   invariant_ring(G1,G2,...[,flags]);
+"USAGE:   invariant_ring(G1,G2,...[,flags]);
          G1,G2,...: <matrices> generating a finite matrix group, flags: an
          optional <intvec> with three entries: if the first one equals 0, the
 …
 THEORY:  Bases of homogeneous invariants are generated successively and those
          are chosen as primary invariants that lower the dimension of the ideal
          generated by the previously found invariants (see paper "Generating a
          Noetherian Normalization of the Invariant Ring of a Finite Group" by
+         generated by the previously found invariants (see paper \"Generating a
+         Noetherian Normalization of the Invariant Ring of a Finite Group\" by
          Decker, Heydtmann, Schreyer (1997) to appear in JSC). In the
          non-modular case secondary invariants are calculated by finding a
 …
          invariants, mapping to invariants with the Reynolds operator and using
          those or their power products such that they are linearly independent
          modulo the primary invariants (see paper "Some Algorithms in Invariant
          Theory of Finite Groups" by Kemper and Steel (1997)). In the modular
          case they are generated according to "Generating Invariant Rings of
          Finite Groups over Arbitrary Fields" by Kemper (1996, to appear in
+         modulo the primary invariants (see paper \"Some Algorithms in Invariant
+         Theory of Finite Groups\" by Kemper and Steel (1997)). In the modular
+         case they are generated according to \"Generating Invariant Rings of
+         Finite Groups over Arbitrary Fields\" by Kemper (1996, to appear in
          JSC).
+"
 { if (size(#)==0)
   { "ERROR:   There are no generators given.";
 …
 proc invariant_ring_random (list #)
 USAGE:   invariant_ring_random(G1,G2,...,r[,flags]);
+"USAGE:   invariant_ring_random(G1,G2,...,r[,flags]);
          G1,G2,...: <matrices> generating a finite matrix group, r: an <int>
          where -|r| to |r| is the range of coefficients of random
 …
          hopefully they lower the dimension of the previously found primary
          invariants by the right amount.
+"
 { if (size(#)<2)
   { "ERROR:   There are too few parameters.";
 …
 proc algebra_containment (poly p, matrix A)
 USAGE:   algebra_containment(p,A);
+"USAGE:   algebra_containment(p,A);
          p: arbitrary <poly>, A: a 1xm <matrix> giving generators of a
          subalgebra of the basering
 …
          to a polynomial only in the y(i) <=> p is contained in the subring
          generated by the polynomials in A.
+"
 { degBound=0;
   if (nrows(A)==1)
 …
 proc module_containment(poly p, matrix P, matrix S)
 USAGE:   module_containment(p,P,S);
+"USAGE:   module_containment(p,P,S);
          p: arbitrary <poly>, P: a 1xn <matrix> giving generators of an algebra,
          S: a 1xt <matrix> giving generators of a module over the algebra
 …
          again. p reduces to a polynomial only in the y(j) and z(i) linear in
          the z(i)) <=> p is contained in the module.
+"
 { def br=basering;
   degBound=0;
 …
 proc orbit_variety (matrix F,string newring)
 USAGE:   orbit_variety(F,s);
+"USAGE:   orbit_variety(F,s);
          F: a 1xm <matrix> defing an invariant ring, s: a <string> giving the
          name for a new ring
 …
          calculated, then the variables of the original ring are eliminated and
          the polynomials that are left over define the orbit variety
+"
 { if (newring=="")
   { "ERROR:   the second parameter may not be an empty <string>";
 …
 proc relative_orbit_variety(ideal I,matrix F,string newring)
 USAGE:   relative_orbit_variety(I,F,s);
+"USAGE:   relative_orbit_variety(I,F,s);
          I: an <ideal> invariant under the action of a group, F: a 1xm
          <matrix> defining the invariant ring of this group, s: a <string>
 …
          the polynomials that are left over define thecrelative orbit variety
          with respect to I.
+"
 { if (newring=="")
   { "ERROR:   the third parameter may not be empty a <string>";
 …
 proc image_of_variety(ideal I,matrix F)
 USAGE:   image_of_variety(I,F);
+"USAGE:   image_of_variety(I,F);
          I: an arbitray <ideal>, F: a 1xm <matrix> defining an invariant ring
          of a some matrix group
 …
          invariant ring. This ideal in the original variables defines the image
          of the variety defined by I
+"
 { if (nrows(F)==1)
   { def br=basering;

Singular/LIB/general.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: general.lib,v 1.6 1998-04-23 17:09:20 Singular Exp $
+// $Id: general.lib,v 1.7 1998-05-05 11:55:27 krueger Exp $
 //system("random",787422842);
 //(GMG, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: general.lib,v 1.6 1998-04-23 17:09:20 Singular Exp $";
+version="$Id: general.lib,v 1.7 1998-05-05 11:55:27 krueger Exp $";
 info="
 LIBRARY:  general.lib   PROCEDURES OF GENERAL TYPE
 …
 proc A_Z (string s,int n)
 USAGE:   A_Z("a",n);  a any letter, n integer (-26<= n <=26, !=0)
+"USAGE:   A_Z(\"a\",n);  a any letter, n integer (-26<= n <=26, !=0)
 RETURN:  string of n small (if a is small) or capital (if a is capital)
          letters, comma seperated, beginning with a, in alphabetical
          order (or revers alphabetical order if n<0)
 EXAMPLE: example A_Z; shows an example
+"
+{
   if ( n>=-26 and n<=26 and n!=0 )
 …
 proc binomial (int n, int k, list #)
 USAGE:   binomial(n,k[,p/s]); n,k,p integers, s string
+"USAGE:   binomial(n,k[,p/s]); n,k,p integers, s string
 RETURN:  binomial(n,k);    binomial coefficient n choose k of type int
                            (machine integer, limited size! )
 …
                            in char of basering if a basering is defined
 EXAMPLE: example binomial; shows an example
+"
+{
    if ( size(#)==0 ) { int rr=1; }
 …
 proc factorial (int n, list #)
 USAGE:   factorial(n[,string]);  n integer
+"USAGE:   factorial(n[,string]);  n integer
 RETURN:  factorial(n); string of n! in char 0
          factorial(n,s);  n! of type number (s any string), computed in char of
          basering if a basering is defined
 EXAMPLE: example factorial; shows an example
+"
+{
    if ( size(#)==0 ) { ring R = 0,x,dp; poly r=1; }
 …
 proc fibonacci (int n, list #)
 USAGE:   fibonacci(n[,string]);  (n integer)
+"USAGE:   fibonacci(n[,string]);  (n integer)
 RETURN:  fibonacci(n); string of nth Fibonacci number,
             f(0)=f(1)=1, f(i+1)=f(i-1)+f(i)
 …
          computed in characteristic of basering if a basering is defined
 EXAMPLE: example fibonacci; shows an example
+"
+{
    if ( size(#)==0 ) { ring fibo = 0,x,dp; number f=1; }
 …
 proc kmemory ()
 USAGE:   kmemory();
+"USAGE:   kmemory();
 RETURN:  memory used by active variables, of type int (in kilobyte)
 EXAMPLE: example kmemory; shows an example
+"
+{
   if ( voice==2 ) { "// memory used by active variables (kilobyte):"; }
 …
 proc killall
 USAGE:   killall(); (no parameter)
          killall("type_name");
          killall("not", "type_name");
+"USAGE:   killall(); (no parameter)
+         killall(\"type_name\");
+         killall(\"not\", \"type_name\");
 COMPUTE: killall(); kills all user-defined variables but not loaded procedures
          killall("type_name"); kills all user-defined variables, of type "type_name"
          killall("not", "type_name"); kills all user-defined
          variables, except those of type "type_name" and except loaded procedures
+         killall(\"type_name\"); kills all user-defined variables, of type \"type_name\"
+         killall(\"not\", \"type_name\"); kills all user-defined
+         variables, except those of type \"type_name\" and except loaded procedures
 RETURN:  no return value
 NOTE:    killall should never be used inside a procedure
 EXAMPLE: example killall; shows an example AND KILLS ALL YOUR VARIABLES
+"
+{
    list L=names(); int joni=size(L);
 …
 proc number_e (int n)
 USAGE:   number_e(n);  n integer
+"USAGE:   number_e(n);  n integer
 COMPUTE: exp(1) up to n decimal digits (no rounding)
          by A.H.J. Sale's algorithm
 …
          display its decimal format
 EXAMPLE: example number_e; shows an example
+"
+{
    int i,m,s,t;
 …
 proc number_pi (int n)
 USAGE:   number_pi(n);  n positive integer
+"USAGE:   number_pi(n);  n positive integer
 COMPUTE: pi (area of unit circle) up to n decimal digits (no rounding)
          by algorithm of S. Rabinowitz
 …
          its decimal format
 EXAMPLE: example number_pi; shows an example
+"
+{
    int i,m,t,e,q,N;
 …
 proc primes (int n, int m)
 USAGE:   primes(n,m);  n,m integers
+"USAGE:   primes(n,m);  n,m integers
 RETURN:  intvec, consisting of all primes p, prime(n)<=p<=m, in increasing
          order if n<=m, resp. prime(m)<=p<=n, in decreasing order if m<n
 NOTE:    prime(n); returns the biggest prime number <= n (if n>=2, else 2)
 EXAMPLE: example primes; shows an example
+"
 {  int change;
    if ( n>m ) { change=n; n=m ; m=change; change=1; }
 …
 proc product (id, list #)
 USAGE:    product(id[,v]); id=ideal/vector/module/matrix
+"USAGE:    product(id[,v]); id=ideal/vector/module/matrix
           resp.id=intvec/intmat, v=intvec (e.g. v=1..n, n=integer)
 RETURN:   poly resp. int which is the product of all entries of id, with index
 …
           identified with corresponding matrix M (columns of M generate m)
 EXAMPLE:  example product; shows an example
+"
+{
    int n,j;
 …
 proc ringweights (r)
 USAGE:   ringweights(r); r ring
+"USAGE:   ringweights(r); r ring
 RETURN:  intvec of weights of ring variables. If, say, x(1),...,x(n) are the
          variables of the ring r, in this order, the resulting intvec is
 …
          the resulting intvec is 1,...,1
 EXAMPLE: example ringweights; shows an example
+"
+{
    int i; intvec v; setring r;
 …
 proc sort (id, list #)
 USAGE:   sort(id[v,o,n]); id=ideal/module/intvec/list (of intvec's or int's)
+"USAGE:   sort(id[v,o,n]); id=ideal/module/intvec/list (of intvec's or int's)
          sort may be called with 1, 2 or 3 arguments in the following way:
          -  sort(id[v,n]); v=intvec, n=integer,
 …
          Zero generators of ideal/module are deleted
 EXAMPLE: example sort; shows an example
+"
+{
    int ii,jj,s,n = 0,0,1,0;
 …
 proc sum (id, list #)
 USAGE:    sum(id[,v]); id=ideal/vector/module/matrix resp. id=intvec/intmat,
+"USAGE:    sum(id[,v]); id=ideal/vector/module/matrix resp. id=intvec/intmat,
                        v=intvec (e.g. v=1..n, n=integer)
 RETURN:   poly resp. int which is the sum of all entries of id, with index
 …
           identified with corresponding matrix M (columns of M generate m)
 EXAMPLE:  example sum; shows an example
+"
+{
    if( typeof(id)=="poly" or typeof(id)=="ideal" or typeof(id)=="vector"
 …
 proc which (command)
 USAGE:    which(command); command = string expression
+"USAGE:    which(command); command = string expression
 RETURN:   Absolute pathname of command, if found in search path.
           Empty string, otherwise.
 NOTE:     Based on the Unix command 'which'.
 EXAMPLE:  example which; shows an example
+"
+{
    int rs;

Singular/LIB/hnoether.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: hnoether.lib,v 1.5 1998-04-23 13:23:23 obachman Exp $
+// $Id: hnoether.lib,v 1.6 1998-05-05 11:55:27 krueger Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
 // last change:           26.03.98
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: hnoether.lib,v 1.5 1998-04-23 13:23:23 obachman Exp $";
+version="$Id: hnoether.lib,v 1.6 1998-05-05 11:55:27 krueger Exp $";
 info="
 LIBRARY:  hnoether.lib   PROCEDURES FOR THE HAMBURGER-NOETHER-DEVELOPMENT
 …
 proc getnm (poly f)
 USAGE:   getnm(f); f polynomial in x,y
+"USAGE:   getnm(f); f polynomial in x,y
 ASSUME:  basering = ...,(x,y),ls;  or ds
 RETURN:  intvec(n,m) : (0,n) is the intersection point of the Newton
 …
          m=-1 if this point doesn't exist
 EXAMPLE: example getnm; shows an example
+"
+{
  // wir gehen davon aus, dass die Prozedur von develop aufgerufen wurde, also
 …
 proc leit (poly f, int n, int m)
 // leit(poly f, int n, int m) returns all monomials on the line
+"// leit(poly f, int n, int m) returns all monomials on the line
 // from (0,n) to (m,0) in the Newton diagram
+"
+{
  return(jet(f,m*n,intvec(n,m))-jet(f,m*n-1,intvec(n,m)))
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc testreducible (poly f, int n, int m)
 // testreducible(poly f,int n,int m) returns true if there are points in the
+"// testreducible(poly f,int n,int m) returns true if there are points in the
 // Newton diagram below the line (0,n)-(m,0)
+"
+{
  return(size(jet(f,m*n-1,intvec(n,m))) != 0)
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc T_Transform (poly f, int Q, int N)
+// returns f(y,xy^Q)/y^NQ
+"// returns f(y,xy^Q)/y^NQ
+"
+{
  map T = basering,y,x*y^Q;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc T1_Transform (poly f, number d, int M)
+// returns f(x,y+d*x^M)
+"// returns f(x,y+d*x^M)
+"
+{
  map T1 = basering,x,y+d*x^M;
 …
 proc T2_Transform (poly f, number d, int M, int N)
 USAGE: T2_Transform(f,d,M,N); f poly, d number; M,N int
+"USAGE: T2_Transform(f,d,M,N); f poly, d number; M,N int
 RETURN: list: poly T2(f,d',M,N), number d' in \{ d, 1/d \}
+"
+{
  //---------------------- compute gcd and extgcd of N,M -----------------------
 …
 proc koeff (poly f, int I, int J)
 USAGE:  koeff(f,I,J); f polynomial in x and y, I,J integers
+"USAGE:  koeff(f,I,J); f polynomial in x and y, I,J integers
 RETURN: if f = sum(a(i,j)*x^i*y^j), then koeff(f,I,J)= a(I,J) (of type number)
 EXAMPLE: example koeff;  shows an example
+{
+"{
   matrix mat = coeffs(coeffs(f,y)[J+1,1],x);
   if (size(mat) <= I) { return(0);}
 …
 proc squarefree (poly f)
 USAGE:  squarefree(f); f poly in x and y
+"USAGE:  squarefree(f); f poly in x and y
 RETURN: a squarefree divisor of f
         Normally the return value is a greatest squarefree divisor, but there
 …
         are lost.
 EXAMPLE: example squarefree; shows some examples.
+{
+"{
  // es gibt noch ein Problem: syz gibt manchmal in Koerpererweiterung (p,a)
  // nicht f/g zurueck, obwohl die Division aufgeht ... In dem Fall ist die
 …
 proc allsquarefree (poly f, poly l)
 USAGE : allsquarefree(f,l);  poly f,l
+"USAGE : allsquarefree(f,l);  poly f,l
         l is the squarefree divisor of f you get by l=squarefree(f);
 RETURN: the squarefree divisor of f consisting of all irreducible factors of f
 …
          at the moment: it can return nonsense, if the basering has parameters)
 EXAMPLE: example allsquarefree;  shows an example
+{
+"{
  //---------- eliminiere bereits mit squarefree gefundene Faktoren ------------
  poly g=l;                            // g = gcd(f,l);
 …
 proc polytest(poly f)
 USAGE : polytest(f); f poly in x and y
+"USAGE : polytest(f); f poly in x and y
 RETURN: a monomial of f with |coefficient| > 16001
           or exponent divisible by 32003, if there is one
 …
 NOTE:   this procedure is only useful in characteristic zero, because otherwise
         there is no appropriate ordering of the leading coefficients
+{
+"{
  poly verbrecher=0;
  intvec leitexp;
 …
 proc develop
 USAGE:   develop(f [,n]); f polynomial in two variables, n integer
+"USAGE:   develop(f [,n]); f polynomial in two variables, n integer
 ASSUME:  f irreducible as a power series (for reducible f use reddevelop)
 RETURN:  Hamburger-Noether development of f, in form of a list:
 …
          For time critical computations it is recommended to use
          "ring ...,(x,y),ls" as basering - it increases the algorithm's speed.
+         \"ring ...,(x,y),ls\" as basering - it increases the algorithm's speed.
 EXAMPLES: example develop; shows an example
           example param;   shows an example for using the 2nd parameter
+{
+"{
  //--------- Abfangen unzulaessiger Ringe: 1) nur eine Unbestimmte ------------
  poly f=#[1];
 …
 proc param
 USAGE:  param(l) takes the output of develop(f)
+"USAGE:  param(l) takes the output of develop(f)
         (list l (matrix m, intvec v, int s[,poly g]))
         and gives a parametrisation for f; the first variable of the active
 …
          example develop;   shows another example
+{
+"{
  //-------------------------- Initialisierungen -------------------------------
  matrix m=#[1];
 …
 proc invariants
 USAGE:  invariants(l) takes the output of develop(f)
+"USAGE:  invariants(l) takes the output of develop(f)
         (list l (matrix m, intvec v, int s[,poly g]))
         and computes some invariants:
 …
          an empty list, if an error occurred in the procedure develop
 EXAMPLE: example invariants; shows an example
+{
+"{
  //-------------------------- Initialisierungen -------------------------------
  matrix m=#[1];
 …
 proc displayInvariants
 USAGE:   displayInvariants(l); takes the output both of
+"USAGE:   displayInvariants(l); takes the output both of
          develop(f) and reddevelop(f)
           ( list l (matrix m, intvec v, int s[,poly g])
 …
 RETURN:  nothing
 EXAMPLE: example displayInvariants;  shows an example
+{
+"{
  int i,j,k,mul;
  string Ausgabe;
 …
 proc multiplicities
 USAGE:   multiplicities(l) takes the output of develop(f)
+"USAGE:   multiplicities(l) takes the output of develop(f)
          (list l (matrix m, intvec v, int s[,poly g]))
 RETURN:  intvec of the different multiplicities that occur during the succes-
          sive blowing up of the curve corresponding to f
 EXAMPLE: example multiplicities;  shows an example
+{
+"{
  matrix m=#[1];
  intvec v=#[2];
 …
 proc puiseux2generators (intvec m, intvec n)
 USAGE:   puiseux2generators (m,n);
+"USAGE:   puiseux2generators (m,n);
          m,n intvecs with 1st resp. 2nd components of puiseux pairs
 RETURN:  intvec of the generators of the semigroup of values
 EXAMPLE: example puiseux2generators;  shows an example
+{
+"{
  intvec beta;
  int q=1;
 …
 proc generators
 USAGE:   generators(l); takes the output of develop(f)
+"USAGE:   generators(l); takes the output of develop(f)
          (list l (matrix m, intvec v, int s[,poly g]))
 RETURN:  intvec of the generators of the semigroup of values
 EXAMPLE: example generators;  shows an example
+"
+{
  list inv=invariants(#);
 …
 proc intersection (list hn1, list hn2)
 USAGE:   intersection(hne1,hne2);
+"USAGE:   intersection(hne1,hne2);
          hne1,hne2 two lists representing a HNE (normally two entries out of
          the output of reddevelop), i.e. list(matrix,intvec,int[,poly])
 …
          (of type int)
 EXAMPLE: example intersection;  shows an example
+"
+{
  //------------------ `intersect' ist schon reserviert ... --------------------
 …
 proc displayHNE(list ldev,list #)
 USAGE:   displayHNE(ldev,[,n]); ldev=list
+"USAGE:   displayHNE(ldev,[,n]); ldev=list
          (output list of develop(f) or reddevelop(f)), n=int
 RETURN:  - if only one argument is given, no return value, but
 …
      The optional parameter is then ignored.
 EXAMPLE: example displayHNE; shows an example
+"
+{
  if ((typeof(ldev[1])=="list") || (typeof(ldev[1])=="none")) {
 …
 proc newtonhoehne (poly f)
 USAGE:   newtonhoehne(f);   f poly
+"USAGE:   newtonhoehne(f);   f poly
 ASSUME:  basering = ...,(x,y),ds  or ls
 RETURN:  list of intvec(x,y) of coordinates of the newtonpolygon of f
 NOTE:    This proc is only available in versions of Singular that know the
+         command  system("newton",f);  f poly
+         command  system(\"newton\",f);  f poly
+"
+{
  intvec nm = getnm(f);
 …
 proc newtonpoly (poly f)
 USAGE:   newtonpoly(f);   f poly
+"USAGE:   newtonpoly(f);   f poly
 RETURN:  list of intvec(x,y) of coordinates of the newtonpolygon of f
 NOTE: There are many assumptions: (to improve speed)
 …
       - f(x,0) != 0 != f(0,y), f(0,0) = 0
 EXAMPLE: example newtonpoly;  shows an example
+"
+{
  intvec A=(0,ord(subst(f,x,0)));
 …
 proc charPoly(poly f, int M, int N)
 USAGE:  charPoly(f,M,N);  f poly in x,y,  M,N int: length and height
+"USAGE:  charPoly(f,M,N);  f poly in x,y,  M,N int: length and height
                           of newtonpolygon of f, which has to be only one line
 RETURN:  the characteristic polynomial of f
 EXAMPLE: example charPoly;  shows an example
+"
+{
  poly charp;
 …
 proc find_in_list(list L,int p)
 USAGE:  find_in_list(L,p); L: list of intvec(x,y)
+"USAGE:  find_in_list(L,p); L: list of intvec(x,y)
         (sorted in y: L[1][2]>=L[2][2]), int p >= 0
 RETURN: int i: L[i][2]=p if existent; otherwise i with L[i][2]<p if existent;
         otherwise i = size(L)+1;
+"
+{
  int i;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc set_list
 USAGE: set_list(L,v,l); L list, v intvec, l element of L (arbitrary type)
+"USAGE: set_list(L,v,l); L list, v intvec, l element of L (arbitrary type)
 RETURN: L with L[v[1]][v[2]][...][v[n]] set to l
 WARNING: Make sure there is no conflict of types!
 …
                          L[a][b][c]=q;
          (but the last command will only produce an error message)
+"
+{
  list L=#[1];
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc get_last_divisor(int M, int N)
 USAGE:   get_last_divisor(M,N); int M,N
+"USAGE:   get_last_divisor(M,N); int M,N
 RETURN:  int Q: M=q1*N+r1, N=q2*r1+r2, ..., ri=Q*r(i+1) (Euclidean alg.)
 EXAMPLE: example get_last_divisor; shows an example
+"
+{
  int R=M%N; int Q=M / N;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc redleit (poly f,intvec S, intvec E)
 USAGE:   redleit(f,S,E); f poly,
+"USAGE:   redleit(f,S,E); f poly,
          S,E intvec(x,y): two different points on a line in the newtonpolygon
          of f (e.g. the starting and the ending point)
 …
 NOTE:    It is not checked whether S and E really belong to the newtonpolygon!
 EXAMPLE: example redleit;  shows an example
+"
+{
  if (E[1]<S[1]) { intvec H=E; E=S; S=H; } // S,E verkehrt herum eingegeben
 …
 proc extdevelop (list l, int Exaktheit)
 USAGE:   extdevelop(l,n);  list l (matrix m, intvec v, int s, poly g), int n
+"USAGE:   extdevelop(l,n);  list l (matrix m, intvec v, int s, poly g), int n
          takes the output l of develop(f) ( or extdevelop(L,n),
          or one entry of the output of reddevelop(f))  and
 …
          Type  help develop;  for more details
 EXAMPLE: example extdevelop;  shows an example
+"
+{
  //------------ Initialisierungen und Abfangen unzulaessiger Aufrufe ----------
 …
 proc stripHNE (list l)
 USAGE:   stripHNE(l);    takes the output both of develop(f) and reddevelop(f)
+"USAGE:   stripHNE(l);    takes the output both of develop(f) and reddevelop(f)
            ( list l (matrix m, intvec v, int s[,poly g])
              or list of lists in the form l            )
 …
          to use extdevelop with them.
 EXAMPLE: example stripHNE;  shows an example
+"
+{
  list h;
 …
 proc extractHNEs(list HNEs, int transvers)
 USAGE:  extractHNEs(HNEs,transvers);  list HNEs (output from HN),
+"USAGE:  extractHNEs(HNEs,transvers);  list HNEs (output from HN),
         int transvers: 1 if x,y were exchanged, 0 else
 RETURN: list of Hamburger-Noether-Extensions in the form of reddevelop
 NOTE:   This procedure is only for internal purpose; examples don't make sense
+"
+{
  int i,maxspalte,hspalte,hnezaehler;
 …
 proc factorfirst(poly f, int M, int N)
 USAGE : factorfirst(f,M,N); f poly, M,N int
+"USAGE : factorfirst(f,M,N); f poly, M,N int
 RETURN: number d: f=c*(y^(N/e) - d*x^(M/e))^e with e=gcd(M,N), number c fitting
 if d does not exist
 EXAMPLE: example factorfirst;  shows an example
+"
+{
  number c = koeff(f,0,N);
 …
 proc reddevelop (poly f)
 USAGE:   reddevelop(f); f poly
+"USAGE:   reddevelop(f); f poly
 RETURN:  Hamburger-Noether development of f :
          A list of lists in the form of develop(f); each entry contains the
 …
          the basering to  ring HNEring=...,(x,y),ls; !
 EXAMPLE: example reddevelop;  shows an example
+"
+{
  def altring = basering;
 …
+}
 ///////////////////////////////////////////////////////////////////////////////
+static
 proc HN (poly f,int grenze, int Aufruf_Ebene)
+NOTE: This procedure is only for internal use, it is called via reddevelop
+"NOTE: This procedure is only for internal use, it is called via reddevelop
+"
+{
  //---------- Variablendefinitionen fuer den unverzweigten Teil: --------------
 …
 ///////////////////////////////////////////////////////////////////////////////
+static
 proc constructHNEs (list HNEs,int hnezaehler,list aneu,list azeilen,int zeile,ideal deltais,int Q,int j)
+NOTE: This procedure is only for internal use, it is called via HN
+"NOTE: This procedure is only for internal use, it is called via HN
+"
+{
   int zaehler,zl;
 …
 proc extrafactor (poly leitf, int M, int N)
 USAGE:   factors,flag=extrafactor(f,M,N);
+"USAGE:   factors,flag=extrafactor(f,M,N);
          list factors, int flag,M,N, poly f in x,y
 ASSUME:  basering is (0,a),(x,y),ds or ls
 …
          It becomes obsolete as soon as factorize works also in such rings.
 EXAMPLE: example extrafactor;  shows an example
+"
+{
  list faktoren;

Singular/LIB/homolog.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: homolog.lib,v 1.5 1998-04-03 22:47:06 krueger Exp $
+// $Id: homolog.lib,v 1.6 1998-05-05 11:55:28 krueger Exp $
 //(BM/GMG, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: homolog.lib,v 1.5 1998-04-03 22:47:06 krueger Exp $";
+version="$Id: homolog.lib,v 1.6 1998-05-05 11:55:28 krueger Exp $";
 info="
 LIBRARY:  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
 …
 proc cup (module M,list #)
 USAGE:   cup(M,[,any,any]);  M=module
+"USAGE:   cup(M,[,any,any]);  M=module
 COMPUTE: cup-product Ext^1(M',M') x Ext^1(M',M') ---> Ext^2(M',M'),
          where M':=R^m/M, if M in R^m, R basering (i.e. M':=coker(matrix(M)))
 …
          For computing cupproduct of M itself, apply proc to syz(M)!
 EXAMPLE: example cup; shows examples
+"
+{
 //---------- initialization ---------------------------------------------------
 …
 proc cupproduct (module M,N,P,int p,q,list #)
 USAGE:   cupproduct(M,N,P,p,q[,any]);  M,N,P modules, p,q integers
+"USAGE:   cupproduct(M,N,P,p,q[,any]);  M,N,P modules, p,q integers
 COMPUTE: cup-product Ext^p(M',N') x Ext^q(N',P') ---> Ext^p+q(M',P')
          where M':=R^m/M, if M in R^m, R basering (i.e. M':=coker(matrix(M)))
 …
          For computing cupproduct of M,N itself, apply proc to syz(M),syz(N)!
 EXAMPLE: example cupproduct; shows examples
+"
+{
 //---------- initialization ---------------------------------------------------
 …
 proc Ext_R (intvec v, module M, list #)
 USAGE:   Ext_R(v,M[,p]);  v=int/intvec , M=module, p=int
+"USAGE:   Ext_R(v,M[,p]);  v=int/intvec , M=module, p=int
 COMPUTE: A presentation of Ext^k(M',R); for k=v[1],v[2],..., M'=coker(M).
          Let ...--> F2 --> F1 --M-> F0-->M'-->0 be a free resolution of M'. If
 …
          or the 2 commands: list L=mres(M,2);  Ext_R(k,L[2]);
 EXAMPLE: example Ext_R; shows examples
+"
+{
 …
 proc Ext (intvec v, module M, module N, list #)
 USAGE:   Ext(v,M,N[,any]);  v=int/intvec, M,N=modules
+"USAGE:   Ext(v,M,N[,any]);  v=int/intvec, M,N=modules
 COMPUTE: A presentation of Ext^k(M',N'); for k=v[1],v[2],... where
          M'=coker(M) and N'=coker(N). Let
 …
          or: list P=mres(M,2); list Q=mres(N,2); Ext(k,P[2],Q[2]);
 EXAMPLE: example Ext;   shows examples
+"
+{
 //---------- initialisation ---------------------------------------------------
 …
 proc Hom (module M, module N, list #)
 USAGE:   Hom(M,N,[any]);  M,N=modules
+"USAGE:   Hom(M,N,[any]);  M,N=modules
 COMPUTE: A presentation of Hom(M',N'), M'=coker(M), N'=coker(N) as follows:
          Let ...-->F1 --M-> F0-->M'-->0 and ...-->G1 --N-> G0-->N'-->0  be
 …
          from another proc has the same effect as decreasing printlevel by 1.
 EXAMPLE: example Hom;  shows examples
+"
+{
 //---------- initialisation ---------------------------------------------------
 …
 proc homology (matrix A,matrix B,module M,module N,list #)
 USAGE:   homology(A,B,M,N);
+"USAGE:   homology(A,B,M,N);
 COMPUTE: Let M and N be submodules of R^m and R^n presenting M'=R^m/M, N'=R^n/N
          (R=basering) and let A,B matrices inducing maps R^k--A-->R^m--B-->R^n.
 …
 NOTE:    homology returns a free module of rank m if ker(B)=im(A)
 EXAMPLE: example homology; shows examples
+"
+{
   module ker,ima;
 …
 proc kernel (matrix A,module M,module N)
 USAGE:   kernel(A,M,N);
+"USAGE:   kernel(A,M,N);
 COMPUTE: Let M and N be submodules of R^m and R^n presenting M'=R^m/M, N'=R^n/N
          (R=basering) and let A:R^m-->R^n a matrix inducing a map A':M'-->N'.
 …
 RETURN:  module K, a presentation of ker(A')
 EXAMPLE: example kernel; shows examples
+"
+{
   module M1 = modulo(A,N);
 …
 proc kohom (matrix M, int j)
 USAGE:   kohom(A,k); A=matrix, k=integer
+"USAGE:   kohom(A,k); A=matrix, k=integer
 RETURN:  matrix Hom(R^k,A) i.e. let A be a matrix defining a map: F1 --> F2 of
          free R-modules, the matrix of Hom(R^k,F1)-->Hom(R^k,F2) is computed
 EXAMPLE: example kohom; shows an example
+"
+{
   if (j==1)
 …
 proc kontrahom (matrix M, int j)
 USAGE:   kontrahom(A,k); A=matrix, k=integer
+"USAGE:   kontrahom(A,k); A=matrix, k=integer
 RETURN:  matrix Hom(A,R^k), i.e. let A be a matrix defining a map: F1 --> F2 of
          free  R-modules, the matrix of Hom(F2,R^k)-->Hom(F1,R^k) is computed
 EXAMPLE: example kontrahom; shows an example
+"
+{
 if (j==1)

Singular/LIB/inout.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: inout.lib,v 1.4 1998-04-03 22:47:06 krueger Exp $
+// $Id: inout.lib,v 1.5 1998-05-05 11:55:29 krueger Exp $
 // system("random",787422842);
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: inout.lib,v 1.4 1998-04-03 22:47:06 krueger Exp $";
+version="$Id: inout.lib,v 1.5 1998-05-05 11:55:29 krueger Exp $";
 info="
 LIBRARY:  inout.lib     PROCEDURES FOR MANIPULATING IN- AND OUTPUT
 …
 proc allprint (list #)
 USAGE:   allprint(L);  L list
+"USAGE:   allprint(L);  L list
 CREATE:  display L[1], L[2], ... if an integer with name ALLprint is defined,
          makes "pause",   if ALLprint > 0
+         makes \"pause\",   if ALLprint > 0
          listvar(matrix), if ALLprint = 2
 RETURN:  no return value
 EXAMPLE: example allprint; shows an example
+"
+{
    if( defined(ALLprint) )
 …
 proc dbpri (int n ,list #)
 USAGE:   dbpri(n,L);  n integer, L list
+"USAGE:   dbpri(n,L);  n integer, L list
 CREATE:  display L[1], L[2], ... if an integer with name printlevel is defined
          and if n<=printlevel, set printlevel to 0 if it is not defined
 …
          It is similair but not the same as the internal function dbprint
 EXAMPLE: example dbpri; shows an example
+"
+{
    int i;
 …
 proc lprint
 USAGE:   lprint(id[,n]);  id poly/ideal/vector/module/matrix, n integer
+"USAGE:   lprint(id[,n]);  id poly/ideal/vector/module/matrix, n integer
 RETURN:  string of id in a format fitting into lines of size n; if only one
          argument is present, n = pagewidth
 …
          can be used as input to reproduce id
 EXAMPLE: example lprint; shows an example
+"
+{
    if (size(#)==1) { int n = pagewidth-3; }
 …
 proc pmat (matrix m, list #)
 USAGE:   pmat(M,[n]);  M matrix, n integer
+"USAGE:   pmat(M,[n]);  M matrix, n integer
 CREATE:  display M in array format if it fits into pagewidth, no return value;
          if n is given, only the first n characters of each colum are shown
 RETURN:  no return value
 EXAMPLE: example pmat; shows an example
+"
+{
 //------------- main case: input is a matrix, no second argument---------------
 …
 proc rMacaulay
 USAGE:   rMacaulay(s[,n]);  s string, n integer
+"USAGE:   rMacaulay(s[,n]);  s string, n integer
 RETURN:  a string which should be readable by Singular if s is a string read
          by Singular from a file which was produced by Macaulay_1 (='Macaulay
 …
          from the screen, the character \ is treated differently
 EXAMPLE: example rMacaulay; shows an example
+"
+{
    int n;
 …
 proc show (id, list #)
 USAGE:   show(id);   id any object of basering or of type ring/qring
+"USAGE:   show(id);   id any object of basering or of type ring/qring
          show(R,s);  R=ring, s=string (s = name of an object belonging to R)
 DISPLAY: display id/s in a compact format together with some information
 …
 CAUTION: show(R,s) does not work inside a procedure
 EXAMPLE: example show; shows an example
+"
+{
 //------------- use funny names in order to avoid name conflicts --------------
 …
 proc showrecursive (id,poly p,list #)
 USAGE:   showrecursive(id,p[ord]); id=any object of basering, p=product of
+"USAGE:   showrecursive(id,p[ord]); id=any object of basering, p=product of
          variables and ord=string (any allowed ordstr)
 DISPLAY: display 'id' in a recursive format as a polynomial in the variables
          occuring in p with coefficients in the remaining variables. Do this
          by mapping in a ring with parameters [and ordering 'ord', if a 3rd
          argument is present (default: ord="dp")] and applying procedure 'show'
+         argument is present (default: ord=\"dp\")] and applying procedure 'show'
 RETURN:  no return value
 EXAMPLE: example showrecursive; shows an example
+"
+{
    def P = basering;
 …
 proc split (string s, list #)
 USAGE:    split(s[,n]); s string, n integer
+"USAGE:    split(s[,n]); s string, n integer
 RETURN:   same string, split into lines of length n separated by \
           (default: n=pagewidth)
 NOTE:     may be used in connection with lprint
 EXAMPLE:  example split; shows an example
+"
+{
    string line,re; int p,l;
 …
 proc tab (int n)
 USAGE:   tab(n);  n integer
+"USAGE:   tab(n);  n integer
 RETURN:  string of n space tabs
 EXAMPLE: example tab; shows an example
+"
+{
    if( n==0 ) { return(""); }
 …
 proc writelist (string fil, string nam, list L)
 USAGE:   writelist(fil,nam,L);  fil,nam=strings (file-name, list-name), L=list
+"USAGE:   writelist(fil,nam,L);  fil,nam=strings (file-name, list-name), L=list
 CREATE:  a file with name `fil`, write the content of the list L into it and
          call the list `nam`.
 …
 NOTE:    The syntax of writelist uses and is similar to the syntax of the
          write command of Singular which does not manage lists properly.
          If, say, (fil,nam) = ("listfile","L1"),  writelist creates (resp.
+         If, say, (fil,nam) = (\"listfile\",\"L1\"),  writelist creates (resp.
          appends if listfile exists) a file with name listfile and stores
          there the list L under the name L1. The Singular command
          execute(read("listfile")); assignes the content of L (stored in
+         execute(read(\"listfile\")); assignes the content of L (stored in
          listfile) to a list L1.
          On a UNIX system, overwrite an existing file if fil=">...", resp.
          append if fil=">>...".
+         On a UNIX system, overwrite an existing file if fil=\">...\", resp.
+         append if fil=\">>...\".
 EXAMPLE: example writelist; shows an example
+"
+{
    int i;

Singular/LIB/invar.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: invar.lib,v 1.5 1998-04-03 22:47:07 krueger Exp $
+// $Id: invar.lib,v 1.6 1998-05-05 11:55:30 krueger Exp $
 ///////////////////////////////////////////////////////
 // invar.lib
 …
 //////////////////////////////////////////////////////
 version="$Id: invar.lib,v 1.5 1998-04-03 22:47:07 krueger Exp $";
+version="$Id: invar.lib,v 1.6 1998-05-05 11:55:30 krueger Exp $";
 info="
 LIBRARY: invar.lib PROCEDURES FOR COMPUTING INVARIANTS OF (C,+)-ACTIONS
 …
 proc der (matrix m, poly f)
 USAGE:   der(m,f);  m matrix, f poly
+"USAGE:   der(m,f);  m matrix, f poly
 RETURN:  poly= application of the vectorfield m befined by the matrix m
          (m[i,1] are the coefficients of d/dx(i)) to f
 NOTE:
 EXAMPLE: example der; shows an example
+"
+{
   matrix mh=matrix(jacob(f))*m;
 …
 proc actionIsProper(matrix m)
 USAGE:   actionIsProper(m); m matrix
+"USAGE:   actionIsProper(m); m matrix
 RETURN:  int= 1 if is proper, 0 else
 NOTE:
 EXAMPLE: example actionIsProper; shows an example
+"
+{
   int i;
 …
 proc reduction(poly p, ideal dom, list #)
 USAGE:   reduction(p,dom,q); p poly, dom ideal, q (optional) monomial
+"USAGE:   reduction(p,dom,q); p poly, dom ideal, q (optional) monomial
 RETURN:  poly= (p-H(f1,...,fr))/q^a, if Lt(p)=H(Lt(f1),...,Lt(fr)) for
                some polynomial H in r variables over the base field,
 …
 NOTE:
 EXAMPLE: example reduction; shows an example
+"
+{
   int i;
 …
 proc completeReduction(poly p, ideal dom, list #)
 USAGE:   completeReduction(p,dom,q); p poly, dom ideal,
+"USAGE:   completeReduction(p,dom,q); p poly, dom ideal,
                                      q (optional) monomial
 RETURN:  poly= the polynomial p reduced with dom via the procedure
 …
 NOTE:
 EXAMPLE: example completeReduction; shows an example
+"
+{
   poly p1=p;
 …
 proc inSubring(poly p, ideal dom)
 USAGE:   inSubring(p,dom); p poly, dom ideal
+"USAGE:   inSubring(p,dom); p poly, dom ideal
 RETURN:  list= 1,string(@(0)-h(@(1),...,@(size(dom)))) :if p = h(dom[1],...,dom[size(dom)])
 ,string(h(@(0),...,@(size(dom)))) :if there is only a nonlinear relation
 …
 NOTE:
 EXAMPLE: example inSubring; shows an example
+"
+{
   int z=size(dom);
 …
 proc localInvar(matrix m, poly p, poly q, poly h)
 USAGE:   localInvar(m,p,q,h); m matrix, p,q,h poly
+"USAGE:   localInvar(m,p,q,h); m matrix, p,q,h poly
 RETURN:  poly= the invariant of the vectorfield m=Sum m[i,1]*d/dx(i) with respect
                to p,q,h, i.e.
 …
 NOTE:
 EXAMPLE: example localInvar; shows an example
+"
+{
   if ((der(m,h) !=0) || (der(m,der(m,q)) !=0))
 …
 proc furtherInvar(matrix m, ideal id, ideal karl, poly q)
 USAGE:   furtherInvar(m,id,karl,q); m matrix, id,karl ideal,q poly
+"USAGE:   furtherInvar(m,id,karl,q); m matrix, id,karl ideal,q poly
 RETURN:  ideal= further invariants of the vectorfield m=Sum m[i,1]*d/dx(i) with respect
                to id,p,q, i.e.
 …
 NOTE:
 EXAMPLE: example furtherInvar; shows an example
+"
+{
   int i;
 …
 proc invariantRing(matrix m, poly p, poly q,list #)
 USAGE:   invariantRing(m,p,q); m matrix, p,q poly
+"USAGE:   invariantRing(m,p,q); m matrix, p,q poly
 RETURN:  ideal= the invariants of the vectorfield m=Sum m[i,1]*d/dx(i)
                 p,q variables with m(p)=q invariant
 NOTE:
 EXAMPLE: example furtherInvar; shows an example
+"
+{
   ideal j;

Singular/LIB/makedbm.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: makedbm.lib,v 1.6 1998-04-03 23:18:16 krueger Exp $
+// $Id: makedbm.lib,v 1.7 1998-05-05 11:55:31 krueger Exp $
 //=========================================================================
 //
 …
 //=============================================================================
+version="$Id: makedbm.lib,v 1.7 1998-05-05 11:55:31 krueger Exp $";
+info="
 LIBRARY:  makedbm.lib     some usefull tools needed by the Arnold-Classifier.
 …
    create_sing_dbm();
    read_sing_dbm();
+";
 //=============================================================================

Singular/LIB/matrix.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: matrix.lib,v 1.5 1998-04-03 22:47:08 krueger Exp $
+// $Id: matrix.lib,v 1.6 1998-05-05 11:55:31 krueger Exp $
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: matrix.lib,v 1.5 1998-04-03 22:47:08 krueger Exp $";
+version="$Id: matrix.lib,v 1.6 1998-05-05 11:55:31 krueger Exp $";
 info="
 LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
 …
 proc compress (A)
 USAGE:   compress(A); A matrix/ideal/module/intmat/intvec
+"USAGE:   compress(A); A matrix/ideal/module/intmat/intvec
 RETURN:  same type, zero columns/generators from A deleted
          (in an intvec zero elements are deleted)
 EXAMPLE: example compress; shows an example
+"
+{
    if( typeof(A)=="matrix" ) { return(matrix(simplify(A,2))); }
 …
 ////////////////////////////////////////////////////////////////////////////////
 proc concat (list #)
 USAGE:   concat(A1,A2,..); A1,A2,... matrices
+"USAGE:   concat(A1,A2,..); A1,A2,... matrices
 RETURN:  matrix, concatenation of A1,A2,... . Number of rows of result matrix is
          max(nrows(A1),nrows(A2),...)
 EXAMPLE: example concat; shows an example
+"
+{
    int i;
 …
 proc diag (list #)
 USAGE:   diag(p,n); p poly, n integer
+"USAGE:   diag(p,n); p poly, n integer
          diag(A);   A matrix
 RETURN:  diag(p,n): diagonal matrix, p times unitmatrix of size n
 …
                     nxm matrix A, taken from the 1st row, 2nd row etc of A
 EXAMPLE: example diag; shows an example
+"
+{
    if( size(#)==2 ) { return(matrix(#[1]*freemodule(#[2]))); }
 …
 proc dsum (list #)
 USAGE:   dsum(A1,A2,..); A1,A2,... matrices
+"USAGE:   dsum(A1,A2,..); A1,A2,... matrices
 RETURN:  matrix, direct sum of A1,A2,...
 EXAMPLE: example dsum; shows an example
+"
+{
    int i,N,a;
 …
 proc flatten (matrix A)
 USAGE:   flatten(A); A matrix
+"USAGE:   flatten(A); A matrix
 RETURN:  ideal, generated by all entries from A
 EXAMPLE: example flatten; shows an example
+"
+{
    return(ideal(A));
 …
 proc genericmat (int n,int m,list #)
 USAGE:   genericmat(n,m[,id]);  n,m=integers, id=ideal
+"USAGE:   genericmat(n,m[,id]);  n,m=integers, id=ideal
 RETURN:  nxm matrix, with entries from id (default: id=maxideal(1))
 NOTE:    if id has less than nxm elements, the matrix is filled with 0's,
          genericmat(n,m); creates the generic nxm matrix
 EXAMPLE: example genericmat; shows an example
+"
+{
    if( size(#)==0 ) { ideal id=maxideal(1); }
 …
 proc is_complex (list c)
 USAGE:   is_complex(c); c = list of size-compatible modules or matrices
+"USAGE:   is_complex(c); c = list of size-compatible modules or matrices
 RETURN:  1 if c[i]*c[i+1]=0 for all i, 0 if not.
 NOTE:    Ideals are treated internally as 1-line matrices
 EXAMPLE: example is_complex; shows an example
+"
+{
    int i;
 …
 proc outer (matrix A, matrix B)
 USAGE:   outer(A,B); A,B matrices
+"USAGE:   outer(A,B); A,B matrices
 RETURN:  matrix, outer product of A and B
 EXAMPLE: example outer; shows an example
+"
+{
    int i,j; list L;
 …
 proc power ( A, int n)
 USAGE:   power(A,n);  A a square-matrix of type intmat or matrix, n=integer
+"USAGE:   power(A,n);  A a square-matrix of type intmat or matrix, n=integer
 RETURN:  inmat resp. matrix, the n-th power of A
 NOTE:    for intamt and big n the result may be wrong because of int overflow
 EXAMPLE: example power; shows an example
+"
+{
 //---------------------------- type checking ----------------------------------
 …
 proc skewmat (int n, list #)
 USAGE:   skewmat(n[,id]);  n integer, id ideal
+"USAGE:   skewmat(n[,id]);  n integer, id ideal
 RETURN:  skew-symmetric nxn matrix, with entries from id
          (default: id=maxideal(1))
 …
          skewmat(n); creates the generic skew-symmetric matrix
 EXAMPLE: example skewmat; shows an example
+"
+{
    matrix B[n][n];
 …
 proc submat (matrix A, intvec r, intvec c)
 USAGE:   submat(A,r,c);  A=matrix, r,c=intvec
+"USAGE:   submat(A,r,c);  A=matrix, r,c=intvec
 RETURN:  matrix, submatrix of A with rows specified by intvec r and columns
          specified by intvec c
 EXAMPLE: example submat; shows an example
+"
+{
    matrix B[size(r)][size(c)]=A[r,c];
 …
 proc symmat (int n, list #)
 USAGE:   symmat(n[,id]);  n integer, id ideal
+"USAGE:   symmat(n[,id]);  n integer, id ideal
 RETURN:  symmetric nxn matrix, with entries from id (default: id=maxideal(1))
 NOTE:    if id has less than n*(n+1)/2 elements, the matrix is filled with 0's,
          symmat(n); creates the generic symmetric matrix
 EXAMPLE: example symmat; shows an example
+"
+{
    matrix B[n][n];
 …
 proc tensor (matrix A, matrix B)
 USAGE:   tensor(A,B); A,B matrices
+"USAGE:   tensor(A,B); A,B matrices
 RETURN:  matrix, tensor product of A and B
 EXAMPLE: example tensor; shows an example
+"
+{
    int i,j;
 …
 proc unitmat (int n)
 USAGE:   unitmat(n);  n integer >= 0
+"USAGE:   unitmat(n);  n integer >= 0
 RETURN:  nxn unit matrix
 NOTE:    needs a basering, diagonal entries are numbers (=1) in the basering
 EXAMPLE: example unitmat; shows an example
+"
+{
    return(matrix(freemodule(n)));
 …
 proc gauss_col (matrix A)
 USAGE:   gauss_col(A); A=matrix with constant coefficients
+"USAGE:   gauss_col(A); A=matrix with constant coefficients
 RETURN:  matrix = col-reduced lower-triagonal normal form of A
 NOTE:    the procedure sets the global option-command: option(noredSB);
 EXAMPLE: example gauss_col; shows an example
+"
+{
    def R=basering;
 …
 proc gauss_row (matrix A)
 USAGE:   gauss_row(A); A=matrix with constant coefficients
+"USAGE:   gauss_row(A); A=matrix with constant coefficients
 RETURN:  matrix = row-reduced upper-triangular normal form of A
 NOTE:    may be used to solve a system of linear equations
 …
          the procedure sets the global option-command: option(noredSB);
 EXAMPLE: example gauss_row; shows an example
+"
+{
    A = gauss_col(transpose(A));
 …
 proc addcol (matrix A, int c1, poly p, int c2)
 USAGE:   addcol(A,c1,p,c2);  A matrix, p poly, c1, c2 positive integers
+"USAGE:   addcol(A,c1,p,c2);  A matrix, p poly, c1, c2 positive integers
 RETURN:  matrix,  A being modified by adding p times column c1 to column c2
 EXAMPLE: example addcol; shows an example
+"
+{
    A[1..nrows(A),c2]=A[1..nrows(A),c2]+p*A[1..nrows(A),c1];
 …
 proc addrow (matrix A, int r1, poly p, int r2)
 USAGE:   addcol(A,r1,p,r2);  A matrix, p poly, r1, r2 positive integers
+"USAGE:   addcol(A,r1,p,r2);  A matrix, p poly, r1, r2 positive integers
 RETURN:  matrix,  A being modified by adding p times row r1 to row r2
 EXAMPLE: example addrow; shows an example
+"
+{
    A[r2,1..ncols(A)]=A[r2,1..ncols(A)]+p*A[r1,1..ncols(A)];
 …
 proc multcol (matrix A, int c, poly p)
 USAGE:   addcol(A,c,p);  A matrix, p poly, c positive integer
+"USAGE:   addcol(A,c,p);  A matrix, p poly, c positive integer
 RETURN:  matrix,  A being modified by multiplying column c with p
 EXAMPLE: example multcol; shows an example
+"
+{
    A[1..nrows(A),c]=p*A[1..nrows(A),c];
 …
 proc multrow (matrix A, int r, poly p)
 USAGE:   addcol(A,r,p);  A matrix, p poly, r positive integer
+"USAGE:   addcol(A,r,p);  A matrix, p poly, r positive integer
 RETURN:  matrix,  A being modified by multiplying row r with p
 EXAMPLE: example multrow; shows an example
+"
+{
    A[r,1..ncols(A)]=p*A[r,1..ncols(A)];
 …
 proc permcol (matrix A, int c1, int c2)
 USAGE:   permcol(A,c1,c2);  A matrix, c1,c2 positive integers
+"USAGE:   permcol(A,c1,c2);  A matrix, c1,c2 positive integers
 RETURN:  matrix,  A being modified by permuting column c1 and c2
 EXAMPLE: example permcol; shows an example
+"
+{
    matrix B=A;
 …
 proc permrow (matrix A, int r1, int r2)
 USAGE:   permrow(A,r1,r2);  A matrix, r1,r2 positive integers
+"USAGE:   permrow(A,r1,r2);  A matrix, r1,r2 positive integers
 RETURN:  matrix,  A being modified by permuting row r1 and r2
 EXAMPLE: example permrow; shows an example
+"
+{
    matrix B=A;

Singular/LIB/normal.lib

-                      r4996f52
+                      rd2b2a7
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: normal.lib,v 1.4 1998-04-03 22:47:08 krueger Exp $";
+version="$Id: normal.lib,v 1.5 1998-05-05 11:55:32 krueger Exp $";
 info="
 LIBRARY: normal.lib: PROCEDURE FOR NORMALIZATION (I)
 …
 proc isR_HomJR (list Li)
 USAGE:   isR_HomJR (Li);  Li = list: ideal SBid, ideal J, poly p
+"USAGE:   isR_HomJR (Li);  Li = list: ideal SBid, ideal J, poly p
 COMPUTE: module Hom_R(J,R) = R:J and compare with R
 ASSUME:  R    = P/SBid,  P = basering
 …
 RETURN:  1 if R = R:J, 0 if not
 EXAMPLE: example isR_HomJR;  shows an example
+"
+{
    int n, ii;
 …
 proc extraweight (list # )
 USAGE:   extraweight (P); P=name of an existing ring (true name, not a string)
+"USAGE:   extraweight (P); P=name of an existing ring (true name, not a string)
 RETURN:  intvec, size=nvars(P), consisting of the weights of the variables of P
 NOTE:    This is useful when enlarging P but keeping the weights of the old
          variables
 EXAMPLE: example extraweight;  shows an example
+"
+{
    int ii,q,fi,fo,fia;
 …
 proc HomJJ (list Li,list #)
 USAGE:   HomJJ (Li);  Li = list: SBid,id,J,poly p
+"USAGE:   HomJJ (Li);  Li = list: SBid,id,J,poly p
 ASSUME:  R    = P/id,  P = basering, a polynomial ring, id an ideal of P,
          SBid = standard basis of id,
 …
          _[2]: an integer which is 1 if phi is an isomorphism, 0 if not
 EXAMPLE: example HomJJ;  shows an example
+"
+{
 //---------- initialisation ---------------------------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc normal(ideal id, list #)
 USAGE:   normal(i,choose);  i ideal,choose empty or 1
+"USAGE:   normal(i,choose);  i ideal,choose empty or 1
          in case you choose 1 the factorizing Buchberger algorithm
          is not used which is sometimes more efficient
 …
 NOTE:    to use the rings: def r=L[i];setring r;
 EXAMPLE: example normal; shows an example
+"
+{
    int i,j,y;
 …
 proc normalizationPrimes(ideal i,ideal ihp, list #)
 USAGE:   normalizationPrimes(i);  i prime ideal
+"USAGE:   normalizationPrimes(i);  i prime ideal
 RETURN:  a list of one ring L=R, in  R are two ideals
          S,M such that R/M is the normalization
 …
 NOTE:    to use the ring: def r=L[1];setring r;
 EXAMPLE: example normalizationPrimes; shows an example
+"
+{
    int y;

Singular/LIB/poly.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: poly.lib,v 1.11 1998-04-06 17:59:38 obachman Exp $
+// $Id: poly.lib,v 1.12 1998-05-05 11:55:33 krueger Exp $
 //system("random",787422842);
 //(GMG, last modified 22.06.96)
 …
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: poly.lib,v 1.11 1998-04-06 17:59:38 obachman Exp $";
+version="$Id: poly.lib,v 1.12 1998-05-05 11:55:33 krueger Exp $";
 info="
 LIBRARY:  poly.lib      PROCEDURES FOR MANIPULATING POLYS, IDEALS, MODULES
 …
 proc cyclic (int n)
 USAGE:   cyclic(n);  n integer
+"USAGE:   cyclic(n);  n integer
 RETURN:  ideal of cyclic n-roots from 1-st n variables of basering
 EXAMPLE: example cyclic; shows examples
+"
+{
 //----------------------------- procedure body --------------------------------
 …
 proc katsura
 USAGE:  katsura([n]); n integer
+"USAGE: katsura([n]); n integer
 RETURN: katsura(n) : n-th katsura ideal of newly created and set ring
                      (32003, x(0..n), dp)
         katsura()  : katsura ideal of basering
 EXAMPLE: example katsura; shows examples
+"
+{
   if ( size(#) == 1 && typeof(#[1]) == "int")
 …
 proc freerank
 USAGE:   freerank(M[,any]);  M=poly/ideal/vector/module/matrix
+"USAGE:   freerank(M[,any]);  M=poly/ideal/vector/module/matrix
 COMPUTE: rank of module presented by M in case it is free. By definition this
          is vdim(coker(M)/m*coker(M)) if coker(M) is free, where m = maximal
 …
          //betti(0) ist -1 statt 0
 EXAMPLE: example freerank; shows examples
+"
+{
   int rk;
 …
 proc is_homog (id)
 USAGE:   is_homog(id);  id  poly/ideal/vector/module/matrix
+"USAGE:   is_homog(id);  id  poly/ideal/vector/module/matrix
 RETURN:  integer which is 1 if input is homogeneous (resp. weighted homogeneous
          if the monomial ordering consists of one block of type ws,Ws,wp or Wp,
 …
          //*** ergaenzen, wenn Matrizen-Spalten Gewichte haben
 EXAMPLE: example is_homog; shows examples
+"
+{
 //----------------------------- procedure body --------------------------------
 …
 proc is_zero
 USAGE:   is_zero(M[,any]); M=poly/ideal/vector/module/matrix
+"USAGE:   is_zero(M[,any]); M=poly/ideal/vector/module/matrix
 RETURN:  integer, 1 if coker(M)=0 resp. 0 if coker(M)!=0, where M is considered
          as matrix
 …
                 L[2] = dim(M)
 EXAMPLE: example is_zero; shows examples
+"
+{
   int d=dim(std(#[1]));
 …
 proc maxcoef (f)
 USAGE:   maxcoef(f);  f  poly/ideal/vector/module/matrix
+"USAGE:   maxcoef(f);  f  poly/ideal/vector/module/matrix
 RETURN:  maximal length of coefficient of f of type int (by counting the
          length of the string of each coefficient)
 EXAMPLE: example maxcoef; shows examples
+"
+{
 //----------------------------- procedure body --------------------------------
 …
 proc maxdeg (id)
 USAGE:   maxdeg(id);  id  poly/ideal/vector/module/matrix
+"USAGE:   maxdeg(id);  id  poly/ideal/vector/module/matrix
 RETURN:  int/intmat, each component equals maximal degree of monomials in the
          corresponding component of id, independent of ring ordering
 …
          an option for computing weighted degrees
 EXAMPLE: example maxdeg; shows examples
+"
+{
    //-------- subprocedure to find maximal degree of given component ----------
 …
 proc maxdeg1 (id,list #)
 USAGE:   maxdeg1(id[,v]);  id=poly/ideal/vector/module/matrix, v=intvec
+"USAGE:   maxdeg1(id[,v]);  id=poly/ideal/vector/module/matrix, v=intvec
 RETURN:  integer, maximal [weighted] degree of monomials of id independent of
          ring ordering, maxdeg1 of i-th variable is v[i] (default: v=1..1).
 …
          maxdeg is faster
 EXAMPLE: example maxdeg1; shows examples
+"
+{
    //-------- subprocedure to find maximal degree of given component ----------
 …
 proc mindeg (id)
 USAGE:   mindeg(id);  id  poly/ideal/vector/module/matrix
+"USAGE:   mindeg(id);  id  poly/ideal/vector/module/matrix
 RETURN:  minimal degree/s of monomials of id, independent of ring ordering
          (mindeg of each variable is 1) of type int if id of type poly, else
 …
          has an option for computing weighted degrees.
 EXAMPLE: example mindeg; shows examples
+"
+{
    //--------- subprocedure to find minimal degree of given component ---------
 …
 proc mindeg1 (id, list #)
 USAGE:   mindeg1(id[,v]);  id=poly/ideal/vector/module/matrix, v=intvec
+"USAGE:   mindeg1(id[,v]);  id=poly/ideal/vector/module/matrix, v=intvec
 RETURN:  integer, minimal [weighted] degree of monomials of id independent of
          ring ordering, mindeg1 of i-th variable is v[i] (default v=1..1).
 …
          mindeg is faster.
 EXAMPLE: example mindeg1; shows examples
+"
+{
    //--------- subprocedure to find minimal degree of given component ---------
 …
 proc normalize (id)
 USAGE:   normalize(id);  id=poly/vector/ideal/module
+"USAGE:   normalize(id);  id=poly/vector/ideal/module
 RETURN:  object of same type with leading coefficient equal to 1
 EXAMPLE: example normalize; shows an example
+"
+{
    return(simplify(id,1));
 …
 ////////////////////////////////////////////////////////////////////////////////
 proc rad_con (poly g,ideal I)
   USAGE:   rad_con(<poly>,<ideal>);
+"  USAGE:   rad_con(<poly>,<ideal>);
   RETURNS: 1 (TRUE) (type <int>) if <poly> is contained in the radical of
            <ideal>, 0 (FALSE) (type <int>) otherwise
   EXAMPLE: example rad_con; shows an example
+"
 { def br=basering;
   int n=nvars(br);
 …
 proc lcm (ideal i)
 USAGE:   lcm(i); i ideal
+"USAGE:   lcm(i); i ideal
 RETURN:  poly = lcm(i[1],...,i[size(i)])
 NOTE:
 EXAMPLE: example lcm; shows an example
+"
+{
   int k,j;
 …
 proc content(f)
 USAGE:   content(f); f polynomial/vector
+"USAGE:   content(f); f polynomial/vector
 RETURN:  number, the content (greatest common factor of coefficients)
          of the polynomial/vector f
 EXAMPLE: example content; shows an example
+"
+{
   return(leadcoef(f)/leadcoef(cleardenom(f)));

Singular/LIB/presolve.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: presolve.lib,v 1.3 1998-04-03 22:47:10 krueger Exp $
+// $Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $
 //system("random",787422842);
 //(GMG), last modified 97/10/07 by GMG
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: presolve.lib,v 1.3 1998-04-03 22:47:10 krueger Exp $";
+version="$Id: presolve.lib,v 1.4 1998-05-05 11:55:34 krueger Exp $";
 info="
 LIBRARY:  presolve.lib     PROCEDURES FOR PRE-SOLVING POLYNOMIAL EQUATIONS
 …
 proc degreepart (id,int d1,int d2,list #)
 USAGE:   degreepart(id,d1,d2[,v]);  id=ideal/module, d1,d1=integers, v=intvec
+"USAGE:   degreepart(id,d1,d2[,v]);  id=ideal/module, d1,d1=integers, v=intvec
 RETURN:  generators of id of [v-weighted] total degree >= d1 and <= d2
          (default: v = 1,...,1)
 EXAMPLE: example degreepart; shows an example
+"
+{
    def dpart = id;
 …
 proc elimlinearpart (ideal i,list #)
 USAGE:   elimlinearpart(i[,n]);  i=ideal, n=integer
+"USAGE:   elimlinearpart(i[,n]);  i=ideal, n=integer
 RETURN:  list of of 5 objects:
          [1]: (interreduced) ideal obtained from i by eliminating (sbstituting)
 …
          // bei ** spaeter eventuell verbessern
 EXAMPLE: example elimlinearpart; shows an example
+"
+{
    int ii,n,fi,k;
 …
 proc elimpart (ideal i,list #)
 USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers
+"USAGE:   elimpart(i[,n,e]);  i=ideal, n,e=integers
          consider 1-st n vars for elimination (better: substitution),
          e =0: substitute from linear part of i (same as elimlinearpart)
 …
          since it avoids internal ring change and mapping
 EXAMPLE: example elimpart; shows an example
+"
+{
    def P = basering;
 …
 proc elimpartanyr (ideal i, list #)
 USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated,
+"USAGE:   elimpartanyr(i[,p,e]);  i=ideal, p=product of vars to be eliminated,
          e=int (default: p=product of all vars, e=1)
 RETURN:  list of of 6 objects:
 …
          placed correctly and then applies 'elimpart';
 EXAMPLE: example elimpartanyr; shows an example
+"
+{
    def P = basering;
 …
 proc fastelim (ideal i, poly p, list #)
 USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be
+"USAGE:   fastelim(i,p[h,o,a,b,e,m]); i=ideal, p=product of variables to be
          eliminated; h,o,a,b,e integers
          (options for Hilbert-std, 'valvars', elimpart, minimizing)
 …
 RETURN:  ideal obtained from i by eliminating those variables which occur in p
 EXAMPLE: example fastelim; shows an example.
+"
+{
    def P = basering;
 …
 proc faststd (@id,string @s1,string @s2, list #)
 USAGE:   faststd(id,s1,s2[,"hilb","sort","dec",o,"blocks"]);
+"USAGE:   faststd(id,s1,s2[,\"hilb\",\"sort\",\"dec\",o,\"blocks\"]);
          id=ideal/module, s1,s2=strings (names for new ring and maped id)
          o = string (allowed ordstring:"lp","dp","Dp","ls","ds","Ds")
          "hilb","sort","dec","block" options for Hilbert-std, sortandmap
 COMPUTE: create a new ring (with "best" ordering of vars) and compute a
+         o = string (allowed ordstring:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\")
+         \"hilb\",\"sort\",\"dec\",\"block\" options for Hilbert-std, sortandmap
+COMPUTE: create a new ring (with \"best\" ordering of vars) and compute a
          std-basis of id (hopefully faster)
          - If say, s1="R" and s2="j", the new basering has name R and the
+         - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the
            std-basis of the image of id in R has name j
          - "hilb"  : use Hilbert-series driven std-basis computation
          - "sort"  : use 'sortandmap' for a best ordering of vars
          - "dec"   : order vars w.r.t. decreasing complexity (with "sort")
          - "block" : create blockordering, each block having ordstr=o, s.t.
                      vars of same complexity are in one block (with "sort")
+         - \"hilb\"  : use Hilbert-series driven std-basis computation
+         - \"sort\"  : use 'sortandmap' for a best ordering of vars
+         - \"dec\"   : order vars w.r.t. decreasing complexity (with \"sort\")
+         - \"block\" : create blockordering, each block having ordstr=o, s.t.
+                     vars of same complexity are in one block (with \"sort\")
          - o       : defines the basic ordering of the resulting ring
          default: o = ordering of 1-st block of basering - if it is allowed,
                       else o="dp",
                   "sort", if none of the optional parameters is given
+                      else o=\"dp\",
+                  \"sort\", if none of the optional parameters is given
 RETURN:  nothing
 NOTE:    This proc is only useful for hard problems where other methods fail.
          "hilb" is useful for hard orderings (as "lp") or for characteristic 0,
          it is correct for "lp","dp","Dp" (and for blockorderings combining
+         \"hilb\" is useful for hard orderings (as \"lp\") or for characteristic 0,
+         it is correct for \"lp\",\"dp\",\"Dp\" (and for blockorderings combining
          these) but not for s-orderings or if the vars have different weights.
          There seem to be only few cases in which "dec" is fast
+         There seem to be only few cases in which \"dec\" is fast
 EXAMPLE: example faststd; shows an example.
+"
+{
    def @P = basering;
 …
 proc findvars(id, list #)
 USAGE:   findvars(id[,any]); id poly/ideal/vector/module/matrix, any=any type
+"USAGE:   findvars(id[,any]); id poly/ideal/vector/module/matrix, any=any type
 RETURN:  ideal of variables occuring in id, if no second argument is present
          list of 4 objects, if a second argument is given (of any type)
 …
          -[4]: intvec of variables not occuring in id
 EXAMPLE: example findvars; shows an example
+"
+{
    int ii,n;
 …
 proc hilbvec (@id, list #)
 USAGE:   hilbvec(id[,c,o]); id poly/ideal/vector/module/matrix, c,o=strings
          c=char, o=ord in which hilb is computed (default: c="32003", o="dp")
+"USAGE:   hilbvec(id[,c,o]); id poly/ideal/vector/module/matrix, c,o=strings
+         c=char, o=ord in which hilb is computed (default: c=\"32003\", o=\"dp\")
 RETURN:  intvec of 1-st Hilbert-series of id, computed in char c and ordering o
          bei ** aendern falls ringmaps vollstaendig ?
 NOTE:    id must be homogeneous (all vars having weight 1)
 EXAMPLE: example hilbvec; shows an example
+"
+{
    def @P = basering;
 …
 proc linearpart (id)
 USAGE:   linearpart(id);  id=ideal/module
+"USAGE:   linearpart(id);  id=ideal/module
 RETURN:  generators of id of total degree <= 1
 EXAMPLE: example linearpart; shows an example
+"
+{
    return(degreepart(id,0,1));
 …
 proc tolessvars (id ,list #)
 USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix,
+"USAGE:   tolessvars(id,[s1,s2]); id poly/ideal/vector/module/matrix,
          s1,s2=strings (names of: new ring, new ordering)
 CREATE:  nothing, if id contains all vars of the basering. Else, create
 …
          new ring, which will be the basering after the proc has finished.
          The name of the new ring is by default R(n), where n is the number of
          variables in the new ring. If, say, s1 = "newR" then the new ring has
+         variables in the new ring. If, say, s1 = \"newR\" then the new ring has
          name newR. In s2 a different ordering for the new ring may be given
          as an allowed ordstring (default is "dp" resp. "ds", depending whether
+         as an allowed ordstring (default is \"dp\" resp. \"ds\", depending whether
          the first block of the old ordering is a p- resp. an s-ordering).
 DISPLAY: If printlevel >=0, display ideal of vars which have been ommitted from
 …
          occurs in the old ring, for the same reason.
 EXAMPLE: example tolessvars; shows an example
+"
+{
 //---------------- initialisation and check occurence of vars -----------------
 …
 proc solvelinearpart (id,list #)
 USAGE:   solvelinearpart(id[,n]);  id=ideal/module, n=integer
+"USAGE:   solvelinearpart(id[,n]);  id=ideal/module, n=integer
 RETURN:  (interreduced) generators of id of degree <=1 in reduced triangular
          form  (default) or if n=0 [non-reduced triangular form if n!=0]
 …
          char 0 instead!
 EXAMPLE: example solvelinearpart; shows an example
+"
+{
    intvec getoption = option(get);
 …
 proc sortandmap (@id,string @s1,string @s2, list #)
 USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);
+"USAGE:   sortandmap(id,s1,s2[,n1,p1,n2,p2...,o1,m1,o2,m2...]);
          id=poly/ideal/vector/module
          s1,s2=strings (names for new ring and maped id)
          p1,p2,...= product of vars, n1,n2,...=integers
          o1,o2,...= allowed ordstrings, m1,m2,...=integers
          (default: p1=product of all vars, n1=0, o1="dp",m1=0)
+         (default: p1=product of all vars, n1=0, o1=\"dp\",m1=0)
          the last pi (containing the remaining vars) may be omitted
 CREATE:  a new ring and map id into it, the new ring has same char as basering
 …
            id, ni controls the sorting in i-th block (= vars occuring in pi):
            ni=0 (resp.!=0) means that less (resp. more) complex vars come first
          - If say, s1="R" and s2="j", the new basering has name R and the image
+         - If say, s1=\"R\" and s2=\"j\", the new basering has name R and the image
            of id in R has name j
          - oi and mi define the monomial ordering of the i-th block:
 …
            each subblock having ordstr=oi, such that vars of same complexity
            are in one block
            default: oi="dp", mi=0
          - only simple ordstrings oi are allowed:"lp","dp","Dp","ls","ds","Ds"
+           default: oi=\"dp\", mi=0
+         - only simple ordstrings oi are allowed:\"lp\",\"dp\",\"Dp\",\"ls\",\"ds\",\"Ds\"
 RETURN:  nothing
 NOTE:    We define a variable x to be more complex than y (with respect to id)
 …
           # of monomials in coefficient of next smaller power of x,...)
 EXAMPLE: example sortandmap; shows an example
+"
+{
    def @P = basering;
 …
 proc sortvars (id, list #)
 USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
+"USAGE:   sortvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
          p1,p2,...= product of vars, n1,n2,...=integers
          (default: p1=product of all vars, n1=0)
 …
           # of monomials in coefficient of next smaller power of x,...)
 EXAMPLE: example sortvars; shows an example
+"
+{
    int ii,jj,n,s;
 …
 proc valvars (id, list #)
 USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
+"USAGE:   valvars(id[,n1,p1,n2,p2,...]); id=poly/ideal/vector/module,
          p1,p2,...= product of vars, n1,n2,...=integers
          ni controls the ordering of vars occuring in pi:
 …
           # of monomials in coefficient of next smaller power of x,...)
 EXAMPLE: example valvars; shows an example
+"
+{
 //---------------------------- initialization ---------------------------------

Singular/LIB/primdec.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: primdec.lib,v 1.12 1998-04-14 15:35:45 Singular Exp $
+// $Id: primdec.lib,v 1.13 1998-05-05 11:55:34 krueger Exp $
 ///////////////////////////////////////////////////////
 // primdec.lib
 …
 //////////////////////////////////////////////////////
 version="$Id: primdec.lib,v 1.12 1998-04-14 15:35:45 Singular Exp $";
+version="$Id: primdec.lib,v 1.13 1998-05-05 11:55:34 krueger Exp $";
 info="
 LIBRARY: primdec.lib: PROCEDURE FOR PRIMARY DECOMPOSITION (I)
 …
 proc sat1 (ideal id, poly p)
 USAGE:   sat1(id,j);  id ideal, j polynomial
+"USAGE:   sat1(id,j);  id ideal, j polynomial
 RETURN:  saturation of id with respect to j (= union_(k=1...) of id:j^k)
 NOTE:    result is a std basis in the basering
 EXAMPLE: example sat; shows an example
+"
+{
    int @k;
 …
 proc sat2 (ideal id, ideal h)
 USAGE:   sat2(id,j);  id ideal, j polynomial
+"USAGE:   sat2(id,j);  id ideal, j polynomial
 RETURN:  saturation of id with respect to j (= union_(k=1...) of id:j^k)
 NOTE:    result is a std basis in the basering
 EXAMPLE: example sat2; shows an example
+"
+{
    int @k,@i;
 …
 proc factor(poly p)
 USAGE:   factor(p) p poly
+"USAGE:   factor(p) p poly
 RETURN:  list=;
 NOTE:
 EXAMPLE: example factor; shows an example
+"
+{
 …
 proc testPrimary(list pr, ideal k)
 USAGE:   testPrimary(pr,k) pr list, k ideal;
+"USAGE:   testPrimary(pr,k) pr list, k ideal;
 RETURN:  int = 1, if the intersection of the ideals in pr is k, 0 if not
 NOTE:
 EEXAMPLE: example testPrimary ; shows an example
+"
+{
    int i;
 …
 ////////////////////////////////////////////////////////////////////////////////
 proc printPrimary( list l, list #)
 USAGE:   printPrimary(l) l list;
+"USAGE:   printPrimary(l) l list;
 RETURN:  nothing
 NOTE:
 EXAMPLE: example printPrimary; shows an example
+"
+{
    if(size(#)>0)
 …
 proc randomLast(int b)
 USAGE:   randomLast
+"USAGE:   randomLast
 RETURN:  ideal = maxideal(1) but the last variable exchanged by
          a sum of it with a linear random combination of the other
 …
 NOTE:
 EXAMPLE: example randomLast; shows an example
+"
+{
 …
 proc zero_decomp (ideal j,ideal ser,int @wr,list #)
 USAGE:   zero_decomp(j,ser,@wr); j,ser ideals, @wr=0 or 1
+"USAGE:   zero_decomp(j,ser,@wr); j,ser ideals, @wr=0 or 1
          (@wr=0 for primary decomposition, @wr=1 for computaion of associated
          primes)
 …
 NOTE:    Algorithm of Gianni, Traeger, Zacharias
 EXAMPLE: example zero_decomp; shows an example
+"
+{
   def   @P = basering;
 …
 proc ggt (ideal i)
 USAGE:   ggt(i); i list of polynomials
+"USAGE:   ggt(i); i list of polynomials
 RETURN:  poly = ggt(i[1],...,i[size(i)])
 NOTE:
 EXAMPLE: example ggt; shows an example
+"
+{
   int k;
 …
 proc lcmP(ideal i)
 USAGE:   lcm(i); i list of polynomials
+"USAGE:   lcm(i); i list of polynomials
 RETURN:  poly = lcm(i[1],...,i[size(i)])
 NOTE:
 EXAMPLE: example lcm; shows an example
+"
+{
   int k,j;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc clearSB (ideal i,list #)
 USAGE:   clearSB(i); i ideal which is SB ordered by monomial ordering
+"USAGE:   clearSB(i); i ideal which is SB ordered by monomial ordering
 RETURN:  ideal = minimal SB
 NOTE:
 EXAMPLE: example clearSB; shows an example
+"
+{
   int k,j;
 …
 proc independSet (ideal j)
 USAGE:   independentSet(i); i ideal
+"USAGE:   independentSet(i); i ideal
 RETURN:  list = new varstring with the independent set at the end,
                 ordstring with the corresponding block ordering,
 …
 NOTE:
 EXAMPLE: example independentSet; shows an example
+"
+{
    int n,k,di;
 …
 proc maxIndependSet (ideal j)
 USAGE:   maxIndependentSet(i); i ideal
+"USAGE:   maxIndependentSet(i); i ideal
 RETURN:  list = new varstring with the maximal independent set at the end,
                 ordstring with the corresponding block ordering,
 …
 NOTE:
 EXAMPLE: example maxIndependentSet; shows an example
+"
+{
    int n,k,di;
 …
 proc prepareQuotientring (int nnp)
 USAGE:   prepareQuotientring(nnp); nnp int
+"USAGE:   prepareQuotientring(nnp); nnp int
 RETURN:  string = to define Kvar(nnp+1),...,var(nvars)[..rest ]
 NOTE:
 EXAMPLE: example independentSet; shows an example
+"
+{
   ideal @ih,@jh;
 …
 proc minAssPrimes(ideal i, list #)
 USAGE:   minAssPrimes(i); i ideal
+"USAGE:   minAssPrimes(i); i ideal
          minAssPrimes(i,1); i ideal  (to use also the factorizing Groebner)
 RETURN:  list = the minimal associated prime ideals of i
 NOTE:
 EXAMPLE: example minAssPrimes; shows an example
+"
+{
    #[1]=1;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc decomp(ideal i,list #)
 USAGE:   decomp(i); i ideal  (for primary decomposition)   (resp.
+"USAGE:   decomp(i); i ideal  (for primary decomposition)   (resp.
          decomp(i,1);        (for the minimal associated primes) )
 RETURN:  list = list of primary ideals and their associated primes
 …
 NOTE:    Algorithm of Gianni, Traeger, Zacharias
 EXAMPLE: example decomp; shows an example
+"
+{
   def  @P = basering;
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc radicalKL (list m,ideal ser,list #)
 USAGE:   decomp(i); i ideal  (for primary decomposition)   (resp.
+"USAGE:   decomp(i); i ideal  (for primary decomposition)   (resp.
          decomp(i,1);        (for the minimal associated primes) )
 RETURN:  list = list of primary ideals and their associated primes
 …
 NOTE:    Algorithm of Gianni, Traeger, Zacharias
 EXAMPLE: example decomp; shows an example
+"
+{
    ideal i=m[2];

Singular/LIB/primitiv.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: primitiv.lib,v 1.4 1998-04-23 13:23:27 obachman Exp $
+// $Id: primitiv.lib,v 1.5 1998-05-05 11:55:35 krueger Exp $
 // author:  Martin Lamm,  email: lamm@mathematik.uni-kl.de
 // last change:           11.3.98
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: primitiv.lib,v 1.4 1998-04-23 13:23:27 obachman Exp $";
+version="$Id: primitiv.lib,v 1.5 1998-05-05 11:55:35 krueger Exp $";
 info="
 LIBRARY:    primitiv.lib    PROCEDURES FOR FINDING A PRIMITIVE ELEMENT
 …
 proc randomLast(int b)
 USAGE:   randomLast
+"USAGE:   randomLast
 RETURN:  ideal = maxideal(1) but the last variable exchanged by
          a sum of it with a linear random combination of the other
          variables
 EXAMPLE: example randomLast; shows an example
+"
+{
   ideal i=maxideal(1);
 …
 proc primitive(ideal i)
 USAGE:  primitive(i); i ideal of the following form:
+"USAGE:  primitive(i); i ideal of the following form:
  Let k be the ground field of your basering, a_1,...,a_n algebraic over k,
  m_1(x1), m_2(x_1,x_2),...,m_n(x_1,...,x_n) polynomials in k such that
 …
          of given algebraic elements (and minimal polynomials)
 EXAMPLE: example primitive;  shows an example
+"
+{
  def altring=basering;
 …
 proc splitring
 USAGE:  splitring(f,R[,L]);  f poly, univariate, irreducible(!), R string,
+"USAGE:  splitring(f,R[,L]);  f poly, univariate, irreducible(!), R string,
                      L list of polys and/or ideals (optional)
 ACTION: defines a ring with name R, in which f is reducible, and changes to it
 …
         The names of variables and orderings are not affected.
         It is also allowed to call splitring with R=="". Then the old basering
+        It is also allowed to call splitring with R==\"\". Then the old basering
         will be REPLACED by the new ring (with the same name as the old ring).
 …
          (e.g. it cannot be a transcendent ring extension of Q or Z/p)
 EXAMPLE: example splitring;  shows an example
+"
+{
  //----------------- split ist bereits eine proc in 'inout.lib' ! -------------

Singular/LIB/random.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: random.lib,v 1.4 1998-04-03 22:47:12 krueger Exp $
+// $Id: random.lib,v 1.5 1998-05-05 11:55:36 krueger Exp $
 //system("random",787422842);
 //(GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: random.lib,v 1.4 1998-04-03 22:47:12 krueger Exp $";
+version="$Id: random.lib,v 1.5 1998-05-05 11:55:36 krueger Exp $";
 info="
 LIBRARY:  random.lib    PROCEDURES OF RANDOM MATRIX AND POLY OPERATIONS
 …
 proc genericid (id, list #)
 USAGE:   genericid(id,[,p,b]);  id ideal/module, k,p,b integers
+"USAGE:   genericid(id,[,p,b]);  id ideal/module, k,p,b integers
 RETURN:  system of generators of id which are generic, sparse, triagonal linear
          combinations of given generators with coefficients in [1,b] and
 …
 NOTE:    For performance reasons try small bound b in characteristic 0
 EXAMPLE: example genericid; shows an example
+"
+{
 //----------------------------- set defaults ----------------------------------
 …
 proc randomid (id, list #)
 USAGE:   randomid(id,[k,b]);  id ideal/module, b,k integers
+"USAGE:   randomid(id,[k,b]);  id ideal/module, b,k integers
 RETURN:  ideal/module having k generators which are random linear combinations
          of generators of id with coefficients in the interval [-b,b]
 …
 NOTE:    For performance reasons try small bound b in characteristic 0
 EXAMPLE: example randomid; shows an example
+"
+{
 //----------------------------- set defaults ----------------------------------
 …
 proc randommat (int n, int m, list #)
 USAGE:   randommat(n,m[,id,b]);  n,m,b integers, id ideal
+"USAGE:   randommat(n,m[,id,b]);  n,m,b integers, id ideal
 RETURN:  nxm matrix, entries are random linear combinations of elements
          of id and coefficients in [-b,b]
 …
 NOTE:    For performance reasons try small bound b in char 0
 EXAMPLE:  example randommat; shows an example
+"
+{
 //----------------------------- set defaults ----------------------------------
 …
 proc sparseid (int k, int u, list #)
 USAGE:   sparseid(k,u[,o,p,b]);  k,u,o,p,b integers
+"USAGE:   sparseid(k,u[,o,p,b]);  k,u,o,p,b integers
 RETURN:  ideal having k generators in each degree d, u<=d<=o, p percent of
          terms in degree d are 0, the remaining have random coefficients
          in the interval [1,b], (default: o=u=d, p=75, b=30000)
 EXAMPLE: example sparseid; shows an example
+"
+{
 //----------------------------- set defaults ----------------------------------
 …
 proc sparsemat (int n, int m, list #)
 USAGE:   sparsemat(n,m[,p,b]);  n,m,p,b integers
+"USAGE:   sparsemat(n,m[,p,b]);  n,m,p,b integers
 RETURN:  nxm integer matrix, p percent of the entries are 0, the remaining
          are random coefficients >=1 and <= b; [defaults: (p,b) = (75,1)]
 EXAMPLE: example sparsemat; shows an example
+"
+{
    int r,h,ii;
 …
 proc sparsepoly (int u, list #)
 USAGE:   sparsepoly(u[,o,p,b]);  u,o,p,b integers
+"USAGE:   sparsepoly(u[,o,p,b]);  u,o,p,b integers
 RETURN:  poly having only terms in degree d, u<=d<=o, p percent of the terms
          in degree d are 0, the remaining have random coefficients in [1,b),
          (defaults: o=u=d, p=75, b=30000)
 EXAMPLE:  example sparsepoly; shows an example
+"
+{
 //----------------------------- set defaults ----------------------------------
 …
 proc sparsetriag (int n, int m, list #)
 USAGE:   sparsetriag(n,m[,p,b]);  n,m,p,b integers
+"USAGE:   sparsetriag(n,m[,p,b]);  n,m,p,b integers
 RETURN:  nxm lower triagonal integer matrix, diagonal entries equal to 1, about
          p percent of lower diagonal entries are 0, the remaining are random
          integers >=1 and <= b; [defaults: (p,b) = (75,1)]
 EXAMPLE: example sparsetriag; shows an example
+"
+{
    int ii,min,l,r; intmat M[n][m];

Singular/LIB/ring.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: ring.lib,v 1.5 1998-04-03 22:47:13 krueger Exp $
+// $Id: ring.lib,v 1.6 1998-05-05 11:55:37 krueger Exp $
 //(GMG, last modified 03.11.95)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: ring.lib,v 1.5 1998-04-03 22:47:13 krueger Exp $";
+version="$Id: ring.lib,v 1.6 1998-05-05 11:55:37 krueger Exp $";
 info="
 LIBRARY:  ring.lib      PROCEDURES FOR MANIPULATING RINGS AND MAPS
 …
 proc changechar (string newr, string c, list #)
 USAGE:   changechar(newr,c[,r]);  newr,c=strings, r=ring
+"USAGE:   changechar(newr,c[,r]);  newr,c=strings, r=ring
 CREATE:  create a new ring with name `newr` and make it the basering if r is
          an existing ring [default: r=basering].
          The new ring differs from the old ring only in the characteristic.
          If, say, (newr,c) = ("R","0,A") and the ring r exists, the new
+         If, say, (newr,c) = (\"R\",\"0,A\") and the ring r exists, the new
          basering will have name R characteristic 0 and one parameter A.
 RETURN:  No return value
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example changechar; shows an example
+"
+{
    if( size(#)==0 ) { def @r=basering; }
 …
 proc changeord (string newr, string o, list #)
 USAGE:   changeord(newr,o[,r]);  newr,o=strings, r=ring/qring
+"USAGE:   changeord(newr,o[,r]);  newr,o=strings, r=ring/qring
 CREATE:  create a new ring with name `newr` and make it the basering if r is
          an existing ring/qring [default: r=basering].
          The new ring differs from the old ring only in the ordering. If, say,
          (newr,o) = ("R","wp(2,3),dp") and the ring r exists and has >=3
+         (newr,o) = (\"R\",\"wp(2,3),dp\") and the ring r exists and has >=3
          variables, the new basering will have name R and ordering wp(2,3),dp.
 RETURN:  No return value
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example changeord; shows an example
+"
+{
    if( size(#)==0 ) { def @r=basering; }
 …
 proc changevar (string newr, string vars, list #)
 USAGE:   changevar(newr,vars[,r]);  newr,vars=strings, r=ring/qring
+"USAGE:   changevar(newr,vars[,r]);  newr,vars=strings, r=ring/qring
 CREATE:  creates a new ring with name `newr` and makes it the basering if r
          is an existing ring/qring [default: r=basering].
          The new ring differs from the old ring only in the variables. If,
          say, (newr,vars) = ("R","t()") and the ring r exists and has n
+         say, (newr,vars) = (\"R\",\"t()\") and the ring r exists and has n
          variables, the new basering will have name R and variables
          t(1),...,t(n).
          If vars = "a,b,c,d", the new ring will have the variables a,b,c,d.
+         If vars = \"a,b,c,d\", the new ring will have the variables a,b,c,d.
 RETURN:  No return value
 NOTE:    This procedure is useful in connection with the procedure ringtensor,
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example changevar; shows an example
+"
+{
    if( size(#)==0 ) { def @r=basering; }
 …
 proc defring (string s1, string s2, int n, string s3, string s4)
 USAGE:   defring(s1,s2,n,s3,s4);  s1..s4=strings, n=integer
+"USAGE:   defring(s1,s2,n,s3,s4);  s1..s4=strings, n=integer
 CREATE:  Define a ring with name 's1', characteristic 's2', ordering 's4' and
          n variables with names derived from s3 and make it the basering.
          If s3 is a single letter, say s3="a", and if n<=26 then a and the
+         If s3 is a single letter, say s3=\"a\", and if n<=26 then a and the
          following n-1 letters from the alphabeth (cyclic order) are taken as
          variables. If n>26 or if s3 is a single letter followed by (, say
          s3="T(", the variables are T(1),...,T(n).
+         s3=\"T(\", the variables are T(1),...,T(n).
 RETURN:  No return value
 NOTE:    This proc is useful for defining a ring in a procedure.
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example defring; shows an example
+"
+{
    string @newring = "ring "+s1+"=("+s2+"),(";
 …
 proc defrings (int n, list #)
 USAGE:   defrings(n,[p]);  n,p integers
+"USAGE:   defrings(n,[p]);  n,p integers
 CREATE:  Defines a ring with name Sn, characteristic p, ordering ds and n
          variables x,y,z,a,b,...if n<=26 (resp. x(1..n) if n>26) and makes it
 …
 RETURN:  No return value
 EXAMPLE: example defrings; shows an example
+"
+{
    int p;
 …
 proc defringp (int n,list #)
 USAGE:   defringp(n,[p]);  n,p=integers
+"USAGE:   defringp(n,[p]);  n,p=integers
 CREATE:  defines a ring with name Pn, characteristic p, ordering dp and n
          variables x,y,z,a,b,...if n<=26 (resp. x(1..n) if n>26) and makes it
 …
 RETURN:  No return value
 EXAMPLE: example defringp; shows an example
+"
+{
    int p;
 …
 proc extendring (string na, int n, string va, string o, list #)
 USAGE:   extendring(na,n,va,o[iv,i,r]);  na,va,o=strings,
+"USAGE:   extendring(na,n,va,o[iv,i,r]);  na,va,o=strings,
          n,i=integers, r=ring, iv=intvec of positive integers or iv=0
 CREATE:  Define a ring with name `na` which extends the ring r by adding n new
 …
          -- The characteristic is the characteristic of r
          -- The new vars are derived from va. If va is a single letter, say
             va="T", and if n<=26 then T and the following n-1 letters from
+            va=\"T\", and if n<=26 then T and the following n-1 letters from
             T..Z..T (resp. T(1..n) if n>26) are taken as additional variables.
             If va is a single letter followed by (, say va="x(", the new
+            If va is a single letter followed by (, say va=\"x(\", the new
             variables are x(1),...,x(n)
          -- The ordering is the product ordering between the ordering of r and
 …
             not contain a 'c' or a 'C' the same rule applies to ordstr(r).
          -  If no intvec iv is given, or if iv=0, o may be any allowed ordstr,
             like "ds" or "dp(2),wp(1,2,3),Ds(2)" or "ds(a),dp(b),ls" if a and b
+            like \"ds\" or \"dp(2),wp(1,2,3),Ds(2)\" or \"ds(a),dp(b),ls\" if a and b
             are globally (!) defined integers and if a+b+1<=n
             If, however, a and b are local to a proc calling extendring, the
             intvec iv must be used to let extendring know the values of a and b
          -  If an intvec iv !=0 is given, iv[1],iv[2],... is taken for the 1st,
 nd,... block of o, if o contains no substring "w" or "W" i.e. no
             weighted ordering (in the above case o="ds,dp,ls" and iv=a,b).
+nd,... block of o, if o contains no substring \"w\" or \"W\" i.e. no
+            weighted ordering (in the above case o=\"ds,dp,ls\" and iv=a,b).
             If o contains a weighted ordering (only one (!) weighted block is
             allowed) iv[1] is taken as size for the weight-vector, the next
             iv[1] values of iv are taken as weights and the remaining values of
             iv as block-size for the remaining non-weighted blocks.
             e.g. o="dp,ws,Dp,ds", iv=3,2,3,4,2,5 creates the ordering
+            e.g. o=\"dp,ws,Dp,ds\", iv=3,2,3,4,2,5 creates the ordering
             dp(2),ws(2,3,4),Dp(5),ds
 RETURN:  No return value
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example extendring; shows an example
+"
+{
 //--------------- initialization and place c/C of ordering properly -----------
 …
 proc fetchall (R, list #)
 USAGE:   fetchall(R[,s]);  R=ring/qring, s=string
+"USAGE:   fetchall(R[,s]);  R=ring/qring, s=string
 CREATE:  fetch all objects of ring R (of type poly/ideal/vector/module/number/
          matrix) into the basering.
          If no 3rd argument is present, the names are the same as in R. If,
          say, f is a poly in R and the 3rd argument is the string "R", then f
+         say, f is a poly in R and the 3rd argument is the string \"R\", then f
          is maped to f_R etc.
 RETURN:  no return value
 …
          //***at the moment it does not work if R contains a map
 EXAMPLE: example fetchall; shows an example
+"
+{
    list @L@=names(R);
 …
 proc imapall (R, list #)
 USAGE:   imapall(R[,s]);  R=ring/qring, s=string
+"USAGE:   imapall(R[,s]);  R=ring/qring, s=string
 CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
          matrix) into the basering, by applying imap to all objects of R.
          If no 3rd argument is present, the names are the same as in R. If,
          say, f is a poly in R and the 3rd argument is the string "R", then f
+         say, f is a poly in R and the 3rd argument is the string \"R\", then f
          is maped to f_R etc.
 RETURN:  no return value
 …
          //***at the moment it does not work if R contains a map
 EXAMPLE: example imapall; shows an example
+"
+{
    list @L@=names(R);
 …
 proc mapall (R, ideal i, list #)
 USAGE:   mapall(R,i[,s]);  R=ring/qring, i=ideal of basering, s=string
+"USAGE:   mapall(R,i[,s]);  R=ring/qring, i=ideal of basering, s=string
 CREATE:  map all objects of ring R (of type poly/ideal/vector/module/number/
          matrix, map) into the basering, by mapping the jth variable of R to
          the jth generator of the ideal i. If no 3rd argument is present, the
          names are the same as in R. If, say, f is a poly in R and the 3rd
          argument is the string "R", then f is maped to f_R etc.
+         argument is the string \"R\", then f is maped to f_R etc.
 RETURN:  no return value
 NOTE:    This procedure has the same effect as defining a map, say psi, by
 …
 CAUTION: mapall does not work inside a procedure
 EXAMPLE: example mapall; shows an example
+"
+{
    list @L@=names(R); map @psi@ = R,i;
 …
 proc ringtensor (string s, list #)
 USAGE:   ringtensor(s,r1,r2,...); s=string, r1,r2,...=rings
+"USAGE:   ringtensor(s,r1,r2,...); s=string, r1,r2,...=rings
 CREATE:  A new base ring with name `s` if r1,r2,... are existing rings.
          If, say, s = "R" and the rings r1,r2,... exist, the new ring will
+         If, say, s = \"R\" and the rings r1,r2,... exist, the new ring will
          have name R, variables from all rings r1,r2,... and as monomial
          ordering the block (product) ordering of r1,r2,... . Hence, R
 …
          start with @ (see the file HelpForProc)
 EXAMPLE: example ringtensor; shows an example
+"
+{
    int @ii,@q;

Singular/LIB/sing.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: sing.lib,v 1.9 1998-04-03 22:47:13 krueger Exp $
+// $Id: sing.lib,v 1.10 1998-05-05 11:55:38 krueger Exp $
 //system("random",787422842);
 //(GMG/BM, last modified 26.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: sing.lib,v 1.9 1998-04-03 22:47:13 krueger Exp $";
+version="$Id: sing.lib,v 1.10 1998-05-05 11:55:38 krueger Exp $";
 info="
 LIBRARY:  sing.lib      PROCEDURES FOR SINGULARITIES
 …
 proc deform (ideal id)
 USAGE:   deform(id); id=ideal or poly
+"USAGE:   deform(id); id=ideal or poly
 RETURN:  matrix, columns are kbase of infinitesimal deformations
 EXAMPLE: example deform; shows an example
+"
+{
    list L=T1(id,"");
 …
 proc dim_slocus (ideal i)
 USAGE:   dim_slocus(i);  i ideal or poly
+"USAGE:   dim_slocus(i);  i ideal or poly
 RETURN:  dimension of singular locus of i
 EXAMPLE: example dim_slocus; shows an example
+"
+{
    return(dim(std(slocus(i))));
 …
 proc is_active (poly f, id)
 USAGE:   is_active(f,id); f poly, id ideal or module
+"USAGE:   is_active(f,id); f poly, id ideal or module
 RETURN:  1 if f is an active element modulo id (i.e. dim(id)=dim(id+f*R^n)+1,
          if id is a submodule of R^n) resp. 0 if f is not active.
 …
          components). proc is_reg tests whether f is a regular parameter
 EXAMPLE: example is_active; shows an example
+"
+{
    if( size(id)==0 ) { return(1); }
 …
 proc is_ci (ideal i)
 USAGE:   is_ci(i); i ideal
+"USAGE:   is_ci(i); i ideal
 RETURN:  intvec = sequence of dimensions of ideals (j[1],...,j[k]), for
          k=1,...,size(j), where j is minimal base of i. i is a complete
 …
          printlevel >=0: display comments (default)
 EXAMPLE: example is_ci; shows an example
+"
+{
    int n; intvec dimvec; ideal id;
 …
 proc is_is (ideal i)
 USAGE:   is_is(id);  id ideal or poly
+"USAGE:   is_is(id);  id ideal or poly
 RETURN:  intvec = sequence of dimensions of singular loci of ideals
          generated by id[1]..id[i], k = 1..size(id); dim(0-ideal) = -1;
 …
 NOTE:    printlevel >=0: display comments (default)
 EXAMPLE: example is_is; shows an example
+"
+{
   int l; intvec dims; ideal j;
 …
 proc is_reg (poly f, id)
 USAGE:   is_reg(f,id); f poly, id ideal or module
+"USAGE:   is_reg(f,id); f poly, id ideal or module
 RETURN:  1 if multiplication with f is injective modulo id, 0 otherwise
 NOTE:    let R be the basering and id a submodule of R^n. The procedure checks
 …
          //**quotient ring
 EXAMPLE: example is_reg; shows an example
+"
+{
    if( f==0 ) { return(0); }
 …
 proc is_regs (ideal i, list #)
 USAGE:   is_regs(i[,id]); i poly, id ideal or module (default: id=0)
+"USAGE:   is_regs(i[,id]); i poly, id ideal or module (default: id=0)
 RETURN:  1 if generators of i are a regular sequence modulo id, 0 otherwise
 NOTE:    let R be the basering and id a submodule of R^n. The procedure checks
 …
          printlevel >=1: display comments during computation
 EXAMPLE: example is_regs; shows an example
+"
+{
    int d,ii,r;
 …
 proc milnor (ideal i)
 USAGE:   milnor(i); i ideal or poly
+"USAGE:   milnor(i); i ideal or poly
 RETURN:  Milnor number of i, if i is ICIS (isolated complete intersection
          singularity) in generic form, resp. -1 if not
 …
          printlevel >=0: display comments (default)
 EXAMPLE: example milnor; shows an example
+"
+{
   i = simplify(i,10);     //delete zeroes and multiples from set of generators
 …
 proc nf_icis (ideal i)
 USAGE:   nf_icis(i); i ideal
+"USAGE:   nf_icis(i); i ideal
 RETURN:  ideal = generic linear combination of generators of i if i is an ICIS
          (isolated complete intersection singularity), return i if not
 …
          printlevel >=0: display comments (default)
 EXAMPLE: example nf_icis; shows an example
+"
+{
    i = simplify(i,10);  //delete zeroes and multiples from set of generators
 …
 proc slocus (ideal i)
 USAGE:   slocus(i);  i dieal
+"USAGE:   slocus(i);  i dieal
 RETURN:  ideal of singular locus of i
 NOTE:    this proc considers lower dimensional components as singular
 EXAMPLE: example slocus; shows an example
+"
+{
   int cod  = nvars(basering)-dim(std(i));
 …
 proc spectrum (poly f, intvec w)
 USAGE:   spectrum(f,w);  f=poly, w=intvec;
+"USAGE:   spectrum(f,w);  f=poly, w=intvec;
 ASSUME:  f is a weighted homogeneous isolated singularity w.r.t. the weights
          given by w; w must consist of as many positive integers as there
 …
          singularity, displays a warning in this case
 EXAMPLE: example spectrum; shows an example
+"
+{
    int i,d,W;
 …
 proc Tjurina (id, list #)
 USAGE:   Tjurina(id[,<any>]);  id=ideal or poly
+"USAGE:   Tjurina(id[,<any>]);  id=ideal or poly
 ASSUME:  id=ICIS (isolated complete intersection singularity)
 RETURN:  standard basis of Tjurina-module of id,
 …
 NOTE:    Tjurina number = -1 implies that id is not an ICIS
 EXAMPLE: example Tjurina; shows examples
+"
+{
 //---------------------------- initialisation ---------------------------------
 …
 proc tjurina (ideal i)
 USAGE:   tjurina(id);  id=ideal or poly
+"USAGE:   tjurina(id);  id=ideal or poly
 ASSUME:  id=ICIS (isolated complete intersection singularity)
 RETURN:  int = Tjurina number of id
 NOTE:    Tjurina number = -1 implies that id is not an ICIS
 EXAMPLE: example tjurina; shows an example
+"
+{
    return(vdim(Tjurina(i)));
 …
 proc T1 (ideal id, list #)
 USAGE:   T1(id[,<any>]);  id = ideal or poly
+"USAGE:   T1(id[,<any>]);  id = ideal or poly
 RETURN:  T1(id): of type module/ideal if id is of type ideal/poly.
          We call T1(id) the T1-module of id. It is a std basis of the
 …
          For a complete intersection the proc Tjurina is faster
 EXAMPLE: example T1; shows an example
+"
+{
    ideal J=simplify(id,10);
 …
 proc T2 (ideal id, list #)
 USAGE:   T2(id[,<any>]);  id = ideal
+"USAGE:   T2(id[,<any>]);  id = ideal
 RETURN:  T2(id): T2-module of id . This is a std basis of a presentation of
          the module of obstructions of R=P/id, if P is the basering.
 …
          Use proc miniversal to get equations of miniversal deformation.
 EXAMPLE: example T2; shows an example
+"
+{
 //--------------------------- initialisation ----------------------------------
 …
 proc T12 (ideal i, list #)
 USAGE:   T12(i[,any]);  i = ideal
+"USAGE:   T12(i[,any]);  i = ideal
 RETURN:  T12(i): list of 2 modules:
              std basis of T1-module =T1(i), 1st order deformations
 …
          the list contains all objects used by proc miniversal
 EXAMPLE: example T12; shows an example
+"
+{
 //--------------------------- initialisation ----------------------------------
 …
 ///////////////////////////////////////////////////////////////////////////////
 proc codim (id1, id2)
 USAGE:   codim(id1,id2); id1,id2 ideal or module, both must be standard bases
+"USAGE:   codim(id1,id2); id1,id2 ideal or module, both must be standard bases
 RETURN:  int, which is:
 . the codimension of id2 in id1, i.e. the vectorspace dimension of
 …
          sum of the coefficients of q(t) (n dimension of basering)
 EXAMPLE: example codim; shows an example
+"
+{
    intvec iv1, iv2, iv;

Singular/LIB/standard.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: standard.lib,v 1.7 1998-04-03 22:47:14 krueger Exp $
+// $Id: standard.lib,v 1.8 1998-05-05 11:55:38 krueger Exp $
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: standard.lib,v 1.7 1998-04-03 22:47:14 krueger Exp $";
+version="$Id: standard.lib,v 1.8 1998-05-05 11:55:38 krueger Exp $";
 info="
 LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
 …
 proc stdfglm (ideal i, list #)
 USAGE:   stdfglm(i[,s]); i ideal, s string (any allowed ordstr of a ring)
+"USAGE:   stdfglm(i[,s]); i ideal, s string (any allowed ordstr of a ring)
 RETURN:  stdfglm(i): standard basis of i in the basering, calculated via fglm
                      from ordering "dp" to the ordering of the basering.
+                     from ordering \"dp\" to the ordering of the basering.
          stdfglm(i,s): standard basis of i in the basering, calculated via
                      fglm from ordering s to the ordering of the basering.
 EXAMPLE: example stdfglm; shows an example
+"
+{
    string os;
 …
 proc stdhilbert(ideal i,list #)
 USAGE:   stdhilbert(i);  i ideal
+"USAGE:   stdhilbert(i);  i ideal
          stdhilbert(i,v); i homogeneous ideal, v intvec (the Hilbert function)
 RETURN:  stdhilbert(i): a standard basis of i (computing v internally)
          stdhilbert(i,v): standard basis of i, using the given Hilbert function
 EXAMPLE: example stdhilbert; shows an example
+"
+{
    def R=basering;

Singular/LIB/tex.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: tex.lib,v 1.5 1998-04-03 22:47:15 krueger Exp $
+// $Id: tex.lib,v 1.6 1998-05-05 11:55:39 krueger Exp $
 //
 // author : Christian Gorzel email: gorzelc@math.uni-muenster.de
 …
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: tex.lib,v 1.5 1998-04-03 22:47:15 krueger Exp $";
+version="$Id: tex.lib,v 1.6 1998-05-05 11:55:39 krueger Exp $";
 info="
 LIBRARY: tex.lib      PROCEDURES FOR TYPESET OF SINGULAROBJECTS IN TEX
 …
 proc closetex(string fname, list #)
 USAGE:   closetex(fname[,style]); fname,style = string
+"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;
+         preceeding \">>\" end ending \".tex\" may miss in fname;
          overwriting an existing file is not possible
 EXAMPLE: example closetex; shows an example
+"
+{
   string default = "latex2e";       // may be changed appropriatly (C.G.)
 …
 proc tex(string fname, list #)
 USAGE:   tex(fname[,style]); fname,style = string
+"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
+         ending \".tex\" may miss in fname
 EXAMPLE: example tex; shows an example
+"
+{
   string default = "latex2e";           // may be changed appropriatly (C.G.)
 …
 proc opentex(string fname, list #)
 USAGE:   opentex(fname[,style]); fname,style = string
+"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
 EXAMPLE: example opentex; shows an example
+"
+{
   int i =1;
 …
 proc texdemo(list #)
 USAGE:   texdemo();
+"USAGE:   texdemo();
 RETURN:  nothing; generates automatically a LaTeX2e file called: texlibdemo.tex
          explaining the  features of tex.lib and its gloabl variables
 NOTE:    this proc takes some minutes
 EXAMPLE: example texdemo; executes the generation
+"
 { int make_demo = size(#);
 …
 proc texfactorize(string fname, poly f, list #)
 USAGE:   opentex(fname,f); fname = string; f = poly
+"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
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname
 EXAMPLE: example texfactorize; shows an example
+"
+{
   def @r = basering;
 …
 proc texmap(string fname, def m, def @r1, def @r2, list #)
 USAGE:   texmap(fname,f); fname = string; m = string/map, @r1,@r2 = ring
+"USAGE:   texmap(fname,f); fname = string; m = string/map, @r1,@r2 = ring
 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
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname
 EXAMPLE: example texmap; shows an example
+"
+{
   int saveDollars= defined(NoDollars);
 …
 proc texname(string fname, string s)
 USAGE:   texname(fname,s);  fname,s = string
 RETURN:  the string s if fname == the empty string "" ;
+"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;
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname;
 EXAMPLE: example texname; shows an example
+"
+{
   string st, extr;
 …
 proc texobj(string fname, list #)
 USAGE:   texobj(fname,l); fname = string,l = list of Singular dataypes
+"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;
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname;
 EXAMPLE: example texobj; shows an example
+"
+{
  int i,j,k,nr,nc,linear,Tw,Dollars;
 …
 proc texproc(string fname,string pname)
 USAGE:   opentex(fname,pname); fname,pname = string
+"USAGE:   opentex(fname,pname); fname,pname = string
 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;
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname;
 CAUTION: texproc cannot applied on itself correctly
 EXAMPLE: example texproc; shows an example
+"
+{
   int i,j=1,1;
 …
 proc texring(string fname, def r, list #)
 USAGE:   texring(fname, r[,l]); fname = string; r = ring;
+"USAGE:   texring(fname, r[,l]); fname = string; r = ring;
                                 l=list of strings : controls the symbol for
                                 coefficint 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;
+NOTE:    preceeding \">>\" end ending \".tex\" may miss in fname;
 EXAMPLE: example texring; shows an example
+"
+{
   int i,galT,flag,mipo,nopar,Dollars,TB,TA;
 …
 proc rmx(string fname)
 USAGE:   rmx(fname); fname = string
+"USAGE:   rmx(fname); fname = string
 RETURN:  nothing; removes .log and .aux files associated to file <fname>
          removes tex and xdvi file too, if suffix ".tex" or ".dvi" is given
+         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
 EXAMPLE: example rmx; shows an example
+"
+{
   int i,suffix= 1,0;
 …
 proc xdvi(string fname, list #)
 USAGE:   xdvi(fname[,style]); fname,style = string
+"USAGE:   xdvi(fname[,style]); fname,style = string
 RETURN:  nothing; displays dvi-file fname.dvi with previewer xdvi
 NOTE:    ending .dvi may miss in fname
          style overwrites the default setting xdvi
 EXAMPLE: example xdvi ; shows an example
+"
+{
   int i=1;
 …
+}
 proc parst(string s,int sec)                // parse parameter
+proc parst(string s,int sec)"                // parse parameter
 // sec parameter to see if in parsp a fraction follows
+"
 { int i,j =1,-1;
   int b,k,jj,mz;                         // begin and end

Singular/LIB/tst.lib

-                      r4996f52
+                      rd2b2a7
 // $Id: tst.lib,v 1.3 1998-04-03 22:47:15 krueger Exp $
+// $Id: tst.lib,v 1.4 1998-05-05 11:55:40 krueger Exp $
 //(obachman, last modified 2/13/98)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: tst.lib,v 1.3 1998-04-03 22:47:15 krueger Exp $";
+version="$Id: tst.lib,v 1.4 1998-05-05 11:55:40 krueger Exp $";
 info="
 LIBRARY:  tst.lib      PROCEDURES FOR RUNNING AUTOMATIC TST TESTS
 …
 proc tst_system(string s)
 USAGE:    tst_system(s); s string
 RETURN:   string which is stdout and stderr of system("sh", s)
+"USAGE:    tst_system(s); s string
+RETURN:   string which is stdout \x and stderr of system(\"sh\", s)
 EXAMPLE:  example tst_system; shows examples
+"
+{
   string tmpfile = "/tmp/tst_" + string(system("pid"));
 …
 proc tst_ignore
 USAGE:    tst_ignore(any,[keyword], [link])
+"USAGE:    tst_ignore(any,[keyword], [link])
             any     -- valid argument to string()
             keyword -- one of "time" or "memory"
+            keyword -- one of \"time\" or \"memory\"
             link    -- a link which can be written to
 RETURN:   none; writes string(any) to link (or stdout, if no link given),
           prepending prefix "// ignore:", or "// ignore: time:",
           "//ignore: memory:"  if called with the respective keywords;
+          prepending prefix \"// ignore:\", or \"// ignore: time:\",
+          \"//ignore: memory:\"  if called with the respective keywords;
           should be used in tst files to output system dependent data
           (like date, pathnames) and timings With the keyword "time",
           resp. memory usgae with the keyword "memory"
+          (like date, pathnames) { and timings With the keyword \"time\",
+          resp. memory usage with the keyword \"memory\"
 EXAMPLE:  example tst_ignore; shows examples
+"
+{
   string s;
 …
 proc tst_init
 USAGE:   tst_init()
+"USAGE:   tst_init()
 RETURN:  none; writes some identification data to stdout;
          should be called as first routine in a tst file
 EXAMPLE: example tst_init; shows example
+"
+{
   tst_ignore("USER    : " + system("getenv", "USER"));

Context Navigation

Changeset d2b2a7 in git for Singular/LIB

Legend:

Singular/LIB/classify.lib

Singular/LIB/deform.lib

Singular/LIB/elim.lib

Singular/LIB/factor.lib

Singular/LIB/fastsolv.lib

Singular/LIB/finvar.lib

Singular/LIB/general.lib

Singular/LIB/hnoether.lib

Singular/LIB/homolog.lib

Singular/LIB/inout.lib

Singular/LIB/invar.lib

Singular/LIB/makedbm.lib

Singular/LIB/matrix.lib

Singular/LIB/normal.lib

Singular/LIB/poly.lib

Singular/LIB/presolve.lib

Singular/LIB/primdec.lib

Singular/LIB/primitiv.lib

Singular/LIB/random.lib

Singular/LIB/ring.lib

Singular/LIB/sing.lib

Singular/LIB/standard.lib

Singular/LIB/tex.lib

Singular/LIB/tst.lib

Download in other formats: