Changeset 6c265b in git

Timestamp:

Sep 30, 2010, 8:07:01 PM (13 years ago)

Author:

Hans Schoenemann <hannes@…>

Branches:

(u'spielwiese', '0d6b7fcd9813a1ca1ed4220cfa2b104b97a0a003')

Children:

3576f6fb6a525ec1407b464179ffc8ad1f2c0ea7

Parents:

2433c5682fb607c4eeab2b77ea5d2c54269b493c

Message:

fix LIB includes

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

File:

• Singular/LIB/paraplanecurves.lib (modified) (94 diffs)

Singular/LIB/paraplanecurves.lib

@@ -10 +10 @@
           F. Seelisch, seelisch@mathematik.uni-kl.de
 
-OVERVIEW: 
+OVERVIEW:
 
 A library for computing rational parametrizations of rational plane curves
@@ -26 +26 @@
 and y as algebraic and computes an integral basis in C(x)[y] of the integral
 closure of C[x] in C(x,y) using the  normalization algorithm from
-@ref normal.lib: see @ref intbasis.lib. In a future edition of the library,
+@ref normal.lib: see @ref integralbasis.lib. In a future edition of the library,
 also van Hoeij's algorithm for computing the integral basis will be
 available. @*
@@ -32 +32 @@
 Alternatively, the algorithm starts with a local analysis of the singular
 locus of C. Then, for each  primary component of the singular locus which
-does not correspond to ordinary multiple points or cusps, the integral 
+does not correspond to ordinary multiple points or cusps, the integral
 basis algorithm is applied separately. The ordinary multiple points and
-cusps, in turn, are adressed by a straightforward direct algorithm. The 
-adjoint ideal is obtained by intersecting all ideals obtained locally. 
+cusps, in turn, are adressed by a straightforward direct algorithm. The
+adjoint ideal is obtained by intersecting all ideals obtained locally.
 The local variant of the algorithm is used by default. @*
 The linear system corresponding to the adjoint ideal maps the curve
@@ -62 +62 @@
 http://www.math.fsu.edu/~hoeij/papers/comments/jsc1994.html
 
-KEYWORDS: 
+KEYWORDS:
 Curves; Parametrization; Rational curves; Adjoint ideal; Geometric genus
 
@@ -85 +85 @@
 paraConic(poly);                  Compute a rational parametrization of a conic
 testParametrization(poly,ring);   Checks whether a given curve is parametrized
-                                  by a given rational map (defined in the 
+                                  by a given rational map (defined in the
                                   given ring)
-testPointConic(poly,ring);        Checks whether a given point (defined in the 
+testPointConic(poly,ring);        Checks whether a given point (defined in the
                                   given ring) lies on the given conic.
 ";
@@ -98 +98 @@
 LIB "random.lib";
 LIB "homolog.lib";
-LIB "intbasis.lib";
+LIB "integralbasis.lib";
 LIB "normal.lib";
 
@@ -111 +111 @@
         not define a birational map.
 RETURN: ring, the coordinate ring of P, with an ideal
-        named J and an ideal named psi. 
-@format The ideal J defines the image of phi.@* 
+        named J and an ideal named psi.
+@format The ideal J defines the image of phi.@*
         The ideal psi gives the inverse of phi.@*
         Note that the entries of psi should be considered as representatives
@@ -127 +127 @@
    def Roriginal = basering;
    int n = nvars(Roriginal);
-   int m = size(phi);    
+   int m = size(phi);
    /*phi: P^(n-1) --> P^(m-1)*/
    list rl = ringlist(Roriginal);
@@ -133 +133 @@
    for(k = 1; k <= n; k++)
      {
-        rl[2][k] = "x("+string(k)+")";     
-     }   
+        rl[2][k] = "x("+string(k)+")";
+     }
    for(k = 1; k <= m; k++)
      {
-        rl[2][k+n] = "y("+string(k)+")";     
-     } 
+        rl[2][k+n] = "y("+string(k)+")";
+     }
    rl[3]= list(list("dp",1:(n+m)),list("C",0));
    /*Use Hilbert driven Buchberger*/
@@ -153 +153 @@
    intvec Hgraph = hilb(graph,1);
    setring Roriginal;
-   rl[3]= list(list("dp",1:n),list("dp",1:m),list("C",0)); 
+   rl[3]= list(list("dp",1:n),list("dp",1:m),list("C",0));
    def Rbig = ring(rl);
    setring Rbig;
    ideal graph = imap(Rbig0,graph);
-   graph = std(graph,Hgraph); 
+   graph = std(graph,Hgraph);
    ideal xv = imap(Rbig0,xv);
    /*The ideal J defines the image of phi*/
@@ -163 +163 @@
    for(k = 1; k <= n; k++)
      {
-        J = subst(J,xv[k],0);     
-     } 
+        J = subst(J,xv[k],0);
+     }
    J = compress(J);
    /*now we start inverting phi to psi*/
@@ -170 +170 @@
    for(k = 1; k <= n; k++)
      {
-        relpsi = subst(relpsi,xv[k],0);     
-     } 
+        relpsi = subst(relpsi,xv[k],0);
+     }
     relpsi = compress(relpsi);
     list rl = ringlist(Rbig);
@@ -210 +210 @@
 "USAGE:  checkAssumptions(f); f poly
 RETURN:  1 if assumptions are satisfied, 0 otherwise.@*
-         Assumptions checked are: basering is polynomial ring in 3 variables 
+         Assumptions checked are: basering is polynomial ring in 3 variables
          with coefficients in Q, f is homogeneous and absolutely irreducible
 "
@@ -216 +216 @@
   def Roriginal = basering;
   list rl = ringlist(Roriginal);
-  rl[3] = list(list("dp",1:3),list("C",0));  
+  rl[3] = list(list("dp",1:3),list("C",0));
   if(size(rl[1])>1){ERROR("ground field is not Q");}
   if(rl[1]!=0){ERROR("ground field is not Q");}
@@ -224 +224 @@
   { ERROR("not a projective plane curve: polynomial is not homogeneous"); }
   def RP2 = ring(rl);
-  setring RP2;   
+  setring RP2;
   poly f = fetch(Roriginal,f);
-  if(isIrreducible(f)==0){ERROR("curve is not absolutely irreducible");} 
+  if(isIrreducible(f)==0){ERROR("curve is not absolutely irreducible");}
   setring Roriginal;
 }
@@ -233 +233 @@
 proc paraPlaneCurve(poly f, list #)
 "USAGE:  paraPlaneCurve(f [,c]); f poly , c optional integer@*
-         optional integer c can be: @*        
+         optional integer c can be: @*
          1: compute integral basis via normalization. @*
          2: make local analysis of singularities first and apply normalization
@@ -258 +258 @@
 Alternatively, the algorithm starts with a local analysis of the singular
 locus of C. Then, for each  primary component of the singular locus which
-does not correspond to ordinary multiple points or cusps, the integral 
+does not correspond to ordinary multiple points or cusps, the integral
 basis algorithm is applied separately. The ordinary multiple points and
-cusps, in turn, are adressed by a straightforward direct algorithm. The 
-adjoint ideal is obtained by intersecting all ideals obtained locally. 
+cusps, in turn, are adressed by a straightforward direct algorithm. The
+adjoint ideal is obtained by intersecting all ideals obtained locally.
 The local variant of the algorithm is used by default. @*
 The linear system corresponding to the adjoint ideal maps the curve
@@ -275 +275 @@
 EXAMPLE:  example paraPlaneCurve; shows an example
 "
-{ 
-  if(size(#)==0) {int choice = 2;} else {int choice = #[1];} 
-  def Roriginal = basering;  
+{
+  if(size(#)==0) {int choice = 2;} else {int choice = #[1];}
+  def Roriginal = basering;
   /*checking assumptions and handling the conic case*/
   checkAssumptions(f);
@@ -284 +284 @@
   rl[3] = list(list("dp",1:3),list("C",0));
   def RP2 = ring(rl);
-  setring RP2;   
+  setring RP2;
   poly f = fetch(Roriginal,f);
   int d = deg(f);
@@ -298 +298 @@
       "//      setring RP1; PARA;";
       return(RP1);
-    } 
+    }
   int k;
-  /*the adjoint ideal*/ 
-  ideal AI = adjointIdeal(f,list(choice,"rattestyes/firstchecksdone"));  
+  /*the adjoint ideal*/
+  ideal AI = adjointIdeal(f,list(choice,"rattestyes/firstchecksdone"));
   /*rattestyes -> causes error message if curve is not rational*/
   /*firstchecksdone -> prevents that check of assumptions will be done again*/
@@ -320 +320 @@
       for(k = 1; k <= m; k++)
         {
-          PROJ = subst(PROJ,var(k),AI[k]);     
+          PROJ = subst(PROJ,var(k),AI[k]);
         }
       setring RP2;
@@ -339 +339 @@
       "//      setring RP1; PARA;";
       return(RP1);
-    } 
+    }
   /*the even dimensional case*/
   /*mapping the rational normal curve to a CONIC in P^2* creating PHI*/
   def RP2conic = rncItProjEven(RNC);  // exports PHI, returns ring
                                       // containing CONIC
-  setring RP2conic; 
+  setring RP2conic;
   /*mapping the conic to P^1 via pencil defined by Ipoint*/
   def RP2conicNew = projConic(CONIC);  // ring containing ideal Ipoint
@@ -356 +356 @@
   for(k = 1; k <= 3; k++)
     {
-      PROJ = subst(PROJ,var(k),PHI[k]);     
-    }    
+      PROJ = subst(PROJ,var(k),PHI[k]);
+    }
   ideal AI = fetch(RP2,AI);
   for(k = 1; k <= m; k++)
     {
-       PROJ = subst(PROJ,var(k+3),AI[k]);     
+       PROJ = subst(PROJ,var(k+3),AI[k]);
     }
   setring RP2conicNew;
@@ -367 +367 @@
   ideal PROJ = imap(Rbig,PROJ);
   /*inverting the composed map to psi*/
-  def rp1 = invertBirMap(PROJ,If); // (ring, (J,psi)) 
+  def rp1 = invertBirMap(PROJ,If); // (ring, (J,psi))
   setring rp1;
   list rl1 = ringlist(rp1);
@@ -394 +394 @@
   def Rp2 = paraPlaneCurve(f2);
   setring Rp2;
-  PARA;  
+  PARA;
 }
 
@@ -402 +402 @@
 ASSUME:  The polynomial f is homogeneous in three variables, JAC is
          the Jacobi ideal of f.
-RETURN:  intvec, say a,b,c. After the coordinate change 
+RETURN:  intvec, say a,b,c. After the coordinate change
          var(3) --> a*var(1)+b*var(2)+c*var(3), the curve {f=0}
          has no singularities at infinity {var(3)=0}.
@@ -421 +421 @@
                 Jfinfty = JAC,a*var(1)+b*var(2)+c*var(3);
                 if(dim(std(Jfinfty)) == 0)
-                  {                  
+                  {
                     return(a,b,c);
                   }
@@ -429 +429 @@
           }
        h = h+1;
-    }  
+    }
 }
 
@@ -459 +459 @@
 Alternatively, the algorithm starts with a local analysis of the singular
 locus of C. Then, for each  primary component of the singular locus which
-does not correspond to ordinary multiple points or cusps, the integral 
+does not correspond to ordinary multiple points or cusps, the integral
 basis algorithm is applied separately. The ordinary multiple points and
-cusps, in turn, are adressed by a straightforward direct algorithm. The 
-adjoint ideal is obtained by intersecting all ideals obtained locally. 
+cusps, in turn, are adressed by a straightforward direct algorithm. The
+adjoint ideal is obtained by intersecting all ideals obtained locally.
 The local variant of the algorithm is used by default. @*
 KEYWORDS: integral basis; normalization.
 EXAMPLE: example adjointIdeal; shows an example
 "
-{ 
+{
   list choices = #;
   if(size(#)==0)
@@ -491 +491 @@
                choices = list(2, choices[1]);
              }
-        }   
-    } 
+        }
+    }
   if(size(#) == 2)
-    {      
+    {
       if(not(find(choices[2],"firstchecksdone")))
         {
           checkAssumptions(f);
-        }  
+        }
     }
   ideal JAC = diff(maxideal(1),ideal(f));
@@ -507 +507 @@
     {
        bb1 = 1;
-       int a,b,c  = findCoordChange(f,JAC); 
-       f = subst(f,var(3),var(3)-a/c*var(1)-b/c*var(2));       
+       int a,b,c  = findCoordChange(f,JAC);
+       f = subst(f,var(3),var(3)-a/c*var(1)-b/c*var(2));
     }
   /*applying a change of coordinates if the point (0:1:0) lies on the curve*/
@@ -514 +514 @@
   int bb2 = ((size(co)-1) != deg(f));
   if(bb2)
-    {   
+    {
        co = coeffs(f,var(1));
        int bb2x = ((size(co)-1) == deg(f));
-       if(bb2x) 
+       if(bb2x)
          {
            map perm = basering, var(2), var(1), var(3);
@@ -524 +524 @@
        else
          {
-           f = subst(f,var(1),var(1)+var(2));  
-         }            
+           f = subst(f,var(1),var(1)+var(2));
+         }
     }
   co = coeffs(f,var(2));
@@ -534 +534 @@
   if(bb2)
     {
-       if(bb2x) 
+       if(bb2x)
          {
            map perm = basering, var(2), var(1), var(3);
@@ -541 +541 @@
        else
          {
-           AI = mstd(substitute(AI,var(1),var(1)-var(2)))[2]; 
-         }             
-      
+           AI = mstd(substitute(AI,var(1),var(1)-var(2)))[2];
+         }
+
     }
   if(bb1==1)
@@ -567 +567 @@
          2: make local analysis of singularities first and apply normalization
             separately. @*
-         The default is 2. @*       
+         The default is 2. @*
          string  may contain substring: @*
          - rattestyes -> causes error message if curve is not rational. @*
@@ -576 +576 @@
          as a polynomial in the second variable (that is, C does not contain
          the point (0:1:0)).@*
-         The curve C is not allowed to have singularities 
+         The curve C is not allowed to have singularities
          at infinity (z = 0). @*
 RETURN:  ideal, the adjoint ideal of the curve defined by f.
 "
-{ 
-  def Roriginal = basering;  
+{
+  def Roriginal = basering;
   list rl = ringlist(Roriginal);
   rl[3] = list(list("dp",1:nvars(Roriginal)),list("C",0));
-  def RP2 = ring(rl);   
+  def RP2 = ring(rl);
   setring RP2;
   poly f = imap(Roriginal,f);
@@ -648 +648 @@
          A(OMP[k][1]) = intersect(A(OMP[k][1]), OMP[k][2]);
        }
-     int i = ub;  
+     int i = ub;
      setring RP2;
      B = maxideal(n-i);
@@ -655 +655 @@
      setring Rdummy;
      B = imap(RP2,B);
-     ideal A; 
+     ideal A;
      while(i>=lb)
-        {  
+        {
           A = A(i)**(i-1);
           B = intersect(B,A);
@@ -685 +685 @@
         }
     }
-  list PD = primdecGTZ(SL);  // could be made faster -- see minAssGTZ 
+  list PD = primdecGTZ(SL);  // could be made faster -- see minAssGTZ
                              // in deltaLocMod -- only one PD needed
   int pd = size(PD);
   setring RP2;
   B = imap(Rdummy,B);
-  list PD = imap(Rdummy,PD); 
+  list PD = imap(Rdummy,PD);
   ideal AI = 1;
   for(k=1;k<=pd;k++)
-    {  
+    {
        AI = intersect(AI,adjointIdealIB(f,insert(choices,PD[k][1],
                                                  size(choices))));
@@ -707 +707 @@
 ///////////////////////////////////////////////////////////////////////////////
 static proc adjointIdealIB(poly f, list choices)
-"USAGE:  adjointIdealIB(f, choices); f polynomial in three variables, choices 
+"USAGE:  adjointIdealIB(f, choices); f polynomial in three variables, choices
          list consisting of one integer followed by one string followed by one
          ideal. @*
@@ -719 +719 @@
          with coefficients in Q. @*
          The polynomial f must be homogeneous and absolutely irreducible.@*
-         Its dehomogenization with respect to the third variable must be monic 
-         as a polynomial in the second variable (that is, C does not contain 
+         Its dehomogenization with respect to the third variable must be monic
+         as a polynomial in the second variable (that is, C does not contain
          the point (0:1:0)).@*
-         The curve C is not allowed to have singularities 
+         The curve C is not allowed to have singularities
          at infinity (z = 0). @*
 RETURN:  ideal containing the adjoint ideal of the curve defined by f. @*
 "
-{ 
+{
   poly dhf = subst(f,var(3),1);
   def Roriginal = basering;
@@ -743 +743 @@
   def Rred = ring(rl);   // make var(2) > var(1)
   rl = ringlist(Rdummy);
-  rl[1] = list(0,list(var(1)),list(list("dp",1)),ideal(0)); 
+  rl[1] = list(0,list(var(1)),list(list("dp",1)),ideal(0));
   rl[2] = list(var(2));
   rl[3] = list(list("dp",1),list("C",0));
@@ -751 +751 @@
     {
       LIntB = integralBasis(f, 2, list(list("inputC", DATA[3]),"isIrred"));
-    }  
+    }
   else                                 // use van Hoeij's algorithm
-    {      
+    {
       LIntB = integralBasisVH(f,DATA[3],2);  // van Hoeij in future version
     }
@@ -760 +760 @@
       setring Roriginal;
       int gg = geomGenusIB(f,imap(Rdummy, LIntB));
-      if(gg!=0){ERROR("not a rational curve");}  
+      if(gg!=0){ERROR("not a rational curve");}
       setring Rdummy;
     }
@@ -776 +776 @@
   poly d = imap(Rdummy,d);
   M=1/d*M;
-  list LUM = ludecomp(M); 
-  list LS;  
+  list LUM = ludecomp(M);
+  list LS;
   matrix dummyvector[sL][1];
   matrix Gij[sL][sL];
@@ -788 +788 @@
      {
        for(j = i; j <= sL; j++)
-          {   
+          {
             setring Rred;
-            Gij = 0;       
-            eiej = IB[i]*IB[j]; 
+            Gij = 0;
+            eiej = IB[i]*IB[j];
             Iij=empty;
             for(k = 1; k <= sL; k++)
                {
                   Iij[k] = reduce(eiej*IB[k],fred);
-               } 
-            Gij = coeffs(ideal(Iij[1..sL]),var(1)); 
+               }
+            Gij = coeffs(ideal(Iij[1..sL]),var(1));
             setring QF;
-            Gij = imap (Rred, Gij);  
-            for(k = 1; k <= sL; k++) 
+            Gij = imap (Rred, Gij);
+            for(k = 1; k <= sL; k++)
                {
                   dummyvector = Gij[1..sL,k];
-                  LS = lusolve(LUM[1], LUM[2], LUM[3], dummyvector);                    
+                  LS = lusolve(LUM[1], LUM[2], LUM[3], dummyvector);
                   Tr[i,j] = Tr[i,j] + 1/d^3*LS[2][k,1];
-               }                
+               }
           }
      }
@@ -811 +811 @@
      {
        for(j = 1; j < i; j++)
-          {  
+          {
              Tr[i,j] = Tr[j,i];
-          }  
-     } 
-  LUM = ludecomp(Tr); 
+          }
+     }
+  LUM = ludecomp(Tr);
   setring Rred;
   poly d2f = imap(Rdummy,d2f);
@@ -840 +840 @@
 EXAMPLE: example mapToRatNormCurve; shows an example
 "
-{ 
+{
    int n = size(AI);
    int k;
@@ -846 +846 @@
    def Roriginal = basering;
    ideal IC = f;
-   list rl = ringlist(Roriginal);    
+   list rl = ringlist(Roriginal);
    /* begin workaround elimination*/
    for(k = 1; k <= 3; k++)
      {
-        rl[2][k] = "x("+string(k)+")";     
-     }   
+        rl[2][k] = "x("+string(k)+")";
+     }
    for(k = 1; k <= n; k++)
      {
-        rl[2][k+3] = "y("+string(k)+")";     
-     } 
+        rl[2][k+3] = "y("+string(k)+")";
+     }
    rl[3]= list(list("dp",1:(3+n)),list("C",0));
    def Relim = ring(rl);
@@ -861 +861 @@
    ideal IC = fetch(Roriginal,IC);
    ideal AI = fetch(Roriginal,AI);
-   ideal J;  
+   ideal J;
    J = IC;
    for(k=1;k<=n;k++)
@@ -899 +899 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc rncAntiCanonicalMap(ideal I)
-"USAGE:  rncAntiCanonicalMap(I); I ideal 
+"USAGE:  rncAntiCanonicalMap(I); I ideal
 ASSUME:  I is a homogeneous ideal in the basering
          defining a rational normal curve C in PP^n.
-NOTE:   The procedure will fail or give a wrong output if I is not the 
+NOTE:   The procedure will fail or give a wrong output if I is not the
         ideal of a rational normal curve.
 RETURN:  ideal defining the anticanonical map  C --> PP^(n-2). @*
-         Note that the entries of the ideal should be considered as 
+         Note that the entries of the ideal should be considered as
          representatives of elements in R/I, where R is the basering.
-THEORY:  The anti-canonical map of a rational normal curve 
+THEORY:  The anti-canonical map of a rational normal curve
          maps C isomorpically to a rational normal curve in PP^(n-2).
 KEYWORDS: rational normal curve, projection.
 EXAMPLE: example rncAntiCanonicalMap; shows an example
 "
-{ 
+{
   def Roriginal = basering;
   list rl = ringlist(Roriginal);
   rl[3] = list(list("dp",1:nvars(Roriginal)),list("C",0));
-  def RoriginalDP = ring(rl); 
+  def RoriginalDP = ring(rl);
   setring RoriginalDP;
   ideal I = imap(Roriginal,I);
@@ -943 +943 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc rncItProjOdd(ideal I)
-"USAGE:  rncItProjOdd(I); I ideal 
+"USAGE:  rncItProjOdd(I); I ideal
 ASSUME:  I is a homogeneous ideal in the basering
          with n+1 variables defining a rational normal curve C in PP^n with n
@@ -950 +950 @@
          ideal of a rational normal curve. It will test whether n is odd.
 RETURN:  ideal PHI defining an isomorphic projection of C to PP^1.@*
-         Note that the entries of PHI should be considered as 
+         Note that the entries of PHI should be considered as
          representatives of elements in R/I, where R is the basering.
 THEORY:  We iterate the procedure @ref rncAntiCanonicalMap to obtain PHI.
@@ -957 +957 @@
 EXAMPLE: example rncItProjOdd; shows an example
 "
-{ 
+{
   int n = nvars(basering);
   if((n mod 2) == 1){ERROR("Pn has even dimension");}
-  def Roriginal = basering; 
+  def Roriginal = basering;
   list rlo = ringlist(Roriginal);
   rlo[3]= list(list("dp",1:n),list("C",0));
@@ -966 +966 @@
   for(k = 1; k <= n; k++)
     {
-      rlo[2][k] = "z("+string(k)+")";     
-    } 
+      rlo[2][k] = "z("+string(k)+")";
+    }
   def RoriginalCopy = ring(rlo);
   for(k = 1; k <= n; k++)
     {
-      rlo[2][k] = "y("+string(k)+")";     
-    } 
+      rlo[2][k] = "y("+string(k)+")";
+    }
   def Rold = ring(rlo);
   setring RoriginalCopy;
@@ -984 +984 @@
   intvec HJJ;
   while(n>2)
-     {       
+     {
         ideal PR = rncAntiCanonicalMap(J);
         list rl = ringlist(Rold);
@@ -993 +993 @@
         for(k = 1; k <= n; k++)
           {
-             dummy = subst(dummy,var(k),PHI[k]);     
-          } 
+             dummy = subst(dummy,var(k),PHI[k]);
+          }
         setring RoriginalCopy;
         PHI = imap(Rbig,dummy);
@@ -1001 +1001 @@
         for(k = 1; k <= n; k++)
           {
-            rl[2][k] = "x("+string(k)+")";     
-          }   
+            rl[2][k] = "x("+string(k)+")";
+          }
         for(k = 1; k <= n-2; k++)
           {
-            rl[2][k+n] = "y("+string(k)+")";     
-          } 
+            rl[2][k+n] = "y("+string(k)+")";
+          }
         rl[3]= list(list("dp",1:(2*n-2)),list("C",0));
         Relim = ring(rl);
@@ -1016 +1016 @@
         for(k = 1; k <= n; k++)
           {
-            pvar = pvar*var(k);     
-          }   
+            pvar = pvar*var(k);
+          }
         for(k=1;k<=n-2;k++)
           {
@@ -1058 +1058 @@
 ///////////////////////////////////////////////////////////////////////////////
 proc rncItProjEven(ideal I)
-"USAGE:  rncItProjEven(I); I ideal 
+"USAGE:  rncItProjEven(I); I ideal
 ASSUME:  I is a homogeneous ideal in the basering
          with n+1 variables defining a rational normal curve C in PP^n with n
          even.
-NOTE:    The procedure will fail or give a wrong output if I is not the 
+NOTE:    The procedure will fail or give a wrong output if I is not the
          ideal of a rational normal curve. It will test whether n is odd.
 RETURN:  ring with an ideal CONIC defining a conic C2 in PP^2. In addition,
          an ideal PHI in the basering defining an isomorphic projection
          of C to C2 will be exported.@*
-         Note that the entries of PHI should be considered as 
+         Note that the entries of PHI should be considered as
          representatives of elements in R/I, where R is the basering.
 THEORY:  We iterate the procedure @ref rncAntiCanonicalMap to obtain PHI.
@@ -1074 +1074 @@
 EXAMPLE: example rncItProjEven; shows an example
 "
-{ 
+{
   int n = nvars(basering);
   if((n mod 2) == 0){ERROR("Pn has odd dimension");}
-  def Roriginal = basering; 
+  def Roriginal = basering;
   list rlo = ringlist(Roriginal);
   rlo[3]= list(list("dp",1:n),list("C",0));
@@ -1083 +1083 @@
   for(k = 1; k <= n; k++)
     {
-      rlo[2][k] = "z("+string(k)+")";     
-    } 
+      rlo[2][k] = "z("+string(k)+")";
+    }
   def RoriginalCopy = ring(rlo);
   for(k = 1; k <= n; k++)
     {
-      rlo[2][k] = "y("+string(k)+")";     
-    } 
+      rlo[2][k] = "y("+string(k)+")";
+    }
   def Rold = ring(rlo);
   setring RoriginalCopy;
@@ -1101 +1101 @@
   intvec HJJ;
   while(n>3)
-     {       
+     {
         ideal PR = rncAntiCanonicalMap(J);
         list rl = ringlist(Rold);
@@ -1110 +1110 @@
         for(k = 1; k <= n; k++)
           {
-             dummy = subst(dummy,var(k),PHI[k]);     
-          } 
+             dummy = subst(dummy,var(k),PHI[k]);
+          }
         setring RoriginalCopy;
         PHI = imap(Rbig,dummy);
@@ -1118 +1118 @@
         for(k = 1; k <= n; k++)
           {
-            rl[2][k] = "x("+string(k)+")";     
-          }   
+            rl[2][k] = "x("+string(k)+")";
+          }
         for(k = 1; k <= n-2; k++)
           {
-            rl[2][k+n] = "y("+string(k)+")";     
-          } 
+            rl[2][k+n] = "y("+string(k)+")";
+          }
         rl[3]= list(list("dp",1:(2*n-2)),list("C",0));
         Relim = ring(rl);
@@ -1133 +1133 @@
         for(k = 1; k <= n; k++)
           {
-            pvar = pvar*var(k);     
-          }   
+            pvar = pvar*var(k);
+          }
         for(k=1;k<=n-2;k++)
           {
@@ -1152 +1152 @@
         Rold = Rnew;
         setring Rold;
-        n = n-2;  
+        n = n-2;
      }
   poly CONIC = J[1];
@@ -1183 +1183 @@
          with coefficients in Q. @*
          The polynomial f must be homogeneous and absolutely irreducible.@*
-         Its dehomogenization with respect to the third variable must be monic 
+         Its dehomogenization with respect to the third variable must be monic
          as a polynomial in the second variable (that is, the curve C = {f = 0}
          does not contain the point (0:1:0)).@*
-         The curve C is not allowed to have singularities 
+         The curve C is not allowed to have singularities
          at infinity (z = 0). @*
 NOTE:    The last two conditions can be met by a suitable change of coordinates in PGL(3)
@@ -1197 +1197 @@
 SEE ALSO: genus.
 "
-{ 
+{
   int bb = size(#);
   poly dhf = subst(f,var(3),1);
@@ -1210 +1210 @@
   if(bb == 0)
     {
-      LIntB = integralBasis(f,2,"isIrred");     
+      LIntB = integralBasis(f,2,"isIrred");
     }
   else
@@ -1224 +1224 @@
   for(k = 1; k <= sL; k++)
      {
-        gg = gg + deg(gcd(d,IB[k]));     
+        gg = gg + deg(gcd(d,IB[k]));
      }
   setring Roriginal;
@@ -1257 +1257 @@
 SEE ALSO: genus
 "
-{   
+{
    int w = printlevel-voice+2;  // w=printlevel (default: w=0)
    int d = deg(F);
@@ -1268 +1268 @@
    int delt,deltaloc,deltainf,tau,tauinf,cusps,iloc,iglob,l,nsing,
        tauloc,tausing,k,rat,nbranchinf,nbranch,nodes,cuspsinf,nodesinf;
-   list inv;  
+   list inv;
    execute("ring newR=("+charstr(R)+"),(x,y),dp;");
    //the singularities at the affine part
@@ -1274 +1274 @@
    ideal I=sigma(F);
 
-   list OMPButNodes; 
-   int sizeOMPButNodes;   
-   int NotOnlyOMPPlusCusps;  
+   list OMPButNodes;
+   int sizeOMPButNodes;
+   int NotOnlyOMPPlusCusps;
 
    ideal I1=jacob(I);
@@ -1315 +1315 @@
 
    ideal NodesPlusCusps  = radical(sat(I+I1, radIDsing)[1]);
-  
+
    nsing=nsing+cusps;
 
@@ -1348 +1348 @@
           delt=delt+nodes+cusps;
           if((w>=1)&&(inv[2]==0)){"smooth at (0,0,1)";}
-          if(inv[4]!=0)  
+          if(inv[4]!=0)
             {
               OMPButNodes = insert(OMPButNodes,list(inv[4],maxideal(1)),
@@ -1356 +1356 @@
           else
             {
-              NotOnlyOMPPlusCusps = NotOnlyOMPPlusCusps + 1; 
+              NotOnlyOMPPlusCusps = NotOnlyOMPPlusCusps + 1;
             }
         }
@@ -1372 +1372 @@
               tausing=tausing+inv[2];
               nbranch=nbranch+inv[3];
-              if(inv[4]!=0)  
+              if(inv[4]!=0)
                 {
                   OMPButNodes = insert(OMPButNodes,list(inv[4],pr[k]),
                                        sizeOMPButNodes);
-                  sizeOMPButNodes = size(OMPButNodes); 
+                  sizeOMPButNodes = size(OMPButNodes);
                 }
               else
                 {
-                  NotOnlyOMPPlusCusps = NotOnlyOMPPlusCusps + 1; 
+                  NotOnlyOMPPlusCusps = NotOnlyOMPPlusCusps + 1;
                 }
            }
@@ -1408 +1408 @@
    }
    setring R;
-   if(sizeOMPButNodes>0)  
+   if(sizeOMPButNodes>0)
      {
-       list OMPButNodes = fetch(newR,OMPButNodes);   
+       list OMPButNodes = fetch(newR,OMPButNodes);
      }
    return(list(genus,NotOnlyOMPPlusCusps,OMPButNodes,
@@ -1529 +1529 @@
       }
    }
-   int intMult = deg(lead(f)); 
-   poly fdummy = f;  
-   poly gdummy = lead(f); 
-   int ivr = 1;  
-   while(ivr)  
+   int intMult = deg(lead(f));
+   poly fdummy = f;
+   poly gdummy = lead(f);
+   int ivr = 1;
+   while(ivr)
       {
         fdummy = fdummy - lead(fdummy);
         if((fdummy ==0) || (deg(lead(fdummy))>intMult)){break;}
-        gdummy = gdummy + lead(fdummy);  
+        gdummy = gdummy + lead(fdummy);
       }
-   ideal SQRpart = sqrfree(gdummy);  
+   ideal SQRpart = sqrfree(gdummy);
    int IntForRet;  ///neu
-   if(deg(SQRpart[1])==intMult)  
+   if(deg(SQRpart[1])==intMult)
      {
-        IntForRet = intMult;    
+        IntForRet = intMult;
      }
    option(noredSB);
@@ -1664 +1664 @@
 proc paraConic(poly q)
 "USAGE:  paraConic(q); q poly
-ASSUME:  The basering must be a polynomial ring in three variables with 
+ASSUME:  The basering must be a polynomial ring in three variables with
          coefficients in Q. @*
          The polynomial q must be homogeneous of degree 2 and absolutely
@@ -1688 +1688 @@
 EXAMPLE: example paraConic; shows an example
 "
-{   
+{
   def Roriginal = basering;
   def RP2 = projConic(q);  // ring with ideal Ipoint
@@ -1699 +1699 @@
   def RP1 = ring(rl);
   setring RP1;
-  ideal PARACONIC = fetch(rp1,psi); 
+  ideal PARACONIC = fetch(rp1,psi);
   export(PARACONIC);
   "// 'paraConic' created a ring together with an ideal RNC.";
@@ -1727 +1727 @@
 static proc projConic(poly q)
 "USAGE:  projConic(q); q poly
-ASSUME:  The basering must be a polynomial ring in three variables with 
+ASSUME:  The basering must be a polynomial ring in three variables with
          coefficients in Q. @*
          The polynomial q must be homogeneous of degree 2 and absolutely
@@ -1740 +1740 @@
 SEE ALSO: rationalPointConic.
 "
-{ 
+{
   def Roriginal = basering;
   list rl = ringlist(Roriginal);
@@ -1751 +1751 @@
                                      //  possibly defined over algebraic number
                                      //  field
-  setring RP21; 
+  setring RP21;
   list rl1 = ringlist(RP21);
-  rl1[2] = list("u","v","w"); 
+  rl1[2] = list("u","v","w");
   rl1[3] = list(list("dp",1:3),list("C",0));
-  def RP2 = ring(rl1);  
+  def RP2 = ring(rl1);
   setring RP2;
   ideal point = fetch(RP21,point);
@@ -2189 +2189 @@
   if ((b mod a) == 0) { l = a, 1, 0; if (a < 0) { l = -a, -1, 0; }; }
   if (size(l) > 1) { return (l); }
-                
+
   temp = a mod b;
   l = extendedEuclid(b, temp);
@@ -2535 +2535 @@
 }
 ///////////////////////////////////////////////////////////////////////////////
-proc testParametrization(poly f, def rTT) 
+proc testParametrization(poly f, def rTT)
 "USAGE:  testParametrization(f,rTT); f poly, rTT ring
-ASSUME:  The assumptions on the basering and the polynomial f are as required 
-         by @ref paraPlaneCurve. The ring rTT has two variables and contains 
+ASSUME:  The assumptions on the basering and the polynomial f are as required
+         by @ref paraPlaneCurve. The ring rTT has two variables and contains
          an ideal PARA (such as the ring obtained by applying
-         @ref paraPlaneCurve to f). 
-RETURN: int which is 1 if PARA defines a parametrization of the curve 
+         @ref paraPlaneCurve to f).
+RETURN: int which is 1 if PARA defines a parametrization of the curve
         {f=0} and 0, otherwise.
 THEORY: We compute the image of PARA and compare it with f.
@@ -2558 +2558 @@
   setring Relim;
   ideal PARA = fetch(rTT,PARA);
-  ideal JJ;  
+  ideal JJ;
   for(k=1;k<=3;k++)
      {
@@ -2578 +2578 @@
   g = reduce(ftest[1],std(ideal(f)));
   if(g!=0){return(0)};
-  return (1);  
+  return (1);
 }
 
@@ -2735 +2735 @@
 adjointIdeal(f,2);
 def RP1 = paraPlaneCurve(f);  // time 0
-testParametrization(f,RP1);  
+testParametrization(f,RP1);
 setring RP1; PARA;
 kill RR;kill RP1;
@@ -2797 +2797 @@
 // -------------------------------------------------------
 ring SS = 0, (u,v,z), dp;
-poly f = 
+poly f =
 2*u^7+u^6*v+3*u^5*v^2+u^4*v^3+2*u^3*v^4+u^2*v^5+2*u*v^6+v^7
 -7780247/995328*u^6*z-78641/9216*u^5*v*z-10892131/995328*u^4*v^2*z
@@ -2836 +2836 @@
 adjointIdeal(f,2);
 def RP1 = paraPlaneCurve(f);  // time 72
-testParametrization(f,RP1);  
+testParametrization(f,RP1);
 setring RP1; PARA;
 kill SS;kill RP1;