Changeset 50cbdc – Singular

Singular/GMPrat.cc

-                      r3de58c
+                      r50cbdc
 #include <stdlib.h>
-#include <float.h>
 #include <math.h>
 #include <ctype.h>
 …
+}
-Rational::Rational( long int a )
+{
-    p = new rep;
-    mpq_init( p->rat );
-    mpq_set_si( p->rat,a,1 );
+}
-Rational::Rational( unsigned long int a )
+{
-    p = new rep;
-    mpq_init( p->rat );
-    mpq_set_ui( p->rat,a,1 );
+}
 Rational::Rational( int a )
+{
 …
+}
-Rational::Rational( unsigned int a )
+{
-    p = new rep;
-    mpq_init( p->rat );
-    mpq_set_ui( p->rat,(unsigned long)a,1 );
+}
 Rational::Rational( const Rational& a )
+{
 …
+}
-Rational::Rational( double a )
+{
-    mpz_t   h1,h2;
-    int     i=0;
-    double  aa=a;
-    p = new rep;
-    mpq_init( p->rat );
-    mpz_init_set_ui( h1,1 );
-    while( fabs( 10.0*aa ) < DBL_MAX && i<DBL_DIG )
+    {
-        aa *= 10.;
-        mpz_mul_ui( h1,h1,10 );
-        i++;
+    }
-    mpz_init_set_d( h2,aa );
-    mpq_set_num( p->rat,h2 );
-    mpq_set_den( p->rat,h1 );
-    mpq_canonicalize( p->rat );
-    mpz_clear( h1 );
-    mpz_clear( h2 );
+}
-Rational::Rational(float a)
+{
-    mpz_t h1,h2;
-    int i=0;
-    double aa=a;
-    p=new rep;
-    mpq_init(p->rat);
-    mpz_init_set_ui(h1,1);
-    while(fabs(10.*aa) < FLT_MAX && i<FLT_DIG){
-        aa*=10.;
-        mpz_mul_ui(h1,h1,10);
-        i++;
+    }
-    mpz_init_set_d(h2,aa);
-    mpq_set_num(p->rat,h2);
-    mpq_set_den(p->rat,h1);
-    mpq_canonicalize(p->rat);
-    mpz_clear(h1);
-    mpz_clear(h2);
+}
-// ----------------------------------------------------------------------------
-//  Create a Rational from a string like "+1234.5678e-1234"
-// ----------------------------------------------------------------------------
-Rational::Rational( char *s )
+{
-    mpz_t   h1;
-    int     exp=0,i=0;
-    char    *s1,*s2,*ss;
-    ss = new char[strlen(s)+1];
-    strcpy( ss,s );
-    s1 = ss;
-    p = new rep;
-    mpq_init( p->rat );
-    if( isdigit(s1[0]) || s1[0]=='-' || s1[0]=='+' )
+    {
-        if (s1[0]=='+') ++s1;
-        if (s1[0]=='-') ++i;
-        while( isdigit( s1[i] ) )
+        {
-            ++i;
+        }
-        if (s1[i]=='.')
+        {
-            ++i;
-            while( isdigit( s1[i] ) )
+            {
-                s1[i-1]=s1[i];
-                ++i;
-                --exp;
+            }
-            s1[i-1]='\0';
+        }
-        if (s1[i]=='e' || s1[i]=='E')
+        {
-            s2=s1+i+1;
+        }
-        else
-            s2="";
-        s1[i]='\0';
-        i=exp+atoi(s2);
-        mpz_init_set_str(h1,s1,10);
-        delete[] ss;
-        mpq_set_z(p->rat,h1);
-        mpq_set_ui(save.p->rat,10,1);
-        if (i>0)
+        {
-            for(int j=0;j<i;j++)
-                mpq_mul(p->rat,p->rat,save.p->rat);
+        }
-        else if (i<0)
+        {
-            for(int j=0;j>i;j--)
-                mpq_div(p->rat,p->rat,save.p->rat);
+        }
-        mpq_canonicalize(p->rat);
-        mpz_clear(h1);
+    }
+}
 // ----------------------------------------------------------------------------
 //  Constructors with two arguments: numerator and denominator
 // ----------------------------------------------------------------------------
-Rational::Rational(long int a, unsigned long int b)
+{
-    p = new rep;
-    mpq_init( p->rat );
-    mpq_set_si( p->rat,a,b );
-    mpq_canonicalize( p->rat );
+}
-Rational::Rational(unsigned long int a, unsigned long int b)
+{
-    p=new rep;
-    mpq_init(p->rat);
-    mpq_set_ui(p->rat,a,b);
-    mpq_canonicalize(p->rat);
+}
-Rational::Rational(int a, unsigned int b)
+{
-    p=new rep;
-    mpq_init(p->rat);
-    mpq_set_si(p->rat,(long int) a,(unsigned long int) b);
-    mpq_canonicalize(p->rat);
+}
-Rational::Rational(unsigned int a, unsigned int b)
+{
-    p=new rep;
-    mpq_init(p->rat);
-    mpq_set_ui(p->rat,(unsigned long) a,(unsigned long int) b);
-    mpq_canonicalize(p->rat);
+}
 Rational::Rational(const Rational& a, const Rational& b)
 …
     mpq_init(p->rat);
     mpq_div(p->rat, a.p->rat, b.p->rat);
+}
-Rational::Rational(long int a, long int b)
+{
-    if (b<0) a=-a;
-    p=new rep;
-    mpq_init(p->rat);
-    mpq_set_si(p->rat,a,abs(b));
-    mpq_canonicalize(p->rat);
+}
 …
+}
-Rational::Rational(char *sn, char *sd)
+{
-  Rational
-    h=sd;
-  p=new rep;
-  mpq_init(p->rat);
-  *this=sn;
-  mpq_div(p->rat,p->rat,h.p->rat);
+}
 // ----------------------------------------------------------------------------
 //  Destructor
 …
 //  Assignment operators
 // ----------------------------------------------------------------------------
 Rational& Rational::operator=(int a)
+{
   disconnect();
   mpq_set_si(p->rat,(long int) a,1);
-  return *this;
+}
-Rational& Rational::operator=(double a)
+{
-  mpz_t
-    h1,
-    h2;
-  int
-    i=0;
-  double
-    aa=a;
-  disconnect();
-  mpz_init_set_ui(h1,1);
-  while(fabs(10.*aa) < DBL_MAX && i<DBL_DIG){
-    aa*=10.;
-    mpz_mul_ui(h1,h1,10);
-    i++;
+  }
-  mpz_init_set_d(h2,aa);
-  mpq_set_num(p->rat,h2);
-  mpq_set_den(p->rat,h1);
-  mpq_canonicalize(p->rat);
-  mpz_clear(h1);
-  mpz_clear(h2);
-  return *this;
+}
-Rational& Rational::operator=(float a)
+{
-  mpz_t
-    h1,
-    h2;
-  int
-    i=0;
-  double
-    aa=a;
-  disconnect();
-  mpz_init_set_ui(h1,1);
-  while(fabs(10.*aa) < FLT_MAX && i<FLT_DIG){
-    aa*=10.;
-    mpz_mul_ui(h1,h1,10);
-    i++;
+  }
-  mpz_init_set_d(h2,aa);
-  mpq_set_num(p->rat,h2);
-  mpq_set_den(p->rat,h1);
-  mpq_canonicalize(p->rat);
-  mpz_clear(h1);
-  mpz_clear(h2);
-  return *this;
+}
-Rational& Rational::operator=(char *s)
+{
-  mpz_t
-    h1;
-  int
-    exp=0,
-    i=0;
-  char
-    *s1=s,
-    *s2,
-    *ss;
-  ss=new char[strlen(s)+1];
-  strcpy(ss,s);
-  s1=ss;
-  disconnect();
-  if (isdigit(s1[0]) || s1[0]=='-' || s1[0]=='+'){
-    if (s1[0]=='+') ++s1;
-    if (s1[0]=='-') ++i;
-    while(isdigit(s1[i]))
-      ++i;
-    if (s1[i]=='.'){
-      ++i;
-      while(isdigit(s1[i])){
-        s1[i-1]=s1[i];
-        ++i;
-        --exp;
+      }
-      s1[i-1]='\0';
+    }
-    if (s1[i]=='e' || s1[i]=='E'){
-      s2=s1+i+1;
+    }
-    else
-      s2="";
-    s1[i]='\0';
-    i=exp+atoi(s2);
-    mpz_init_set_str(h1,s1,10);
-    delete[] ss;
-    mpq_set_z(p->rat,h1);
-    mpq_set_ui(save.p->rat,10,1);
-    if (i>0){
-      for(int j=0;j<i;j++)
-        mpq_mul(p->rat,p->rat,save.p->rat);
+    }
-    else if (i<0){
-      for(int j=0;j>i;j--)
-        mpq_div(p->rat,p->rat,save.p->rat);
+    }
-    mpq_canonicalize(p->rat);
-    mpz_clear(h1);
+  }
-  else
-    mpq_set_ui(p->rat,0,1);
   return *this;
+}
 …
 // ----------------------------------------------------------------------------
+Rational::operator bool()
+{
+    if (mpq_sgn(p->rat)) return true;
+    return false;
+}
+Rational::operator long int()
+Rational::operator int()
+{
   mpz_t
 …
   return ret_val;
+}
-Rational::operator unsigned long int()
+{
-  mpz_t
-    h;
-  unsigned long int
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_ui(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator int()
+{
-  mpz_t
-    h;
-  long int
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_si(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator unsigned int()
+{
-  mpz_t
-    h;
-  unsigned long int
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_ui(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator short int()
+{
-  mpz_t
-    h;
-  short int
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_si(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator unsigned short int()
+{
-  mpz_t
-    h;
-  unsigned short int
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_ui(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator char()
+{
-  mpz_t
-    h;
-  char
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_si(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator unsigned char()
+{
-  mpz_t
-    h;
-  unsigned char
-    ret_val;
-  mpz_init(h);
-  mpz_tdiv_q(h,mpq_numref(p->rat),mpq_denref(p->rat));
-  ret_val=mpz_get_ui(h);
-  mpz_clear(h);
-  return ret_val;
+}
-Rational::operator double()
+{
-  return mpq_get_d(p->rat);
+}
-Rational::operator float()
+{
-  return mpq_get_d(p->rat);
+}

Singular/GMPrat.h

-                      r3de58c
+                      r50cbdc
     Rational( );
-    Rational( long int );
-    Rational( unsigned long int );
     Rational( int );
-    Rational( unsigned int );
-    Rational( double );
-    Rational( float );
-    Rational( char* );
     Rational( const Rational& );
-    Rational( long int,unsigned long int );
-    Rational( unsigned long int,unsigned long int );
-    Rational( int, unsigned int );
-    Rational( unsigned int,unsigned int );
     Rational( const Rational&,const Rational& );
-    Rational( long int,long int );
     Rational( int,int );
-    Rational( char*,char* );
     ~Rational( );
     Rational& operator = ( int );
-    Rational& operator = ( double );
-    Rational& operator = ( float );
     Rational& operator = ( char *s );
     Rational& operator = ( const Rational& );
 …
     int      get_num_si( );
     int      get_den_si( );
-    operator bool( );
-    operator long int( );
-    operator unsigned long int( );
     operator int( );
-    operator unsigned int( );
-    operator short int( );
-    operator unsigned short int( );
-    operator char( );
-    operator unsigned char( );
-    operator double( );
-    operator float( );
     Rational  operator - ( );

Singular/LIB/all.lib

-                      r3de58c
+                      r50cbdc
 // $Id: all.lib,v 1.36 2001-05-17 14:36:29 Singular Exp $
+// $Id: all.lib,v 1.37 2001-08-27 14:47:46 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: all.lib,v 1.36 2001-05-17 14:36:29 Singular Exp $";
+version="$Id: all.lib,v 1.37 2001-08-27 14:47:46 Singular Exp $";
 category = "General purpose";
 info="

Singular/LIB/brnoeth.lib

-                      r3de58c
+                      r50cbdc
+version="$Id: brnoeth.lib,v 1.11 2001-02-09 13:11:35 lossen Exp $";
+version="$Id: brnoeth.lib,v 1.12 2001-08-27 14:47:46 Singular Exp $";
+category="Miscellaneous";
 info="
 LIBRARY:   brnoeth.lib  Brill-Noether Algorithm, Weierstrass-SG and AG-codes
 …
           In the intvec L[4] (conductor) the i-th entry corresponds to the
           i-th entry in the list of places L[3].
           With no optional arguments, the conductor is computed by
           local invariants of the singularities; otherwise it is computed
 …
           of the places above P in the list of closed places L[3]. @*
           If the point is at infinity, P[1] is a homogeneous irreducible
           polynomial in two variables.
           If @code{printlevel>=0} additional comments are displayed (default:
           @code{printlevel=0}).
+          polynomial in two variables.
+          If @code{printlevel>=0} additional comments are displayed (default:
+          @code{printlevel=0}).
 KEYWORDS: Hamburger-Noether expansions; adjunction divisor
 SEE ALSO: closed_points, NSplaces
 …
   Aff_SLocus;             // ideal of the affine singular locus
   Aff_SPoints[1];         // 1st affine singular point: (1:1:1), no.1
   Inf_Points[1];          // singular point(s) at infinity: (1:0:0), no.4
+  Inf_Points[1];          // singular point(s) at infinity: (1:0:0), no.4
   Inf_Points[2];          // list of non-singular points at infinity
   //
 …
   //
   pause("press RETURN");
   // we look at the place(s) of degree 2 by changing to the ring
+  // we look at the place(s) of degree 2 by changing to the ring
   C[5][2][1];
   def S(2)=C[5][2][1];
+  def S(2)=C[5][2][1];
   setring S(2);
   POINTS;                // base point(s) of place(s) of degree 2: (1:a:1)
 …
           See @ref{Adj_div} for a description of the entries in L.
 NOTE:     The list_expression should be the output of the procedure Adj_div.@*
           If @code{printlevel>=0} additional comments are displayed (default:
           @code{printlevel=0}).
+          If @code{printlevel>=0} additional comments are displayed (default:
+          @code{printlevel=0}).
 SEE ALSO: closed_points, Adj_div
 EXAMPLE:  example NSplaces; shows an example
 …
   list C=Adj_div(x3y+y3+x);
   C=NSplaces(3,C);
   // the first 3 Places in C[3] are of degree 1.
+  // the first 3 Places in C[3] are of degree 1.
   // we define the rational divisor G = 4*C[3][1]+4*C[3][3] (of degree 8):
   intvec G=4,0,4;
 …
   // programm
   poly auxp=gcd(F[1],F[2]);
   return(ideal(division(auxp,F)[1]));
+  return(ideal(division(F,auxp)[1]));
+}
 ///////////////////////////////////////////////////////////////////////////////
 …
 NOTE:     The procedure must be called from the ring CURVE[1][2],
           where CURVE is the output of the procedure @code{NSplaces}.
 @*        i represents the place CURVE[3][i].
+@*        i represents the place CURVE[3][i].
 @*        Rational functions are represented by numerator/denominator
           in form of ideals with two homogeneous generators.
 …
   def ER=HC[1][4];
   setring ER;
   intvec G=5;      // the rational divisor G = 5*HC[3][1]
+  intvec G=5;      // the rational divisor G = 5*HC[3][1]
   intvec D=2..9;   // D = sum of the rational places no. 2..9 over F_4
   // let us construct the corresponding evaluation AG code :
 …
   def ER=HC[1][4];
   setring ER;
   intvec G=5;      // the rational divisor G = 5*HC[3][1]
+  intvec G=5;      // the rational divisor G = 5*HC[3][1]
   intvec D=2..9;   // D = sum of the rational places no. 2..9 over F_4
   // let us construct the corresponding residual AG code :
 …
   def ER=HC[1][4];
   setring ER;
   intvec G=5;      // the rational divisor G = 5*HC[3][1]
+  intvec G=5;      // the rational divisor G = 5*HC[3][1]
   intvec D=2..9;   // D = sum of the rational places no. 2..9 over F_4
   // construct the corresp. residual AG code of type [8,3,>=5] over F_4:
   matrix C=AGcode_Omega(G,D,HC);
   // we can correct 1 error and the genus is 1, thus F must have degree 2
+  // we can correct 1 error and the genus is 1, thus F must have degree 2
   // and support disjoint from that of D;
   intvec F=2;
 …
   def ER=HC[1][4];
   setring ER;
   intvec G=5;      // the rational divisor G = 5*HC[3][1]
+  intvec G=5;      // the rational divisor G = 5*HC[3][1]
   intvec D=2..9;   // D = sum of the rational places no. 2..9 over F_4
   // construct the corresp. residual AG code of type [8,3,>=5] over F_4:

Singular/LIB/classify.lib

-                      r3de58c
+                      r50cbdc
 // KK,GMG last modified: 17.12.00
 ///////////////////////////////////////////////////////////////////////////////
 version  = "$Id: classify.lib,v 1.48 2001-02-06 11:26:15 anne Exp $";
+version  = "$Id: classify.lib,v 1.49 2001-08-27 14:47:48 Singular Exp $";
 category="Singularities";
 info="
 …
 "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 differentiable
+          equivalence, as given in the book \"Singularities of differentiable
           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 beta. Please send bugs and
           comments to: \"Kai Krueger\" <krueger@mathematik.uni-kl.de> @*
           Be sure to have at least Singular version 1.0.1. Updates can be
+          Be sure to have at least Singular version 1.0.1. Updates can be
           found at: @*
           URL=http://www.mathematik.uni-kl.de/~krueger/Singular/

Singular/LIB/equising.lib

-                      r3de58c
+                      r50cbdc
 version="$Id: equising.lib,v 1.7 2001-02-05 12:01:37 lossen Exp $";
+version="$Id: equising.lib,v 1.8 2001-08-27 14:47:49 Singular Exp $";
 category="Singularities";
 info="
 …
          printlevel > 0 displays comments and pauses after intermediate
          computations (default: printlevel=0) @*
          This procedure uses @code{execute} or calls a procedure using
+         This procedure uses @code{execute} or calls a procedure using
          @code{execute}.
 EXAMPLE: example esStratum; shows an example
 …
          on the deformation parameters.
 RETURN:  list l of two integers, where
 @format
+@format
    l[1]=1 if F is an equisingular deformation,  l[1]=0 otherwise.
    l[2]=1 if some error has occured,  l[2]=0 otherwise.
 @end format
 NOTE:    If m is given, the computation stops after m steps of the iteration. @*
          This procedure uses @code{execute} or calls a procedure using
+         This procedure uses @code{execute} or calls a procedure using
          @code{execute}.
 EXAMPLE: example isEquising; shows an example

Singular/LIB/general.lib

-                      r3de58c
+                      r50cbdc
 //anne, added deleteSublist and watchdog 12.12.2000
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: general.lib,v 1.39 2001-03-26 14:05:30 Singular Exp $";
+version="$Id: general.lib,v 1.40 2001-08-27 14:47:50 Singular Exp $";
 category="General purpose";
 info="
 …
       ERROR("First argument of watchdog has to be a positive integer.");
+    }
+  }
+  else
+  {
     ERROR("MP-support is not enabled in this version of Singular.");
+  }

Singular/LIB/hnoether.lib

-                      r3de58c
+                      r50cbdc
 // This library is for Singular 1-3-7 or newer
 version="$Id: hnoether.lib,v 1.29 2001-02-05 13:27:00 Singular Exp $";
+version="$Id: hnoether.lib,v 1.30 2001-08-27 14:47:51 Singular Exp $";
 category="Singularities";
 info="
 …
 proc further_hn_proc()
 "USAGE: further_hn_proc();
 NOTE:  The library @code{hnoether.lib} contains some more procedures which
        are not shown when typing @code{help hnoether.lib;}. They may be useful
+NOTE:  The library @code{hnoether.lib} contains some more procedures which
+       are not shown when typing @code{help hnoether.lib;}. They may be useful
        for interactive use (e.g. if you want to do the calculation of an HN
        development \"by hand\" to see the intermediate results), and they
+       development \"by hand\" to see the intermediate results), and they
        can be enumerated by calling @code{further_hn_proc()}. @*
        Use @code{help <procedure>;} for detailed information about each of
+       Use @code{help <procedure>;} for detailed information about each of
        them.
+"
 …
  referencepoly(D);   a polynomial f s.t. D is the Newton diagram of f";
-// extrafactor(f,M,N); try to factor charPoly(f,M,N) where 'factorize' cannot
-// (will hopefully become obsolete soon)
-//
 //       static procedures not useful for interactive use:
 // polytest(f);        tests coefficients and exponents of poly f
 …
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables).
 RETURN:  poly, a squarefree divisor of f.
 NOTE:    Usually, the return value is the greatest squarefree divisor, but
          there is one exception: factors with a p-th root, p the
+NOTE:    Usually, the return value is the greatest squarefree divisor, but
+         there is one exception: factors with a p-th root, p the
          characteristic of the basering, are lost.
 SEE ALSO: allsquarefree
 …
 proc is_irred (poly f)
 "USAGE:   is_irred(f); f poly
 ASSUME:  f is a squarefree bivariate polynomial (in the first 2 ring
+ASSUME:  f is a squarefree bivariate polynomial (in the first 2 ring
          variables).
 RETURN:  int (0 or 1): @*
          - @code{is_irred(f)=1} if f is irreducible as a formal power
          series over the algebraic closure of its coefficient field (f
+RETURN:  int (0 or 1): @*
+         - @code{is_irred(f)=1} if f is irreducible as a formal power
+         series over the algebraic closure of its coefficient field (f
          defines an analytically irreducible curve at zero), @*
          - @code{is_irred(f)=0} otherwise.
 NOTE:    0 and units in the ring of formal power series are considered to be
+NOTE:    0 and units in the ring of formal power series are considered to be
          not irreducible.
 KEYWORDS: irreducible power series
 …
 proc develop
 "USAGE:   develop(f [,n]); f poly, n int
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables) and
+ASSUME:  f is a bivariate polynomial (in the first 2 ring variables) and
          irreducible as power series (for reducible f use @code{reddevelop}).
 RETURN:  list @code{L} with:
 …
          Hamburger-Noether expansion (HNE). The end of the line is marked in
          the matrix by the first ring variable (usually x).
 @item @code{L[2]}; intvec:
+@item @code{L[2]}; intvec:
          indicating the length of lines of the HNE
 @item @code{L[3]}; int:
   if the 1st ring variable was transversal (with respect to f), @*
   if the variables were changed at the beginning of the
+  if the variables were changed at the beginning of the
             computation, @*
         -1  if an error has occurred.
 @item @code{L[4]}; poly:
          the transformed polynomial of f to make it possible to extend the
+        -1  if an error has occurred.
+@item @code{L[4]}; poly:
+         the transformed polynomial of f to make it possible to extend the
          Hamburger-Noether development a posteriori without having to do
          all the previous calculation once again (0 if not needed)
 @item @code{L[5]}; int:
   if the curve has exactly one branch (i.e., is irreducible), @*
   else (i.e., the curve has more than one HNE, or f is not valid).
+  else (i.e., the curve has more than one HNE, or f is not valid).
 @end table
 @end texinfo
 …
          the LAST line of the HNE. If it is given, the HN-matrix @code{L[1]}
          will have at least @code{n} columns. @*
          Otherwise, the number of columns will be chosen minimal such that the
          matrix contains all necessary information (i.e., all lines of the HNE
+         Otherwise, the number of columns will be chosen minimal such that the
+         matrix contains all necessary information (i.e., all lines of the HNE
          but the last (which is in general infinite) have place). @*
          If @code{n} is negative, the algorithm is stopped as soon as the
          computed information is sufficient for @code{invariants(L)}, but the
          HN-matrix @code{L[1]} may still contain undetermined elements, which
+         If @code{n} is negative, the algorithm is stopped as soon as the
+         computed information is sufficient for @code{invariants(L)}, but the
+         HN-matrix @code{L[1]} may still contain undetermined elements, which
          are marked with the 2nd variable (of the basering). @*
          For time critical computations it is recommended to use
          @code{ring ...,(x,y),ls} as basering - it increases the algorithm's
          speed. @*
          If @code{printlevel>=0} comments are displayed (default is
          @code{printlevel=0}).
+         If @code{printlevel>=0} comments are displayed (default is
+         @code{printlevel=0}).
 SEE ALSO: reddevelop, extdevelop, displayHNE
 EXAMPLES: example develop; shows an example
 …
 proc param
 "USAGE:  param(L [,x]); L list, x any type (optional)
 ASSUME:  L is the output of @code{develop(f)}, or of
         @code{extdevelop(develop(f),n)}, or one entry of the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+        @code{extdevelop(develop(f),n)}, or one entry of the output of
         @code{reddevelop(f)}.
 RETURN: a parametrization for f in the following format: @*
         - if only the list L is given, the result is an ideal of two
+        - if only the list L is given, the result is an ideal of two
         polynomials p[1],p[2]: if the HNE was finite then f(p[1],p[2])=0};
         if not, the \"real\" parametrization will be two power series and
         p[1],p[2] are truncations of these series.@*
+        if not, the \"real\" parametrization will be two power series and
+        p[1],p[2] are truncations of these series.@*
         - if the optional parameter x is given, the result is a list l:
         l[1]=param(L) (ideal) and l[2]=intvec with two entries indicating
         the highest degree up to which the coefficients of the monomials in
+        l[1]=param(L) (ideal) and l[2]=intvec with two entries indicating
+        the highest degree up to which the coefficients of the monomials in
         l[1] are exact (entry -1 means that the corresponding parametrization
         is exact).
 NOTE:   If the basering has only 2 variables, the first variable is chosen
         as indefinite. Otherwise, the 3rd variable is chosen.
+NOTE:   If the basering has only 2 variables, the first variable is chosen
+        as indefinite. Otherwise, the 3rd variable is chosen.
 SEE ALSO: develop, extdevelop
 KEYWORDS: parametrization
 …
 proc invariants
 "USAGE:   invariants(L); L list
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or one entry of the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or one entry of the output of
          @code{reddevelop(f)}.
 RETURN:  list, if L contains a valid HNE:
 …
 proc displayInvariants
 "USAGE:  displayInvariants(L); L list
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or (one entry of) the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or (one entry of) the output of
          @code{reddevelop(f)}.
 RETURN:  none
 …
 proc multiplicities
 "USAGE:   multiplicities(L); L list
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or one entry of the output of
          @code{reddevelop(f)}.
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or one entry of the output of
+         @code{reddevelop(f)}.
 RETURN:  intvec of the different multiplicities that occur when successively
          blowing-up the curve singularity corresponding to f.
 …
 proc puiseux2generators (intvec m, intvec n)
 "USAGE:   puiseux2generators(m,n); m,n intvec
+"USAGE:   puiseux2generators(m,n); m,n intvec
 ASSUME:  m, resp. n, represent the 1st, resp. 2nd, components of Puiseux pairs
          (e.g., @code{m=invariants(L)[3]}, @code{n=invariants(L)[4]}).
+         (e.g., @code{m=invariants(L)[3]}, @code{n=invariants(L)[4]}).
 RETURN:  intvec of the generators of the semigroup of values.
 SEE ALSO: invariants
 …
 proc intersection (list hn1, list hn2)
 "USAGE:   intersection(hne1,hne2); hne1, hne2 lists
 ASSUME:  hne1, hne2 represent a HNE (i.e., are the output of
         @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, or
+ASSUME:  hne1, hne2 represent a HNE (i.e., are the output of
+        @code{develop(f)}, or of @code{extdevelop(develop(f),n)}, or
         one entry of the output of @code{reddevelop(f)}).
 RETURN:  int, the intersection multiplicity of the branches corresponding to
 …
   list hne=reddevelop((x2-y3)*(x2+y3));
   intersection(hne[1],hne[2]);
   kill HNEring,r;
+  kill HNEring,r;
   printlevel=plevel; echo = 0;
   // --- restore HNEring if previously defined ---
 …
 proc multsequence
 "USAGE:   multsequence(L); L list
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or one entry of the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or one entry of the output of
          @code{reddevelop(f)}.
 RETURN:  intvec corresponding to the multiplicity sequence of (a branch)
+RETURN:  intvec corresponding to the multiplicity sequence of (a branch)
          of the curve (the same as @code{invariants(L)[6]}).
 ASSUME:  L is the output of @code{reddevelop(f)}.
 …
 @table @asis
 @item  @code{multsequence(L)[1][i,*]}
    contains the multiplicities of the branches at their infinitely near point
    of 0 in its (i-1) order neighbourhood (i.e., i=1: multiplicity of the
    branches themselves, i=2: multiplicity of their 1st quadratic transformed,
+   contains the multiplicities of the branches at their infinitely near point
+   of 0 in its (i-1) order neighbourhood (i.e., i=1: multiplicity of the
+   branches themselves, i=2: multiplicity of their 1st quadratic transformed,
    etc., @*
    Hence, @code{multsequence(L)[1][*,j]} is the multiplicity sequence
+   Hence, @code{multsequence(L)[1][*,j]} is the multiplicity sequence
    of branch j.
 @item  @code{multsequence(L)[2][i,*]}:
+@item  @code{multsequence(L)[2][i,*]}:
    contains the information which of these infinitely near points coincide.
 @end table
 @end texinfo
 NOTE:  The order of elements of the list obtained from @code{reddevelop(f)}
+NOTE:  The order of elements of the list obtained from @code{reddevelop(f)}
        must not be changed (because then the coincident infinitely near points
        couldn't be grouped together, cf. meaning of 2nd intmat in example).
 …
+  }
   // ------ the example starts here -------
   "EXAMPLE:"; echo = 2;
+  "EXAMPLE:"; echo = 2;
   int plevel=printlevel; printlevel=-1;
   ring r=0,(x,y),dp;
 …
 proc displayMultsequence
 "USAGE:   displayMultsequence(L);
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or (one entry of) the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or (one entry of) the output of
          @code{reddevelop(f)}.
 RETURN:  nothing
 DISPLAY: the sequence of multiplicities:
 @format
  -  if @code{L=develop(f)} or @code{L=reddevelop(f)[i]}:
                       @code{a , b , c , ....... , 1}
  - if @code{L=reddevelop(f)}:
+ -  if @code{L=develop(f)} or @code{L=reddevelop(f)[i]}:
+                      @code{a , b , c , ....... , 1}
+ - if @code{L=reddevelop(f)}:
                       @code{[(a_1, .... , b_1 , .... , c_1)],}
                       @code{[(a_2, ... ), ... , (... , c_2)],}
                       @code{ ........................................ ,}
                       @code{[(a_n),(b_n), ....., (c_n)]}
      with:
+     with:
        @code{a_1 , ... , a_n} the sequence of multiplicities of the 1st branch,
        @code{[...]} the multiplicities of the j-th transformed of all branches,
 …
   displayMultsequence(hne);
   kill HNEring,r;
   printlevel=plevel;
+  printlevel=plevel;
   echo = 0;
   // --- restore HNEring if previously defined ---
 …
 proc separateHNE (list hn1,list hn2)
 "USAGE:    separateHNE(hne1,hne2);  hne1, hne2 lists
 ASSUME:   hne1, hne2 are HNEs (=output of
           @code{develop(f)}, @code{extdevelop(develop(f),n)}, or
+ASSUME:   hne1, hne2 are HNEs (=output of
+          @code{develop(f)}, @code{extdevelop(develop(f),n)}, or
           one entry of the output of @code{reddevelop(f)}).
 RETURN:   number of quadratic transformations needed to separate both curves
+RETURN:   number of quadratic transformations needed to separate both curves
           (branches).
 SEE ALSO: develop, reddevelop, multsequence, displayMultsequence
 …
 proc displayHNE(list ldev,list #)
 "USAGE:   displayHNE(L[,n]); L list, n int
 ASSUME:  L has the format of the output of @code{develop(f)}, resp. of
+ASSUME:  L has the format of the output of @code{develop(f)}, resp. of
          @code{reddevelop(f)}.
 RETURN:  - if only one argument is given, no return value, but
 …
      HNE[r+1]=           []*z(r)^2+[]*z(r)^3+......
      @end example
      where @code{x},@code{y} are the first 2 variables of the basering.
      The values of @code{[]} are the coefficients of the Hamburger-Noether
      matrix, the values of @code{<>} are represented by @code{x} in the
      HN-matrix.@*
+     where @code{x},@code{y} are the first 2 variables of the basering.
+     The values of @code{[]} are the coefficients of the Hamburger-Noether
+     matrix, the values of @code{<>} are represented by @code{x} in the
+     HN-matrix.@*
      - if a second argument is given, create and export a new ring with
      name @code{displayring} containing an ideal @code{HNE} as described
+     name @code{displayring} containing an ideal @code{HNE} as described
      above.@*
      - if L corresponds to the output of @code{reddevelop(f)},
      @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the form
+     - if L corresponds to the output of @code{reddevelop(f)},
+     @code{displayHNE(L[,n])} shows the HNE's of all branches of f in the form
      described above. The optional parameter is then ignored.
 NOTE:  The 1st line of the above ideal (i.e., @code{HNE[1]}) means that
      @code{y=[]*z(0)^1+...}, the 2nd line (@code{HNE[2]}) means that
      @code{x=[]*z(1)^2+...}, so you can see which indeterminate
      corresponds to which line (it's also possible that @code{x} corresponds
+     @code{x=[]*z(1)^2+...}, so you can see which indeterminate
+     corresponds to which line (it's also possible that @code{x} corresponds
      to the 1st line and @code{y} to the 2nd).
 SEE ALSO: develop, reddevelop
 EXAMPLE: example displayHNE; shows an example
 …
 proc extdevelop (list l, int Exaktheit)
 "USAGE:   extdevelop(L,N); list L, int N
+"USAGE:   extdevelop(L,N); list L, int N
 ASSUME:  L is the output of @code{develop(f)}, or of @code{extdevelop(l,n)},
          or one entry of the output of @code{reddevelop(f)}.
 RETURN:  an extension of the Hamburger-Noether development of f as a list
+RETURN:  an extension of the Hamburger-Noether development of f as a list
          in the same format as L has (up to the last entry in the output
          of @code{develop(f)}).@*
          Type @code{help develop;}, resp. @code{help reddevelop;} for more
+         Type @code{help develop;}, resp. @code{help reddevelop;} for more
          details.
 NOTE:    The new HN-matrix will have at least N columns (if the HNE is not
          finite). In particular, if f is irreducible then (in most cases)
          @code{extdevelop(develop(f),N)} will produce the same result as
+         @code{extdevelop(develop(f),N)} will produce the same result as
          @code{develop(f,N)}.@*
          If the matrix M of L has n columns then, compared with
+         If the matrix M of L has n columns then, compared with
          @code{param(L)}, @code{param(extdevelop(L,N))} will increase the
          exactness by at least (N-n) more significant monomials.
 …
+  }
   // ------ the example starts here -------
   "EXAMPLE:"; echo = 2;
+  "EXAMPLE:"; echo = 2;
   ring exring=0,(x,y),dp;
   list hne=reddevelop(x14-3y2x11-y3x10-y2x9+3y4x8+y5x7+3y4x6+x5*(-y6+y5)
                       -3y6x3-y7x2+y8);
   print(hne[1][1]);    // HNE of 1st branch is finite
+  print(hne[1][1]);    // HNE of 1st branch is finite
   print(extdevelop(hne[1],5)[1]);
   print(hne[2][1]);    // HNE of 2nd branch can be extended
 …
 proc stripHNE (list l)
 "USAGE:   stripHNE(L);  L list
 ASSUME:  L is the output of @code{develop(f)}, or of
          @code{extdevelop(develop(f),n)}, or (one entry of) the output of
+ASSUME:  L is the output of @code{develop(f)}, or of
+         @code{extdevelop(develop(f),n)}, or (one entry of) the output of
          @code{reddevelop(f)}.
 RETURN:  list in the same format as L, but all polynomials L[4], resp.
 …
+}
 example
+{
+{
   "EXAMPLE:"; echo = 2;
   int plevel=printlevel; printlevel=-1;
 …
 "USAGE:   HNdevelop(f); f poly
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables)
 CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
          @code{ls} over a field extension of the current basering's ground
+CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
+         @code{ls} over a field extension of the current basering's ground
          field. @*
          Since the Hamburger-Noether development usually does not exist
          in the originally given basering, @code{HNdevelop} always defines
          @code{HNEring} and CHANGES to it. The field extension is chosen
+         @code{HNEring} and CHANGES to it. The field extension is chosen
          minimally.
 RETURN:  list @code{L} of lists @code{L[i]} (corresponding to the output of
          @code{develop(f[i])}, f[i] a branch of f, but the last entry being
+         @code{develop(f[i])}, f[i] a branch of f, but the last entry being
          omitted).
 @texinfo
 …
 @item @code{L[i][1]}; matrix:
          Each row contains the coefficients of the corresponding line of the
          Hamburger-Noether expansion (HNE) for f[i]. The end of the line is
+         Hamburger-Noether expansion (HNE) for f[i]. The end of the line is
          marked in the matrix by the first ring variable (usually x).
 @item @code{L[i][2]}; intvec:
+@item @code{L[i][2]}; intvec:
          indicating the length of lines of the HNE
 @item @code{L[i][3]}; int:
   if the 1st ring variable was transversal (with respect to f[i]), @*
   if the variables were changed at the beginning of the
+  if the variables were changed at the beginning of the
             computation, @*
         -1  if an error has occurred.
 @item @code{L[i][4]}; poly:
          the transformed polynomial of f[i] to make it possible to extend the
+        -1  if an error has occurred.
+@item @code{L[i][4]}; poly:
+         the transformed polynomial of f[i] to make it possible to extend the
          Hamburger-Noether development a posteriori without having to do
          all the previous calculation once again (0 if not needed)
 …
          If f is known to be irreducible as a power series, @code{develop(f)}
          should be chosen instead to avoid the change of basering. @*
          If @code{printlevel>=0} comments are displayed (default is
          @code{printlevel=0}).
+         If @code{printlevel>=0} comments are displayed (default is
+         @code{printlevel=0}).
 SEE ALSO: develop, reddevelop, extdevelop, essdevelop, param, displayHNE
 EXAMPLE: example HNdevelop;  shows an example
 …
 "USAGE:   reddevelop(f); f poly
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables)
 CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
          @code{ls} over a field extension of the current basering's ground
+CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
+         @code{ls} over a field extension of the current basering's ground
          field. @*
          Since the Hamburger-Noether development of a reducible curve
          singularity usually does not exist in the originally given basering,
          @code{reddevelop} always defines @code{HNEring} and CHANGES to it.
+         @code{reddevelop} always defines @code{HNEring} and CHANGES to it.
          The field extension is chosen minimally.
 RETURN:  list @code{L} of lists @code{L[i]} (corresponding to the output of
          @code{develop(f[i])}, f[i] a branch of f, but the last entry being
+         @code{develop(f[i])}, f[i] a branch of f, but the last entry being
          omitted).
 @texinfo
 …
 @item @code{L[i][1]}; matrix:
          Each row contains the coefficients of the corresponding line of the
          Hamburger-Noether expansion (HNE) for f[i]. The end of the line is
+         Hamburger-Noether expansion (HNE) for f[i]. The end of the line is
          marked in the matrix by the first ring variable (usually x).
 @item @code{L[i][2]}; intvec:
+@item @code{L[i][2]}; intvec:
          indicating the length of lines of the HNE
 @item @code{L[i][3]}; int:
   if the 1st ring variable was transversal (with respect to f[i]), @*
   if the variables were changed at the beginning of the
+  if the variables were changed at the beginning of the
             computation, @*
         -1  if an error has occurred.
 @item @code{L[i][4]}; poly:
          the transformed polynomial of f[i] to make it possible to extend the
+        -1  if an error has occurred.
+@item @code{L[i][4]}; poly:
+         the transformed polynomial of f[i] to make it possible to extend the
          Hamburger-Noether development a posteriori without having to do
          all the previous calculation once again (0 if not needed)
 @end table
 @end texinfo
 NOTE:    If @code{printlevel>=0} comments are displayed (default is
          @code{printlevel=0}).
+NOTE:    If @code{printlevel>=0} comments are displayed (default is
+         @code{printlevel=0}).
 SEE ALSO: develop, extdevelop, essdevelop, param, displayHNE
 EXAMPLE: example reddevelop;  shows an example
 …
           +126x10y4+4x8y6-126x8y5+84x6y6-36x4y7+9x2y8-1y9;
   list hne=reddevelop(f);
   size(hne);            // number of branches
+  size(hne);            // number of branches
   print(hne[1][1]);     // HN-matrix of 1st branch
   print(hne[4][1]);     // HN-matrix of 4th branch
 …
 "USAGE:   essdevelop(f); f poly
 ASSUME:  f is a bivariate polynomial (in the first 2 ring variables)
 CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
          @code{ls} over a field extension of the current basering's ground
+CREATE:  ring with name @code{HNEring}, variables @code{x,y} and ordering
+         @code{ls} over a field extension of the current basering's ground
          field. @*
          Since the Hamburger-Noether development of a reducible curve
          singularity usually does not exist in the originally given basering,
          @code{essdevelop} always defines @code{HNEring} and CHANGES to it.
+         @code{essdevelop} always defines @code{HNEring} and CHANGES to it.
          The field extension is chosen minimally.
 RETURN:  list @code{L} of lists @code{L[i]} (corresponding to the output of
          @code{develop(f[i])}, f[i] an \"essential\" branch of f, but the last
+         @code{develop(f[i])}, f[i] an \"essential\" branch of f, but the last
          entry being omitted).@*
          For more details type @code{help reddevelop;}.
 …
          Use @code{reddevelop} or @code{HNdevelop} to compute a complete HNE,
          i.e., a HNE for all branches.@*
          If @code{printlevel>=0} comments are displayed (default is
          @code{printlevel=0}).
+         If @code{printlevel>=0} comments are displayed (default is
+         @code{printlevel=0}).
 SEE ALSO: develop, reddevelop, HNdevelop, extdevelop
 EXAMPLE: example essdevelop;  shows an example
 …
  //---------- Sonderbehandlung: faktorisere einige Polynome ueber Q(a): -------
      if (charstr(basering)=="0,a") {
+       faktoren,flag=extrafactor(leitf,M,N);  // damit funktion. Bsp. Baladi 5
+       if (flag==0)
+         { ERROR("Could not factorize in field of type (0,a)!"); }
+       faktoren=factorize(charPoly(leitf,M,N),2);  // damit funktion. Bsp. Baladi 5
+     }
      else {
 …
+}
 ///////////////////////////////////////////////////////////////////////////////
-proc extrafactor (poly leitf, int M, int N)
-"USAGE:   factors,flag=extrafactor(f,M,N);
-         list factors, int flag,M,N, poly f in x,y
-RETURN:  for some special f, factors is a list of the factors of
-         charPoly(f,M,N), same format as factorize
-         (see help charPoly; help factorize)
-         In this case, flag!=0 (TRUE). If extrafactor cannot factorize f,
-         flag will be 0 (FALSE), factors will be the empty list.
-ASSUME:  basering is (0,a),(x,y),ds or ls
-         Newton polygon of f is one side with height N, length M
-NOTE:    This procedure is designed to make reddevelop able to compute some
-         special cases that need a ring extension in char 0.
-         It becomes obsolete as soon as `factorize' works also in such rings.
-EXAMPLE: example extrafactor;  shows an example
+"
+{
- list faktoren;
-      if (a2==-1) {
-       poly testpol=charPoly(leitf,M,N);
-       if (testpol==1+2y2+y4) {
-         faktoren=list(ideal(y+a,y-a),intvec(2,2));
-         testpol=0;
+       }
- //------------ ist Poly von der Form q*i+r*y^n, n in N, q,r in Q ?: ----------
-       if ((size(testpol)==2) && (find(string(lead(testpol)),"a")>0)
-           && (find(string(testpol-lead(testpol)),"a")==0)) {
-        faktoren=list(ideal(testpol),intvec(1));
-        testpol=0;
+       }
+      }
-      if (a4==-625) {
-        poly testpol=charPoly(leitf,M,N);
-        if (testpol==4a2-4y2)
-         { faktoren=list(ideal(-4,y+a,y-a),intvec(1,1,1)); testpol=0;}
-        if (testpol==-4a2-4y2)
-         { faktoren=list(ideal(-4,y+1/25*a3,y-1/25*a3),intvec(1,1,1));
-           testpol=0;}
+      }
-      if (a2+a==-1) {
-        poly testpol=charPoly(leitf,M,N);
-        if (testpol==1+2y+3y2+2y3+y4)
-         { faktoren=list(ideal(1,y-a,y+a+1),intvec(1,2,2)); testpol=0;}
+      }
-      if (defined(testpol)==0) { poly testpol=1; }
-      if (testpol!=0) {
-        "factorize not implemented in char (0,a)!";
-        "could not factorize:",charPoly(leitf,M,N);
-        if (printlevel>0) { pause("Hit RETURN to continue:"); }
+      }
- return(faktoren,(testpol==0)); // Test: faktoren==list() geht leider nicht
+}
-example
-{ "EXAMPLE:"; echo=2;
-  ring r=(0,a),(x,y),ds;
-  minpoly=a2+1;
-  poly f=x4+2x2y2+y4;
-  charPoly(f,4,4);
-  list factors;
-  int flag;
-  factors,flag=extrafactor(f,4,4);
-  if (flag!=0) {factors;}
+}

Singular/LIB/latex.lib

-                      r3de58c
+                      r50cbdc
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: latex.lib,v 1.19 2001-02-09 10:19:33 lossen Exp $";
+version="$Id: latex.lib,v 1.20 2001-08-27 14:47:53 Singular Exp $";
 category="Visualization";
 info="
 …
   @code{TeXwidth} (int) -1, 0, 1..9, >9:  controls breaking of long polynomials
   @code{TeXnofrac} (int) flag:  write 1/2 instead of \\frac@{1@}@{2@}
   @code{TeXbrack} (string) \"@{\", \"(\", \"<\", \"|\", empty string:
+  @code{TeXbrack} (string) \"@{\", \"(\", \"<\", \"|\", empty string:
                                    controls brackets around ideals and matrices
   @code{TeXproj} (int) flag:  write \":\" instead of \",\" in vectors
 …
   texobj("exp001","An ideal ",I);
   closetex("exp001");
   tex("exp001");
+  tex("exp001");
   echo=0;
   pause("the created files will be deleted after pressing <RETURN>");
 …
 proc texfactorize(string fname, poly f, list #)
 "USAGE:   texfactorize(fname,f); fname string, f poly
 RETURN:  if @code{fname=\"\"}: string, f as a product of its irreducible
+RETURN:  if @code{fname=\"\"}: string, f as a product of its irreducible
          factors@*
          otherwise: append this string to the file @code{<fname>}, and
+         otherwise: append this string to the file @code{<fname>}, and
          return nothing.
 NOTE:    preceeding \">>\" are deleted and suffix \".tex\" (if not given)
 …
 proc texmap(string fname, def m, def @r1, def @r2, list #)
 "USAGE:   texmap(fname,m,@r1,@r2); fname string, m string/map, @r1,@r2 rings
 RETURN:  if @code{fname=\"\"}: string, the map m from @r1 to @r2 (preceeded
+RETURN:  if @code{fname=\"\"}: string, the map m from @r1 to @r2 (preceeded
          by its name if m = string) in TeX-typesetting;@*
          otherwise: append this string to the file @code{<fname>}, and
+         otherwise: append this string to the file @code{<fname>}, and
          return nothing.
 NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
+NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
          (if not given) is added to @code{fname}.
          If m is a string then it has to be the name of an existing map
 …
   n = n+5*(i-anf);
   anf =i;            // the next text in ( , ) as exponent
   if (op)
+  {
+  if (op)
+  {
     if (s[i]== ","){anf = anf+1;}
     while(s[i] !=")"){ i++;}
 …
 "USAGE:   texname(fname,s);  fname,s  strings
 RETURN:  if @code{fname=\"\"}: string, the transformed string s, where the
          following rules apply:
 @example
+         following rules apply:
+@example
       s' + \"~\"             -->  \"\\tilde@{\"+ s' +\"@}\"
      \"_\" + int             -->       \"_@{\" + int +\"@}\"
+     \"_\" + int             -->       \"_@{\" + int +\"@}\"
   \"[\" + s' + \"]\"           -->      \"_@{\" + s' + \"@}\"
    \"A..Z\" + int            --> \"A..Z\" + \"^@{\" + int + \"@}\"
+   \"A..Z\" + int            --> \"A..Z\" + \"^@{\" + int + \"@}\"
    \"a..z\" + int            --> \"a..z\" + \"_@{\" + int + \"@}\"
 \"(\" + int + \",\" + s' + \")\" --> \"_@{\"+ int +\"@}\" + \"^@{\" + s'+\"@}\"
 @end example
          Anyhow, strings which begin with a @code{\"@{\"} are only changed
          by deleting the first and last character (intended to remove the
+         by deleting the first and last character (intended to remove the
          surrounding curly brackets).
          if @code{fname!=\"\"}: append the transformed string s to the file
+         if @code{fname!=\"\"}: append the transformed string s to the file
          @code{<fname>}, and return nothing.
 NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
+NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
          (if not given) is added to @code{fname}.
 EXAMPLE: example texname; shows an example
 …
   st=manipul(s);
   if (size(fname))
+  {
+  {
     int i=1;
     while (fname[i]==">"){i++;}
     fname = fname[i,size(fname)-i+1];
     if (size(fname)>=4)            // check if filename is ending with ".tex"
+    {
+    {
       if(fname[size(fname)-3,4]!=".tex") {fname = fname +".tex"; }
+    }
 …
 static proc absterm(poly f)
+{
+{
   int k;
   for (k=1; k<=nvars(basering); k++)
 …
 "USAGE:   texobj(fname,l); fname string, l list
 RETURN:  if @code{fname=\"\"}: string, the entries of l in LaTeX-typesetting;@*
          otherwise: append this string to the file @code{<fname>}, and
+         otherwise: append this string to the file @code{<fname>}, and
          return nothing.
 NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
+NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
          (if not given) is added to @code{fname}.
 EXAMPLE: example texobj; shows an example
 …
    { if (defined(`obj`))
      { if (typeof(`obj`)=="ideal")
+       {
+       {
          Iname = obj; def e = `obj`;     //convert to correct type ideal
          kill obj; def obj = e; kill e;
 …
+}
 example
+{
+{
    echo=0;
    // -------- prepare for example ---------
 …
 "USAGE:   texproc(fname,pname); fname,pname strings
 ASSUME:  @code{`pname`} is a procedure.
 RETURN:  if @code{fname=\"\"}: string, the proc @code{`pname`} in a verbatim
+RETURN:  if @code{fname=\"\"}: string, the proc @code{`pname`} in a verbatim
          environment in LaTeX-typesetting;@*
          otherwise: append this string to the file @code{<fname>}, and
+         otherwise: append this string to the file @code{<fname>}, and
          return nothing.
 NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
+NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
          (if not given) is added to @code{fname}.@*
          @code{texproc} cannot be applied to itself correctly.
 …
 "USAGE:   texring(fname, r[,L]); fname string, r ring, L list
 RETURN:  if @code{fname=\"\"}: string, the ring in TeX-typesetting;@*
          otherwise: append this string to the file @code{<fname>} and
+         otherwise: append this string to the file @code{<fname>} and
          return nothing.
 NOTE:    preceeding \">>\" are deleted and suffix \".tex\" (if not given)
 …
   texring("",ralg,"mipo");
   //
   ring r49=(49,a),x,dp;                // Galois field
+  ring r49=(49,a),x,dp;                // Galois field
   texring("",r49);
   //
 …
 proc rmx(string fname)
 "USAGE:   rmx(fname); fname string
 RETURN:  nothing; removes the @code{.log} and @code{.aux} files associated to
+RETURN:  nothing; removes the @code{.log} and @code{.aux} files associated to
          the LaTeX file <fname>.@*
 NOTE:    If @code{fname} ends by @code{\".dvi\"} or @code{\".tex\"}, the
+NOTE:    If @code{fname} ends by @code{\".dvi\"} or @code{\".tex\"}, the
          @code{.dvi} or @code{.tex} file will be deleted, too.
 EXAMPLE: example rmx; shows an example
 …
 { "EXAMPLE:"; echo = 2;
   intmat m[3][4] = 9,2,4,5,2,5,-2,4,-6,10,-1,2,7;
   opentex("exp001");
+  opentex("exp001");
   texobj("exp001","An intmat:  ",m);
   closetex("exp001");
 …
 static proc parsr(string s)                     // parse real
+{
+{
   string t;
   if (s=="      Inf") { return("\\infty",3);}
 …
     else {return(s[1,5]+"*10^"+t,23);}
+  }
   else
+  else
+  {
     return(s[1,5],12);
 …
 static proc parsg(string s)                  // parse Galois field
+{
+{
   int i,j = 1,1;
   string t;
   if (short)
+  {
+  {
     t =s[1];
     if(size(s)>1) {return(t+"^{" + s[2,size(s)-1] + "}",3+2*(size(s)-1));}
 …
+  }
   else
+  {
+  {
     return(parselong(s+"!"));
+  }
 …
 "USAGE:   texpoly(fname,p); fname string, p poly
 RETURN:  if @code{fname=\"\"}: string, the poly p in LaTeX-typesetting;@*
          otherwise: append this string to the file @code{<fname>}, and
+         otherwise: append this string to the file @code{<fname>}, and
          return nothing.
 NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
+NOTE:    preceeding \">>\" are deleted in @code{fname}, and suffix \".tex\"
          (if not given) is added to @code{fname}.
 EXAMPLE: example texpoly; shows an example
 …
  This document illustrates the functionality of the library."+"\\\\" +  nl);
  write(fname,"\\begin{tabular}{ll}" + nl +
 "LIBRARY: {\\tt latex.lib} &   PROCEDURES FOR TYPESETTING SINGULAR" +
+"LIBRARY: {\\tt latex.lib} &   PROCEDURES FOR TYPESETTING SINGULAR" +
 "\\\\" +  nl +
 " & OBJECTS IN LATEX2E"+
 …
 "{\\tt  texdemo([n]);} & produces a file explaining the features of this lib"+
 "\\\\" +  nl +
 "{\\tt  texfactorize(fnm,f);} & creates string in \\LaTeX-format for
+"{\\tt  texfactorize(fnm,f);} & creates string in \\LaTeX-format for
 factors of poly f"+ "\\\\" +  nl +
 "{\\tt  texmap(fnm,m,r1,r2);} & creates string in \\LaTeX-format for
 map m:r1$\\rightarrow$r2"+ "\\\\" +  nl +
 "{\\tt  texname(fnm,s);} &      creates string in \\LaTeX-format for
+"{\\tt  texname(fnm,s);} &      creates string in \\LaTeX-format for
 identifier"+ "\\\\" +  nl +
 "{\\tt  texobj(l);} &           creates string in \\LaTeX-format for
 …
 "{\\tt  texproc(fnm,p);} &      creates string in \\LaTeX-format of
 text from proc p"+ "\\\\" +  nl +
 "{\\tt  texring(fnm,r[,l]);} &  creates string in \\LaTeX-lformat for
+"{\\tt  texring(fnm,r[,l]);} &  creates string in \\LaTeX-lformat for
 ring/qring"+ "\\\\" +  nl +
 "{\\tt  rmx(s);} &              removes .aux and .log files of \\LaTeX-files"+
 …
 "\\\\" +  nl2 + "\\vspace{0.2cm}" + nl2 +
 "The global variables {\\tt TeXwidth}, {\\tt TeXnofrac}, {\\tt
  TeXbrack}, {\\tt TeXproj}, {\\tt TeXaligned}, {\\tt TeXreplace}, {\\tt
+ TeXbrack}, {\\tt TeXproj}, {\\tt TeXaligned}, {\\tt TeXreplace}, {\\tt
  NoDollars} are used to control the typesetting: "
 );
 …
 write(fname,"Notice that none of these global variables are defined when
 loading \\verb|latex.lib|. A flag variable is set as soon as it is defined.");
 //% The procs and
 …
    write(fname,"\\section{Opening a \\LaTeX\\ file}");
    write(fname,"In order to create a \\LaTeX\\ document and write a standard
 header into it, use the following command."+
+header into it, use the following command."+
 bv+
 "> string fname = \"" + fname + "\";" + nl +
 "> texopen(fname);" +
+"> texopen(fname);" +
 ev + nl);
 …
 static proc part1(string fname)
+{
+{
   int st = defined(texdemopart);
 …
 // -1a------ a ring in char 0, short varnames and poly. ordering ----------
 write(fname,
 " A ring in characteristic 0 with short names of variables and polynomial
+" A ring in characteristic 0 with short names of variables and polynomial
 ordering." +nl);
  ring r0=0,(x,y,z),dp;
 …
 "> texring(fname,r0);" +
 ev);
   texring(fname,r0);
+  texring(fname,r0);
   write(fname,nl2);
 write(fname,
 …
 "> texpoly(fname,g);" +nl +
 ev);
   texpoly(fname,g);
+  texpoly(fname,g);
   write(fname,"\\\\"+nl2);
 …
 ev
 );
   texpoly(fname,g/280);
+  texpoly(fname,g/280);
   kill r0;
 write(fname,"\\\\"+nl2);
 write(fname,"\\Line");
 // -2-------- a ring in char 7, indexed varnames and series ordering ----------
 write(fname,
 " A ring in characteristic 7 with indexed names of variables and local
+" A ring in characteristic 7 with indexed names of variables and local
 ordering." +nl);
  ring r1=7,(x1,x2,x3,x4),Ds;
  poly g=-2*x1+x4-1;
 write(fname,
 bv +
 "> ring r1=7,(x1,x2,x3,x4),Ds;" +nl +
+ poly g=-2*x1+x4-1;
+write(fname,
+bv +
+"> ring r1=7,(x1,x2,x3,x4),Ds;" +nl +
 "> texring(fname,r1);" +nl +
 ev);
 texring(fname,r1);
+texring(fname,r1);
 write(fname,lb);
 write(fname, bv +
 "> poly g=-2*x1+x4-1;  g;" +nl +
+"> poly g=-2*x1+x4-1;  g;" +nl +
 "> texpoly(fname,g);" +nl +
 ev);
   texpoly(fname,g);
 write(fname,lb);
 write(fname,"\\Line");
 …
 // -3-------- a ring in char 0, indexed varnames and local ordering ----------
 write(fname,
 " A ring in characteristic 0 with indexed names of variables and local
+" A ring in characteristic 0 with indexed names of variables and local
 ordering.
 " +nl);
 …
 "> texring(fname,r2);" +nl +
 ev);
   texring(fname,r2);
+  texring(fname,r2);
 write(fname,
 bv +
 "> poly g=-y(1)^3*x(5)+y(1)*x(2);  g;" +nl+
  string(g) + nl +
+ string(g) + nl +
 "> texpoly(fname,g);"  +nl +
 ev
 );
   texpoly(fname,g);
+  texpoly(fname,g);
   write(fname,lb);
 write(fname,"\\Line");
 …
 );
   texpoly(fname,g); write(fname,lb);
 write(fname,"\\Line");
 …
 ev);
  texring(fname,r0t);
 write(fname,
+write(fname,
 bv +
 "> poly g=8*(-s+2t)/(st+t3)*x+t2*x-1;  g;"+nl+
 …
 write(fname,
 bv +
+bv +
 "> poly g=-(2a13+a)*x2+a2*x-a+1;  g;" +nl+
  string(g) +nl +
 …
 write(fname,
 bv +
+bv +
 "> poly g=-(i+1)*x+2i2y2+i+x;  g;" +nl+
  string(g) +nl +
 …
 "It is possible to display a ground field different from the
 actual one by passing any letter in \\LaTeX \\ notation as additional
 argument.  Predefined values are \\verb|\"\\\\C\"|, \\verb|\"\\\\R\"|,
+argument.  Predefined values are \\verb|\"\\\\C\"|, \\verb|\"\\\\R\"|,
 \\verb|\"k\"|, \\verb|\"K\"| and \\verb|\"R\"|."+nl+
 "If for example a ground field of characteristic 0 should be written as
 …
  special role when the ground field is an algebraic extension. In this case
 the parameters will be omitted.");
 write(fname,
 bv +
 …
 write(fname,nl+ "\\vspace{0.2cm}" + nl2);
 write(fname,"The first and the last variable will always be printed.
 In order to print only these it is sufficient to give a 1 as third argument.");
 …
 write(fname,"It is also possible to pass several of the arguments described
 above at once (in any order).");
 write(fname,
 …
 static proc part2(string fname)
+{
+{
   int st = defined(texdemopart);
 …
 write(fname,"\\subsection{Factorized polynomials}");
 write(fname,"The command \\verb|texfactorize| calls internally the
 {\\sc Singular} command \\verb|factorize| and returns the product of the
 irreducible factors. Note that, at the moment, it is not possible to pass
+write(fname,"The command \\verb|texfactorize| calls internally the
+{\\sc Singular} command \\verb|factorize| and returns the product of the
+irreducible factors. Note that, at the moment, it is not possible to pass
 any optional arguments for \\verb|factorize| through \\verb|texfactorize|.");
 …
 // ---------------------------------------------
 write(fname,"By setting the global variable \\verb|TeXreplace| it is possible
 to define rules for replacing strings or variable names.
+to define rules for replacing strings or variable names.
 \\verb|TeXreplace| has to be a list of twoelemented lists where the first
 entry is the text which should be replaced by the second entry.
 This may be applied to replace names of variables, but is also used
+This may be applied to replace names of variables, but is also used
 when calling \\verb|texname| or \\verb|texmap|. Note that it
 is necessary to write a double backslash \\verb|\\\\\| at the beginning of
 …
 "\\]",nl);
 write(fname,"Note that the size of terms is calculated with certain
+write(fname,"Note that the size of terms is calculated with certain
 multiplicities.",nl);
 …
 ev);
   setring r0;
+  setring r0;
   poly g=-x2y+2y13z+1;
   poly f=g^2;
 …
 write(fname,nl2,"\\Line");
 write(fname,"There are two possibilities to convert a polynomial into
+write(fname,"There are two possibilities to convert a polynomial into
 \\LaTeX \\ code: either by using \\verb|texpoly| or by calling \\verb|texobj|.
 The difference is that \\verb|texpoly| puts the polynomial in textmode
 …
 // setring r3;
   ring r3=0,(x_1,x_2,x_3),wp(3,2,1);
   poly g=-x_1*x_2+2*x_2*x_3+x_1*x_3;
 …
 write(fname,"If the global variable \\verb|Texaligned| is set then the ideal
 is displayed as a row vector.");
 write(fname,
 bv +
 …
 static proc part3(string fname)
+{
+{
   int st=defined(texdemopart);
   string nl=newline;
 …
   if (not(st) or st>=3)
+  {
+  {
     print(" Call part2 first");
     return();
 …
 write(fname,"\\section{Typeseting maps between rings}");
 write(fname,"By default, maps are displayed in the following way:");
 write(fname,
 bv +
 …
 "> texmap(fname,phi,r4,r5);" + nl +
 ev);
   ring @r4_h=0,(x,y,z),dp;
   if(system("with","Namespaces")) { exportto(Current, @r4_h); }
 …
 write(fname,"If the global variable \\verb|TeXaligned| is set, then the
 map is displayed in one line.");
 write(fname,
 bv +
 …
 the second one contains the parameters for the domain. Note that if only one
 list is present then it is applied to both of the rings.");
 write(fname,
 bv +
 …
 ev );
  texmap(fname,@phi_h,@r4_h,r5,list(),list("{"));
+ texmap(fname,@phi_h,@r4_h,r5,list(),list("{"));
 write(fname,nl+"\\Line");
 …
 write(fname, "Complex data structures such as matrices, vectors or modules
 can be displayed by using the procedure \\verb|texobj|.");
 write(fname,"\\subsection{Matrices and vectors}");
 //=======================================================================
 …
 ev );
   setring r;
+  setring r;
   ideal I=3xz5+x2y3-3z,7xz5+y3z+x-z,-xyz2+4yz+2x;
   int TeXproj; export TeXproj;
   texobj(fname,V);
   kill TeXproj;
 …
 "> kill TeXproj;"+nl+
 ev);
 write(fname,"\\subsection{Modules}",nl2);
 …
 write(fname,"Integer matrices are displayed in the following way.");
 intmat m[3][4]=-1,3,5,2,-2,8,6,0,2,5,8,7;
 …
       "// not an isolated singularity";
+    }
     return(m_nr);
+    return(m_nr);
+  }
   export(milnor_number);
 …
 write(fname,"The following procedure allows to include the source code
 of procedures into a \\LaTeX document.");
 write(fname,
+write(fname,
 bv +
 "> texproc(fname,\"milnor\_number\");" +nl+
 ev);
  texproc(fname,"milnor_number");
   kill(milnor_number);
 // ------------------------------ closing the tex file -------------------
 write(fname,"\\section{Closing the \\LaTeX\\ file}");

Singular/LIB/lll.lib

-                      r3de58c
+                      r50cbdc
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: lll.lib,v 1.2 2001-03-26 12:05:00 Singular Exp $";
+version="$Id: lll.lib,v 1.3 2001-08-27 14:47:54 Singular Exp $";
 category="Commutative Algebra";
 info="
 LIBRARY: LLL.lib      Integral LLL-Algorithm
+LIBRARY: LLL.lib      Integral LLL-Algorithm
 AUTHOR:  Alberto Vigneron-Tenorio and Alfredo Sanchez-Navarro
          email: alberto.vigneron@uca.es, alfredo.sanchez@uca.es
 …
+  {
     dummy=system("sh","rm -f "+file+" "+resfile);
+  }
+  }
   else
+  {
     ERROR("external program returns "+string(dummy)+newline+
           "see "+file+" and "+resfile+" for details");
+  }
+  }
   execute(solution); // result is now in list "res"
 …
   list l=list(1,-2,4),list(2,1,-7);
   LLL(l);
+}
+}
 ///////////////////////////////////////////////////////////////////////////////

Singular/LIB/mprimdec.lib

-                      r3de58c
+                      r50cbdc
 // $Id: mprimdec.lib,v 1.3 2001-07-10 11:49:19 dreyer Exp $
+// $Id: mprimdec.lib,v 1.4 2001-08-27 14:47:54 Singular Exp $
 ///////////////////////////////////////////////////////////////////////////////
 // mprimdec.lib
 // algorithms for primary decomposition for modules based on
 // the algorithms of Gianni, Trager and Zacharias and
+// algorithms for primary decomposition for modules based on
+// the algorithms of Gianni, Trager and Zacharias and
 // Shimoyama and Yokoyama (generalization of the latter
 // suggested by Hans-Gert Gräbe, Leipzig  )
 // using elments of primdec.lib
 // written by Alexander Dreyer
+// suggested by Hans-Gert Gräbe, Leipzig  )
+// using elments of primdec.lib
+// written by Alexander Dreyer
 //
 // $Log: not supported by cvs2svn $
+// Revision 1.3  2001/07/10 11:49:19  dreyer
+// + changed commands factor to factorize(...,2), idealsEqual to modulesEqual
+//   minAssPrimes to minAssGTZ;  minAssChar;
+//
 //
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: mprimdec.lib,v 1.3 2001-07-10 11:49:19 dreyer Exp $";
+version="$Id: mprimdec.lib,v 1.4 2001-08-27 14:47:54 Singular Exp $";
 category="Commutative Algebra";
 …
+  {
     if( (size(#)>0) ){
       list pr = minAssChar(ann);   // causes message  "/ ** redefining @res **"
+      list pr = minAssChar(ann);   // causes message  "/ ** redefining @res **"
+    }
     else{
       list pr = minAssGTZ(ann);
+      list pr = minAssGTZ(ann);
+    }
+  }

Singular/LIB/normal.lib

-                      r3de58c
+                      r50cbdc
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: normal.lib,v 1.35 2001-03-19 22:57:16 greuel Exp $";
+version="$Id: normal.lib,v 1.36 2001-08-27 14:47:56 Singular Exp $";
 category="Commutative Algebra";
 info="
 …
 PROCEDURES:
+ normal(I);             computes the normalization of basering/I
+ normal(I[,wd]);        computes the normalization of basering/I
+                        resp. computes the normalization of basering/I and
+                        the delta-invariante
  HomJJ(L);              presentation of End_R(J) as affine ring, L a list
+ genus(I);              computes the genus of the projective curve defined
+                        by I
 ";
 …
 LIB "inout.lib";
 LIB "ring.lib";
+LIB "hnoether.lib";
 ///////////////////////////////////////////////////////////////////////////////
-static proc isR_HomJR (list Li)
-"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
-         SBid = standard basis of an ideal in P,
-         J    = ideal in P containing the polynomial p,
-         p    = nonzero divisor of R
-RETURN:  1 if R = R:J, 0 if not
-EXAMPLE: example isR_HomJR;  shows an example
+"
+{
-   int n, ii;
- def P = basering;
-   ideal SBid = Li[1];
-   ideal J = Li[2];
-   poly p = Li[3];
-   attrib(SBid,"isSB",1);
-   attrib(p,"isSB",1);
- qring R    = SBid;
-   ideal J  = fetch(P,J);
-   poly p   = fetch(P,p);
-   ideal f  = quotient(p,J);
-   ideal lp = std(p);
-   n=1;
-   for (ii=1; ii<=size(f); ii++ )
+   {
-      if ( reduce(f[ii],lp) != 0)
-      { n = 0; break; }
+   }
-   return (n);
- //?spaeter hier einen Test ob Hom(I,R) = Hom(I,I)?
+}
-example
-{"EXAMPLE:";  echo = 2;
-  ring r   = 0,(x,y,z),dp;
-  ideal id = y7-x5+z2;
-  ideal J  = x3,y+z;
-  poly p   = xy;
-  list Li  = std(id),J,p;
-  isR_HomJR (Li);
-  ring s   = 0,(t,x,y),dp;
-  ideal id = x2-y2*(y-t);
-  ideal J  = jacob(id);
-  poly p   = J[1];
-  list Li  = std(id),J,p;
-  isR_HomJR (Li);
+}
-///////////////////////////////////////////////////////////////////////////////
 proc HomJJ (list Li)
 "USAGE:   HomJJ (Li); Li list: ideal SBid, ideal id, ideal J, poly p, int count
+"USAGE:   HomJJ (Li);  Li = list: ideal SBid, ideal id, ideal J, poly p
 ASSUME:  R    = P/id,  P = basering, a polynomial ring, id an ideal of P,
 @*       SBid = standard basis of id,
 @*       J    = ideal of P containing the polynomial p,
 @*       p    = nonzero divisor of R
-@*       count controls printlevel during recursive call
 COMPUTE: Endomorphism ring End_R(J)=Hom_R(J,J) with its ring structure as
          affine ring, together with the canonical map R --> Hom_R(J,J),
 …
                endphi describes the canonical map R -> Hom_R(J,J)
          l[2] : an integer which is 1 if phi is an isomorphism, 0 if not
+         l[3] : an integer, the contribution to delta
 @end format
 NOTE:    printlevel >=1: display comments (default: printlevel=0)
 …
 //---------- initialisation ---------------------------------------------------
    int isIso,isPr,isCo,isRe,isEq,ii,jj,q,y,count;
+   int isIso,isPr,isCo,isRe,isEq,oSAZ,ii,jj,q,y;
    intvec rw,rw1;
    list L;
+   if(size(Li)>=5)
+   {
+     count = Li[5];
+   }
+   y = printlevel-voice+count;
+ def P = basering;
+   y = printlevel-voice+2;  // y=printlevel (default: y=0)
+   def P = basering;
    ideal SBid, id, J = Li[1], Li[2], Li[3];
    poly p = Li[4];
 …
       if(attrib(id,"isPrim")==1)  { isPr=1; }
+   }
+   if( typeof(attrib(id,"onlySingularAtZero"))=="int" )
+   {
+      if(attrib(id,"onlySingularAtZero")==1){oSAZ=1; }
+   }
    if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
+   {
 …
+   }
 //-------------------------- go to quotient ring ------------------------------
  qring R  = SBid;
+   qring R  = SBid;
    ideal id = fetch(P,id);
    ideal J  = fetch(P,J);
 …
    ideal f,rf,f2;
    module syzf;
 //---------- computation of p*Hom(J,J) as R-ideal -----------------------------
    if ( y>=1 )
 …
+   }
    f  = quotient(p*J,J);
    if ( y>=1 )
    { "// the module p*Hom(J,J) = p*J:J, p a non-zerodivisor";
       "// p"; p;
+      "// f=p*J:J";
+      if( y>=2 ) { f; }
+      "// f=p*J:J";f;
+   }
    f2 = std(p);
+   if(isIso==0)
+   {
+     ideal f1=std(f);
+     attrib(f1,"isSB",1);
+    // if( codim(f1,f2) >= 0 )
+    // {
+    //  dbprint(printlevel-voice+3,"// dimension of non-normal locus is zero");
+    //    isIso=1;
+    // }
+  }
 //---------- Test: Hom(J,J) == R ?, if yes, go home ---------------------------
    rf = interred(reduce(f,f2));       // represents p*Hom(J,J)/p*R = Hom(J,J)/R
    if ( size(rf) == 0 )
+   {
 …
       setring lastRing;
+      attrib(endid,"onlySingularAtZero",oSAZ);
       attrib(endid,"isCohenMacaulay",isCo);
       attrib(endid,"isPrim",isPr);
 …
       L=lastRing;
       L = insert(L,1,1);
+      dbprint(y,"// case R = Hom(J,J)");
       if(y>=1)
+      {
          "// case R = Hom(J,J), we are ready with this component";
+         "//   R=Hom(J,J)";
          "   ";
+       if( y>=2 )
+       {
+        lastRing;
+         lastRing;
          "   ";
          "//   the new ideal";
          if( y>=2 ) { endid; }
+         endid;
          "   ";
          "//   the old ring";
 …
          pause();
          newline;
+       }
+      }
       setring P;
+      L[3]=0;
       return(L);
+   }
 …
+   {
       "// R is not equal to Hom(J,J), we have to try again";
+    if( y>=2 )
+    {  pause();
+       newline;
+    }
+      pause();
+      newline;
+   }
 //---------- Hom(J,J) != R: create new ring and map from old ring -------------
 // the ring newR1/SBid+syzf will be isomorphic to Hom(J,J) as R-module
+   f=mstd(f)[2];
+   ideal ann=quotient(f2,f);
+   int delta;
+   if(isIso&&isEq){delta=vdim(std(modulo(f,ideal(p))));}
    f = p,rf;          // generates pJ:J mod(p), i.e. p*Hom(J,J)/p*R as R-module
    q = size(f);
    syzf = syz(f);
 …
    attrib(SBid,"isSB",1);
+ qring newR = std(SBid);
+   qring newR = std(SBid);
    map psi = R,ideal(X(1..nvars(R)));
    ideal id = psi(id);
 …
       "//   the linear relations";
       " ";
+      if( y>=2 )
+      {  Lin;
+         pause();
+         "";
+      }
+   }
+      Lin;
+      "   ";
+   }
    for (ii=2; ii<=q; ii++ )
+   {
 …
+      }
+   }
    if(y>=1)
+   {
       "//   the quadratic relations";
+        if( y>=2 )
+      {
+          "   ";
+         interred(Quad);
+         pause();
+         newline;
+      }
+   }
+   Q = Lin+Quad;
+      "   ";
+      interred(Quad);
+      pause();
+      newline;
+   }
+   Q = Lin,Quad;
    Q = subst(Q,T(1),1);
    Q = interred(reduce(Q,std(0)));
+   Q=mstd(Q)[2];
 //---------- reduce number of variables by substitution, if possible ----------
    if (homo==1)
 …
+   }
    ideal endid  = imap(newR,id)+imap(newR,Q);
+   ideal endid  = imap(newR,id),imap(newR,Q);
    ideal endphi = ideal(X(1..nvars(R)));
    L=substpart(endid,endphi,homo,rw);
    def lastRing=L[1];
    setring lastRing;
+   attrib(endid,"onlySingularAtZero",0);
+   map sigma=R,endphi;
+   ideal an=sigma(ann);
+   export(an);  //noetig?
+   ideal te=an,endid;
+   if(isIso&&(size(reduce(te,std(maxideal(1))))==0))
+   {
+      attrib(endid,"onlySingularAtZero",oSAZ);
+   }
+   kill te;
    attrib(endid,"isCohenMacaulay",isCo);
    attrib(endid,"isPrim",isPr);
 …
    attrib(endid,"isCompleteIntersection",0);
    attrib(endid,"isRad",0);
-  // export(endid);
-  // export(endphi);
    if(y>=1)
+   {
       "//   the new ring after reduction of the number of variables";
+      show(lastRing);
+      pause(); "
+      ";
+    if(y >=2)
+    {
+      "   ";
       lastRing;
       "   ";
 …
       pause();
       newline;
+    }
+   }
    L = lastRing;
    L = insert(L,0,1);
+   L[3]=delta;
    return(L);
+}
 …
 proc normal(ideal id, list #)
 "USAGE:   normal(i [,choose]);  i a radical ideal, choose empty or 1
+"USAGE:   normal(i [,choose]);  i a radical ideal, choose empty, 1 or "wd"
          if choose=1 the normalization of the associated primes is computed
          (which is sometimes more efficient)
+         if choose="wd" the delta-invariant is computed simultaneously
+         this may take much more time in the reducible case because the
+         factorizing standardbasis algorithm cannot be used.
 ASSUME:  The ideal must be radical, for non radical ideals the output may
          be wrong (i=radical(i); makes i radical)
 RETURN:   a list of rings, say nor:
+RETURN:   a list of rings, say nor and in case of choose="wd" an integer
 @format
+         at the end of the list.
          each ring nor[i] contains two ideals
          with given names norid and normap such that
 …
 @end format
 NOTE:    to use the i-th ring type: def R=nor[i]; setring R;.
+@*       Not implemented for local or mixed orderings and quotient rings.
+@*       Increasing printlevel displays more comments (default: printlevel=0)
+@*       Not implemented for local or mixed orderings.
 @*       If the input ideal i is weighted homogeneous a weighted ordering may
          be used (qhweight(i); computes weights).
-@*       printlevel = 1: count normalization loops (default: printlevel=0)
-@*       printlevel > 1: protocoll of normalization steps
-@*       printlevel > 2: protocoll of all normalization steps, pauses
-@*       printlevel > 3: display some (>4 all) intermediate results, pauses
 EXAMPLE: example normal; shows an example
+"
+{
    int i,j,y;
+   int i,j,y,withdelta;
    string sr;
    list result,prim,keepresult;
    y = printlevel-voice+2;
+   if(size(#)>0)
+   {
+     if(typeof(#[1])=="string")
+     {
+       kill #;
+       list #;
+       withdelta=1;
+     }
+   }
    attrib(id,"isRadical",1);
    if ( ord_test(basering) != 1)
 …
       if(y>=1)
+      {
+        "";
+         "// we have ",size(prim),"equidimensional component(s)";
+         "// we have ",size(prim),"equidimensional components";
+      }
+      if(withdelta &&(size(prim)>1))
+      {
+         withdelta=0;
+         "WARNING!  cannot compute delta,";
+         "the ideal is not equidimensional";
+      }
+      if(!withdelta)
+      {
+         option(redSB);
+         for(j=1;j<=size(prim);j++)
+         {
+            keepresult=keepresult+facstd(prim[j]);
+         }
+         prim=keepresult;
+         option(noredSB);
+      }
+   }
 …
          else
+         {
             prim=minAssGTZ(id);
+            prim=minAssPrimes(id);
+         }
+      }
       else
+      {
          prim=minAssGTZ(id);
+         prim=minAssPrimes(id);
+      }
       if(y>=1)
+      {
+         "";
+         "// we have ",size(prim),"irreducible component(s)";
+         "// we have ",size(prim),"irreducible components";
+      }
+   }
 …
       if(y>=1)
+      {
+         "";
+         "// BEGIN with equidimensional/irreducible component",i;
+         "// we are in loop ",i;
+      }
       attrib(prim[i],"isCohenMacaulay",0);
 …
       attrib(prim[i],"isEquidimensional",1);
       attrib(prim[i],"isCompleteIntersection",0);
+      attrib(prim[i],"onlySingularAtZero",0);
+      if( typeof(attrib(id,"onlySingularAtZero"))=="int" )
+      {
+            if(attrib(id,"onlySingularAtZero")==1)
+             {attrib(prim[i],"onlySingularAtZero",1); }
+      }
       if( typeof(attrib(id,"isIsolatedSingularity"))=="int" )
 …
+      }
       keepresult=normalizationPrimes(prim[i],maxideal(1),0);
+      for(j=1;j<=size(keepresult);j++)
+      for(j=1;j<=size(keepresult)-1;j++)
+      {
          result=insert(result,keepresult[j]);
+      }
+      sr = string(size(result));
+      sr = string(size(result));
+   }
+   if(withdelta)
+   {
+      sr = string(size(keepresult)-1);
+      result=keepresult;
+   }
       dbprint(y+1,"
 // 'normal' created a list of "+sr+" ring(s).
+// nor["+sr+"+1] is the delta-invariant in case of choose=wd.
 // To see the rings, type (if the name of your list is nor):
      show(nor);
+     show( nor);
 // To access the 1-st ring and map (similar for the others), type:
      def R = nor[1]; setring R;  norid; normap;
 …
    norid;
    normap;
+   ring s=0,(x,y),dp;
+   ideal i=(x-y^2)^2 - y*x^3;
+   nor=normal(i,"wd");
+   //the delta-invariant
+   nor[size(nor)];
+}
 ///////////////////////////////////////////////////////////////////////////////
 static proc normalizationPrimes(ideal i,ideal ihp, int count, list #)
 "USAGE:   normalizationPrimes(i,ihp[,si,countt]);  i prime ideal, ihp map
          (partial normalization), si ideal of singular locus,
          count = integer to count the number of normalization loops
 RETURN:  a list of one ring L=R, in  R are two ideals
          S,M such that R/M is the normalization of original basering
          S is a standardbasis of M
+NOTE:    to use the ring: def r=L[1];setring r;
          printlevel = 1: count normalization loops (default: printlevel=0)
          printlevel > 1: protocoll of normalization steps
          printlevel > 2: protocoll of all normalization steps, pauses
          printlevel > 3: display some (>4 all) intermediate results, pauses
+static proc normalizationPrimes(ideal i,ideal ihp,int delta, list #)
+"USAGE:   normalizationPrimes(i,ihp[,si]);  i equidimensional ideal, ihp map
+         (partial normalization),delta partial delta-invariant,
+          # ideal of singular locus
+RETURN:   a list of rings, say nor, and an integer, the delta-invariant
+          at the end of the list.
+          each ring nor[i] contains two ideals
+          with given names norid and normap such that
+           - the direct sum of the rings nor[i]/norid is
+             the normalization of basering/id;
+           - normap gives the normalization map from basering/id
+             to nor[i]/norid (for each i)
 EXAMPLE: example normalizationPrimes; shows an example
+"
+{
+   count = count+1;
+   int y = printlevel-voice+count+1;  // y=printlevel (default: y=0)
+   if(y>=0)
+   {
+     "// START normalization LOOP ",count;
+   }
+   if( y>=3)
+   {
+     "// with ideal";  "";
+   int y = printlevel-voice+2;  // y=printlevel (default: y=0)
+   if(y>=1)
+   {
+     "";
+     "// START a normalization loop with the ideal";  "";
      i;  "";
      basering;  "";
 …
      newline;
+   }
    def BAS=basering;
 …
          export normap;
          result=newR7;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
 …
    if(y>=1)
+   {
+   "// SB-computation of ideal of size",size(i),"in ring with",nvars(basering),"variables";
+   }
+// -------------- SB-computation of the input ideal ----------------------
+   list SM=mstd(i);                //here the work starts, SM[1] a SB of i
+                                   //SM[2] a smaller set of generators of i
+   int dimSM =  dim(SM[1]);        //dimension of i, V(i)=variety to normalize
+     "// SB-computation of the input ideal";
+   }
+   list SM=mstd(i);                //here the work starts
+   int dimSM =  dim(SM[1]);        //dimension of variety to normalize
   // Case: Get an ideal containing a unit
    if( dimSM == -1)
 …
          export normap;
          result=newR6;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
 …
       dimSM;"";
+   }
+   if(size(#)>0)                   //ideal of sing locus is given in #[1]
+   {
+      list JM=mstd(#[1]);
+      if( typeof(attrib(#[1],"isRad"))!="int" )
+      {
+         attrib(JM[2],"isRad",0);
+      }
+   }
+// -------- transfer attributes from ideal i to SM[2], SM = mstd(i) --------
+   if(size(#)>0)
+   {
+      if(attrib(i,"onlySingularAtZero"))
+      {
+         list JM=maxideal(1),maxideal(1);
+         attrib(JM[1],"isSB",1);
+         attrib(JM[2],"isRad",1);
+      }
+      else
+      {
+         ideal te=#[1],SM[2];
+         list JM=mstd(te);
+         kill te;
+         if( typeof(attrib(#[1],"isRad"))!="int" )
+         {
+            attrib(JM[2],"isRad",0);
+         }
+      }
+   }
    if(attrib(i,"isPrim")==1)
+   {
 …
       attrib(SM[2],"isEquidimensional",0);
+   }
     if(attrib(i,"isCompleteIntersection")==1)
+   if(attrib(i,"isCompleteIntersection")==1)
+   {
       attrib(SM[2],"isCompleteIntersection",1);
 …
       attrib(SM[2],"isCompleteIntersection",0);
+   }
+//************* case 0: check and prepare special cases ****************
+//no computation for the normalization in case 0
+//-------------------------- the smooth case ----------------------------
+   if(attrib(i,"onlySingularAtZero")==1)
+   {
+      attrib(SM[2],"onlySingularAtZero",1);
+   }
+   else
+   {
+      attrib(SM[2],"onlySingularAtZero",0);
+   }
+   if((attrib(SM[2],"isIsolatedSingularity")==1)&&(homog(SM[2])==1))
+   {
+      attrib(SM[2],"onlySingularAtZero",1);
+   }
+   //the smooth case
    if(size(#)>0)
+   {
 …
+         }
          MB=SM[2];
          intvec rw;
+         intvec rw;;
          list LL=substpart(MB,ihp,0,rw);
          def newR6=LL[1];
 …
          export normap;
          result=newR6;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
+     }
+   }
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+//---------------- the homogeneous zero-dimensional case ----------------
+   //the zero-dimensional case
    if((dim(SM[1])==0)&&(homog(SM[2])==1))
+   {
 …
       export normap;
       result=newR5;
+      result[size(result)+1]=delta;
       setring BAS;
       return(result);
+   }
+//------------- the homogeneous one-dimensional case -------------------
+//in this case i defines a line because it is irreducible and homogeneous
+   //the one-dimensional case
+   //in this case it is a line because
+   //it is irreducible and homogeneous
    if((dim(SM[1])==1)&&(attrib(SM[2],"isPrim")==1)
         &&(homog(SM[2])==1))
 …
       export normap;
       result=newR4;
+      result[size(result)+1]=delta;
       setring BAS;
       return(result);
+   }
+//----------------------- the higher dimensional case ----------------------
+   //the higher dimensional case
    //we test first of all CohenMacaulay and
    //complete intersection
 …
+      }
+   }
+   //compute the singular locus+lower dimensional components
+//------- case: not(isolated singularity and homogeneous) -------------------
+   if((attrib(SM[2],"isIsolatedSingularity")==0) && (size(#)==0))
+   {
+//---------- computation of ideal of singular locus -------------------------
+   if((attrib(SM[2],"onlySingularAtZero")==0)&&(size(i)==1))
+   {
+      int tau=vdim(std(i+jacob(i)));
+      if(tau>=0)
+      {
+        execute("ring BASL="+charstr(BAS)+",("+varstr(BAS)+"),ds;");
+        ideal i=imap(BAS,i);
+        int tauloc=vdim(std(i+jacob(i)));
+        setring BAS;
+        attrib(SM[2],"onlySingularAtZero",(tau==tauloc));
+        kill BASL;
+      }
+   }
+   //compute the singular locus
+   if((attrib(SM[2],"onlySingularAtZero")==0)&&(size(#)==0))
+   {
       J=minor(jacob(SM[2]),nvars(basering)-dim(SM[1]));
-      //ti=timer;
       if(y >=1 )
+      {
+         "// SB of singular locus will be computed ";
+         if(y >=2 )
+         {
+           "//in ring:";
+           show(basering);
+         }
+      }
+      J = simplify(J,16);  //this makes ist for huge J much faster
+      ideal sin=J,SM[2];
+         "// SB of singular locus will be computed";
+      }
+      ideal sin=J,SM[1];
       list JM=mstd(sin);
+      //JM[1] SB of singular locus, JM[2] minbasis of singular locus
       //SM[1] SB of ideal in normalisation loop, SM[2] minbasis
+      attrib(JM[1],"isSB",1);
+      //JM[1] SB of singular locus, JM[2]=minbasis of singular locus
+      //SM[1] SB of the input ideal, SM[2] minbasis
       if(y>=1)
+      {
 …
          dim(JM[1]); "";
+      }
+      //   timer-ti;
+      attrib(JM[1],"isSB",1);
       if(dim(JM[1])==-1)
+      {
 …
          export normap;
          result=newR3;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
+      }
       if(dim(JM[1])==0 && (homog(SM[2])==1))
+      if(dim(JM[1])==0)
+      {
          attrib(SM[2],"isIsolatedSingularity",1);
+         if(homog(SM[2])){attrib(SM[2],"onlySingularAtZero",1);}
+      }
       if(dim(JM[1])<=dim(SM[1])-2)
 …
+      }
+   }
+//------------ case: isolated singularity and homogeneous -----------------
+   if(attrib(SM[2],"isIsolatedSingularity")==1)
+   else
+   {
      if(size(#)==0)
+     {
+        if(defined(JM)==voice)
+        {  JM=maxideal(1),maxideal(1);
+        }
+        else
+        {  list JM=maxideal(1),maxideal(1);
+        }
+        list JM=maxideal(1),maxideal(1);
         attrib(JM[1],"isSB",1);
+        if(dim(SM[1])>=2){attrib(SM[2],"isRegInCodim2",1);}
+     }
+   }
-//------------ case: Cohen Macaulay and regular in codim 2 -----------------
-//in this case we are ready, the ring is normal
    if((attrib(SM[2],"isRegInCodim2")==1)&&(attrib(SM[2],"isCohenMacaulay")==1))
+   {
 …
       export normap;
       result=newR6;
+      result[size(result)+1]=delta;
       setring BAS;
       return(result);
+   }
+//************* case 1: isolated singularity and homogeneous ****************
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+   //if SM is an isolated singularity and homogeneous, we know that this
+   //persists in the following normalization loops and things are easier
+   //since the radical of the singular locus is the maximal ideal
+   //if it is an isolated singularity only at 0 things are easier
    //JM ideal of singular locus, SM ideal of variety
+   if(attrib(SM[2],"isIsolatedSingularity")==1)
+   {
+      if(y>=1)
+      {
+         "// CASE 1: unique isolated singularity at 0";
+         "// radial of singular locus is the maximal ideal";
+      }
+   if(attrib(SM[2],"onlySingularAtZero"))
+   {
+      attrib(SM[2],"isIsolatedSingularity",1);
       ideal SL=simplify(reduce(maxideal(1),SM[1]),2);
       //SL = vars not contained in ideal
+      //vars not contained in ideal
       ideal Ann=quotient(SM[2],SL[1]);
       ideal qAnn=simplify(reduce(Ann,SM[1]),2);
+      ideal qAnn=simplify(reduce(Ann,SM[1]),2);
       //qAnn=0 ==> the first var(=SL[1]) not contained in SM is a nzd of R/SM
-  //--------------- case: a nonzero-divisor was found ---------------
       if(size(qAnn)==0)
+      {
 …
+         {
             "";
-            "//   a nonzero-divisor was found";
             "//   the ideal rad(J):";
             "";
             maxideal(1);
             newline;
-            "// TEST for normality: R=Hom(J,J)?";
-            "";
+         }
     //test for normality:
          //?spaeter: test for normality, Hom(I,R)==R?
+         //again test for normality
+         //Hom(I,R)=R
          list RR;
+         RR=SM[1],SM[2],maxideal(1),SL[1],count;
+         //  ti=timer;
+         RR=HomJJ(RR);
+         //  timer-ti;
+         if(RR[2]==0)
+    //the ring is not normal, start a new normalization loop
+         RR=SM[1],SM[2],maxideal(1),SL[1];
+         RR=HomJJ(RR,y);
+         if(RR[2]==0)
+         {
             def newR=RR[1];
             setring newR;
             map psi=BAS,endphi;
+         //  ti=timer;
+            list tluser=normalizationPrimes(endid,psi(ihp),count);
+         //  timer-ti;
+            list tluser=normalizationPrimes(endid,psi(ihp),delta+RR[3],an);
             setring BAS;
             return(tluser);
+         }
-    //the ring is normal, prepare output and go home
          MB=SM[2];
          execute("ring newR7="+charstr(basering)+",("+varstr(basering)+"),("
 …
          ideal norid=fetch(BAS,MB);
          ideal normap=fetch(BAS,ihp);
+         delta=delta+RR[3];
          export norid;
          export normap;
          result=newR7;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
+       }
+  //--------------- case: a zero-divisor was found ---------------
+      //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor of R/SM
+      //Now the case where qAnn!=0, i.e.SL[1] is a zero divisor of R/SM
       //and we have found a splitting: id and id1
       //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1])
+      //id=Ann defines components of R/SM in the complement of V(SL[1])
       //id1 defines components of R/SM in the complement of V(id)
-      //?????instead of id1 we can take SL[1]+Ann+SM[2]???????????
        else
+       {
+         if(y>=0)
+         {
+            "//   a zero-divisor was found, we have SPLITTING of ideals";
+           if(y >=2 )
+           {
+             "// in ring:";
+             show(basering);
+            }
+            "";
+         }
+          ideal id=qAnn+SM[2];
+          ideal id=Ann;
           attrib(id,"isCohenMacaulay",0);
           attrib(id,"isPrim",0);
 …
           attrib(id,"isCompleteIntersection",0);
           attrib(id,"isEquidimensional",0);
+          if(y>=0)
+          {
+    "//   start a normalization loop with 1st split ideal (size",size(id),"in",nvars(basering),"vars)";
+          }
+          keepresult1=normalizationPrimes(id,ihp,count);
+          ideal id1=quotient(SM[2],Ann)+SM[2];
+//          evtl. qAnn statt Ann nehmen
+//          ideal id=SL[1]+SM[2];
+          attrib(id,"onlySingularAtZero",1);
+          ideal id1=quotient(SM[2],Ann);
+          //ideal id=SL[1],SM[2];
           attrib(id1,"isCohenMacaulay",0);
           attrib(id1,"isPrim",0);
 …
           attrib(id1,"isCompleteIntersection",0);
           attrib(id1,"isEquidimensional",0);
+          if(y>=0)
+          {
+              "//   start a normalization loop with 2nd split ideal (size",size(id),"in",nvars(basering),"vars)";
+          }
+          keepresult2=normalizationPrimes(id1,ihp,count);
+          for(lauf=1;lauf<=size(keepresult2);lauf++)
+          attrib(id1,"onlySingularAtZero",1);
+          ideal t1=id,id1;
+          int mul=vdim(std(t1));
+          kill t1;
+          keepresult1=normalizationPrimes(id,ihp,0);
+          keepresult2=normalizationPrimes(id1,ihp,0);
+          delta=delta+mul+keepresult1[size(keepresult1)]
+                         +keepresult1[size(keepresult1)];
+          for(lauf=1;lauf<=size(keepresult2)-1;lauf++)
+          {
              keepresult1=insert(keepresult1,keepresult2[lauf]);
+          }
+          keepresult1[size(keepresult1)]=delta;
           return(keepresult1);
+       }
+   }
+//********** case 2: no unique isolated singularity at 0 *************
+   //in this case the radical must be computed
+   // recall: SM = mstd(i), i = ideal to start with in normaliztion loop
+   //         JM = mstd(#[1]), #[1]= ideal of singular locus of i
+   //              #[1] is given after the first normalization loop
+   //test for normality:  Hom(J,J)=R
+   //test for non-normality: Hom(J,J)!=R, we can use Hom(J,J) to continue
+      if(y>=1)
+      {
+         "// CASE 2: no unique isolated singularity";
+         "// radical has to be computed";
+      }
+   //test for non-normality
+   //Hom(I,I)<>R
+   //we can use Hom(I,I) to continue
    ideal SL=simplify(reduce(JM[2],SM[1]),2);
-   //SL = elements of ideal of singular locus not contained in ideal i
    ideal Ann=quotient(SM[2],SL[1]);
    ideal qAnn=simplify(reduce(Ann,SM[1]),2);
+   //qAnn=0 ==> SL[1] is a nonzero-divisor of R/SM
+  //--------------- case: a nonzero-divisor was found ---------------
    if(size(qAnn)==0)
+   {
       list RR;
       list RS;
     //now we have to compute the radical
+      //now we have to compute the radical
       if(y>=1)
+      {
+         "// radical computation of singular locus";
+      }
+      J=radical(JM[2]);   //the singular locus
+      JM=mstd(J);
+      if((vdim(JM[1])==1)&&(size(reduce(J,std(maxideal(1))))==0))
+      {
+         attrib(SM[2],"onlySingularAtZero",1);
+      }
+      if(y>=1)
+      {
+        "//   radical is equal to:";"";
+        J;
         "";
+         "//   a nonzero-divisor was found";
+         "//   radical computation of ideal of singular locus";
+      }
+    //-------------- computation of the radical J --------------------
+    //We have at least two possibilities:
+    //J=radical(JM[2]), the radical of the full singular locus, or
+    //J=radical(SM[2]+ideal(SL[1])), JM[2] contains SM[2]+ideal(SL[1])
+      //the first is usually better!
+      if(y>=1)
+      {
+        "// compute radical J of ideal of singular locus";"";
+      }
+      J=radical(JM[2]);
+      // alternativ:   J=radical(SM[2]+ideal(SL[1]));
+      if(y>=2)
+      {
+          "// the radical is equal to:";
+          J;
+          newline;
+      }
+      if(y>=1)
+      {
+        "// TEST for normality: R=Hom(J,J)?";
+        "";
+      }
+      JM=J,J;              //J = new ideal for singular locus
+      }
+      if(deg(SL[1])>deg(J[1]))
+      {
+         Ann=quotient(SM[2],J[1]);
+         qAnn=simplify(reduce(Ann,SM[1]),2);
+         if(size(qAnn)==0){SL[1]=J[1];}
+      }
       //evtl. fuer SL[1] anderen Nichtnullteiler aus J waehlen
+    //test for normality:
+      RR=SM[1],SM[2],JM[2],SL[1],count;
+      RS=HomJJ(RR);
+    //--- the ring is normal, prepare output and go home
+      RR=SM[1],SM[2],JM[2],SL[1];
+      //   evtl eine geeignete Potenz von JM?
+     if(y>=1)
+     {
+        "// compute Hom(rad(J),rad(J))";
+     }
+     RS=HomJJ(RR,y);
       if(RS[2]==1)
+      {
 …
          export norid;
          export normap;
+         result=lastR;
+         result[size(result)+1]=delta+RS[3];
          setring BAS;
+         return(lastR);
+      }
+    //--- the ring is not normal, start a new normalization loop
+         return(result);
+      }
       int n=nvars(basering);
       ideal MJ=JM[2];
 …
       map psi=BAS,endphi;
       list tluser=
            normalizationPrimes(endid,psi(ihp),count,simplify(psi(MJ)+endid,4));
+             normalizationPrimes(endid,psi(ihp),delta+RS[3],psi(MJ));
       setring BAS;
       return(tluser);
+   }
+  //--------------- case: a zero-divisor was found ---------------
+  //Now the case where qAnn!=0, i.e.SL[1] is a zero-divisor of R/SM
+  //and we have found a splitting: id and id1
+  //id=qAnn+SM[2] defines components of R/SM in the complement of V(SL[1])
+  //id1 defines components of R/SM in the complement of V(id)
+      //?????instead of id1 we can take SL[1]+Ann+SM[2]???????????
+   // A component with singular locus the whole component found:
+    // A component with singular locus the whole component found
    if( Ann == 1)
+   {
 …
          export normap;
          result=newR6;
+         result[size(result)+1]=delta;
          setring BAS;
          return(result);
+   }
-   // The general case with splitting of ring, i.e. qAnn!=0
    else
+   {
       int equi=attrib(SM[2],"isEquidimensional");
+      ideal new1=qAnn+SM[2];
+      int oSAZ=attrib(SM[2],"onlySingularAtZero");
+      int isIs=attrib(SM[2],"isIsolatedSingularity");
+      ideal new1=Ann;
+      ideal new2=quotient(SM[2],Ann);
+      //ideal new2=SL[1],SM[2];
+      int mul;
+      if(equi&&isIs)
+      {
+          ideal t2=new1,new2;
+          mul=vdim(std(t2));
+      }
       execute("ring newR1="+charstr(basering)+",("+varstr(basering)+"),("
                       +ordstr(basering)+");");
+      if(y>=0)
+      {
+            "//   a zero-divisor was found, we have SPLITTING of ideals";
+            "";
+      if(y>=1)
+      {
+         "// zero-divisor found";
+      }
       ideal vid=fetch(BAS,new1);
 …
       attrib(vid,"isCohenMacaulay",0);
       attrib(vid,"isPrim",0);
       attrib(vid,"isIsolatedSingularity",0);
+      attrib(vid,"isIsolatedSingularity",isIs);
       attrib(vid,"isRegInCodim2",0);
+      if(equi==1)
+      {
+         attrib(vid,"isEquidimensional",1);
+      }
+      else
+      {
+         attrib(vid,"isEquidimensional",0);
+      }
+      attrib(vid,"onlySingularAtZero",oSAZ);
+      attrib(vid,"isEquidimensional",equi);
       attrib(vid,"isCompleteIntersection",0);
+      if(y>=0)
+      {
+            "// start a normalization loop with 1st split ideal (size",size(vid),"in",nvars(basering),"vars)";
+      }
+      keepresult1=normalizationPrimes(vid,ihp,count);
+      keepresult1=normalizationPrimes(vid,ihp,0);
+      int delta1=keepresult1[size(keepresult1)];
       setring BAS;
+      ideal new2=quotient(SM[2],Ann)+SM[2];
+// evtl. qAnn nehmen
       execute("ring newR2="+charstr(basering)+",("+varstr(basering)+"),("
                       +ordstr(basering)+");");
 …
       attrib(vid,"isCohenMacaulay",0);
       attrib(vid,"isPrim",0);
       attrib(vid,"isIsolatedSingularity",0);
+      attrib(vid,"isIsolatedSingularity",isIs);
       attrib(vid,"isRegInCodim2",0);
+      if(equi==1)
+      {
+         attrib(vid,"isEquidimensional",1);
+      }
+      else
+      {
+         attrib(vid,"isEquidimensional",0);
+      }
+      attrib(vid,"isEquidimensional",equi);
       attrib(vid,"isCompleteIntersection",0);
+      if(y>=0)
+      {
+            "// start a normalization loop with 2nd split ideal (size",size(vid),"in",nvars(basering),"vars)";
+      }
+      keepresult2=normalizationPrimes(vid,ihp,count);
+      attrib(vid,"onlySingularAtZero",oSAZ);
+      keepresult2=normalizationPrimes(vid,ihp,0);
+      int delta2=keepresult2[size(keepresult2)];
       setring BAS;
+      for(lauf=1;lauf<=size(keepresult2);lauf++)
+      for(lauf=1;lauf<=size(keepresult2)-1;lauf++)
+      {
          keepresult1=insert(keepresult1,keepresult2[lauf]);
+      }
+      keepresult1[size(keepresult1)]=delta+mul+delta1+delta2;
       return(keepresult1);
+   }
 …
    b6c+bc6+a2b4e-3ab2c2de+c4d2e-a3cde2-abd3e2+bce5;
    list pr=normalizationPrimes(i,maxideal(1),1);
+   list pr=normalizationPrimes(i);
    def r1=pr[1];
    setring r1;
 …
    int ii,jj;
    map phi = basering,maxideal(1);
-   //endid=diagon(endid);
    list Le = elimpart(endid);
 …
    return(L);
+}
+///////////////////////////////////////////////////////////////////////////////
+static
+proc diagon(ideal i)
+/////////////////////////////////////////////////////////////////////////////
+proc genus(ideal K,list #)
+"USAGE:   genus(I) or genus(i,1); I a 1-dimensional ideal
+RETURN:  an integer, the geometric genus p_g = p_a - delta of the projective
+         curve defined by I, where p_a is the arithmetic genus.
+NOTE:    delta is the sum of all local delta-invariants of the singularities,
+         i.e. dim(R'/R), R' the normalization of the local ring R of the
+         singularity.
+         genus(i,1) uses the normalization to compute delta. Usually this
+         is slow but sometimes not.
+EXAMPLE: example genus; shows an example
+"
+{
+   matrix m;
+   intvec iv = option(get);
+   option(redSB);
+   ideal j=liftstd(jet(i,1),m);
+   option(set,iv);
+   return(ideal(matrix(i)*m));
+   int w = printlevel-voice+2;  // w=printlevel (default: w=0)
+   def R=basering;
+   K=std(K);
+   if(nvars(R)==3)
+   {
+      if((dim(K)!=2)||(!homog(K))||(size(K)>1)){ERROR("Input is not a curve");}
+      execute("ring newR=("+charstr(R)+"),(x,y),dp;");
+      map kappa=R,x,y,1;
+      ideal K=kappa(K);
+   }
+   if((nvars(R)>3)||(size(K)>1))
+   {  // hier geeignet projezieren
+      ERROR("This case is not implemented yet");
+   }
+   if(nvars(R)==2)
+   {
+      execute("ring newR=("+charstr(R)+"),(x,y),dp;");
+      map kappa=R,x,y;
+      ideal K=kappa(K);
+   }
+   // assume now that R is a ring with two variables
+   poly p=K[1];
+   ideal I;
+   if(homog(p))
+   {
+      if(deg(squarefree(p))<deg(p)){ERROR("Curve is not reduced");}
+      return(-deg(p)+1);
+   }
+   execute("ring S=("+charstr(R)+"),(x,y,t),dp;");
+   execute("ring C=("+charstr(R)+"),(x,y),ds;");
+   ideal I;
+   execute("ring A=("+charstr(R)+"),(x,t),dp;");
+   map phi=S,1,x,t;
+   map psi=S,x,1,t;
+   poly g,h;
+   ideal I,I1;
+   execute("ring B=("+charstr(R)+"),(x,t),ds;");
+   setring S;
+   poly F=imap(newR,p);
+   F=homog(F,t);
+   int d=deg(F);
+   int genus=(d-1)*(d-2)/2;
+//   if(w>=1){"test for smoothness";}
+//   if(dim(std(jacob(F)))==0)  //the smooth case
+//   {
+//      setring R;
+//      return(genus);
+//   }
+   int delta,deltaloc,deltainf,tau,tauinf,cusps,iloc,iglob,
+       tauloc,tausing,k,rat,nbranchinf,nbranch,nodes;
+   list inv;
+   if(w>=1){"singularities at oo";}
+   setring A;
+   g=phi(F);
+   h=psi(F);
+   I=g,jacob(g),var(2);
+   I=std(I);
+   if(deg(I[1])>0)
+   {
+      list qr=minAssGTZ(I);
+      for(k=1;k<=size(qr);k++)
+      {
+         inv=deltaLoc(g,qr[k]);
+         deltainf=deltainf+inv[1];
+         tauinf=tauinf+inv[2];
+         nbranchinf=nbranchinf+inv[3];
+      }
+   }
+   inv=deltaLoc(h,maxideal(1));
+   deltainf=deltainf+inv[1];
+   tauinf=tauinf+inv[2];
+   if(inv[2]>0){nbranchinf=nbranchinf+inv[3];}
+   if(w>=1)
+   {
+      "branches at oo:";nbranchinf;
+      "tau at oo:";tauinf;
+      "delta at oo:";deltainf;
+      "singularities not at oo";
+   }
+   setring newR;         //the singularities at the affine part
+   map sigma=S,var(1),var(2),1;
+   I=sigma(F);
+   if((size(#)!=0)||((char(basering)<181)&&(char(basering)!=0)))
+   {                              //uses the normalization to compute delta
+      list nor=normal(I,"wd");
+      delta=nor[size(nor)];
+      genus=genus-delta-deltainf;
+      setring R;
+      return(genus);
+   }
+   ideal I1=jacob(I);
+   matrix Hess[2][2]=jacob(I1);
+   ideal ID=I+I1+ideal(det(Hess));
+   if(w>=1){"the cusps and nodes";}
+   ideal radID=std(radical(ID));
+   ideal IDsing=minor(jacob(ID),2)+radID;
+   iglob=vdim(std(IDsing));
+   if(iglob!=0)
+   {
+      ideal radIDsing=reduce(IDsing,radID);
+      if(size(radIDsing)==0)
+      {
+         radIDsing=radID;
+         attrib(radIDsing,"isSB",1);
+      }
+      else
+      {
+         radIDsing=std(radical(IDsing));
+      }
+      iglob=vdim(radIDsing);
+   }
+   cusps=vdim(radID)-iglob;
+   if(w>=1){"the other singularities";}
+   if(iglob==0)   //only cusps and double points
+   {
+      tau=vdim(std(I+jacob(I)));
+      nodes=tau-2*cusps;
+      delta=nodes+cusps;
+      nbranch=2*tau-3*cusps;
+   }
+   else
+   {
+       setring C;
+       ideal I1=imap(newR,IDsing);
+       iloc=vdim(std(I1));
+       if(iglob==iloc)  // only cusps and nodes outside 0
+       {
+          I=imap(newR,I);
+          tauloc=vdim(std(I+jacob(I)));
+          setring newR;
+          inv=deltaLoc(I[1],maxideal(1));
+          delta=inv[1];
+          tau=inv[2];
+          nodes=tau-tauloc-2*cusps;
+          nbranch=inv[3]+ 2*nodes+cusps;
+          delta=delta+nodes+cusps;
+        }
+        else
+        {
+           setring newR;
+           list pr=minAssGTZ(IDsing);
+           for(k=1;k<=size(pr);k++)
+           {
+              inv=deltaLoc(I[1],pr[k]);
+              delta=delta+inv[1];
+              tausing=tausing+inv[2];
+              nbranch=nbranch+inv[3];
+           }
+           nodes=tau-tauloc-2*cusps;
+           tau=vdim(std(I+jacob(I)));
+           delta=delta+nodes+cusps;
+           nbranch=nbranch+2*nodes+cusps;
+        }
+   }
+   if(w>=1)
+   {
+      "branches :";nbranch;
+      "nodes:"; nodes;
+      "cusps:";cusps;
+      "tau :";tau;
+      "delta:";delta;
+   }
+   genus=genus-delta-deltainf;
+   setring R;
+   return(genus);
+}
+/////////////////////////////////////////////////////////////////////////////
+example
+{ "EXAMPLE:"; echo = 2;
+   ring r=0,(x,y),dp;
+   ideal i=y^9 - x^2*(x - 1)^9;
+   genus(i);
+}
+///////////////////////////////////////////////////////////////////////////
+proc deltaLoc(poly f,ideal singL)
+{
+   def R=basering;
+   execute("ring S=("+charstr(R)+"),(x,y),lp;");
+   map phi=R,x,y;
+   ideal singL=phi(singL);
+   singL=std(singL);
+   int d=vdim(singL);
+   poly f=phi(f);
+   int i;
+   if(d==1)
+   {
+      map alpha=S,var(1)-singL[2][2],var(2)-singL[1][2];
+      f=alpha(f);
+      execute("ring C=("+charstr(S)+"),("+varstr(S)+"),ds;");
+      poly f=imap(S,f);
+   }
+   else
+   {
+      poly p;
+      poly c;
+      map psi;
+      while((deg(singL[1])>1)&&(deg(singL[2])>1))
+      {
+         psi=S,x,y+random(-100,100)*x;
+         singL=psi(singL);
+         singL=std(singL);
+      }
+      if(deg(singL[2])==1){p=singL[1];c=singL[2][2];}
+      if(deg(singL[1])==1)
+      {
+         psi=S,y,x;
+         f=psi(f);
+         singL=psi(singL);
+         p=singL[2];
+         c=singL[1][2];
+      }
+      execute("ring B=("+charstr(S)+"),a,dp;");
+      map beta=S,a,a;
+      poly p=beta(p);
+      execute("ring C=("+charstr(S)+",a),("+varstr(S)+"),ds;");
+      number p=number(imap(B,p));
+      minpoly=p;
+      number c=number(imap(S,c));
+      map alpha=S,x-c,y+a;
+      poly f=alpha(f);
+      f=cleardenom(f);
+   }
+   ideal fstd=std(ideal(f)+jacob(f));
+   poly hc=highcorner(fstd);
+   int tau=vdim(fstd);
+   int o=ord(f);
+   int delta,nb;
+   if(tau==0)                 //smooth case
+   {
+      setring R;
+      return(list(0,0,1));
+   }
+   if((char(basering)>=181)||(char(basering)==0))
+   {
+      if(o==2)                //A_k-singularity
+      {
+         setring R;
+         delta=(tau+1)/2;
+         return(list(d*delta,d*tau,d*(2*delta-tau+1)));
+      }
+      if((lead(f)==var(1)*var(2)^2)||(lead(f)==var(1)^2*var(2)))
+      {//D_k- singularity
+         setring R;
+         delta=(tau+2)/2;
+         return(list(d*delta,d*tau,d*(2*delta-tau+1)));
+      }
+      int mu=vdim(std(jacob(f)));
+      poly g=f+var(1)^mu+var(2)^mu;  //to obtain a convinient Newton-polygon
+      list NP=newton(g);
+      int s=size(NP);
+      int nN=-NP[1][2]-NP[s][1]+1;  // computation of the Newton-number
+      intmat m[2][2];
+      for(i=1;i<=s-1;i++)
+      {
+         m=NP[i+1],NP[i];
+         nN=nN+det(m);
+      }
+      if(mu==nN)                   // the Newton-polygon is non-degenerate
+      {                            // compute nb, the number of branches
+        for(i=1;i<=s-1;i++)
+        {
+          nb=nb+gcd(NP[i][2]-NP[i+1][2],NP[i][1]-NP[i+1][1]);
+        }
+        return(list(d*(mu+nb-1)/2,d*tau,d*nb));
+      }
+   //da reddevelop nur benutzt wird, um die Anzahl der Zweige zu bestimmen
+   //kann man das sicher schneller machen:
+   //die Aufblasung durchfuehren und stets testen, ob das Newton-polyeder
+   //nicht ausgeartet ist.
+      if(s>2)    //  splitting of f
+      {
+         intvec v=NP[1][2]-NP[2][2],NP[2][1];
+         int de=w_deg(g,v);
+         int st=w_deg(hc,v)+v[1]+v[2];
+         poly f1=var(2)^NP[2][2];
+         poly f2=jet(g,de,v)/var(2)^NP[2][2];
+         poly h=g-f1*f2;
+         de=w_deg(h,v);
+         poly k;
+         ideal wi=var(2)^NP[2][2],f2;
+         matrix li;
+         while(de<st)
+         {
+           k=jet(h,de,v);
+           li=lift(wi,k);
+           f1=f1+li[2,1];
+           f2=f2+li[1,1];
+           h=g-f1*f2;
+           de=w_deg(h,v);
+         }
+         nb=deltaLoc(f1,maxideal(1))[3]+deltaLoc(f2,maxideal(1))[3];
+         return(list(d*(mu+nb-1)/2,d*tau,d*nb));
+      }
+      f=jet(f,deg(hc)+2);
+      list hne=reddevelop(f);
+      nb=size(hne);
+      setring R;
+      kill HNEring;
+      return(list(d*(mu+nb-1)/2,d*tau,d*nb));
+   }
+   else             //the case of small characteristic
+   {
+      f=jet(f,deg(hc)+2);
+      list hne=reddevelop(f);
+      nb=size(hne);
+      if(nb==1)
+      {
+         delta=invariants(hne[1])[5]/2;
+         setring R;
+         kill HNEring;
+         return(list(d*delta,d*tau,d));
+      }
+      setring R;
+      kill HNEring;
+      //delta direkt aus reddevelop zurueckgeben
+      ERROR("the case of small characteristic is not fully implemented yet");
+   }
+}
+proc w_deg(poly p, intvec v)
+{
+   if(p==0){return(-1);}
+   int d=0;
+   while(jet(p,d,v)==0){d++;}
+   d=(transpose(leadexp(jet(p,d,v)))*v)[1];
+   return(d);
+}
+proc newton (poly f)
+{
+   def R1=basering;
+   execute("ring R2=("+charstr(R1)+"),("+varstr(R1)+"),ls;");
+   poly f=imap(R1,f);
+   intvec A=(0,ord(subst(f,var(1),0)));
+   intvec B=(ord(subst(f,var(2),0)),0);
+   intvec C,H; list L;
+   int abbruch,i;
+   poly hilf;
+   L[1]=A;
+   f=jet(f,A[2]*B[1]-1,intvec(A[2],B[1]));
+   map xytausch=R2,var(2),var(1);
+   for (i=2; f!=0; i++)
+   {
+      abbruch=0;
+      while (abbruch==0)
+      {
+         C=leadexp(f);
+         if(jet(f,A[2]*C[1]-A[1]*C[2]-1,intvec(A[2]-C[2],C[1]-A[1]))==0)
+         {
+            abbruch=1;
+         }
+         else
+         {
+            f=jet(f,-C[1]-1,intvec(-1,0));
+         }
+     }
+     hilf=jet(f,A[2]*C[1]-A[1]*C[2],intvec(A[2]-C[2],C[1]-A[1]));
+     H=leadexp(xytausch(hilf));
+     A=H[2],H[1];
+     L[i]=A;
+     f=jet(f,A[2]*B[1]-1,intvec(A[2],B[1]-A[1]));
+   }
+   L[i]=B;
+   setring R1;
+   return(L);
+}
+///////////////////////////////////////////////////////////////////////////
 /*
-Aenderungen:
-. normal kommentiert, bei Berechnung de singulaeren Ortes ein simplify(J,16)
-eingefuehrt, um bei riesigen Minorenzahlen, das Ideal zu verkleinern (bis
-Faktor 10 Beschleunigung).
-Protokoll mit printlevel so gesteuert, dass es bei rekursivem Aufruf korrekt
-arbeitet.
-list nor = normal(i);     //mit equidim Zerlegung
-list nor = normal(i,1);   //mit prim Zerlegung
-Zeiten au sony_pumuckel (P2, 500)
                            Examples:
 LIB"normal.lib";
+//1. Huneke, 1 Komponente
+//prim: 2 sec equidim:1sec
+//Huneke
 ring qr=31991,(a,b,c,d,e),dp;
 ideal i=
 …
 //2. Vasconcelos (dauert laenger: 83 sec auf sony_pumuckel)
+//Vasconcelos (dauert laenger: 70 sec)
 ring r=32003,(x,y,z,w,t),dp;
 ideal i=
 …
 xw3+z3t+ywt2,
 y2w4-xy2z2t-w3t3;
-//2a. Vasconcelos verkleinert
-//prim:2Komp, 2 Ringe, 16 sec (manchmal lange, haengt am Faktorisierer)
-//equidim: 1 Komp, 7 loops, 2 ringe, 12sec
-ring r=32003,(x,y,z,w,t),dp;
-ideal i=
-x+zw,
-y3+xwt,
-xw3+z3t+ywt2;
-//3. GM1
-// irreducible, 13 normalization loops, 1 Ring
-//2sec mit prim, 1 sec mit equidim
-ring r=32003,(x,y,z,u),dp;
-ideal i = x2+y3,z2+u3,y2+z3;
-//3a. GM1
-ring r=32003,(x,y),dp;
-ideal i = intersect(y3+x2,y2+x3);  // beide 0 sec
-ideal i = intersect(y3+x2,y2+x3,y2+x2+x3);
-//prim 0sec,
-//equidim sehr lange (Relationen in HomJJ zu gross)
-//4. GM2
-//i nicht reduziert, equidim bricht ab (0 sec)
-//prim: 11 irred comp, 11 loops, (1sec)
-ring r=32003,(x,y,z,u),dp;
-ideal i = x2+y3,z2+u3,y2+z3,x2+z3;
-//5. GM3,  radical von GM2
-//prim: 11 irred comp, 11 loops, 11 Ringe, (1sec)
-//equidim: 1 equidim comp, 1 loop, 1 Ring, (0sec)
-ring r=32003,(x,y,z,u),dp;
-ideal i =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
-//GM4
-//equidim: 2 equidim comp, 3 Ringe, (0sec);
-//prim: 3 Komp, (0sec)
-ring r=32003,(x,y,z,u),dp;
-ideal i1 = x2+y3,u,z;
-ideal i2 = u2+z3,x,y;
-ideal i3 = x2+y2+z2+u4;
-ideal i = intersect(i1,i2,i3);
-//GM4a  Hier dauert prim laenger! (## facstd)
-//equidim: 3 equidim Komp, 4 Ringe(0sec)
-//prim 13 Komp (63 sec), wegen facstd
-//##ev minAssGTZ(i,1) verwenden (ohne facstd, ist noch fehlerhaft)
-ring r=32003,(x,y,z,u),dp;
-ideal i1 = x2+y3,u,z;
-ideal i2 = u2+z3,x,y;
-ideal i3 = x2+y2+z2+u4;
-ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y;
-ideal i = intersect(i1,i2,i3,i4);
-//GM5
-//equidim: 4 Komp,0sec, prim 13 Komp, 1sec
-ring r=32003,(x,y,z,u,v),dp;
-ideal i1 = x2+y3,v;                            //2dim
-ideal i2 = u2+z3,x,y;                          //3dim
-ideal i3 = x2+y2+z2+u4;                        //4dim
-ideal i4 =yu+u,yz+z,y2+y,xy+x,x2+y,u3+z2,z3-y; //1dim
-ideal i = intersect(i1,i2,i3,i4);
-//cyclic 5
-//equidim: 1 Komp 0sec, prim: 20 Komp, 3 sec
-ring r=32003,(x,y,z,u,v),dp;
-ideal i =
-x+y+z+u+v,
-xy+yz+zu+xv+uv,
-xyz+yzu+xyv+xuv+zuv,
-xyzu+xyzv+xyuv+xzuv+yzuv,
-xyzuv-1;
-// cyclic 5 hat Normalisierung (1 embim weniger)
-///equidim: 1 Komp 0sec, prim: 20 Komp, 2 sec
-ring r=32003,(x,y,z,u),dp;
-ideal i =
-x2+xz-yz+2xu+yu+u2,
-xy2-xyz+y2z-y2u+xzu+yzu+z2u-xu2-2yu2+zu2-u3,
-xyz2+xyzu+y2zu-xz2u+yz2u-z3u-xyu2-xzu2-2z2u2+xu3+yu3-zu3+u4,
-xyzu2+y2zu2+2yz2u2-xyu3-2xzu3-yzu3-z2u3+xu4+yu4-2zu4+u5-1;
-//cyclic(6)
-//equidim: 1Komp in 5 vars 1sec
-//prim: 90 (!) Ringe, 12 sec
 //Theo1
 …
 ad;
-//Sturmfels, wo vorher Prim schneller (2 sec,sonst 860 sec)
 //ist CM
+//prim: 15 loops, 15 Komp, 1 sec,
+//equidim:15 Ringe, 93 sec mit simplify(J,16),
+//ohne simlify(J,16) 860sec?,
+//andere simplify sind z.T. viel langsamer
+//Sturmfels
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 ideal i=
 …
 //Horrocks:
+//CHAR 32003:mit prim 1 sec, equidim: 115 sec, beide 6 Ringe
+//           Singulaere Ort hat zu Beginn > 106 000 Erzeuger!!
+//char 31991: prim 1sec, 8 Ringe, equidim: 25 Ringe(!), 162 sec,
+//            nicht reduziert!
+//            Singulaere Ort hat zu Beginn > 28 000 Erzeuger!!
+//            i=radical(i) -> 8 Ringe, 1sec (radical <1 sec)
+//Horrocks:
+ring r=31991,(a,b,c,d,e,f),dp;
+ring r=32003,(a,b,c,d,e,f),dp;
 ideal i=
 adef-16000be2f+16001cef2,
 …
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;   //3sec
+ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 ideal k=
 wy-vz,
 …
 ideal i=mstd(intersect(j,k))[2];
+//22,
+// neu, prim: 3 sec, equidim 1 sec, je 4 Ringe
 ring r=32003,(b,s,t,u,v,w,x,y,z),dp;
 ideal i=
 …
+//riemenschneider, 5 Komponenten
+//33(alte Zeiten), normal+primary 3, primary 9, radical 1, minAssGTZ; 2
+//neu: prim 0sec, equi 1 sec, je 5 Ringe
+//riemenschneider
 ring r=32000,(p,q,s,t,u,v,w,x,y,z),wp(1,1,1,1,1,1,2,1,1,1);
 ideal i=
 …
 ring r=0,(u,v,w,x,y,z),wp(1,1,1,3,2,1);
+ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;   //0sec
+ideal i=wx,wy,wz,vx,vy,vz,ux,uy,uz,y3-x2;
+//Yoshihiko Sakai
+ring r=0,(x,y),dp;   //genus 0 4 nodes and 6 cusps
+ideal i=(x2+y^2-1)^3 +27x2y2;
+ring r=0,(x,y),dp;   //genus 0
+ideal i=(x-y^2)^2 - y*x^3;
+ring r=0,(x,y),dp;  //genus 4
+ideal i=y3-x6+1;
+int m=9;           // q=9: genus 0
+int p=2;
+int q=9;//2,...,9
+ring r=0,(x,y),dp;
+ideal i=y^m - x^p*(x - 1)^q;
+ring r=0,(x,y),dp;  //genus 19
+ideal i=55*x^8+66*y^2*x^9+837*x^2*y^6-75*y^4*x^2-70*y^6-97*y^7*x^2;
+ring r=0,(x,y),dp;  //genus 34
+ideal i=y10+(-2494x2+474)*y8+(84366+2042158x4-660492)*y6
+        +(128361096x4-47970216x2+6697080-761328152x6)*y4
+        +(-12024807786x4-506101284x2+15052058268x6+202172841-3212x8)*y2
+        +34263110700x4-228715574724x6+5431439286x2+201803238
+        -9127158539954x10-3212722859346x8;
+//Rob Koelman
+ring r=0,(x,y,z),dp;//genus 10  with 26 cusps
+ideal i=
+761328152*x^6*z^4-5431439286*x^2*y^8+2494*x^2*z^8+228715574724*x^6*y^4+
+ 9127158539954*x^10-15052058268*x^6*y^2*z^2+3212722859346*x^8*y^2-
+ 134266087241*x^8*z^2-202172841*y^8*z^2-34263110700*x^4*y^6-6697080*y^6*z^4-
+ 2042158*x^4*z^6-201803238*y^10+12024807786*x^4*y^4*z^2-128361096*x^4*y^2*z^4+
+ 506101284*x^2*z^2*y^6+47970216*x^2*z^4*y^4+660492*x^2*z^6*y^2-
+ z^10-474*z^8*y^2-84366*z^6*y^4;
+ring r=0,(x,y),dp;//genus 10  with 26 cusps
+ideal i=9127158539954x10+3212722859346x8y2+228715574724x6y4-34263110700x4y6
+-5431439286x2y8-201803238y10-134266087241x8-15052058268x6y2+12024807786x4y4
++506101284x2y6-202172841y8+761328152x6-128361096x4y2+47970216x2y4-6697080y6
+-2042158x4+660492x2y2-84366y4+2494x2-474y2-1;
+ring r=0,(x,y),dp;   // genuss 1  with 5 cusps
+ideal i=57y5+516x4y-320x4+66y4-340x2y3+73y3+128x2-84x2y2-96x2y;;
+//Mark van Hoeij
+ring r=0,(x,y),dp;  //genus 19
+ideal i=y20+y13x+x4y5+x3*(x+1)^2;
+ring r=0,(x,y),dp;  //genus 35
+ideal i=y30+y13x+x4y5+x3*(x+1)^2;
+ring r=0,(x,y),dp;   //genus 55
+ideal i=y40+y13x+x4y5+x3*(x+1)^2;
+ring r=0,(x,y),dp;  //genus 55
+ideal i=((x2+y3)^2+xy6)*((x3+y2)^2+x10y);
 */

Singular/LIB/ntsolve.lib

-                      r3de58c
+                      r50cbdc
 //(GMG, last modified 16.12.00)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: ntsolve.lib,v 1.12 2001-02-19 14:17:47 lossen Exp $";
+version="$Id: ntsolve.lib,v 1.13 2001-08-27 14:47:56 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
 …
  ipar[1]: max. number of iterations
  ipar[2]: accuracy (we have the l_2-norm ||.||): accept solution @code{sol}
           if ||gls(sol)|| < eps0*(0.1^ipar[2])
+          if ||gls(sol)|| < eps0*(0.1^ipar[2])
           where eps0 = ||gls(ini)|| is the initial error
   @end format

Singular/LIB/paramet.lib

-                      r3de58c
+                      r50cbdc
 // last change:           17.01.2001
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: paramet.lib,v 1.11 2001-02-19 14:17:47 lossen Exp $";
+version="$Id: paramet.lib,v 1.12 2001-08-27 14:47:57 Singular Exp $";
 category="Visualization";
 info="
 …
 SEE ALSO: normal_lib, primdec_lib, hnoether_lib
 PROCEDURES:
  parametrize(I);       parametrizes a prime ideal via the normalization
+PROCEDURES:
+ parametrize(I);       parametrizes a prime ideal via the normalization
  parametrizepd(I);     calculates the prim.dec. and parametrizes the components
  parametrizesing(f);   parametrizes an isolated plane curve singularity
 …
 proc parametrize(ideal I)
 "USAGE:   parametrize(I); I ideal in an arbitrary number of variables,
           whose radical is prime, in a ring with global ordering
+          whose radical is prime, in a ring with global ordering
 CREATE:   If the parametrization is successful, the basering will be changed to
           the parametrization ring, that is to the ring PR=0,(s,t),dp;
           respectively PR=0,t(1..d),dp;, depending on the dimension of the
+          the parametrization ring, that is to the ring PR=0,(s,t),dp;
+          respectively PR=0,t(1..d),dp;, depending on the dimension of the
           parametrized variety.
 RETURN:   a list containing the parametrization ideal resp. the original ideal,
 …
 "USAGE:   parametrizepd(I); I ideal in a polynomial ring with global ordering
 CREATE:   If the parametrization is successful, the basering will be changed to
           the parametrization ring, that is to the ring PR=0,(s,t),dp;
           respectively PR=0,t(1..d),dp;, depending on the dimension of the
+          the parametrization ring, that is to the ring PR=0,(s,t),dp;
+          respectively PR=0,t(1..d),dp;, depending on the dimension of the
           parametrized variety.
 RETURN:   a list of lists, where each entry contains the parametrization
 …
           the parametrization ring, that is to the ring  0,(x,y),ls;
 RETURN:   a list containing the parametrizations of the different branches of the
           singularity at the origin resp. 0, if f was not of the desired kind
+          singularity at the origin resp. 0, if f was not of the desired kind
 SEE ALSO: hnoether_lib, reddevelop
 KEYWORDS: parametrization; curve singularities

Singular/LIB/presolve.lib

-                      r3de58c
+                      r50cbdc
 //last change: 13.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: presolve.lib,v 1.17 2001-02-19 14:17:48 lossen Exp $";
+version="$Id: presolve.lib,v 1.18 2001-08-27 14:47:57 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
 …
           s1: name of new ring,@*
           s2: new ordering@*
           (default: s1=\"R(n)\" where n is the # of vars in the new ring,
+          (default: s1=\"R(n)\" where n is the # of vars in the new ring,
           s2=\"dp\" or \"ds\" depending whether the first block of the old
           ordering is a p- resp. an s-ordering)
 CREATE:  nothing, if id contains all vars of the basering.@*
          Else, create a ring with same char as the basering, but possibly less
 …
          but with new ordering and vars sorted in the following manner:
   @format
   - each block of vars occuring in pi is sorted w.r.t. its complexity in id,
+  - each block of vars occuring in pi is sorted w.r.t. its complexity in 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
 …
       in one block
   @end format
   Note that only simple ordstrings oi are allowed:
+  Note that 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)
          if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x:@*
+         valuation vector of x:@*
          consider id as list of polynomials in x with coefficients in the
          remaining variables. Then:@*
 …
 { "EXAMPLE:"; echo = 2;
    ring s = 32003,(x,y,z),dp;
    ideal i=x3+y2,xz+z2;
+   ideal i=x3+y2,xz+z2;
    sortandmap(i,"R_r","i");
    // i is now an ideal in the new basering R_r
 …
 NOTE:    We define a variable x to be more complex than y (with respect to id)
          if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x:@*
+         valuation vector of x:@*
          consider id as list of polynomials in x with coefficients in the
          remaining variables. Then:@*
 …
 { "EXAMPLE:"; echo = 2;
    ring s=0,(x,y,z,w),dp;
    ideal i = x3+y2+yw2,xz+z2,xyz-w2;
+   ideal i = x3+y2+yw2,xz+z2,xyz-w2;
    sortvars(i,0,xy,1,zw);
+}
 …
          We define a variable x to be more complex than y (with respect to id)
          if val(x) > val(y) lexicographically, where val(x) denotes the
          valuation vector of x:@*
+         valuation vector of x:@*
          consider id as list of polynomials in x with coefficients in the
          remaining variables. Then:@*

Singular/LIB/primdec.lib

-                      r3de58c
+                      r50cbdc
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: primdec.lib,v 1.99 2001-03-29 11:34:59 Singular Exp $";
+version="$Id: primdec.lib,v 1.100 2001-08-27 14:47:58 Singular Exp $";
 category="Commutative Algebra";
 info="
 …
 ///////////////////////////////////////////////////////////////////////////////
 static proc idealsEqual( ideal k, ideal j)
+proc idealsEqual( ideal k, ideal j)
+{
    return(stdIdealsEqual(std(k),std(j)));
 …
 static proc primaryTest (ideal i, poly p)
+proc primaryTest (ideal i, poly p)
+{
    int m=1;
 …
     for(i=1;i<=size(keep);i++)
+    {
+       l[size(l)+1]=keep[i];
+       l[size(l)+1]=primaryTest(keep[i],keep[i][1]);
+       if(deg(keep[i][1])>0)
+       {
+          l[size(l)+1]=keep[i];
+          l[size(l)+1]=primaryTest(keep[i],keep[i][1]);
+       }
+    }
+  }
 …
+     }
+  }
   if(size(#)==0)
+  {
 …
 RETURN:  ideal, the radical of i.
 NOTE:    Uses the algorithm of Eisenbud/Huneke/Vasconcelos, which
          reduces the computation to the complete intersection case,
+         reduces the computation to the complete intersection case,
          by taking, in the general case, a generic linear combination
          of the input.
 …
    intvec op=option(get);
    matrix M;
    option(redSB);
    list m=mstd(i);

Singular/LIB/primitiv.lib

-                      r3de58c
+                      r50cbdc
 // This library is for Singular 1.2 or newer
 version="$Id: primitiv.lib,v 1.15 2001-02-05 12:01:39 lossen Exp $";
+version="$Id: primitiv.lib,v 1.16 2001-08-27 14:47:59 Singular Exp $";
 category="Commutative Algebra";
 info="
 …
 "USAGE:   primitive(i); i ideal
 ASSUME:   i is given by generators m[1],...,m[n] such that for j=1,...,n @*
           -  m[j] is a polynomial in k[x(1),...,x(j)] @*
           -  m[j](a[1],...,a[j-1],x(j)) is the minimal polynomial for a[j] over
+          -  m[j] is a polynomial in k[x(1),...,x(j)] @*
+          -  m[j](a[1],...,a[j-1],x(j)) is the minimal polynomial for a[j] over
              k(a[1],...,a[j-1]) @*
           (k the ground field of the current basering and x(1),...,x(n)
           the ring variables).
+          the ring variables).
 RETURN:   ideal j in k[x(n)] with
           - j[1] a minimal polynomial for a primitive element b of
+          - j[1] a minimal polynomial for a primitive element b of
                  k(a[1],...,a[n]) over k,
           - j[2],...,j[n+1] polynomials in k[x(n)] such that j[i+1](b)=a[i]
+          - j[2],...,j[n+1] polynomials in k[x(n)] such that j[i+1](b)=a[i]
                  for i=1,...,n.
 NOTE:     the number of variables in the basering has to be exactly n,
+NOTE:     the number of variables in the basering has to be exactly n,
           the number of given generators (i.e., minimal polynomials).@*
           If the ground field k has only a few elements it may happen that no
           linear combination of a[1],...,a[n] is a primitive element. In this
+          If the ground field k has only a few elements it may happen that no
+          linear combination of a[1],...,a[n] is a primitive element. In this
           case @code{primitive(i)} returns the zero ideal, and one should use
           @code{primitive_extra(i)} instead.
 …
  j[2];
  j[3];
  // no element was primitive -- the calculation of primitive elements
+ // no element was primitive -- the calculation of primitive elements
  // is based on a random choice.
+}
 …
 "USAGE:   primitive_extra(i); i ideal
 ASSUME:  The ground field of the basering is k=Q or k=Z/pZ and the ideal
          i is given by 2 generators f,g with the following properties:
+         i is given by 2 generators f,g with the following properties:
 @format
    f is the minimal polynomial of a in k[x],
+   f is the minimal polynomial of a in k[x],
    g is a polynomial in k[x,y] s.th. g(a,y) is the minpoly of b in k(a)[y].
 @end format
 …
    j[2] is a polynomial s.th. j[2](c)=a.
 @end format
 NOTE:    While @code{primitive(i)} may fail for finite fields,
          @code{primitive_extra(i)} tries all elements of k(a,b) and, hence,
+NOTE:    While @code{primitive(i)} may fail for finite fields,
+         @code{primitive_extra(i)} tries all elements of k(a,b) and, hence,
          always finds a primitive element. @*
          In order to do this (try all elements), field extensions like Z/pZ(a)
          are not allowed for the ground field k. @*
          @code{primitive_extra(i)} assumes that the second generator, g, is
+         @code{primitive_extra(i)} assumes that the second generator, g, is
          monic as polynomial in (k[x])[y].
 EXAMPLE: example primitive_extra;  shows an example
 …
 proc splitring
 "USAGE:   splitring(f,R[,L]); f poly, R string, L list of polys and/or ideals
+"USAGE:   splitring(f,R[,L]); f poly, R string, L list of polys and/or ideals
          (optional)
 ASSUME:  f is univariate and irreducible over the active basering. @*
          The active ring must allow an algebraic extension (e.g., it cannot
+         The active ring must allow an algebraic extension (e.g., it cannot
          be a transcendent ring extension of Q or Z/p).
 CREATE:  a ring with name R, in which f is reducible, and CHANGE to it.
 RETURN:  list L mapped into the new ring R, if L is given; else nothing
 NOTE:    If the old ring has no parameter, the name @code{a} is chosen for the
          parameter of R (if @code{a} is no ring variable; if it is, @code{b} is
          chosen, etc.; if @code{a,b,c,o} are ring variables,
          @code{splitring(f,R[,L])} produces an error message), otherwise the
          name of the parameter is kept and only the minimal polynomial is
+         parameter of R (if @code{a} is no ring variable; if it is, @code{b} is
+         chosen, etc.; if @code{a,b,c,o} are ring variables,
+         @code{splitring(f,R[,L])} produces an error message), otherwise the
+         name of the parameter is kept and only the minimal polynomial is
          changed. @*
          The names of the ring variables and the orderings are not affected. @*
          It is also allowed to call @code{splitring} with R=\"\".
          Then the old basering will be REPLACED by the new ring (with the
+         Then the old basering will be REPLACED by the new ring (with the
          same name as the old ring).
 KEYWORDS: algebraic field extension; extension of rings
 …
  ring r=0,(x,y),dp;
  splitring(x2-2,"r1");   // change to Q(sqrt(2))
  // change to Q(sqrt(2),sqrt(sqrt(2)))=Q(a) and return the transformed
+ // change to Q(sqrt(2),sqrt(sqrt(2)))=Q(a) and return the transformed
  // old parameter:
  splitring(x2-a,"r2",a);
+ splitring(x2-a,"r2",a);
  // the result is (a)^2 = (sqrt(sqrt(2)))^2
  nameof(basering);

Singular/LIB/reesclos.lib

-                      r3de58c
+                      r50cbdc
 PROCEDURES:
  ReesAlgebra(I);        computes the Rees Algebra of an ideal I
  normalI(I[,p[,r]]);    computes the integral closure of an ideal I using R[It]
+ ReesAlgebra(I);        computes the Rees Algebra of an ideal I
+ normalI(I[,p[,r]]);    computes the integral closure of an ideal I using R[It]
 ";
 LIB "normal.lib";       // for HomJJ
+LIB "normal.lib";       // for HomJJ
 LIB "standard.lib";     // for groebner
 …
   ideal m = maxideal(1);
   // Create a new ring with variables for each generator of I
   execute ("ring Rees = "+oldchar+",("+oldvar+",U(1.."+string(n)+")),dp");
   // Kxt is the old ring with additional variable t
   // Here I -> t*I, so the generators of I generate the subalgebra R[It] in Kxt
 …
   for (k=1;k<=n;k++)
+  {
     I[k]=t*I[k];
+  }
+    I[k]=t*I[k];
+  }
   // Now we map from Rees to Kxt, identity on the original variables, and
 …
   ideal ker = preimage(Kxt,phi,zero);
   export (ker);
   list result = Rees,Kxt;
   return(result);
+}
 example
 …
   ker;                   // R[It] is isomorphic to Rees/ker
+}
 ////////////////////////////////////////////////////////////////////////////
 …
 static
 proc ClosureRees (list L)
 "USAGE:    ClosureRees (L); L a list
+"USAGE:    ClosureRees (L); L a list
 ASSUME:   L is a list containing
           - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is
+          - a ring L[1], inside L[1] an ideal ker such that L[1]/ker is
             isomorphic to the Rees Algebra R[It] of an ideal I in k[x]
           - a ring L[2]=k[x,t], inside L[1] an ideal mapI defining the
             map L[1] --> L[2] with image R[It]
 RETURN:   quotients of elements of k[x,t] representing generators of the
           integral closure of R[It]. The result of ClosureRees is a list
+          integral closure of R[It]. The result of ClosureRees is a list
           images, the first size(images)-1 entries are the numerators of the
           generators, the last one is the universal denominator
+"
+{
   int dblvl=printlevel-voice+2;   // toggles how much data is printed
+  int dblvl=printlevel-voice+2;   // toggles how much data is printed
                                   // during the procedure
 …
+  {
     "// STEP 1: Compute the integral closure of R[It]";
+  }
+  }
   list RS;
 …
         list JM=groebner(sin),sin;
+      }
       J=radical(JM[2]);
+    }
 …
       ideal J=radical(JM[2]);
+    }
     if (dblvl>0)
+    {
 …
     JM =J,J;
     poly nzd=SL[1];           // universal denominator for HomJJ
     if (dblvl>0)
+    {
 …
     {                         // ring R(i+1)
       ideal MJ=JM[2];
       def R(i+1)=RS[1];       // the data of and some variable decla-
+      def R(i+1)=RS[1];       // the data of and some variable decla-
       setring R(i+1);         // rations in R(i+1) needed in STEP 2
       ideal ker(i+1)=endid;
 …
   list preimages;          // here the fractions are stored in the
                            // form var(j)=preimages[j]/preimages[length+1]
                            // ('=' means identification via the inclusion)
+                           // ('=' means identification via the inclusion)
                            // the last entry corresponds to nzd in R(i)
 …
     for (k=i;k>1;k--)
+    {
       // clear the fraction in the representation in R(i)
       p=p*phi(nzd);
+      // clear the fraction in the representation in R(i)
+      p=p*phi(nzd);
       // compute the preimage of [p mod ker(k)] under phi in R(k-1):
 …
          // compute this normal form h...
       if (j==1)    // in the first iteration: construct S(k)=R(k)[Z], fetch
+      if (j==1)    // in the first iteration: construct S(k)=R(k)[Z], fetch
                    // endphi (the ideal defining phi) and ker(k) and construct
                    // the ideal from above
 …
   // at the end: go back to the original basering and construct gene-
   // rators of the closure of I
+  // rators of the closure of I
   setring Kxt;
   map psi=R(1),mapI;              // from ReesAlgebra: the map Rees->Kxt
   list images=psi(preimages);
+  list images=psi(preimages);
   if (dblvl>-1)
+  {
 …
             (the first size(L)-1 elements are the numerators, the last one
             is the denominator)
           - if # is given: #[1] is an integer, compute generators for the
+          - if # is given: #[1] is an integer, compute generators for the
                            closure of I, I^2, ..., I^#[1]
 RETURN:   the integral closure of I, ... I^#[1]. If # is not given, compute
 …
           closure of the desired powers of I. "
+{
   int dblvl=printlevel-voice+2;   // toggles how much data is printed
                                   // during the procedure
+  int dblvl=printlevel-voice+2;   // toggles how much data is printed
+                                  // during the procedure
   int j,k,d,computepow;                    // some counters
 …
   intmat m[nvars(basering)-1][1];  // an intvec used for jet and maxdeg1
   intvec tw=m,1;                   // such that t has weight 1 and all
+  intvec tw=m,1;                   // such that t has weight 1 and all
                                    // other variables have weight 0
 …
+      }
+    }
+  }
+  }
   if (dblvl>0)
 …
+    {
       image=images[j]-jet(images[j],k-1,tw);
       if (image<>0)
+      {
+      if (image<>0)
+      {
         image=subst(image/t^k,t,0);
         if (image<>0)
 …
   for (k=2;k<=pow;k++)
+  {
+  {
     for (j=1;j<=(k div 2);j++)
+    {
+    {
       result[k]=result[k]+result[j]*result[k-j];
+    }
+  }
   return(result);
+}
 …
+    {
       "// Trivial case: I is a principal ideal";
+    }
+    }
     list result=I;
     if (size(#)>0)
 …
         result=insert(result,I*result[k],k);
+      }
+    }
+    }
     return(result);
+  }
 …
           result=insert(result,I*result[k],k);
+        }
+      }
+      }
       return(result);
+    }
 …
     "// We start with the Rees Algebra of I:";
+  }
   list Rees = ReesAlgebra(I);
   def R(1)=Rees[1];
   def Kxt=Rees[2];
   setring R(1);
   if (dblvl>0)
+  {
 …
     "// Now ClosureRees computes generators for the integral closure";
     "// of R[It] step by step";
+  }
+  }
   // ClosureRees computes fractions in R[x,t] representing the generators
 …
       "//I is integrally closed!";
+    }
     setring BAS;
     list result=I;
 …
         result=insert(result,I*result[k],k);
+      }
+    }
+    }
     return(result);
+  }
   // construct the fractions corresponding to the generators of the
   // closure of I and its powers, depending on # (in fact, they will
+  // closure of I and its powers, depending on # (in fact, they will
   // not be real fractions, of course). This is done in ClosurePower.
 …
   setring BAS;
   list result=fetch(Kxt,result);
   return(result);
+  return(result);
+}
 example

Singular/LIB/solve.lib

-                      r3de58c
+                      r50cbdc
 //last change: 13.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: solve.lib,v 1.21 2001-02-19 14:17:49 lossen Exp $";
+version="$Id: solve.lib,v 1.22 2001-08-27 14:48:00 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
 …
 d>0: gives precision (1<d<p) for near-zero-determination,@*
 (default: d=1/2*p)
 ASSUME:  the ground field has char 0;@*
          l was computed using Algorithm of Lazard or Algorithm of Moeller

Singular/LIB/spcurve.lib

-                      r3de58c
+                      r50cbdc
 // (anne, last modified 31.5.99)
 /////////////////////////////////////////////////////////////////////////////
 version="$Id: spcurve.lib,v 1.15 2001-02-06 11:38:07 anne Exp $";
+version="$Id: spcurve.lib,v 1.16 2001-08-27 14:48:00 Singular Exp $";
 category="Singularities";
 info="
 …
               e.g. \"R\" leads to ring names R and R1
            *  v of size n(n+1) leads to the following module ordering @*
               gen(v[1]) > gen(v[2]) > ... > gen(v[n(n+1)]) where the matrix
+              gen(v[1]) > gen(v[2]) > ... > gen(v[n(n+1)]) where the matrix
               entry ij corresponds to gen((i-1)*n+j)
 ASSUME:    M is a quasihomogeneous n x (n+1) matrix where the n minors define

Singular/LIB/spectrum.lib

-                      r3de58c
+                      r50cbdc
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: spectrum.lib,v 1.15 2001-05-03 07:56:41 mschulze Exp $";
+version="$Id: spectrum.lib,v 1.16 2001-08-27 14:48:00 Singular Exp $";
 category="Singularities";
 info="
 …
 proc spectrumnd (poly f,list #)
 "USAGE:    spectrumnd(f[,1]); poly f
 ASSUME:   basering has characteristic 0 and local ordering,
+ASSUME:   basering has characteristic 0 and local ordering,
           f has isolated singularity at 0 and nondegenerate principal part
 RETURN:
 …
     int S[2][i]: multiplicity of spectral number S[1][i]
 @end format
 NOTE:     if a second argument 1 is given,
+NOTE:     if a second argument 1 is given,
           no test for a degenerate principal part will be done
 SEE_ALSO: gaussman_lib
 …
+}
 ///////////////////////////////////////////////////////////////////////////////
+proc spadd(list s1, list s2)
+"USAGE:   spadd(s1,s2); list s1, s2
+RETURN:  a list containing the sum of the two spectra s1 and s2
+EXAMPLE: example spadd; shows an example
+"
+{
+  return (system("spadd",s1,s2));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),ds;
+  list s1=spectrumnd(x5+x2y2+y5);
+  s1;
+  list s2=spectrumnd(x2+y3);
+  s2;
+  spadd(s1,s2);
+}
+///////////////////////////////////////////////////////////////////////////////
+proc spmul(list s, int k)
+"USAGE:   spmul(s,k); list s, int k
+RETURN:  a list containing the product of the spectrum s with the integer k
+EXAMPLE: example spmul; shows an example
+"
+{
+  return (system("spmul",s,k));
+}
+example
+{ "EXAMPLE:"; echo = 2;
+  ring r=0,(x,y),ds;
+  list s=spectrumnd(x5+x2y2+y5);
+  s;
+  spmul(s,2);
+>>>>>>> 1.12.2.1
+}
+///////////////////////////////////////////////////////////////////////////////

Singular/LIB/standard.lib

-                      r3de58c
+                      r50cbdc
 //////////////////////////////////////////////////////////////////////////////
 version="$Id: standard.lib,v 1.58 2001-02-22 16:02:55 westenb Exp $";
+version="$Id: standard.lib,v 1.59 2001-08-27 14:48:01 Singular Exp $";
 category="Miscellaneous";
 info="
 …
 PURPOSE: computes the standard basis of the homogeneous ideal in the basering,
          via a Hilbert driven standard basis computation.@*
          An optional second argument will be used as 1-st Hilbert function.
+         An optional second argument will be used as 1st Hilbert function.
 ASSUME:  The optional second argument is the first Hilbert series as computed
          by @code{hilb}.
 …
   // we are still here -- do the actual computation
   string ordstr_P = ordstr(P);
   if (find(ordstr_P,"s") > 0)
+  if ((find(ordstr_P,"s") > 0)||(find(ordstr_P,"M") > 0))
+  {
     //spaeter den lokalen fall ueber lp oder aehnlich behandeln
 …
 @item @strong{Purpose:}
 computes a (possibly minimal) free resolution of an ideal or module using
 a heuristically choosen method.
+a heuristically chosen method.
 @* The second (int) argument (say, @code{k}) specifies the length of
 the resolution. If it is not positive then @code{k} is assumed to be the
 …
 SYNTAX:  @code{quot (} module_expression@code{,} ideal_expression @code{)}
 TYPE:    module
 PURPOSE: computes the quotient of the first and the 2nd argument.
+PURPOSE: computes the quotient of the 1st and the 2nd argument.
          If a 3rd argument 'n' is given the n-th method is used
          (n=1...5).

Singular/LIB/surf.lib

-                      r3de58c
+                      r50cbdc
 //last change: 02.03.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: surf.lib,v 1.19 2001-03-02 13:41:19 westenb Exp $";
+version="$Id: surf.lib,v 1.20 2001-08-27 14:48:01 Singular Exp $";
 category="Visualization";
 info="
 …
 proc  plot(ideal I,list #)
 "USAGE:   plot(I);  I ideal
 ASSUME: I defines a plane curve or a surface
+"USAGE:   plot(I);  I ideal or poly
+ASSUME: I defines a plane curve or a surface given by one equation
 RETURN: nothing
 NOTE: requires the external program 'surf' to be installed
 …
+  }
   ideal I=simplify(phi(I),2);
+  if (leadcoef(I[1]) <0) { I[1]=-I[1]; }
   if (ncols(I)==1 and n<=2) // curve
+  {
 …
 example
 { "EXAMPLE:"; echo =2;
    // ---------  plane curves ------------
    ring rr0 = 0,(x1,x2),dp;
+  // ---------  plane curves ------------
+  ring rr0 = 0,(x1,x2),dp;
    ideal I = x1^3 - x2^2;
    plot(I);
+  ideal I = x1^3 - x2^2;
+  plot(I);
    ring rr1 = 0,(x,y,z),dp;
    ideal I(1) = 2x2-1/2x3 +1-y+1;
    plot(I(1));
+  ring rr1 = 0,(x,y,z),dp;
+  ideal I(1) = 2x2-1/2x3 +1-y+1;
+  plot(I(1));
   //  ---- Singular Logo --------------
 …
   plot(logo);
+   // --------- implicit curves ------------
+   // implicit curves
+   ideal I(1) = y,-x2;
+   plot(I(1));
+   ideal I(2) = x2,-y2 +4;
+   plot(I(2));
+  // Steiner surface
+  ideal J(2) = x^2*y^2+x^2*z^2+y^2*z^2-17*x*y*z;
+  plot(J(2));
+   //the lemniscate
+   ideal I(3) = x4+2x2y2 + y4, x2-y2;
+   plot(I(3));
+   // ----------- surfaces -------------------
+   ideal J(1) = 3xy4 + 2xy2, x5y3 + x + y6,10x2;
+   plot(J(1));
+   // Steiner surface
+   ideal J(2) = x^2*y^2+x^2*z^2+y^2*z^2-17*x*y*z;
+   plot(J(2));
+  // --------------------
   plot(x*(x2-y2)+z2);

Singular/LIB/zeroset.lib

-                      r3de58c
+                      r50cbdc
 // Last change 12.02.2001 (Eric Westenberger)
 ///////////////////////////////////////////////////////////////////////////////
 version="$Id: zeroset.lib,v 1.7 2001-02-19 14:17:50 lossen Exp $";
+version="$Id: zeroset.lib,v 1.8 2001-08-27 14:48:02 Singular Exp $";
 category="Symbolic-numerical solving";
 info="
 …
   - 'roots' is the list of roots of the polynomial f (no multiplicities)
   - if the groundfield is Q(a') and the extension field is Q(a), then
     'newA' is the representation of a' in Q(a).
+    'newA' is the representation of a' in Q(a).
     If the basering contains a parameter 'a' and the minpoly remains unchanged
     then 'newA' = 'a'.
 …
     If the basering contains a parameter 'a' and the minpoly remains unchanged
     then 'newA' = 'a'.
     If the basering does not contain a parameter then 'newA' = 'a' (default).
+    If the basering does not contain a parameter then 'newA' = 'a' (default).
   - 'id' is the ideal I in Q(a)[x_1,...] (a' substituted by 'newA')
   @end format

Singular/Makefile.in

-                      r3de58c
+                      r50cbdc
 @SET_MAKE@
 CC              = @CC@
+LD              = @LD@
 CXX             = @CXX@
 LEX             = @LEX@
 …
 SOURCES=${CSOURCES} ${CXXSOURCES} \
         grammar.y scanner.l libparse.l syz2.cc prCopyTemplate.cc \
         p_Delete__Template.cc p_ShallowCopyDelete__Template.cc \
         p_Copy__Template.cc p_Mult_nn__Template.cc  pp_Mult_nn__Template.cc \
         pp_Mult_mm__Template.cc p_Mult_mm__Template.cc \
         p_Minus_mm_Mult_qq__Template.cc p_Add_q__Template.cc \
         p_Neg__Template.cc pp_Mult_Coeff_mm_DivSelect__Template.cc \
         pp_Mult_Coeff_mm_DivSelectMult__Template.cc \
         p_Merge_q__Template.cc pp_Mult_mm_Noether__Template.cc\
         p_kBucketSetLm__Template.cc \
+        p_Delete__T.cc p_ShallowCopyDelete__T.cc \
+        p_Copy__T.cc p_Mult_nn__T.cc  pp_Mult_nn__T.cc \
+        pp_Mult_mm__T.cc p_Mult_mm__T.cc \
+        p_Minus_mm_Mult_qq__T.cc p_Add_q__T.cc \
+        p_Neg__T.cc pp_Mult_Coeff_mm_DivSelect__T.cc \
+        pp_Mult_Coeff_mm_DivSelectMult__T.cc \
+        p_Merge_q__T.cc pp_Mult_mm_Noether__T.cc\
+        p_kBucketSetLm__T.cc \
         kInline.cc utils.cc utils.h febase.inc \
         tesths.cc mpsr_Tok.cc claptmpl.cc
 …
 # MAKE SURE THAT THIS IS UP_TO_DATE
+#
+SLIBS = ainvar.lib   algebra.lib   all.lib       brnoeth.lib    classify.lib \
+SLIBS = COPYING \
+        ainvar.lib   algebra.lib   all.lib       brnoeth.lib    classify.lib \
         deform.lib   elim.lib      equising.lib  finvar.lib     gaussman.lib \
         general.lib  graphics.lib  hnoether.lib  homolog.lib    inout.lib \
         intprog.lib  latex.lib     linalg.lib    makedbm.lib    matrix.lib \
+        mondromy.lib mprimdec.lib  mregular.lib  normal.lib     ntsolve.lib \
+        paramet.lib  poly.lib      presolve.lib  primdec.lib    primitiv.lib \
+        qhmoduli.lib random.lib    reesclos.lib  ring.lib       rinvar.lib \
+        sing.lib     solve.lib     spcurve.lib   spectrum.lib   standard.lib \
+        stratify.lib surf.lib     toric.lib     triang.lib    zeroset.lib
+        mprimdec.lib \
+        mondromy.lib mregular.lib  normal.lib    ntsolve.lib    paramet.lib \
+        poly.lib     presolve.lib  primdec.lib   primitiv.lib   qhmoduli.lib \
+        random.lib   reesclos.lib  ring.lib      rinvar.lib     sing.lib \
+        solve.lib    spcurve.lib   spectrum.lib  standard.lib   stratify.lib \
+        surf.lib     toric.lib     triang.lib    zeroset.lib
 SLIBS_FILES = $(addprefix LIB/,${SLIBS})
 …
 p_Procs_%.so: p_Procs_Lib_%.dl_o
         ld ${SLDFLAGS} -o $@ $^
+        $(LD) ${SLDFLAGS} -o $@ $^
 mpsr.so: $(MPSR_SOURCES:.cc=.dl_o)
         ld ${SLDFLAGS} -o $@ $^ -L${libdir} ${MP_LIBS}
+        $(LD) ${SLDFLAGS} -o $@ $^ -L${libdir} ${MP_LIBS}
 dbmsr.so: $(DBMSR_SOURCES:.cc=.dl_o)
         ld ${SLDFLAGS} -o $@ $^
+        $(LD) ${SLDFLAGS} -o $@ $^
 src: scanner.cc grammar.h grammar.cc libparse.cc
 …
         ${INSTALL_PROGRAM} ${SING_EXEC} ${SINGULAR}
         ${INSTALL_PROGRAM} libparse ${RUN_SINGULARS} ${bindir}
+        ${INSTALL_PROGRAM} ESingular ${bindir}
+        ${INSTALL_PROGRAM} TSingular ${bindir}
+        ${INSTALL_PROGRAM} ${DL_LIBS} ${bindir}
+        ${INSTALL_PROGRAM} ESingular TSingular ${DL_LIBS} ${bindir}
         chmod a+x ${SINGULAR}
         rm -f ${bindir}/${SING_EXEC}${EXEC_EXT}
 …
         ${MKINSTALLDIRS} ${install_bindir}
         ${INSTALL_PROGRAM} -s  ${SING_EXEC} ${install_bindir}/Singular
         ${INSTALL_PROGRAM} -s  libparse ${RUN_SINGULARS} ESingular TSingular ${install_bindir}
+        ${INSTALL_PROGRAM} -s  libparse ${RUN_SINGULARS} ESingular TSingular ${DL_LIBS} ${install_bindir}
         echo "#undef MAKE_DISTRIBUTION " > distrib.h
-        ${INSTALL_PROGRAM} ${DL_LIBS} ${install_bindir}
 install-sharedist: ${SLIBS_FILES} LIB/gftables

Singular/clapsing.cc

-                      r3de58c
+                      r50cbdc
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 // $Id: clapsing.cc,v 1.77 2001-02-21 10:17:57 Singular Exp $
+// $Id: clapsing.cc,v 1.78 2001-08-27 14:46:49 Singular Exp $
 /*
 * ABSTRACT: interface between Singular and factory
 …
 ideal singclap_factorize ( poly f, intvec ** v , int with_exps)
+{
   // with_exps: 1 return only true factors
+  // with_exps: 3,1 return only true factors, no exponents
   //            2 return true factors and exponents
   //            0 return factors and exponents
+  //            0 return coeff, factors and exponents
   ideal res=NULL;
+  // handle factorize(0) =========================================
   if (f==NULL)
+  {
 …
     return res;
+  }
+  // handle factorize(mon) =========================================
+  if (pNext(f)==NULL)
+  {
+    int i=0;
+    int n=0;
+    int e;
+    for(i=pVariables;i>0;i--) if(pGetExp(f,i)!=0) n++;
+    if (with_exps==0) n++; // with coeff
+    res=idInit(max(n,1),1);
+    switch(with_exps)
+    {
+      case 0: // with coef & exp.
+        res->m[0]=pOne();
+        pSetCoeff(res->m[0],nCopy(pGetCoeff(f)));
+        // no break
+      case 2: // with exp.
+        (*v)=new intvec(n);
+        (**v)[0]=1;
+        // no break
+      case 1: ;
+      #ifdef TEST
+      default: ;
+      #endif
+    }
+    if (n==0)
+    {
+      res->m[0]=pOne();
+      // (**v)[0]=1; is already done
+      return res;
+    }
+    for(i=pVariables;i>0;i--)
+    {
+      e=pGetExp(f,i);
+      if(e!=0)
+      {
+        n--;
+        poly p=pOne();
+        pSetExp(p,i,1);
+        pSetm(p);
+        res->m[n]=p;
+        if (with_exps!=1) (**v)[n]=e;
+      }
+    }
+    return res;
+  }
+  // use factory/libfac in general ==============================
   Off(SW_RATIONAL);
   On(SW_SYMMETRIC_FF);
 …
   number N=NULL;
   number NN=NULL;
+  number old_lead_coeff=nCopy(pGetCoeff(f));
   if (rField_is_Q() || rField_is_Zp())
 …
   else if (rField_is_Extension())
+  {
     if (nGetChar()==1) setCharacteristic( 0 );
     else               setCharacteristic( -nGetChar() );
+    if (rField_is_Q_a()) setCharacteristic( 0 );
+    else                 setCharacteristic( -nGetChar() );
     if ((currRing->minpoly!=NULL)
     && (nGetChar()<(-1)))
+    )
+    {
       CanonicalForm mipo=convSingTrClapP(((lnumber)currRing->minpoly)->z);
 …
       CanonicalForm F( convSingAPClapAP( f,a ) );
       L.insert(F);
       if (F.isUnivariate())
+      if ((nGetChar()<(-1)) && F.isUnivariate())
+      {
         L = factorize( F, a );
 …
       else
+      {
+        CanonicalForm G( convSingTrPClapP( f ) );
+#ifdef HAVE_LIBFAC_P
+        CFList as(mipo);
+        L = newfactoras( G, as, 1);
+#else
         WarnS("complete factorization only for univariate polynomials");
-        CanonicalForm G( convSingTrPClapP( f ) );
         if (nGetChar()==1) /* Q(a) */
+        {
 …
         else
+        {
-#ifdef HAVE_LIBFAC_P
-          L = Factorize( G );
-#else
           goto notImpl;
-#endif
+        }
+#endif
+      }
+    }
 …
+    }
     // delete constants
     if ((with_exps!=0) && (res!=NULL))
+    if (res!=NULL)
+    {
       int i=IDELEMS(res)-1;
 …
       for(;i>=0;i--)
+      {
+        if ((res->m[i]!=NULL) && (pNext(res->m[i])==NULL) && (pIsConstant(res->m[i])))
+        if ((res->m[i]!=NULL)
+        && (pNext(res->m[i])==NULL)
+        && (pIsConstant(res->m[i])))
+        {
+          pDelete(&(res->m[i]));
+          if ((v!=NULL) && ((*v)!=NULL))
+            (**v)[i]=0;
+          j++;
+        }
+          if (with_exps!=0)
+          {
+            pDelete(&(res->m[i]));
+            if ((v!=NULL) && ((*v)!=NULL))
+              (**v)[i]=0;
+            j++;
+          }
+          else if (i!=0)
+          {
+            res->m[0]=pMult(res->m[0],res->m[i]);
+            res->m[i]=NULL;
+            if ((v!=NULL) && ((*v)!=NULL))
+              (**v)[i]=0;
+            j++;
+          }
+        }
+      }
       if (j>0)
 …
+    }
+  }
+  if (rField_is_Q_a() && (currRing->minpoly!=NULL))
+  {
+    int i=IDELEMS(res)-1;
+    for(;i>=1;i--)
+    {
+      pNorm(res->m[i]);
+    }
+    pSetCoeff(res->m[0],old_lead_coeff);
+  }
+  else
+    nDelete(&old_lead_coeff);
 notImpl:
   if (res==NULL)
 …
+  }
+  LL=IrrCharSeries(L);
+  int m= LL.length(); // Anzahl Zeilen
+  int n=0;
+  // a very bad work-around --- FIX IT in libfac
+  // should be fixed as of 2001/6/27
+  int tries=0;
+  int m,n;
   ListIterator<CFList> LLi;
+  CFListIterator Li;
+  for ( LLi = LL; LLi.hasItem(); LLi++ )
+  {
+    n = max(LLi.getItem().length(),n);
+  loop
+  {
+    LL=IrrCharSeries(L);
+    m= LL.length(); // Anzahl Zeilen
+    n=0;
+    for ( LLi = LL; LLi.hasItem(); LLi++ )
+    {
+      n = max(LLi.getItem().length(),n);
+    }
+    if ((m!=0) && (n!=0)) break;
+    tries++;
+    if (tries>=5) break;
+  }
   if ((m==0) || (n==0))
 …
+  }
   res=mpNew(m,n);
+  CFListIterator Li;
   for ( m=1, LLi = LL; LLi.hasItem(); LLi++, m++ )
+  {
 …
   intvec *v=NULL;
   int sw=(int)dummy->Data();
+  ideal f=singclap_factorize((poly)(u->Data()), &v, sw);
+  int fac_sw=sw;
+  if ((sw<0)||(sw>2)) fac_sw=1;
+  ideal f=singclap_factorize((poly)(u->Data()), &v, fac_sw);
   if (f==NULL)
     return TRUE;

Singular/claptmpl.cc

-                      r3de58c
+                      r50cbdc
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 // $Id: claptmpl.cc,v 1.24 2000-07-06 13:26:22 pohl Exp $
+// $Id: claptmpl.cc,v 1.25 2001-08-27 14:46:49 Singular Exp $
 /*
 * ABSTRACT - instantiation of all templates
 …
     template class ListIterator<CFFactor>;
     template class List<CanonicalForm>;
+    template class List<List<CanonicalForm> >;
     template class ListIterator<CanonicalForm>;
     template class Array<CanonicalForm>;
 …
     #ifndef NOSTREAMIO
     template ostream & operator<<(ostream &, const List<Factor<CanonicalForm> > &);
+    template ostream & operator<<(ostream &, const List<List<CanonicalForm> > &);
     template ostream & operator<<(ostream &, const List<Variable> &);
     #endif
 …
     T exp() const { return _exp; }
 #ifndef NOSTREAMIO
+    friend ostream & operator <<(ostream &, const Substitution<T> &);
+    friend ostream & operator <<<>(ostream &, Substitution<T> &);
+    void Substitution<T>::print ( ostream& s ) const
+    {
+      s << "("  << factor() << ")^" << exp();
+    }
 #endif
 };
 …
 #ifndef NOSTREAMIO
 template <class T>
+ostream& operator<< ( ostream & os, const Substitution<T> & a ) { return os; }
+ostream & operator <<(ostream & os, Substitution<T> &a)
+{
+  a.print(os);
+  return os;
+}
+template ostream & operator <<(ostream &, Substitution<CanonicalForm> &);
+template ostream & operator <<(ostream &, const List<CanonicalForm> &);
+template ostream & operator <<(ostream &, const Array<CanonicalForm> &);
+template ostream & operator<<(ostream &, const List<Substitution<CanonicalForm> > &);
 #endif
 …
 // for charsets:
-    template class List<CFList>;
     template class ListIterator<CFList>;

Singular/cntrlc.cc

-                      r3de58c
+                      r50cbdc
 *  Computer Algebra System SINGULAR     *
 ****************************************/
 /* $Id: cntrlc.cc,v 1.37 2001-03-05 11:48:54 Singular Exp $ */
+/* $Id: cntrlc.cc,v 1.38 2001-08-27 14:46:50 Singular Exp $ */
 /*
 * ABSTRACT - interupt handling
 …
 void sigsegv_handler(int sig, sigcontext s)
+{
   fprintf(stderr,"Singular : signal %d (v: %d/%lu):\n",sig,SINGULAR_VERSION,feVersionId);
+  fprintf(stderr,"Singular : signal %d (v: %d/%u):\n",sig,SINGULAR_VERSION,feVersionId);
   if (sig!=SIGINT)
+  {
 …
 void sigsegv_handler(int sig, int code, struct sigcontext *scp, char *addr)
+{
   fprintf(stderr,"Singular : signal %d, code %d (v: %d/%lu):\n",
+  fprintf(stderr,"Singular : signal %d, code %d (v: %d/%u):\n",
     sig,code,SINGULAR_VERSION,feVersionId);
   if ((sig!=SIGINT)&&(sig!=SIGABRT))
 …
 void sigsegv_handler(int sig)
+{
   fprintf(stderr,"Singular : signal %d (v: %d/%lu):\n",
+  fprintf(stderr,"Singular : signal %d (v: %d/%u):\n",
     sig,SINGULAR_VERSION,feVersionId);
   if (sig!=SIGINT)

Singular/configure

-                      r3de58c
+                      r50cbdc
 SINGULAR_MAJOR_VERSION=${SINGULAR_MAJOR_VERSION:-2}
 SINGULAR_MINOR_VERSION=${SINGULAR_MINOR_VERSION:-1}
 SINGULAR_SUB_VERSION=${SINGULAR_SUB_VERSION:-0}
+SINGULAR_SUB_VERSION=${SINGULAR_SUB_VERSION:-2}
 SINGULAR_VERSION="${SINGULAR_VERSION:-$SINGULAR_MAJOR_VERSION${VERSION_SEP}$SINGULAR_MINOR_VERSION${VERSION_SEP}$SINGULAR_SUB_VERSION}"
 VERSION_DATE=${VERSION_DATE:-"March 2001"}
+VERSION_DATE=${VERSION_DATE:-"August 2001"}
 …

Context Navigation

Changeset 50cbdc in git

Legend:

Singular/GMPrat.cc

Singular/GMPrat.h

Singular/LIB/all.lib

Singular/LIB/brnoeth.lib

Singular/LIB/classify.lib

Singular/LIB/equising.lib

Singular/LIB/general.lib

Singular/LIB/hnoether.lib

Singular/LIB/latex.lib

Singular/LIB/lll.lib

Singular/LIB/mprimdec.lib

Singular/LIB/normal.lib

Singular/LIB/ntsolve.lib

Singular/LIB/paramet.lib

Singular/LIB/presolve.lib

Singular/LIB/primdec.lib

Singular/LIB/primitiv.lib

Singular/LIB/reesclos.lib

Singular/LIB/solve.lib

Singular/LIB/spcurve.lib

Singular/LIB/spectrum.lib

Singular/LIB/standard.lib

Singular/LIB/surf.lib

Singular/LIB/zeroset.lib

Singular/Makefile.in

Singular/clapsing.cc

Singular/claptmpl.cc

Singular/cntrlc.cc

Singular/configure