Changeset 3939bc in git

Timestamp:

May 29, 1998, 5:02:06 PM (26 years ago)

Author:

Hans Schönemann <hannes@…>

Branches:

(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')

Children:

1d4300694bf8c8b67ec71e837ab58b13264fedf7

Parents:

311499b3c35b89d435a5b5b44c51e0ace5b13c6c

Message:

* hannes: changed res->nres, resu->res


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

Files:

• Singular/ChangeLog (modified) (1 diff)
• Singular/LIB/deform.lib (modified) (2 diffs)
• Singular/LIB/fastsolv.lib (modified) (3 diffs)
• Singular/LIB/finvar.lib (modified) (2 diffs)
• Singular/LIB/homolog.lib (modified) (3 diffs)
• Singular/LIB/matrix.lib (modified) (2 diffs)
• Singular/LIB/primdec.lib (modified) (82 diffs)
• Singular/LIB/sing.lib (modified) (6 diffs)
• Singular/LIB/standard.lib (modified) (19 diffs)
• Singular/iparith.cc (modified) (2 diffs)
• doc/examples.doc (modified) (previous)
• doc/reference.doc (modified) (previous)
• doc/types.doc (modified) (previous)

Singular/ChangeLog

@@ +1 @@
+Fri May 29 17:00:27 MET DST 1998 hannes
+        * change res to nres (cmd), resu to res(standard.lib)
+          including changes to libs, docs (partially)
 Wed May 27 19:13:10 MET DST 1998 hannes
         * removed #define HAVE_GMP and non-gmp-parts

Singular/LIB/deform.lib

@@ -1 @@
-// $Id: deform.lib,v 1.11 1998-05-14 18:44:57 Singular Exp $
+// $Id: deform.lib,v 1.12 1998-05-29 15:01:55 Singular Exp $
 // author: Bernd Martin email: martin@math.tu-cottbus.de
 //(bm, last modified 4/98)
 ///////////////////////////////////////////////////////////////////////////////
-version="$Id: deform.lib,v 1.11 1998-05-14 18:44:57 Singular Exp $";
+version="$Id: deform.lib,v 1.12 1998-05-29 15:01:55 Singular Exp $";
 info="
 LIBRARY:  deform.lib       PROCEDURES FOR COMPUTING MINIVERSAL DEFORMATION
@@ -579 +579 @@
    matrix M0,M1,M2,ker,kb1,lift1,kb2,A,B,C,D;
 //------- resM ---------------------------------------------------------------
-   list resM = res(Mo,3);
+   list resM = nres(Mo,3);
    M0 = resM[1];
    M1 = resM[2];

Singular/LIB/fastsolv.lib

@@ -1 +1 @@
 //
-version="$Id: fastsolv.lib,v 1.4 1998-05-14 18:44:59 Singular Exp $";
+version="$Id: fastsolv.lib,v 1.5 1998-05-29 15:01:56 Singular Exp $";
 info="";
 
@@ -181 +181 @@
      if (#[4]==1)
      {
-       mres(@a,1,@a0);
-       @a=@a0(1);
+       @a=mres(@a,1)[1];
      }
      return(@a);
@@ -229 +228 @@
    if (#[4]==1)
    {
-     mres(@b,1,@b0);
-     @b=@b0(1);
+     @b=mres(@b,1)[1];
    }
 

Singular/LIB/finvar.lib

@@ -1 @@
-// $Id: finvar.lib,v 1.11 1998-05-14 18:45:00 Singular Exp $
+// $Id: finvar.lib,v 1.12 1998-05-29 15:01:57 Singular Exp $
 // author: Agnes Eileen Heydtmann, email:agnes@math.uni-sb.de
 // last change: 3.5.98
 //////////////////////////////////////////////////////////////////////////////
-version="$Id: finvar.lib,v 1.11 1998-05-14 18:45:00 Singular Exp $"
+version="$Id: finvar.lib,v 1.12 1998-05-29 15:01:57 Singular Exp $"
 info="
 LIBRARY:  finvar.lib       LIBRARY TO CALCULATE INVARIANT RINGS & MORE
@@ -5081 +5081 @@
     M(1)[i,1..k]=B[1..k];              // we will look for the syzygies of M(1)
   }
-  module M(2)=res(M(1),2)[2];
+  module M(2)=nres(M(1),2)[2];
   int m=ncols(M(2));                   // number of generators of the module
                                        // M(2) -

Singular/LIB/homolog.lib

@@ -1 @@
-// $Id: homolog.lib,v 1.6 1998-05-05 11:55:28 krueger Exp $
+// $Id: homolog.lib,v 1.7 1998-05-29 15:01:58 Singular Exp $
 //(BM/GMG, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: homolog.lib,v 1.6 1998-05-05 11:55:28 krueger Exp $";
+version="$Id: homolog.lib,v 1.7 1998-05-29 15:01:58 Singular Exp $";
 info="
 LIBRARY:  homolog.lib   PROCEDURES FOR HOMOLOGICAL ALGEBRA
@@ -56 +56 @@
 //apply Hom(-,M) and compute the Ext's
 //-----------------------------------------------------------------------------
-   list resM = res(M,3);
+   list resM = nres(M,3);
    M1 = resM[2];
    M2 = resM[3];
@@ -241 +241 @@
 //                     N<--G(0)<--- ...  <---G(q+1)
 //-----------------------------------------------------------------------------
-   list resM = res(M,p+q+1);
+   list resM = nres(M,p+q+1);
    M1 = resM[p];
    M2 = resM[p+1];
-   list resN = res(N,q+1);
+   list resN = nres(N,q+1);
    N1 = resN[q];
    N2 = resN[q+1];

Singular/LIB/matrix.lib

@@ -1 @@
-// $Id: matrix.lib,v 1.7 1998-05-14 18:45:10 Singular Exp $
+// $Id: matrix.lib,v 1.8 1998-05-29 15:01:59 Singular Exp $
 // (GMG/BM, last modified 22.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: matrix.lib,v 1.7 1998-05-14 18:45:10 Singular Exp $";
+version="$Id: matrix.lib,v 1.8 1998-05-29 15:01:59 Singular Exp $";
 info="
 LIBRARY:  matrix.lib    PROCEDURES FOR MATRIX OPERATIONS
@@ -233 +233 @@
    ring r=32003,(x,y,z),ds;
    ideal i=x4+y5+z6,xyz,yx2+xz2+zy7;
-   list L=res(i,0);
+   list L=nres(i,0);
    is_complex(L);
    L[4]=matrix(i);

Singular/LIB/primdec.lib

@@ -1 @@
-// $Id: primdec.lib,v 1.20 1998-05-20 13:03:56 schmidt Exp $
+// $Id: primdec.lib,v 1.21 1998-05-29 15:02:00 Singular Exp $
 ////////////////////////////////////////////////////////////////////////////////
 // primdec.lib                                                                //
@@ -8 +8 @@
 // algorithms for primary decomposition based on                              //
 // the ideas of Shimoyama/Yokoyama                                            //
-// written by Wolfram Decker and Hans Schoenemann                             // 
+// written by Wolfram Decker and Hans Schoenemann                             //
 ////////////////////////////////////////////////////////////////////////////////
 
-version="$Id: primdec.lib,v 1.20 1998-05-20 13:03:56 schmidt Exp $";
+version="$Id: primdec.lib,v 1.21 1998-05-29 15:02:00 Singular Exp $";
 info="
 LIBRARY: primdec.lib: PROCEDURE FOR PRIMARY DECOMPOSITION
@@ -193 +193 @@
    ideal fac=tsil[2];
    poly f=tsil[3];
-   
+
    ideal star=quotient(laedi,f);
    action=1;
@@ -208 +208 @@
         g=1;
         verg=laedi;
-        
+
          for(j=1;j<=size(fac);j++)
          {
@@ -217 +217 @@
          }
          verg=quotient(laedi,g);
-         
+
          if(specialIdealsEqual(verg,star)==1)
          {
@@ -231 +231 @@
       }
    }
-   l=star,fac,f;   
+   l=star,fac,f;
    return(l);
 }
@@ -239 +239 @@
 {
   poly keep=p;
-  
+
    int i;
    poly q=act[1][1]^act[2][1];
@@ -252 +252 @@
       "ERROR IN FACTOR";
       basering;
-      
+
       act;
       keep;
       pause;
-      
+
       p;
       q;
@@ -478 +478 @@
          m=m-1;
       }
-      //check whether i[m] =(c*var(n)+h)^e modulo prm for some 
+      //check whether i[m] =(c*var(n)+h)^e modulo prm for some
       //h in K[var(n+1),...,var(nvars(basering))], c in K
       //if not (0) is returned, else var(n)+h is added to prm
@@ -655 +655 @@
    {
      attrib(l[2*i-1],"isSB",1);
-     
+
      if((size(ser)>0)&&(size(reduce(ser,l[2*i-1],1))==0)&&(deg(l[2*i-1][1])>0))
      {
        "Achtung in split";
-       
+
          l[2*i-1]=ideal(1);
          l[2*i]=ideal(1);
@@ -724 +724 @@
      return(primary);
   }
-  
-  j=interred(j);  
+
+  j=interred(j);
   attrib(j,"isSB",1);
   if(vdim(j)==deg(j[1]))
-  {    
+  {
      act=factor(j[1]);
      for(@k=1;@k<=size(act[1]);@k++)
@@ -746 +746 @@
        primary[2*@k]=interred(@qh);
        attrib( primary[2*@k-1],"isSB",1);
-       
+
        if((size(ser)>0)&&(size(reduce(ser,primary[2*@k-1],1))==0))
        {
           primary[2*@k-1]=ideal(1);
-          primary[2*@k]=ideal(1);          
+          primary[2*@k]=ideal(1);
        }
      }
@@ -824 +824 @@
   }
   else
-  {  
+  {
      primary[1]=j;
      if((size(#)>0)&&(act[2][1]>1))
@@ -843 +843 @@
   if(size(#)==0)
   {
-    
+
      primary=splitPrimary(primary,ser,@wr,act);
-     
+
   }
 
@@ -868 +868 @@
     }
   }
-    
+
   @k=0;
   ideal keep;
@@ -894 +894 @@
                     jmap2[zz]=primary[2*@k-1][@n];
                     @qht[@n]=var(zz);
-                     
+
                 }
              }
@@ -906 +906 @@
        phi1=@P,jmap1;
        phi=@P,jmap;
- 
+
        for(@n=1;@n<=nva;@n++)
        {
@@ -915 +915 @@
 
        @qh=phi(@qht);
-       
+
        if(npars(@P)>0)
        {
@@ -943 +943 @@
        kill @Phelp1;
        @qh=clearSB(@qh);
-       attrib(@qh,"isSB",1);       
+       attrib(@qh,"isSB",1);
        ser1=phi1(ser);
        @lh=zero_decomp (@qh,phi(ser1),@wr);
 //       @lh=zero_decomp (@qh,psi(ser),@wr);
-       
-       
+
+
        kill lres0;
        list lres0;
@@ -1547 +1547 @@
    map phi=@P,qr[2];
    i=qr[1];
-   
+
    execute "ring gnir = ("+charstr(basering)+"),("+varstr(basering)+"),("
              +ordstr(basering)+");";
@@ -1788 +1788 @@
       }
   }
-  
+
   homo=homog(i);
-  
+
   if(homo==1)
   {
@@ -1837 +1837 @@
   option(redSB);
 
-  ideal ser=fetch(@P,ser);  
+  ideal ser=fetch(@P,ser);
 
   if(homo==1)
@@ -1891 +1891 @@
     }
   }
- 
+
   //----------------------------------------------------------------
   //j is the ring
@@ -1929 +1929 @@
      return(primary);
   }
-  
+
  //------------------------------------------------------------------
  //the zero-dimensional case
@@ -1983 +1983 @@
       indep=maxIndependSet(@j);
    }
-  
+
   ideal jkeep=@j;
 
@@ -2007 +2007 @@
       ideal jwork=std(imap(gnir,@j),@hilb);
     }
-    
+
   }
   else
@@ -2018 +2018 @@
   di=dim(jwork);
   keepdi=di;
-  
+
   setring gnir;
   for(@m=1;@m<=size(indep);@m++)
@@ -2034 +2034 @@
         attrib(@j,"isSB",1);
         ideal ser=fetch(gnir,ser);
-        
+
      }
      else
@@ -2051 +2051 @@
         }
         ideal ser=phi(ser);
-        
-     }
-     option(noredSB);     
+
+     }
+     option(noredSB);
      if((deg(@j[1])==0)||(dim(@j)<jdim))
      {
@@ -2109 +2109 @@
         }
         //the primary decomposition of j*K(var(nnp+1),..,var(nva))[..the rest..]
-        option(redSB);        
+        option(redSB);
         list uprimary= zero_decomp(@j,ser,@wr);
         option(noredSB);
@@ -2171 +2171 @@
      //mentioned above is really computed
      for(@n=@n3/2+1;@n<=@n2/2;@n++)
-     {       
+     {
         if(specialIdealsEqual(quprimary[2*@n-1],quprimary[2*@n]))
         {
@@ -2186 +2186 @@
         }
      }
-    
+
      if(size(@h)>0)
      {
@@ -2196 +2196 @@
         if(@wr!=1)
         {
-          @q=minSat(jwork,@h)[2];   
+          @q=minSat(jwork,@h)[2];
         }
         else
@@ -2216 +2216 @@
         }
         jwork=std(jwork,@q);
-        keepdi=dim(jwork);        
+        keepdi=dim(jwork);
         if(keepdi<di)
         {
@@ -2241 +2241 @@
   {
     keepdi=di-1;
-  }  
+  }
   //---------------------------------------------------------------
   //notice that j=sat(j,gh) intersected with (j,gh^n)
@@ -2272 +2272 @@
 
         if(size(ser)>0)
-        { 
-           ser=intersect(htest,ser); 
+        {
+           ser=intersect(htest,ser);
         }
         else
         {
           ser=htest;
-        } 
+        }
         setring gnir;
         ser=imap(@Phelp,ser);
      }
      if(size(reduce(ser,peek,1))!=0)
-     {       
+     {
         for(@m=1;@m<=size(restindep);@m++)
         {
          // if(restindep[@m][3]>=keepdi)
-         // { 
+         // {
            isat=0;
            @n2=0;
            option(redSB);
-           
+
            if(restindep[@m][1]==varstr(basering))
            //this is the good case, nothing to do, just to have the same notations
@@ -2318 +2318 @@
            }
            option(noredSB);
-           
+
            for (lauf=1;lauf<=size(@j);lauf++)
            {
@@ -2367 +2367 @@
            }
            //the primary decomposition of j*K(var(nnp+1),..,var(nva))[..the rest..]
-           
+
            option(redSB);
            list uprimary= zero_decomp(@j,ser,@wr);
            option(noredSB);
-           
-            
+
+
            //we need the intersection of the ideals in the list quprimary with the
            //polynomialring, i.e. let q=(f1,...,fr) in the quotientring such an ideal
@@ -2407 +2407 @@
            @n2=size(quprimary);
            @n3=@n2;
-           
+
            for(@n1=1;@n1<=size(collectprimary)/2;@n1++)
            {
@@ -2420 +2420 @@
               }
            }
-           
-           
+
+
            //here the intersection with the polynomialring
            //mentioned above is really computed
@@ -2460 +2460 @@
               ser=imap(@Phelp,ser);
            }
-           
+
          // }
-        }             
+        }
         if(size(reduce(ser,peek,1))!=0)
         {
@@ -2482 +2482 @@
         }
      }
-     
+
    }
   //------------------------------------------------------------
@@ -2488 +2488 @@
   //the final result: primary
   //------------------------------------------------------------
-  
+
   setring @P;
   primary=imap(gnir,quprimary);
@@ -2520 +2520 @@
    return(phi(j));
 }
- 
+
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2534 +2534 @@
       return(ideal(0));
    }
-   
+
    def  @P = basering;
    list indep,allindep,restindep,fett,@mu;
@@ -2594 +2594 @@
 
       return(ideal(@p));
-   }   
+   }
    //------------------------------------------------------------------
    //the case of a complete intersection
@@ -2610 +2610 @@
    if (jdim==0)
    {
-      @j1=finduni(@j); 
+      @j1=finduni(@j);
       for(@k=1;@k<=size(@j1);@k++)
       {
@@ -2625 +2625 @@
       return(@j);
    }
-  
+
    //------------------------------------------------------------------
    //search for a maximal independent set indep,i.e.
@@ -2634 +2634 @@
 
    indep=maxIndependSet(@j);
-  
+
    di=dim(@j);
 
@@ -2763 +2763 @@
       {
          fac=ideal(0);
-         for(lauf=1;lauf<=ncols(@h);lauf++)   
+         for(lauf=1;lauf<=ncols(@h);lauf++)
          {
             if(deg(@h[lauf])>0)
@@ -2777 +2777 @@
          }
 
-       
+
          @mu=mstd(quotient(@j+ideal(@q),rad));
          @j=@mu[1];
          attrib(@j,"isSB",1);
-       
+
       }
       if((deg(rad[1])>0)&&(deg(collectrad[1])>0))
@@ -2796 +2796 @@
 
       te=simplify(reduce(te*rad,@j),2);
- 
+
       if((dim(@j)<di)||(size(te)==0))
       {
@@ -2810 +2810 @@
    {
       return(rad);
-   }   
+   }
   // rad=intersect(rad,radicalKL(@mu,rad,@wr));
    rad=intersect(rad,radicalKL(@mu,ideal(1),@wr));
@@ -2829 +2829 @@
       il=#[1];
    }
-   
+
    option(redSB);
    list m=mstd(i);
@@ -2846 +2846 @@
         return(quotient(I,J));
       }
-   
+
       for(l=1;l<=cod;l++)
       {
@@ -2864 +2864 @@
          if(il==1)
          {
-      
+
             return(radI1);
          }
@@ -2874 +2874 @@
             return(radI1);
          }
-         return(intersect(radI1,radicalEHV(I2,re,il)));       
+         return(intersect(radI1,radicalEHV(I2,re,il)));
       }
    }
@@ -2904 +2904 @@
   }
   return(ann);
-} 
- 
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -2915 +2915 @@
   {
      matrix f=transpose(re[n+1]);      //Hom(_,R)
-     module k=res(f,2)[2];             //the kernel
+     module k=nres(f,2)[2];            //the kernel
      matrix g=transpose(re[n]);        //the image of Hom(_,R)
 
@@ -2924 +2924 @@
      ideal ann=Ann(transpose(re[n]));
   }
-  return(ann);            
+  return(ann);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -2937 +2937 @@
       re=intersect1(re,quotient(a,module(b[i])));
    }
-   return(re);   
+   return(re);
 }
 
@@ -2944 +2944 @@
 
 proc analyze(list pr)
-{ 
+{
    int ii,jj;
    for(ii=1;ii<=size(pr)/2;ii++)
@@ -2964 +2964 @@
          }
       }
-   }   
+   }
 }
 
@@ -2976 +2976 @@
 {
   def r=basering;
-  
+
   int j,k;
   map phi;
   poly p;
-  
+
   ideal iwork=i;
   ideal imap1=maxideal(1);
   ideal imap2=maxideal(1);
-  
+
 
   for(j=1;j<=nvars(basering);j++)
@@ -2999 +2999 @@
         iwork[k]=var(j);
         imap1=maxideal(1);
-        imap2[j]=-p;        
+        imap2[j]=-p;
         break;
       }
@@ -3007 +3007 @@
 }
 
-        
+
 ///////////////////////////////////////////////////////
 // ini_mod
@@ -3605 +3605 @@
             }
         }
-        dimSP=dim(SP);
+        dimSP=dim(SP);
         for(j=size(m);j>=1; j--)
         {
@@ -3802 +3802 @@
       {
         f=polys[k];
-        degf=deg(f);
+        degf=deg(f);
       }
     }
@@ -4012 +4012 @@
    return(0);
 }
-        
-        
+
+
 proc quotient2(module a,module b)
 {
@@ -4030 +4030 @@
   setring @newP;
  ideal re=imap(@newr,re);
- return(re);   
+ return(re);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -4043 +4043 @@
       re[i]=he;
    }
-   return(re);   
+   return(re);
 }
 ///////////////////////////////////////////////////////////////////////////////
@@ -4056 +4056 @@
       re[2*i]=l[i][2];
    }
-   return(re);   
+   return(re);
 }
 
@@ -4066 +4066 @@
 
 proc primdecGTZ(ideal i)
-"USAGE:  primdecGTZ(i); i ideal 
-RETURN:  list = list of primary ideals 
+"USAGE:  primdecGTZ(i); i ideal
+RETURN:  list = list of primary ideals
                 and their associated primes
 NOTE:    Algorithm of Gianni, Traeger, Zacharias
@@ -4087 +4087 @@
 
 proc primdecSY(ideal i)
-"USAGE:  primdecSY(i); i ideal 
-RETURN:  list = list of primary ideals 
+"USAGE:  primdecSY(i); i ideal
+RETURN:  list = list of primary ideals
                 and their associated primes
 NOTE:    Algorithm of Shimoyama-Yokoyama
@@ -4149 +4149 @@
 proc equiRadical(ideal i)
 "USAGE:  equiRadical(i); i ideal
-RETURN:  ideal = the intersection of associated primes  
+RETURN:  ideal = the intersection of associated primes
          of i of dimension of i
 NOTE:
@@ -4170 +4170 @@
 "USAGE:  radical(i); i ideal
 RETURN:  ideal = the radical of i
-NOTE:    a combination of the algorithms of Krick/Logar 
+NOTE:    a combination of the algorithms of Krick/Logar
          and Eisenbud/Huneke/Vasconcelos
 EXAMPLE: example radical; shows an example
@@ -4179 +4179 @@
    if(size(#)>0)
    {
-     il=#[1]; 
+     il=#[1];
    }
    ideal re=1;
@@ -4186 +4186 @@
    map phi=@P,qr[2];
    i=qr[1];
-   
+
    list pr=facstd(i);
 
@@ -4223 +4223 @@
      int odim=dim(pr[1]);
      int count=1;
-   
+
      for(j=2;j<=s;j++)
      {
@@ -4281 +4281 @@
   else
   {
-     list re=mres(i,0);             
-  }  
+    list re=mres(i,0);
+  }
   for(e=cod;e<=nvars(basering);e++)
   {
@@ -4293 +4293 @@
   }
   return(er);
-}  
+}
 example
 { "EXAMPLE:";  echo = 2;
@@ -4306 +4306 @@
 proc testPrimary(list pr, ideal k)
 "USAGE:   testPrimary(pr,k) pr=primdecGTZ(k) or primdecSY(k)
-RETURN:   int = 1, if the intersection of the primary ideals 
+RETURN:   int = 1, if the intersection of the primary ideals
                 in pr is k, 0 if not
 NOTE:

Singular/LIB/sing.lib

@@ -1 @@
-// $Id: sing.lib,v 1.11 1998-05-14 18:45:16 Singular Exp $
+// $Id: sing.lib,v 1.12 1998-05-29 15:02:01 Singular Exp $
 //system("random",787422842);
 //(GMG/BM, last modified 26.06.96)
 ///////////////////////////////////////////////////////////////////////////////
 
-version="$Id: sing.lib,v 1.11 1998-05-14 18:45:16 Singular Exp $";
+version="$Id: sing.lib,v 1.12 1998-05-29 15:02:01 Singular Exp $";
 info="
 LIBRARY:  sing.lib      PROCEDURES FOR SINGULARITIES
@@ -539 +539 @@
 //--------------------------- presentation of J -------------------------------
    int rk;
-  def P = basering;
+   def P = basering;
    module jac, t1;
    jac  = jacob(J);                 // jacobian matrix of J converted to module
-   res(J,2,A);                      // compute presentation of J
-                                    // A(2) = 1st syzygy module of J
+   list A=nres(J,2);                // compute presentation of J
+   def A(1..2)=A[1..2]; kill A;     // A(2) = 1st syzygy module of J
 //---------- go to quotient ring mod J and compute normal bundle --------------
-  qring  R    = std(J);
+   qring  R    = std(J);
    module jac = fetch(P,jac);
    module t1  = transpose(fetch(P,A(2)));
-   res(t1,2,B);                     // resolve t1, B(2)=(J/J^2)*=normal_bdl
+   list B=nres(t1,2,B);             // resolve t1, B(2)=(J/J^2)*=normal_bdl
+   def B(1..2)=B[1..2]; kill B;
    t1         = modulo(B(2),jac);   // pres. of normal_bdl/trivial_deformations
    rk=nrows(t1);
 //-------------------------- pull back to basering ----------------------------
-  setring P;
+   setring P;
    t1 = fetch(R,t1)+J*freemodule(rk);  // T1-module, presentation of T1
    t1 = std(t1);
@@ -609 +610 @@
    int n,rk;
 //------------------- presentation of non-trivial syzygies --------------------
-   res(J,2,A);                            // resolve J, A(2)=syz
+   list A=nres(J,2);                      // resolve J, A(2)=syz
+   def A(1..2)=A[1..2]; kill A;
    kos  = koszul(2,J);                    // module of Koszul relations
    SK   = modulo(A(2),kos);               // presentation of syz/kos
@@ -615 +617 @@
 //?*** sollte bei der Berechnung von res mit anfallen, zu aendern!!
 //---------------------- fetch to quotient ring mod J -------------------------
-  qring R = J0;                           // make P/J the basering
+   qring R = J0;                          // make P/J the basering
    module A2' = transpose(fetch(P,A(2))); // dual of syz
    module t2  = transpose(fetch(P,SK));   // dual of syz/kos
-   res(t2,2,B);                           // resolve (syz/kos)*
+   list B=nres(t2,2);                     // resolve (syz/kos)*
+   def B(1..2)=B[1..2]; kill B;
    t2 = modulo(B(2),A2');                 // presentation of T2
    rk = nrows(t2);
 //---------------------  fetch back to basering -------------------------------
-  setring P;
+   setring P;
    t2 = fetch(R,t2)+J*freemodule(rk);
    t2 = std(t2);
@@ -683 +686 @@
    ideal  i0 = std(i);
 //-------------------- presentation of non-trivial syzygies -------------------
-   list I= res(i,2);                            // resolve i
+   list I= nres(i,2);                           // resolve i
    Syz  = matrix(I[2]);                         // syz(i)
    jac = jacob(i);                              // jacobi ideal
@@ -693 +696 @@
    matrix No  = transpose(fetch(P,Syz));        // ker(No) = Hom(syz,Ox)
    module So  = transpose(fetch(P,SK));         // Hom(syz/kos,R)
-   list resS  = res(So,2);
+   list resS  = nres(So,2);
    matrix Sx  = resS[2];
-   list resN  = res(No,2);
+   list resN  = nres(No,2);
    matrix Nx  = resN[2];
    module T2  = modulo(Sx,No);                  // presentation of T2

Singular/LIB/standard.lib

@@ -1 @@
-// $Id: standard.lib,v 1.16 1998-05-25 21:28:33 obachman Exp $
+// $Id: standard.lib,v 1.17 1998-05-29 15:02:02 Singular Exp $
 //////////////////////////////////////////////////////////////////////////////
 
-version="$Id: standard.lib,v 1.16 1998-05-25 21:28:33 obachman Exp $";
+version="$Id: standard.lib,v 1.17 1998-05-29 15:02:02 Singular Exp $";
 info="
 LIBRARY: standard.lib   PROCEDURES WHICH ARE ALWAYS LOADED AT START-UP
@@ -8 +8 @@
  stdfglm(ideal[,ord])   standard basis of the ideal via fglm [and ordering ord]
  stdhilb(ideal)         standard basis of the ideal using the Hilbert function
- groebner(ideal/module) standard basis of ideal or module using a 
-                        heuristically choosen method 
+ groebner(ideal/module) standard basis of ideal or module using a
+                        heuristically choosen method
 ";
 
@@ -126 +126 @@
 proc groebner(def i, list #)
 "USAGE: groebner(i[, wait]) i -- ideal/module; wait -- int
-RETURNS: Standard basis of ideal or module which is computed using a 
-         heuristically choosen method: 
+RETURNS: Standard basis of ideal or module which is computed using a
+         heuristically choosen method:
          If the ordering of the current ring is a local ordering, or
          if it is a non-block ordering and the current ring has no
-         parameters, then std(i) is returned.  
+         parameters, then std(i) is returned.
          Otherwise, i is mapped into a ring with no parameters and
          ordering dp, where its Hilbert series is computed. This is
@@ -136 +136 @@
          original ring.
 NOTE: If a 2nd argument 'wait' is given, then the computation proceeds
-      at most 'wait' seconds. That is, if no result could be computed in 
-      'wait' seconds, then the computation is interrupted, 0 is returned, 
-      a warning message is displayed, and the global variable 
-      'groebner_error' is defined. 
+      at most 'wait' seconds. That is, if no result could be computed in
+      'wait' seconds, then the computation is interrupted, 0 is returned,
+      a warning message is displayed, and the global variable
+      'groebner_error' is defined.
 EXAMPLE: example groebner; shows an example"
 {
@@ -153 +153 @@
         int wait = #[1];
         int j = 10;
-        
+
         string bs = nameof(basering);
         link l_fork = "MPtcp:fork";
@@ -160 +160 @@
         int pid = read(l_fork);
         write(l_fork, quote(groebner(eval(i))));
-        
+
         // sleep in small intervalls for appr. one second
         if (wait > 0)
@@ -170 +170 @@
           }
         }
-        
+
         // sleep in intervalls of one second from now on
         j = 1;
@@ -178 +178 @@
           j = j + 1;
         }
-        
+
         if (status(l_fork, "read", "ready"))
         {
@@ -226 +226 @@
     return(std(i));
   }
-   
+
   int IsSimple_P;
   if (system("nblocks") <= 2)
@@ -265 +265 @@
     option(mem);
   }
-   
+
   // construct ring in which first std computation is done
   string varstr_P = varstr(P);
   string parstr_P = parstr(P);
-  int is_homog = (homog(i) && (npars_P == 0)); 
-   
+  int is_homog = (homog(i) && (npars_P == 0));
+
   string ri = "ring Phelp =" + string(char(P)) + ",(" + varstr_P;
   // parameters are converted to ring variables
@@ -287 +287 @@
   // change the ring
   execute(ri);
-   
+
   // get ideal from previous ring
   if (is_homog)
@@ -298 +298 @@
     ideal qh=homog(imap(P,i),@t);
   }
-   
+
   // compute std and hilbert series
   if (p_opt)
@@ -322 +322 @@
     // additional variables were introduced
     // need another intermediate ring
-    ri = "ring Phelp1 =" + string(char(P)) 
+    ri = "ring Phelp1 =" + string(char(P))
       + ",(" + varstr(Phelp) + "),(" + ordstr_P;
-     
+
     // for lp without parameters, we do not need a block ordering
     if ( ! (IsSimple_P && (npars_P + is_homog < 2) && find(ordstr_P, "l")))
@@ -332 +332 @@
     }
     ri = ri + ");";
-     
+
     // change to intermediate ring
     execute(ri);
@@ -348 +348 @@
       qh = subst(qh, @t, 1);
     }
-     
+
     // go back to original ring
     setring P;
@@ -370 +370 @@
   "EXAMPLE: "; echo = 2;
   ring r = 0, (a,b,c,d), lp;
-  option(prot); 
+  option(prot);
   ideal i = a+b+c+d, ab+ad+bc+cd, abc+abd+acd+bcd, abcd-1; // cyclic 4
   groebner(i);
@@ -384 +384 @@
 
 //////////////////////////////////////////////////////////////////////////
-proc resu(list #)
+proc res(list #)
 {
    def P=basering;
    list result;
    def m=#[1]; //the ideal or module
-   
+
    int i=#[2]; //the length of the resolution
                //if size(#)>2 a minimal resolution is computed
@@ -414 +414 @@
       setring P;
       result=imap(Phelp,re);
-      return(result);   
+      return(result);
    }
 
@@ -439 +439 @@
    setring P;
    result=imap(Phelp,re);
-   return(result);      
+   return(result);
 }
 
 proc minresu(list #)
 {
-   return(resu(#[1],#[2],1));
-}
+   return(res(#[1],#[2],1));
+}

Singular/iparith.cc

@@ -219 +219 @@
   { "not",         0, NOT ,               NOT},
   { "npars",       0, NPARS_CMD ,         CMD_1},
+  #ifdef OLD_RES
+  { "nres",        0, RES_CMD ,           CMD_23},
+  #else
+  { "nres",        0, RES_CMD ,           CMD_2},
+  #endif
   { "nrows",       0, ROWS_CMD ,          CMD_1},
   { "number",      0, NUMBER_CMD ,        RING_DECL},
@@ -246 +251 @@
   { "reduce",      0, REDUCE_CMD ,        CMD_23},
   { "regularity",  0, REGULARITY_CMD ,    CMD_1},
-  #ifdef OLD_RES
-  { "res",         0, RES_CMD ,           CMD_23},
-  #else
-  { "res",         0, RES_CMD ,           CMD_2},
-  #endif
   { "reservedName",0, RESERVEDNAME_CMD ,  CMD_M},
   { "resolution",  0, RESOLUTION_CMD ,    RING_DECL},