Changeset c99fd4 in git for Singular/LIB


Ignore:
Timestamp:
Oct 6, 2008, 7:04:28 PM (16 years ago)
Author:
Hans Schönemann <hannes@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '38dfc5131670d387a89455159ed1e071997eec94')
Children:
886b0dae50b58b9f8b0863c63abf2f0ddacf9a26
Parents:
100025a806c37776e35dd4b839e192304f203af8
Message:
*hannes/gmg: elim, select, nselect, select1


git-svn-id: file:///usr/local/Singular/svn/trunk@11098 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/algebra.lib

    r100025 rc99fd4  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: algebra.lib,v 1.16 2008-07-02 09:42:59 Singular Exp $";
     2version="$Id: algebra.lib,v 1.17 2008-10-06 17:04:26 Singular Exp $";
    33category="Commutative Algebra";
    44info="
    … …  
    395395        ideal A = imap(R2,A);
    396396        A = std(A);
    397         ideal ker = nselect(A,1,n);
     397        ideal ker = nselect(A,1..n);
    398398        setring R2;
    399399        if ( defined(Q)==voice )
    … …  
    717717    def bsr = basering;
    718718 // ------- checking whether phi is injective by computing the kernel -------
    719     ideal ker = nselect(A,1,n);
     719    ideal ker = nselect(A,1..n);
    720720    t = size(ker);
    721721    setring pr;

  • Singular/LIB/bfct.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: bfct.lib,v 1.4 2008-10-01 17:44:37 levandov Exp $";
     2version="$Id: bfct.lib,v 1.5 2008-10-06 17:04:26 Singular Exp $";
    33category="Noncommutative";
    44info="
    … …  
    994994  setring DDh;
    995995  dbprint(ppl, "the initial ideal:", string(matrix(inF)));
    996   inF = nselect(inF,3,2*n+4);
     996  inF = nselect(inF,3..2*n+4);
    997997  inF = nselect(inF,1);
    998998  dbprint(ppl, "generators containing only s:", string(matrix(inF)));

  • Singular/LIB/dmod.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmod.lib,v 1.30 2008-08-07 20:14:21 levandov Exp $";
     2version="$Id: dmod.lib,v 1.31 2008-10-06 17:04:26 Singular Exp $";
    33category="Noncommutative";
    44info="
    … …  
    880880  dbprint(ppl-1, K);
    881881  ideal M = engine(K,eng);
    882   ideal K2 = nselect(M,1,Nnew-1);
     882  ideal K2 = nselect(M,1..Nnew-1);
    883883  kill K,M;
    884884  dbprint(ppl,"// -2-3- _x,_Dx are eliminated in @R2");
    … …  
    11091109  dbprint(ppl-1, K);
    11101110  ideal M = engine(K,eng);
    1111   ideal K2 = nselect(M,1,Nnew-1);
     1111  ideal K2 = nselect(M,1..Nnew-1);
    11121112  kill K,M;
    11131113  dbprint(ppl,"// -2-3- _x,_Dx are eliminated in @R2");
    … …  
    12591259  ideal M = engine(J,eng);
    12601260  int Nnew = nvars(@R2);
    1261   ideal K2 = nselect(M,1,Nnew-1);
     1261  ideal K2 = nselect(M,1..Nnew-1);
    12621262  int ppl = printlevel-voice+2;
    12631263  dbprint(ppl,"// -1-1- _x,_Dx are eliminated in basering");
    … …  
    14541454  ideal M = engine(J,eng);
    14551455  int Nnew = nvars(@R2);
    1456   ideal K2 = nselect(M,1,Nnew-1);
     1456  ideal K2 = nselect(M,1..Nnew-1);
    14571457  dbprint(ppl,"// -2-0- _x,_Dx are eliminated in basering");
    14581458  dbprint(ppl-1, K2);
    … …  
    17601760  dbprint(ppl-1, K);
    17611761  ideal M = engine(K,eng);
    1762   ideal K2 = nselect(M,1,Nnew-1);
     1762  ideal K2 = nselect(M,1..Nnew-1);
    17631763  kill K,M;
    17641764  dbprint(ppl,"// -2-3- _x,_Dx are eliminated in @R2");
    … …  
    22602260  dbprint(ppl-1, I);
    22612261  ideal J = engine(I,eng);
    2262   ideal K = nselect(J,1,P);
     2262  ideal K = nselect(J,1..P);
    22632263  kill I,J;
    22642264  dbprint(ppl,"// -1-3- all t(i) are eliminated");
    … …  
    23452345  dbprint(ppl-1, K);
    23462346  ideal M = engine(K,eng);
    2347   ideal K2 = nselect(M,1,Nnew-P);
     2347  ideal K2 = nselect(M,1..Nnew-P);
    23482348  kill K,M;
    23492349  dbprint(ppl,"// -2-3- _x,_Dx are eliminated in @R2");
    … …  
    25812581  dbprint(ppl-1, I);
    25822582  ideal J = engine(I,eng);
    2583   ideal K = nselect(J,1,2);
     2583  ideal K = nselect(J,1..2);
    25842584  dbprint(ppl,"// -1-3- u,v are eliminated");
    25852585  dbprint(ppl-1, K);  // K is without u,v
    … …  
    26532653  dbprint(ppl-1, K);
    26542654  ideal M  = engine(K,eng);
    2655   ideal K2 = nselect(M,1,2);
     2655  ideal K2 = nselect(M,1..2);
    26562656  dbprint(ppl,"// -2-3- t,Dt are eliminated");
    26572657  dbprint(ppl-1, K2);
    … …  
    27222722  dbprint(ppl-1, K);
    27232723  ideal M = engine(K,eng);
    2724   ideal K3 = nselect(M,1,Nnew-1);
     2724  ideal K3 = nselect(M,1..Nnew-1);
    27252725  dbprint(ppl,"// -3-3-  _x,_Dx are eliminated in @R3");
    27262726  dbprint(ppl-1, K3);
    … …  
    29592959  dbprint(ppl-1, I);
    29602960  ideal J = engine(I,eng);
    2961   ideal K = nselect(J,1,2);
     2961  ideal K = nselect(J,1..2);
    29622962  dbprint(ppl,"// -1-3- u,v are eliminated");
    29632963  dbprint(ppl-1, K);  // K is without u,v
    … …  
    30313031  dbprint(ppl-1, K);
    30323032  ideal M  = engine(K,eng);
    3033   ideal K2 = nselect(M,1,2);
     3033  ideal K2 = nselect(M,1..2);
    30343034  dbprint(ppl,"// -2-3- t,Dt are eliminated");
    30353035  dbprint(ppl-1, K2);
    … …  
    34643464  dbprint(ppl-1, I);
    34653465  ideal J = engine(I,eng);
    3466   ideal K = nselect(J,1,2);
     3466  ideal K = nselect(J,1..2);
    34673467  dbprint(ppl,"// -1-3- t,Dt are eliminated");
    34683468  dbprint(ppl-1, K);  // K is without t, Dt
    … …  
    36893689  dbprint(ppl-1, I);
    36903690  ideal J = engine(I,eng);
    3691   ideal K = nselect(J,1,2);
     3691  ideal K = nselect(J,1..2);
    36923692  dbprint(ppl,"// -1-3- t,Dt are eliminated");
    36933693  dbprint(ppl-1, K);  // K is without t, Dt
    … …  
    38613861  ideal M = engine(J,eng);
    38623862  int Nnew = nvars(@R2);
    3863   ideal K2 = nselect(M,1,Nnew-1);
     3863  ideal K2 = nselect(M,1..Nnew-1);
    38643864  int ppl = printlevel-voice+2;
    38653865  dbprint(ppl,"// -1-1- _x,_Dx are eliminated in basering");
    … …  
    41164116//   dbprint(ppl,"// -1-2- starting the elimination of u,v in @R");
    41174117//   ideal J = engine(I,eng);
    4118 //   ideal K = nselect(J,1,2);
     4118//   ideal K = nselect(J,1..2);
    41194119//   dbprint(ppl,"// -1-3- u,v are eliminated in @R");
    41204120//   dbprint(ppl-1,K); // without u,v: not yet our answer
    … …  
    41884188//   dbprint(ppl,"// -2-2- starting elimination for t,Dt in @R2");
    41894189//   ideal J  = engine(K2,eng);
    4190 //   ideal K  = nselect(J,1,2);
     4190//   ideal K  = nselect(J,1..2);
    41914191//   dbprint(ppl,"// -2-3- t,Dt are eliminated");
    41924192//   dbprint(ppl-1,K);
    … …  
    50295029  dbprint(ppl-1, J);
    50305030  ideal G = engine(J,eng);
    5031   ideal K = nselect(G,1,N-1);
     5031  ideal K = nselect(G,1..N-1);
    50325032  kill J,G;
    50335033  dbprint(ppl,"// -1-3- _x,_Dx are eliminated");

  • Singular/LIB/dmodapp.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmodapp.lib,v 1.8 2008-10-01 17:44:38 levandov Exp $";
     2version="$Id: dmodapp.lib,v 1.9 2008-10-06 17:04:26 Singular Exp $";
    33category="Noncommutative";
    44info="
    … …  
    852852  ideal M = groebner(J);
    853853  int Nnew = nvars(@R2);
    854   ideal K2 = nselect(M,1,Nnew-1);
     854  ideal K2 = nselect(M,1..Nnew-1);
    855855  int ppl = printlevel-voice+2;
    856856  dbprint(ppl,"// -1-1- _x,_Dx are eliminated in basering");
    … …  
    11711171  dbprint(ppl-1,"// -1-2-1- result of the  elimination of @t,@Dt in @R");
    11721172  dbprint(ppl-1, J);;
    1173   ideal K = nselect(J,1,2);
     1173  ideal K = nselect(J,1..2);
    11741174  dbprint(ppl,"// -1-3- @t,@Dt are eliminated");
    11751175  dbprint(ppl-1, K);  // K is without t, Dt

  • Singular/LIB/elim.lib

    r100025 rc99fd4  
    1 // $Id: elim.lib,v 1.22 2008-04-22 17:20:51 Singular Exp $
     1// $Id: elim.lib,v 1.23 2008-10-06 17:04:26 Singular Exp $
    22// (GMG, last modified 22.06.96)
    33///////////////////////////////////////////////////////////////////////////////
    4 version="$Id: elim.lib,v 1.22 2008-04-22 17:20:51 Singular Exp $";
     4version="$Id: elim.lib,v 1.23 2008-10-06 17:04:26 Singular Exp $";
    55category="Commutative Algebra";
    66info="
    … …  
    99PROCEDURES:
    1010 blowup0(j[,s1,s2]);    create presentation of blownup ring of ideal j
    11  elim(id,n,m);          variable n..m eliminated from id (ideal/module)
     11 elim(id,v);            eliminate variables in v from id (ideal/module)
    1212 elim1(id,p);           p=product of vars to be eliminated from id
    13  nselect(id,n[,m]);     select generators not containing nth [..mth] variable
     13 nselect(id,v);         select generators not containing variables given by v
    1414 sat(id,j);             saturated quotient of ideal/module id by ideal j
    15  select(id,n[,m]);      select generators containing all variables n...m
    16  select1(id,n[,m]);     select generators containing one variable n...m
     15 select(id,v);          select generators containing all variables given by v
     16 select1(id,v);         select generators containing one variable given by v
     17
    1718           (parameters in square brackets [] are optional)
    1819";
    … …  
    188189///////////////////////////////////////////////////////////////////////////////
    189190
    190 proc elim (id, int n, int m)
    191 "USAGE:   elim(id,n,m);  id ideal/module, n,m integers
    192 RETURNS: ideal/module obtained from id by eliminating variables var(n) to var(m)
     191proc elim (id, intvec va)
     192"USAGE:   elim(id,v);  id ideal/module, v intvec
     193RETURNS: ideal/module obtained from id by eliminating variables in v
    193194NOTE:    no special monomial ordering is required, result is a SB with
    194195         respect to ordering dp (resp. ls) if the first var not to be
    … …  
    201202//---- get variables to be eliminated and create string for new ordering ------
    202203   int ii; poly vars=1;
    203    for( ii=n; ii<=m; ii++ ) { vars=vars*var(ii); }
     204   for( ii=1; ii<=size(va); ii++ ) { vars=vars*var(va[ii]); }
    204205   if(  attrib(basering,"global")) { string ordering = "),dp;"; }
    205206   else { string ordering = "),ls;"; }
    … …  
    221222   ring r=0,(x,y,u,v,w),dp;
    222223   ideal i=x-u,y-u2,w-u3,v-x+y3;
    223    elim(i,3,4);
     224   elim(i,3..4);
    224225   module m=i*gen(1)+i*gen(2);
    225    m=elim(m,3,4);show(m);
     226   m=elim(m,3..4);show(m);
    226227}
    227228///////////////////////////////////////////////////////////////////////////////
    … …  
    267268///////////////////////////////////////////////////////////////////////////////
    268269
    269 proc nselect (id, int n, list#)
    270 "USAGE:   nselect(id,n[,m]); id a module or ideal, n, m integers
    271 RETURN:  generators of id not containing the variable n [up to m]
     270proc nselect (id_inp, intvec v)
     271"USAGE:   nselect(id,v); id = module or ideal, v = intvec
     272RETURN:  generators of id not containing the variables with index an entry of v
    272273SEE ALSO: select, select1
    273274EXAMPLE: example nselect; shows examples
    274 "{
    275    int j,k;
    276    if( size(#)==0 ) { #[1]=n; }
    277    for( k=1; k<=ncols(id); k++ )
    278    {  for( j=n; j<=#[1]; j++ )
    279       {  if( size(id[k]/var(j))!=0) { id[k]=0; break; }
    280       }
    281    }
    282    return(simplify(id,2));
     275"
     276{
     277  if (typeof(id_inp)!="ideal") { module id=module(id_inp); }
     278  else                         { ideal id=id_inp;         }
     279  int j,k;
     280  int n,m = size(v), ncols(id);
     281  //listvar(id);
     282  for( k=1; k<=m; k++ )
     283  { 
     284    for( j=1; j<=n; j++ )
     285    { 
     286      if( size(id[k]/var(v[j]))!=0 )
     287      {
     288         id[k]=0; break;
     289      }
     290    }
     291  }
     292  //if(typeof(id)=="ideal") { return(simplify(id,2)); }
     293  //return(simplify(module(id),2));
     294  id=(simplify(module(id),2));
     295  //listvar(id);
     296  return(id);
     297  //return(simplify(id,2));
    283298}
    284299example
    … …  
    289304   module m=i*(gen(1)+gen(2));
    290305   show(m);
    291    show(nselect(m,3,4));
     306   show(nselect(m,3..4));
    292307}
    293308///////////////////////////////////////////////////////////////////////////////
    … …  
    333348///////////////////////////////////////////////////////////////////////////////
    334349
    335 proc select (id, int n, list#)
    336 "USAGE:   select(id,n[,m]); id ideal/module, n, m integers
    337 RETURN:  generators of id containing the variable n [all variables up to m]
     350proc select (id, intvec v)
     351"USAGE:   select(id,n[,m]); id = ideal/module, v= intvec
     352RETURN:  generators of id containing all variables with index an entry of v
    338353NOTE:    use 'select1' for selecting generators containing at least one of the
    339          variables between n and m
     354         variables with index an entry of v
    340355SEE ALSO: select1, nselect
    341356EXAMPLE: example select; shows examples
    342357"{
    343    if( size(#)==0 ) { #[1]=n; }
    344358   int j,k;
    345    for( k=1; k<=ncols(id); k++ )
    346    {  for( j=n; j<=#[1]; j++ )
    347       {   if( size(id[k]/var(j))==0) { id[k]=0; break; }
     359   int n,m = size(v), ncols(id);
     360   for( k=1; k<=m; k++ )
     361   { 
     362      for( j=1; j<=n; j++ )
     363      {   
     364         if( size(id[k]/var(v[j]))==0)
     365         {
     366            id[k]=0; break;
     367         }
    348368      }
    349369   }
    … …  
    358378   module m=i*(gen(1)+gen(2));
    359379   m;
    360    select(m,1,2);
    361 }
    362 ///////////////////////////////////////////////////////////////////////////////
    363 
    364 proc select1 (id, int n, list#)
    365 "USAGE:   select1(id,n[,m]); id ideal/module, n, m integers
    366 RETURN:  generators of id containing the variable n
    367          [at least one of the variables up to m]
     380   select(m,1..2);
     381}
     382///////////////////////////////////////////////////////////////////////////////
     383
     384proc select1 (id, intvec v)
     385"USAGE:   select1(id,v); id = ideal/module, v = intvec
     386RETURN:  generators of id containing at least one of the variables with
     387         index an entry of v
    368388NOTE:    use 'select' for selecting generators containing all the
    369          variables between n and m
     389         variables with index an entry of v
    370390SEE ALSO: select, nselect
    371391EXAMPLE: example select1; shows examples
    372392"{
    373    if( size(#)==0 ) { #[1]=n; }
    374393   int j,k;
     394   int n,m = size(v), ncols(id);
    375395   execute (typeof(id)+" I;");
    376    for( k=1; k<=ncols(id); k++ )
    377    {  for( j=n; j<=#[1]; j++ )
    378       {
    379          if( size(subst(id[k],var(j),0)) != size(id[k]) )
    380          { I=I,id[k]; break; }
     396   for( k=1; k<=m; k++ )
     397   {  for( j=1; j<=n; j++ )
     398      {
     399         if( size(subst(id[k],var(v[j]),0)) != size(id[k]) )
     400         { 
     401            I = I,id[k]; break;
     402         }
    381403      }
    382404   }
    … …  
    391413   module m=i*(gen(1)+gen(2));
    392414   m;
    393    select1(m,1,2);
    394 }
    395 ///////////////////////////////////////////////////////////////////////////////
     415   select1(m,1..2);
     416}
     417///////////////////////////////////////////////////////////////////////////////

  • Singular/LIB/equising.lib

    r100025 rc99fd4  
    1 version="$Id: equising.lib,v 1.17 2006-07-18 15:48:12 Singular Exp $";
     1version="$Id: equising.lib,v 1.18 2008-10-06 17:04:26 Singular Exp $";
    22category="Singularities";
    33info="
    … …  
    854854  if (typ==1) // isEquising
    855855  {
    856     if(ideal(nselect(J,1,no_b))<>0)
     856    if(ideal(nselect(J,1..no_b))<>0)
    857857    {
    858858      setring old_ring;
    … …  
    941941  if (typ==1) // isEquising
    942942  {
    943     if(ideal(nselect(J,1,no_b))<>0)
     943    if(ideal(nselect(J,1..no_b))<>0)
    944944    {
    945945      setring old_ring;
    … …  
    10621062        {
    10631063          if (defined(artin_bd)) { J=jet(Jnew,artin_bd-1); }
    1064           if(ideal(nselect(J,1,no_b))<>0)
     1064          if(ideal(nselect(J,1..no_b))<>0)
    10651065          {
    10661066            setring old_ring;
    … …  
    10771077      {
    10781078        if (defined(artin_bd)) { J=jet(Jnew,artin_bd-1); }
    1079         if(ideal(nselect(J,1,no_b))<>0)
     1079        if(ideal(nselect(J,1..no_b))<>0)
    10801080        {
    10811081          setring old_ring;
    … …  
    11211121  {
    11221122    if (defined(artin_bd)) { J=jet(Jnew,artin_bd-1); }
    1123     if(ideal(nselect(J,1,no_b))<>0)
     1123    if(ideal(nselect(J,1..no_b))<>0)
    11241124    {
    11251125      setring old_ring;
    … …  
    11731173  }
    11741174
    1175   Jtriv = nselect(Jtriv,1,no_b);
    1176   ideal J_no_b = nselect(J,1,no_b);
     1175  Jtriv = nselect(Jtriv,1..no_b);
     1176  ideal J_no_b = nselect(J,1..no_b);
    11771177  if (size(J) > size(J_no_b))
    11781178  {
    … …  
    12271227      option(redSB);
    12281228      J=std(J);
    1229       J=nselect(J,1,no_b);
     1229      J=nselect(J,1..no_b);
    12301230
    12311231      setring myRing;
    12321232      // back to "myRing"
    12331233
    1234       J=nselect(J,1,no_b);
     1234      J=nselect(J,1..no_b);
    12351235      Jnew=imap(QQ,J);
    12361236
    … …  
    12421242    {
    12431243      J=std(J);
    1244       J=nselect(J,1,no_b);
     1244      J=nselect(J,1..no_b);
    12451245      if (defined(artin_bd)){ J=jet(J,artin_bd-1); }
    12461246    }

  • Singular/LIB/finvar.lib

    r100025 rc99fd4  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: finvar.lib,v 1.76 2008-01-22 09:17:19 Singular Exp $"
     2version="$Id: finvar.lib,v 1.77 2008-10-06 17:04:27 Singular Exp $"
    33category="Invariant theory";
    44info="
    … …  
    71077107  }
    71087108
    7109   M=elim(module(M),1,n);               // eliminating x(1..n), std-calculation
     7109  M=elim(module(M),1..n);               // eliminating x(1..n), std-calculation
    71107110                                         // is done internally -
    71117111  M=homog(module(M),h);            // homogenize for 'minbase'
    … …  
    76317631    { I[i]=I[i]-y(i);
    76327632    }
    7633     I=elim(I,1,n);
     7633    I=elim(I,1..n);
    76347634    execute("ring "+newring+"=("+charstr(br)+"),(y(1..m)),dp(m);");
    76357635    execute("minpoly=number("+mp+");");

  • Singular/LIB/freegb.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: freegb.lib,v 1.11 2008-10-02 08:14:35 Singular Exp $";
     2version="$Id: freegb.lib,v 1.12 2008-10-06 17:04:27 Singular Exp $";
    33category="Noncommutative";
    44info="
    … …  
    529529  dbprint(ppl,J);
    530530  // 4. skip shifted elts
    531   ideal K = select1(J,1,s); // s = size(OrigNames)
     531  ideal K = select1(J,1..s); // s = size(OrigNames)
    532532  dbprint(ppl,K);
    533533  dbprint(ppl, "done with GB");
    … …  
    11881188  dbprint(ppl,J);
    11891189  // 4. skip shifted elts
    1190   ideal K = select1(J,1,s); // s = size(OrigNames)
     1190  ideal K = select1(J,1..s); // s = size(OrigNames)
    11911191  dbprint(ppl,K);
    11921192  dbprint(ppl, "done with GB");

  • Singular/LIB/mregular.lib

    r100025 rc99fd4  
    11// IB/PG/GMG, last modified:  15.10.2004
    22//////////////////////////////////////////////////////////////////////////////
    3 version = "$Id: mregular.lib,v 1.8 2005-05-06 14:38:47 hannes Exp $";
     3version = "$Id: mregular.lib,v 1.9 2008-10-06 17:04:27 Singular Exp $";
    44category="Commutative Algebra";
    55info="
    … …  
    9191//----- If the ideal i is not proper:
    9292   if ( d == -1 )
    93      {
    94        dbprint(printlevel-voice+2,
    95                "// The ideal i is (1)!
     93   {
     94     dbprint(printlevel-voice+2,
     95             "// The ideal i is (1)!
    9696// Its Castelnuovo-Mumford regularity is:");
    97        return (0);
    98      }
     97     return (0);
     98   }
    9999//----- If the ideal i is 0:
    100100   if ( size(I) == 0 )
    101      {
    102        dbprint(printlevel-voice+2,
    103                "// The ideal i is (0)!
     101   {
     102     dbprint(printlevel-voice+2,
     103             "// The ideal i is (0)!
    104104// Its Castelnuovo-Mumford regularity is:");
    105        return (0);
    106      }
     105     return (0);
     106   }
    107107//----- When the ideal i is 0-dimensional:
    108108   if ( d == 0 )
    109      {
    110        H=maxdeg1(minbase(quotient(I,maxideal(1))))+1;
    111        time=rtimer-time;
    112        // Additional information:
    113        dbprint(printlevel-voice+2,
    114                "// Dimension of S/i : 0");
    115        dbprint(printlevel-voice+2,
    116                "// Time for computing regularity: " + string(time) + " sec.");
    117        dbprint(printlevel-voice+2,
     109   {
     110     H=maxdeg1(minbase(quotient(I,maxideal(1))))+1;
     111     time=rtimer-time;
     112     // Additional information:
     113     dbprint(printlevel-voice+2,
     114             "// Dimension of S/i : 0");
     115     dbprint(printlevel-voice+2,
     116             "// Time for computing regularity: " + string(time) + " sec.");
     117     dbprint(printlevel-voice+2,
    118118"// The Castelnuovo-Mumford regularity of i coincides with its satiety, and
    119119 // with the regularity of the Hilbert function of S/i. Its value is:");
    120        return (H);
    121      }
     120     return (H);
     121   }
    122122//----- Determine the situation: NT, or NP, or nothing.
    123123//----- Choose the method depending on the situation, on the
    … …  
    125125//----- in order to get the mon. ideal of nested type associated to i
    126126   if ( e == 1 )
    127      {
    128        ch=0;
    129      }
     127   { ch=0; }
    130128   NPtest=is_NP(I);
    131129   if ( NPtest == 1 )
    132      {
    133        nesttest=is_nested(I);
    134      }
     130   {
     131     nesttest=is_nested(I);
     132   }
    135133   if ( ch != 0 )
    136      {
     134   {
     135     if ( NPtest == 0 )
     136     {
     137       N=d*n-d*(d-1)/2;
     138       s = "ring rtr = (ch,t(1..N)),x(0..n),dp;";
     139       execute(s);
     140       ideal chcoord,m,i,I;
     141       poly P;
     142       map phi;
     143       i=imap(r1,i);
     144       chcoord=select1(maxideal(1),1..(n-d+1));
     145       acc=0;
     146       for ( ii = 1; ii<=d; ii++ )
     147       {
     148         matrix trex[1][n-d+ii+1]=t((1+acc)..(n-d+ii+acc)),1;
     149         m=select1(maxideal(1),1..(n-d+1+ii));
     150         for ( jj = 1; jj<=n-d+ii+1; jj++ )
     151         {
     152           P=P+trex[1,jj]*m[jj];
     153         }
     154         chcoord[n-d+1+ii]=P;
     155         P=0;
     156         acc=acc+n-d+ii;
     157         kill trex;
     158       }
     159       phi=rtr,chcoord;
     160       I=simplify(lead(std(phi(i))),1);
     161       setring r1;
     162       I=imap(rtr,I);
     163       attrib(I,"isSB",1);
     164     }
     165     else
     166     {
     167       if ( nesttest == 0 )
     168       {
     169         N=d*(d-1)/2;
     170         s = "ring rtr = (ch,t(1..N)),x(0..n),dp;";
     171         execute(s);
     172         ideal chcoord,m,i,I;
     173         poly P;
     174         map phi;
     175         i=imap(r1,i);
     176         chcoord=select1(maxideal(1),1..(n-d+2));
     177         acc=0;
     178         for ( ii = 1; ii<=d-1; ii++ )
     179         {
     180           matrix trex[1][ii+1]=t((1+acc)..(ii+acc)),1;
     181           m=select1(maxideal(1),(n-d+2)..(n-d+2+ii));
     182           for ( jj = 1; jj<=ii+1; jj++ )
     183           {
     184             P=P+trex[1,jj]*m[jj];
     185           }
     186           chcoord[n-d+2+ii]=P;
     187           P=0;
     188           acc=acc+ii;
     189           kill trex;
     190         }
     191         phi=rtr,chcoord;
     192         I=simplify(lead(std(phi(i))),1);
     193         setring r1;
     194         I=imap(rtr,I);
     195         attrib(I,"isSB",1);
     196       }
     197     }
     198   }
     199   else
     200   {
     201     if ( NPtest == 0 )
     202     {
     203       while ( nl < 30 )
     204       {
     205         chcoord=select1(maxideal(1),1..(n-d+1));
     206         nl=nl+1;
     207         for ( ii = 1; ii<=d; ii++ )
     208         {
     209           ran=random(100,1,n-d+ii);
     210           ran=intmat(ran,1,n-d+ii+1);
     211           ran[1,n-d+ii+1]=1;
     212           m=select1(maxideal(1),1..(n-d+1+ii));
     213           for ( jj = 1; jj<=n-d+ii+1; jj++ )
     214           {
     215             P=P+ran[1,jj]*m[jj];
     216           }
     217           chcoord[n-d+1+ii]=P;
     218           P=0;
     219         }
     220         phi=r1,chcoord;
     221         dbprint(printlevel-voice+2,"// (1 random change of coord.)");
     222         I=simplify(lead(std(phi(i))),1);
     223         attrib(I,"isSB",1);
     224         NPtest=is_NP(I);
     225         if ( NPtest == 1 )
     226         {
     227           break;
     228         }
     229       }
    137230       if ( NPtest == 0 )
    138          {
    139            N=d*n-d*(d-1)/2;
    140            s = "ring rtr = (ch,t(1..N)),x(0..n),dp;";
    141            execute(s);
    142            ideal chcoord,m,i,I;
    143            poly P;
    144            map phi;
    145            i=imap(r1,i);
    146            chcoord=select1(maxideal(1),1,(n-d+1));
    147            acc=0;
    148            for ( ii = 1; ii<=d; ii++ )
    149              {
    150                matrix trex[1][n-d+ii+1]=t((1+acc)..(n-d+ii+acc)),1;
    151                m=select1(maxideal(1),1,(n-d+1+ii));
    152                for ( jj = 1; jj<=n-d+ii+1; jj++ )
    153                  {
    154                    P=P+trex[1,jj]*m[jj];
    155                  }
    156                chcoord[n-d+1+ii]=P;
    157                P=0;
    158                acc=acc+n-d+ii;
    159                kill trex;
    160              }
    161                phi=rtr,chcoord;
    162                I=simplify(lead(std(phi(i))),1);
    163                setring r1;
    164                I=imap(rtr,I);
    165                attrib(I,"isSB",1);
    166          }
    167        else
    168          {
    169            if ( nesttest == 0 )
    170              {
    171                N=d*(d-1)/2;
    172                s = "ring rtr = (ch,t(1..N)),x(0..n),dp;";
    173                execute(s);
    174                ideal chcoord,m,i,I;
    175                poly P;
    176                map phi;
    177                i=imap(r1,i);
    178                chcoord=select1(maxideal(1),1,(n-d+2));
    179                acc=0;
    180                for ( ii = 1; ii<=d-1; ii++ )
    181                  {
    182                    matrix trex[1][ii+1]=t((1+acc)..(ii+acc)),1;
    183                     m=select1(maxideal(1),(n-d+2),(n-d+2+ii));
    184                    for ( jj = 1; jj<=ii+1; jj++ )
    185                      {
    186                        P=P+trex[1,jj]*m[jj];
    187                      }
    188                    chcoord[n-d+2+ii]=P;
    189                    P=0;
    190                    acc=acc+ii;
    191                    kill trex;
    192                  }
    193                phi=rtr,chcoord;
    194                I=simplify(lead(std(phi(i))),1);
    195                setring r1;
    196                I=imap(rtr,I);
    197                attrib(I,"isSB",1);
    198              }
    199          }
    200      }
    201    else
    202      {
    203        if ( NPtest == 0 )
    204          {
    205            while ( nl < 30 )
    206              {
    207                chcoord=select1(maxideal(1),1,(n-d+1));
    208                nl=nl+1;
    209                for ( ii = 1; ii<=d; ii++ )
    210                  {
    211                    ran=random(100,1,n-d+ii);
    212                    ran=intmat(ran,1,n-d+ii+1);
    213                    ran[1,n-d+ii+1]=1;
    214                    m=select1(maxideal(1),1,(n-d+1+ii));
    215                    for ( jj = 1; jj<=n-d+ii+1; jj++ )
    216                      {
    217                        P=P+ran[1,jj]*m[jj];
    218                      }
    219                    chcoord[n-d+1+ii]=P;
    220                    P=0;
    221                  }
    222                phi=r1,chcoord;
    223                dbprint(printlevel-voice+2,"// (1 random change of coord.)");
    224                I=simplify(lead(std(phi(i))),1);
    225                attrib(I,"isSB",1);
    226                NPtest=is_NP(I);
    227                if ( NPtest == 1 )
    228                  {
    229                    break;
    230                  }
    231              }
    232            if ( NPtest == 0 )
    233              {
     231       {
    234232       "// WARNING from proc regIdeal from lib mregular.lib:
    235233// The procedure has entered in 30 loops and could not put the variables
    … …  
    237235// of coordinates may enter an infinite loop when the field is finite.
    238236// Try removing this optional argument.";
    239        return (-1);
    240              }
    241            i=phi(i);
    242            nesttest=is_nested(I);
    243          }
     237         return (-1);
     238       }
     239       i=phi(i);
     240       nesttest=is_nested(I);
     241     }
     242     if ( nesttest == 0 )
     243     {
     244       while ( nl < 30 )
     245       {
     246         chcoord=select1(maxideal(1),1..(n-d+2));
     247         nl=nl+1;
     248         for ( ii = 1; ii<=d-1; ii++ )
     249         {
     250           ran=random(100,1,ii);
     251           ran=intmat(ran,1,ii+1);
     252           ran[1,ii+1]=1;
     253           m=select1(maxideal(1),(n-d+2)..(n-d+2+ii));
     254           for ( jj = 1; jj<=ii+1; jj++ )
     255           {
     256             P=P+ran[1,jj]*m[jj];
     257           }
     258           chcoord[n-d+2+ii]=P;
     259           P=0;
     260         }
     261         phi=r1,chcoord;
     262         dbprint(printlevel-voice+2,"// (1 random change of coord.)");
     263         I=simplify(lead(std(phi(i))),1);
     264         attrib(I,"isSB",1);
     265         nesttest=is_nested(I);
     266         if ( nesttest == 1 )
     267         {
     268           break;
     269         }
     270       }
    244271       if ( nesttest == 0 )
    245          {
    246            while ( nl < 30 )
    247              {
    248                chcoord=select1(maxideal(1),1,(n-d+2));
    249                nl=nl+1;
    250                for ( ii = 1; ii<=d-1; ii++ )
    251                  {
    252                    ran=random(100,1,ii);
    253                    ran=intmat(ran,1,ii+1);
    254                    ran[1,ii+1]=1;
    255                    m=select1(maxideal(1),(n-d+2),(n-d+2+ii));
    256                    for ( jj = 1; jj<=ii+1; jj++ )
    257                      {
    258                        P=P+ran[1,jj]*m[jj];
    259                      }
    260                    chcoord[n-d+2+ii]=P;
    261                    P=0;
    262                  }
    263                phi=r1,chcoord;
    264                dbprint(printlevel-voice+2,"// (1 random change of coord.)");
    265                I=simplify(lead(std(phi(i))),1);
    266                attrib(I,"isSB",1);
    267                nesttest=is_nested(I);
    268                if ( nesttest == 1 )
    269                  {
    270                    break;
    271                  }
    272              }
    273            if ( nesttest == 0 )
    274              {
     272       {
    275273       "// WARNING from proc regIdeal from lib mregular.lib:
    276274// The procedure has entered in 30 loops and could not find a monomial
    … …  
    279277// infinite loop when the field is finite.
    280278// Try removing this optional argument.";
    281        return (-1);
    282              }
    283          }
    284      }
     279         return (-1);
     280       }
     281     }
     282   }
    285283//
    286284// At this stage, we have obtained a monomial ideal I of nested type
    … …  
    289287//----- When S/i is Cohen-Macaulay:
    290288   for ( ii = n-d+2; ii <= n+1; ii++ )
    291      {
    292        K=K+select(I,ii);
    293      }
     289   {
     290     K=K+select(I,ii);
     291   }
    294292   if ( size(K) == 0 )
    295      {
    296        s="ring nr = ",charstr(r0),",x(0..n-d),dp;";
    297        execute(s);
    298        ideal I;
    299        I = imap(r1,I);
    300        H=maxdeg1(minbase(quotient(I,maxideal(1))))+1;
    301        time=rtimer-time;
    302        // Additional information:
    303        dbprint(printlevel-voice+2,
     293   {
     294     s="ring nr = ",charstr(r0),",x(0..n-d),dp;";
     295     execute(s);
     296     ideal I;
     297     I = imap(r1,I);
     298     H=maxdeg1(minbase(quotient(I,maxideal(1))))+1;
     299     time=rtimer-time;
     300     // Additional information:
     301     dbprint(printlevel-voice+2,
    304302               "// S/i is Cohen-Macaulay");
    305        dbprint(printlevel-voice+2,
     303     dbprint(printlevel-voice+2,
    306304               "// Dimension of S/i ( = depth(S/i) ): "+string(d));
    307        dbprint(printlevel-voice+2,
     305     dbprint(printlevel-voice+2,
    308306               "// Regularity attained at the last step of m.g.f.r. of i: YES");
    309        dbprint(printlevel-voice+2,
     307     dbprint(printlevel-voice+2,
    310308               "// Regularity of the Hilbert function of S/i: " + string(H-d));
    311        dbprint(printlevel-voice+2,
     309     dbprint(printlevel-voice+2,
    312310               "// Time for computing regularity: " + string(time) + " sec.");
    313        dbprint(printlevel-voice+2,
     311     dbprint(printlevel-voice+2,
    314312               "// The Castelnuovo-Mumford regularity of i is:");
    315        return(H);
    316      }
     313     return(H);
     314   }
    317315//----- When d=1:
    318316   if ( d == 1 )
    319      {
    320        H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
    321        sat=H;
    322        J=subst(I,x(n),1);
    323        s = "ring nr = ",charstr(r0),",x(0..n-1),dp;";
    324        execute(s);
    325        ideal J=imap(r1,J);
    326        attrib(J,"isSB",1);
    327        h=maxdeg1(minbase(quotient(J,maxideal(1))))+1;
    328        time=rtimer-time;
    329        if ( h > H )
    330          {
    331            H=h;
    332          }
    333        // Additional information:
    334        dbprint(printlevel-voice+2,
     317   {
     318     H=maxdeg1(simplify(reduce(quotient(I,maxideal(1)),I),2))+1;
     319     sat=H;
     320     J=subst(I,x(n),1);
     321     s = "ring nr = ",charstr(r0),",x(0..n-1),dp;";
     322     execute(s);
     323     ideal J=imap(r1,J);
     324     attrib(J,"isSB",1);
     325     h=maxdeg1(minbase(quotient(J,maxideal(1))))+1;
     326     time=rtimer-time;
     327     if ( h > H )
     328     {
     329       H=h;
     330     }
     331     // Additional information:
     332     dbprint(printlevel-voice+2,
    335333               "// Dimension of S/i: 1");
    336        dbprint(printlevel-voice+2,
     334     dbprint(printlevel-voice+2,
    337335               "// Depth of S/i: 0");
    338        dbprint(printlevel-voice+2,
     336     dbprint(printlevel-voice+2,
    339337               "// Satiety of i: "+string(sat));
    340        dbprint(printlevel-voice+2,
     338     dbprint(printlevel-voice+2,
    341339               "// Upper bound for the a-invariant of S/i: end(H^1(S/i)) <= "+
    342340               string(h-2));
    343        if ( H == sat )
    344          {
    345            dbprint(printlevel-voice+2,
     341     if ( H == sat )
     342     {
     343       dbprint(printlevel-voice+2,
    346344                   "// Regularity attained at the last step of m.g.f.r. of i: YES");
    347            dbprint(printlevel-voice+2,
     345       dbprint(printlevel-voice+2,
    348346                   "// Regularity of the Hilbert function of S/i: "+string(H));
    349          }
    350        else
    351          {
    352            dbprint(printlevel-voice+2,
     347     }
     348     else
     349     {
     350       dbprint(printlevel-voice+2,
    353351                   "// Regularity attained at the last step of m.g.f.r. of i: NO");
    354          }
    355            dbprint(printlevel-voice+2,
     352     }
     353     dbprint(printlevel-voice+2,
    356354                   "// Time for computing regularity: "+ string(time) + " sec.");
    357            dbprint(printlevel-voice+2,
     355     dbprint(printlevel-voice+2,
    358356                   "// The Castelnuovo-Mumford regularity of i is:");
    359            return(H);
    360      }
     357     return(H);
     358   }
    361359//----- Now d>1 and S/i is not Cohen-Macaulay:
    362360//
    363361//----- First, determine the last variable really occuring
    364        lastv=n-d;
    365        h=n;
    366        while ( lastv == n-d and h > n-d )
    367          {
    368            K=select(I,h+1);
    369            if ( size(K) == 0 )
    370              {
    371                h=h-1;
    372              }
    373            else
    374              {
    375                lastv=h;
    376              }
    377          }
     362   lastv=n-d;
     363   h=n;
     364   while ( lastv == n-d and h > n-d )
     365   {
     366     K=select(I,h+1);
     367     if ( size(K) == 0 )
     368     {
     369       h=h-1;
     370     }
     371     else
     372     {
     373       lastv=h;
     374     }
     375   }
    378376//----- and compute Castelnuovo-Mumford regularity:
    379        s = "ring nr = ",charstr(r0),",x(0..lastv),dp;";
    380        execute(s);
    381        ideal I,K,KK,LL;
    382        I=imap(r1,I);
    383        attrib(I,"isSB",1);
    384        K=simplify(reduce(quotient(I,maxideal(1)),I),2);
    385        H=maxdeg1(K)+1;
    386        firstind=H;
    387        KK=minbase(subst(I,x(lastv),1));
    388        for ( ii = n-lastv; ii<=d-2; ii++ )
    389          {
    390            LL=minbase(subst(I,x(n-ii-1),1));
    391            attrib(LL,"isSB",1);
    392            s = "ring mr = ",charstr(r0),",x(0..n-ii-1),dp;";
    393            execute(s);
    394            ideal K,KK;
    395            KK=imap(nr,KK);
    396            attrib(KK,"isSB",1);
    397            K=simplify(reduce(quotient(KK,maxideal(1)),KK),2);
    398            h=maxdeg1(K)+1;
    399            if ( h > H )
    400              {
    401                H=h;
    402              }
    403            setring nr;
    404            kill mr;
    405            KK=LL;
    406          }
    407        // We must determine one more sat. index:
    408        s = "ring mr = ",charstr(r0),",x(0..n-d),dp;";
    409        execute(s);
    410        ideal KK,K;
    411        KK=imap(nr,KK);
    412        attrib(KK,"isSB",1);
    413        K=simplify(reduce(quotient(KK,maxideal(1)),KK),2);
    414        h=maxdeg1(K)+1;
    415        lastind=h;
    416        if ( h > H )
    417          {
    418            H=h;
    419          }
    420        setring nr;
    421        kill mr;
    422        time=rtimer-time;
    423        // Additional information:
    424        dbprint(printlevel-voice+2,
     377   s = "ring nr = ",charstr(r0),",x(0..lastv),dp;";
     378   execute(s);
     379   ideal I,K,KK,LL;
     380   I=imap(r1,I);
     381   attrib(I,"isSB",1);
     382   K=simplify(reduce(quotient(I,maxideal(1)),I),2);
     383   H=maxdeg1(K)+1;
     384   firstind=H;
     385   KK=minbase(subst(I,x(lastv),1));
     386   for ( ii = n-lastv; ii<=d-2; ii++ )
     387   {
     388     LL=minbase(subst(I,x(n-ii-1),1));
     389     attrib(LL,"isSB",1);
     390     s = "ring mr = ",charstr(r0),",x(0..n-ii-1),dp;";
     391     execute(s);
     392     ideal K,KK;
     393     KK=imap(nr,KK);
     394     attrib(KK,"isSB",1);
     395     K=simplify(reduce(quotient(KK,maxideal(1)),KK),2);
     396     h=maxdeg1(K)+1;
     397     if ( h > H )
     398     {
     399       H=h;
     400     }
     401     setring nr;
     402     kill mr;
     403     KK=LL;
     404   }
     405   // We must determine one more sat. index:
     406   s = "ring mr = ",charstr(r0),",x(0..n-d),dp;";
     407   execute(s);
     408   ideal KK,K;
     409   KK=imap(nr,KK);
     410   attrib(KK,"isSB",1);
     411   K=simplify(reduce(quotient(KK,maxideal(1)),KK),2);
     412   h=maxdeg1(K)+1;
     413   lastind=h;
     414   if ( h > H )
     415   {
     416     H=h;
     417   }
     418   setring nr;
     419   kill mr;
     420   time=rtimer-time;
     421   // Additional information:
     422   dbprint(printlevel-voice+2,
    425423               "// Dimension of S/i: "+string(d));
    426        dbprint(printlevel-voice+2,
     424   dbprint(printlevel-voice+2,
    427425               "// Depth of S/i: "+string(n-lastv));
    428        dbprint(printlevel-voice+2,
     426   dbprint(printlevel-voice+2,
    429427               "// end(H^"+string(n-lastv)+"(S/i)) = "
    430428               +string(firstind-n+lastv-1));
    431        dbprint(printlevel-voice+2,
     429   dbprint(printlevel-voice+2,
    432430               "// Upper bound for the a-invariant of S/i: end(H^"
    433431               +string(d)+"(S/i)) <= "+string(lastind-d-1));
    434        if ( H == firstind )
    435          {
    436            dbprint(printlevel-voice+2,
     432   if ( H == firstind )
     433   {
     434     dbprint(printlevel-voice+2,
    437435                   "// Regularity attained at the last step of m.g.f.r. of i: YES");
    438            dbprint(printlevel-voice+2,
     436     dbprint(printlevel-voice+2,
    439437                   "// Regularity of the Hilbert function of S/i: "
    440438                   +string(H-n+lastv));
    441          }
    442        else
    443          {
    444            dbprint(printlevel-voice+2,
     439   }
     440   else
     441   {
     442     dbprint(printlevel-voice+2,
    445443                   "// Regularity attained at the last step of m.g.f.r. of i: NO");
    446          }
    447        dbprint(printlevel-voice+2,
     444   }
     445   dbprint(printlevel-voice+2,
    448446               "// Time for computing regularity: "+ string(time) + " sec.");
    449        dbprint(printlevel-voice+2,
     447   dbprint(printlevel-voice+2,
    450448               "// The Castelnuovo-Mumford regularity of i is:");
    451        return(H);
     449   return(H);
    452450}
    453451example
    … …  
    648646           map phi;
    649647           i=imap(r1,i);
    650            chcoord=select1(maxideal(1),1,(n-d+1));
     648           chcoord=select1(maxideal(1),1..(n-d+1));
    651649           acc=0;
    652650           for ( ii = 1; ii<=d; ii++ )
    653651             {
    654652               matrix trex[1][n-d+ii+1]=t((1+acc)..(n-d+ii+acc)),1;
    655                m=select1(maxideal(1),1,(n-d+1+ii));
     653               m=select1(maxideal(1),1..(n-d+1+ii));
    656654               for ( jj = 1; jj<=n-d+ii+1; jj++ )
    657655                 {
    … …  
    680678               map phi;
    681679               i=imap(r1,i);
    682                chcoord=select1(maxideal(1),1,(n-d+2));
     680               chcoord=select1(maxideal(1),1..(n-d+2));
    683681               acc=0;
    684682               for ( ii = 1; ii<=d-1; ii++ )
    685683                 {
    686684                   matrix trex[1][ii+1]=t((1+acc)..(ii+acc)),1;
    687                     m=select1(maxideal(1),(n-d+2),(n-d+2+ii));
     685                    m=select1(maxideal(1),(n-d+2)..(n-d+2+ii));
    688686                   for ( jj = 1; jj<=ii+1; jj++ )
    689687                     {
    … …  
    709707           while ( nl < 30 )
    710708             {
    711                chcoord=select1(maxideal(1),1,(n-d+1));
     709               chcoord=select1(maxideal(1),1..(n-d+1));
    712710               nl=nl+1;
    713711               for ( ii = 1; ii<=d; ii++ )
    … …  
    716714                   ran=intmat(ran,1,n-d+ii+1);
    717715                   ran[1,n-d+ii+1]=1;
    718                    m=select1(maxideal(1),1,(n-d+1+ii));
     716                   m=select1(maxideal(1),1..(n-d+1+ii));
    719717                   for ( jj = 1; jj<=n-d+ii+1; jj++ )
    720718                     {
    … …  
    750748           while ( nl < 30 )
    751749             {
    752                chcoord=select1(maxideal(1),1,(n-d+2));
     750               chcoord=select1(maxideal(1),1..(n-d+2));
    753751               nl=nl+1;
    754752               for ( ii = 1; ii<=d-1; ii++ )
    … …  
    757755                   ran=intmat(ran,1,ii+1);
    758756                   ran[1,ii+1]=1;
    759                    m=select1(maxideal(1),(n-d+2),(n-d+2+ii));
     757                   m=select1(maxideal(1),(n-d+2)..(n-d+2+ii));
    760758                   for ( jj = 1; jj<=ii+1; jj++ )
    761759                     {
    … …  
    10301028           while ( nl < 30 )
    10311029             {
    1032                chcoord=select1(maxideal(1),1,(n-d+1));
     1030               chcoord=select1(maxideal(1),1..(n-d+1));
    10331031               nl=nl+1;
    10341032               for ( ii = 1; ii<=d; ii++ )
    … …  
    10371035                   ran=intmat(ran,1,n-d+ii+1);
    10381036                   ran[1,n-d+ii+1]=1;
    1039                    m=select1(maxideal(1),1,(n-d+1+ii));
     1037                   m=select1(maxideal(1),1..(n-d+1+ii));
    10401038                   for ( jj = 1; jj<=n-d+ii+1; jj++ )
    10411039                     {
    … …  
    10711069           while ( nl < 30 )
    10721070             {
    1073                chcoord=select1(maxideal(1),1,(n-d+2));
     1071               chcoord=select1(maxideal(1),1..(n-d+2));
    10741072               nl=nl+1;
    10751073               for ( ii = 1; ii<=d-1; ii++ )
    … …  
    10781076                   ran=intmat(ran,1,ii+1);
    10791077                   ran[1,ii+1]=1;
    1080                    m=select1(maxideal(1),(n-d+2),(n-d+2+ii));
     1078                   m=select1(maxideal(1),(n-d+2)..(n-d+2+ii));
    10811079                   for ( jj = 1; jj<=ii+1; jj++ )
    10821080                     {
    … …  
    15361534   while ( nl < 30 )
    15371535   {
    1538      chcoord=select1(maxideal(1),1,(n-d+1));
     1536     chcoord=select1(maxideal(1),1..(n-d+1));
    15391537     nl=nl+1;
    15401538     for ( ii = 1; ii<=d; ii++ )
    … …  
    15431541       ran=intmat(ran,1,n-d+ii+1);
    15441542       ran[1,n-d+ii+1]=1;
    1545        m=select1(maxideal(1),1,(n-d+1+ii));
     1543       m=select1(maxideal(1),1..(n-d+1+ii));
    15461544       for ( jj = 1; jj<=n-d+ii+1; jj++ )
    15471545       {

  • Singular/LIB/noether.lib

    r100025 rc99fd4  
    11// AH last modified:  01.07.2007
    22//////////////////////////////////////////////////////////////////////////////
    3 version = "$Id: noether.lib,v 1.10 2008-04-11 14:04:40 Singular Exp $";
     3version = "$Id: noether.lib,v 1.11 2008-10-06 17:04:28 Singular Exp $";
    44category="Commutative Algebra";
    55info="
    … …  
    199199    for ( ii = n; ii>=0; ii-- )
    200200    {
    201       chcoord=select1(maxideal(1),1,(ii));
     201      chcoord=select1(maxideal(1),1..ii);
    202202      ran=random(100,1,ii);
    203203      ran=intmat(ran,1,ii+1);
    204204      ran[1,ii+1]=1;
    205       m=select1(maxideal(1),1,(ii+1));
     205      m=select1(maxideal(1),1..(ii+1));
    206206      for ( jj = 1; jj<=ii+1; jj++ )
    207207      {
    … …  
    279279     for ( ii = n; ii>=0; ii-- )
    280280     {
    281        chcoord=select1(maxideal(1),1,(ii));
     281       chcoord=select1(maxideal(1),1..ii);
    282282       ran=random(100,1,ii);
    283283       ran=intmat(ran,1,ii+1);
    284284       ran[1,ii+1]=1;
    285        m=select1(maxideal(1),1,(ii+1));
     285       m=select1(maxideal(1),1..(ii+1));
    286286       for ( jj = 1; jj<=ii+1; jj++ )
    287287       {
    … …  
    384384  {
    385385    nl=nl+1;
    386     chcoord=select1(maxideal(1),1,(n));
     386    chcoord=select1(maxideal(1),1..n);
    387387    ran=random(100,1,n);
    388388    ran=intmat(ran,1,n+1);
    389389    ran[1,n+1]=1;
    390     m=select1(maxideal(1),1,(n+1));
     390    m=select1(maxideal(1),1..(n+1));
    391391    for ( jj = 1; jj<=n+1; jj++ )
    392392    {
    … …  
    479479  {
    480480    nl=nl+1;
    481     chcoord=select1(maxideal(1),1,(n));
     481    chcoord=select1(maxideal(1),1..n);
    482482    ran=random(100,1,n);
    483483    ran=intmat(ran,1,n+1);
    484484    ran[1,n+1]=1;
    485     m=select1(maxideal(1),1,(n+1));
     485    m=select1(maxideal(1),1..(n+1));
    486486    for ( jj = 1; jj<=n+1; jj++ )
    487487    {

  • Singular/LIB/reszeta.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: reszeta.lib,v 1.11 2007-02-24 15:15:26 Singular Exp $";
     2version="$Id: reszeta.lib,v 1.12 2008-10-06 17:04:28 Singular Exp $";
    33category="Commutative Algebra";
    44info="
    … …  
    35423542//--- refine the comparison by passing to each of the numerical zeros
    35433543//--- of the two minpolys
    3544   ideal stid=nselect(interId,1,nvars(R));
     3544  ideal stid=nselect(interId,1..nvars(R));
    35453545  ring compl_st=complex,(s,t),dp;
    35463546  def stid=imap(S,stid);

  • Singular/LIB/rinvar.lib

    r100025 rc99fd4  
    11// Last change 10.12.2000 (TB)
    22///////////////////////////////////////////////////////////////////////////////
    3 version="$Id: rinvar.lib,v 1.16 2006-07-18 15:22:15 Singular Exp $";
     3version="$Id: rinvar.lib,v 1.17 2008-10-06 17:04:28 Singular Exp $";
    44category="Invariant theory";
    55info="
    … …  
    146146  I2 = G, I1;
    147147  I2 = std(I2);
    148   Gn = nselect(I2, 1, nvars(RIGB));
     148  Gn = nselect(I2, 1.. nvars(RIGB));
    149149  imageSize = ncols(Gn);
    150150
    … …  
    329329  // forget all elements which contain other than the slack variables
    330330
    331   J2 = nselect(J1, 1, nvars(RARB));
     331  J2 = nselect(J1, 1.. nvars(RARB));
    332332
    333333  execute(ringSTR2);
    … …  
    904904  // eliminate
    905905
    906   N = nselect(J, 1, groupVars);
     906  N = nselect(J, 1.. groupVars);
    907907
    908908  // substitute

  • Singular/LIB/sagbi.lib

    r100025 rc99fd4  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="$Id: sagbi.lib,v 1.11 2007-07-13 12:31:06 Singular Exp $";
     2version="$Id: sagbi.lib,v 1.12 2008-10-06 17:04:28 Singular Exp $";
    33category="Commutative Algebra";
    44info="
    … …  
    8383
    8484    A=groebner(A);
    85     ideal kern=nselect(A,1,n);// "kern" is the kernel of the ring map:
     85    ideal kern=nselect(A,1..n);// "kern" is the kernel of the ring map:
    8686                        // R1----->bsr ;y(z)----> lead(id[z]).
    8787                        //"kern" is the ideal of algebraic relations between
    … …  
    216216                            // to A to get std(A1).
    217217    A=A+@Res;
    218     kern1=nselect(@Res,1,n);
     218    kern1=nselect(@Res,1..n);
    219219    kern=kern+kern1;
    220220    export kern,kern1,A;
    … …  
    342342    if(choose==2)
    343343    {
    344       ideal kern= nselect(groebner(dom),1,n);//"nselect" is combinatorial command
     344      ideal kern= nselect(groebner(dom),1..n);//"nselect" is combinatorial command
    345345                                         //which uses the internal command
    346346                                         // "simplify"

  • Singular/LIB/standard.lib

    r100025 rc99fd4  
    33//groebner mit Optionen versehen
    44//////////////////////////////////////////////////////////////////////////////
    5 version="$Id: standard.lib,v 1.101 2008-01-28 11:42:30 Singular Exp $";
     5version="$Id: standard.lib,v 1.102 2008-10-06 17:04:28 Singular Exp $";
    66category="Miscellaneous";
    77info="
    … …  
    824824
    825825  def P=basering;
    826   if ((typeof(i_par)=="vector")||(typeof(i_par)=="module")) {module i=i_par;}
    827   else {ideal i=i_par; }
     826  if ((typeof(i_par)=="vector")||(typeof(i_par)=="module")||(typeof(i_par)=="matrix")) {module i=i_par;}
     827  else {ideal i=i_par; } // int, poly, number, ideal
    828828  kill i_par;
    829829
    … …  
    13461346      string ri= "ring Phelp ="
    13471347                  +string(char(P))+",("+varstr_P+"),(dp,C);";
     1348      ri = ri + "minpoly = "+string(minpoly) + ";";
    13481349      execute(ri);
    13491350      def m=imap(P,m);
    … …  
    13611362      string ri= "ring Phelp ="
    13621363                  +string(char(P))+",("+varstr_P+"),(ls,c);";
     1364      ri = ri + "minpoly = "+string(minpoly) + ";";
    13631365      execute(ri);
    13641366      def m=imap(P,m);
    … …  
    13741376   string ri= "ring Phelp ="
    13751377                  +string(char(P))+",("+varstr_P+"),(ls,C);";
     1378   ri = ri + "minpoly = "+string(minpoly) + ";";
    13761379   execute(ri);
    13771380   def m=imap(P,m);
Note: See TracChangeset for help on using the changeset viewer.