Changeset 52d301 in git for Singular


Ignore:
Timestamp:
Nov 4, 2022, 1:41:50 PM (18 months ago)
Author:
Hans Schoenemann <hannes@…>
Branches:
(u'spielwiese', '17f1d200f27c5bd38f5dfc6e8a0879242279d1d8')
Children:
4969bd84679f00e0090770de53eae064004f1330
Parents:
4c83c9834db9cbdfc54c7e750ea85bc9df089d8e
Message:
chg: ringlist -> ring_list if possible
Location:
Singular/LIB
Files:
6 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/normal.lib

    r4c83c98 r52d301  
    277277  {
    278278    // We change to dp ordering.
    279     list rl = ringlist(origR);
     279    list rl = ring_list(origR);
    280280    list origOrd = rl[3];
    281281    list newOrd = list("dp", intvec(1:nvars(origR))), list("C", 0);
    … …  
    298298      // We define anyway a new ring, equal to R, to be able to return it.
    299299      setring origR;
    300       list lR = ringlist(origR);
     300      list lR = ring_list(origR);
    301301      def ROut = ring(lR);
    302302      setring ROut;
    … …  
    422422        savebasering=basering;
    423423        setring newR; // must be in a compatible ring to newR
    424                       // as ringlist may produce ring-dep. stuff
     424                      // as ring_list may produce ring-dep. stuff
    425425        if(!defined(newRList)) { list newRList;}
    426         newRList = ringlist(newR);
     426        newRList = ring_list(newR);
    427427        setring savebasering;
    428428        U = norComp[j][1];
    … …  
    908908  else
    909909  {
    910     list RL = ringlist(newRing);
     910    list RL = ring_list(newRing);
    911911    def lastRing = ring(RL);
    912912    setring lastRing;
    … …  
    11761176   int ti=timer;
    11771177
    1178    gnirlist = ringlist(BAS);
     1178   gnirlist = ring_list(BAS);
    11791179
    11801180//----------- the trivial case of a zero ideal as input, RETURN ------------
    … …  
    23242324   {
    23252325     list newvar=N[1..ncols(N)];
    2326      list @rl0=ringlist(R0);
     2326     list @rl0=ring_list(R0);
    23272327     @rl0[2]=list(N[1..ncols(N)]);
    23282328     @rl0[3]=list(list("dp",1:ncols(N)),list("C",0));
    … …  
    23302330     setring R;
    23312331     ideal I =imap(R0,I);
    2332      list @rl0=ringlist(R0);
     2332     list @rl0=ring_list(R0);
    23332333     if((@rl0[3][1][1]=="dp")&&(size(@rl0[3])==2))
    23342334     {
    … …  
    23542354   else
    23552355   {
    2356      list @rl0=ringlist(R0);
     2356     list @rl0=ring_list(R0);
    23572357     if(dim(I)==0)
    23582358     {
    … …  
    26952695   option(redSB);
    26962696   def R=basering;
    2697    list @rl=ringlist(R);
     2697   list @rl=ring_list(R);
    26982698   @rl[2]=list("x","y");
    26992699   @rl[3]=list(list("lp",1:2),list("C",0));
    … …  
    29872987
    29882988  int dblvl = printlevel-voice+2;
    2989   list gnirlist = ringlist(basering);
     2989  list gnirlist = ring_list(basering);
    29902990
    29912991  //---- Some auxiliary variables:
    … …  
    30123012  {
    30133013      def R = L[1];
    3014       list Rlist = ringlist(R);
     3014      list Rlist = ring_list(R);
    30153015      def BAS = basering;
    30163016      setring R;
    … …  
    30223022      ker=simplify(interred(ker),15);
    30233023      // Rlist may be not defined in this new ring, so we define it again.
    3024       list Rlist2 = ringlist(R);
     3024      list Rlist2 = ring_list(R);
    30253025      def R0 = ring(Rlist2);
    30263026      setring R0;
    … …  
    33233323          {
    33243324             //### noch abfragen ob Z(i) definiert ist
    3325              list gnirlist = ringlist(R(k));
     3325             list gnirlist = ring_list(R(k));
    33263326             n2 = size(gnirlist[2]);
    33273327             n3 = size(gnirlist[3]);
    … …  
    35003500        {
    35013501         //### noch abfragen ob Z(i) definiert ist
    3502          list gnirlist = ringlist(R(k));
     3502         list gnirlist = ring_list(R(k));
    35033503         n2 = size(gnirlist[2]);
    35043504         n3 = size(gnirlist[3]);
    … …  
    37333733       result[2]=result[1];
    37343734       def BR = basering;
    3735        list rl = ringlist(basering);
     3735       list rl = ring_list(basering);
    37363736       def rng = ring(rl);
    37373737       setring rng;
    … …  
    40454045   }
    40464046
    4047       list gnirlist = ringlist(basering);
     4047      list gnirlist = ring_list(basering);
    40484048      endid = Le[1];
    40494049//endphi;"";
    … …  
    41944194  def R = basering;
    41954195  poly c = J[1];                     // the denominator
    4196   list gnirlist = ringlist(basering);
     4196  list gnirlist = ring_list(basering);
    41974197  string svars = varstr(basering);
    41984198  int nva = nvars(basering);
    … …  
    45384538      // We define anyway a new ring, equal to R, to be able to return it.
    45394539      setring R;
    4540       list lR = ringlist(R);
     4540      list lR = ring_list(R);
    45414541      def ROut = ring(lR);
    45424542      setring ROut;
    … …  
    46694669    {
    46704670      // We change to global dp ordering.
    4671       list rl = ringlist(R);
     4671      list rl = ring_list(R);
    46724672      list origOrd = rl[3];
    46734673      list newOrd = list("dp", intvec(1:nvars(R))), list("C", 0);
    … …  
    48714871      // We define anyway a new ring, equal to R, to be able to return it.
    48724872      setring R;
    4873       list lR = ringlist(R);
     4873      list lR = ring_list(R);
    48744874      def ROut = ring(lR);
    48754875      setring ROut;
    … …  
    50655065
    50665066  def R = basering;
    5067   list RL = ringlist(R);
     5067  list RL = ring_list(R);
    50685068  // We keep everything from R but we change the ordering to lp, and we
    50695069  // order the variables as needed.
    … …  
    52195219  if(isGlobal != 1)
    52205220  {
    5221     list rl = ringlist(origEre);
     5221    list rl = ring_list(origEre);
    52225222    list origOrd = rl[3];
    52235223    list newOrd = list("dp", intvec(1:nvars(origEre))), list("C", 0);
    … …  
    67836783
    67846784    //--------- create new ring with one dp block keeping weights ------------
    6785     list LR = ringlist(R);
     6785    list LR = ring_list(R);
    67866786    list g3 = LR[3];
    67876787    int n3 = size(g3);
    … …  
    71647164//### minor verbessern
    71657165//### preimage verbessern (Ist imm Kern map oder imap verwendet?)
    7166 //### Gleich in Ordnung dp wechseln, ringlist verwenden
     7166//### Gleich in Ordnung dp wechseln, ring_list verwenden
    71677167//### interred ev nur zum Schluss
    71687168//    (z.B. wenn nacher std; wenn nacher minor: testen )

  • Singular/LIB/paraplanecurves.lib

    r4c83c98 r52d301  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="version paraplanecurves.lib 4.1.2.0 Feb_2019 "; // $Id$
     2version="version paraplanecurves.lib 4.3.2.2 Nov_2022 "; // $Id$
    33category="Algebraic Geometry";
    44info="
    … …  
    130130   int m = size(phi);
    131131   /*phi: P^(n-1) --> P^(m-1)*/
    132    list rl = ringlist(Roriginal);
     132   list rl = ring_list(Roriginal);
    133133   int k;
    134134   for(k = 1; k <= n; k++)
    … …  
    174174     }
    175175    relpsi = compress(relpsi);
    176     list rl = ringlist(Rbig);
     176    list rl = ring_list(Rbig);
    177177    list rl2 = rl[2];
    178178    rl[2] = list(rl2[n+1..n+m]);
    … …  
    300300  /*checking assumptions and handling the conic case*/
    301301  checkAssumptions(f);
    302   list rl = ringlist(Roriginal);
     302  list rl = ring_list(Roriginal);
    303303  rl[2] = list("x","y","z");
    304304  rl[3] = list(list("dp",1:3),list("C",0));
    … …  
    349349      def rp1 = invertBirMap(PROJ,If); // ring containing ideal psi
    350350      setring rp1;
    351       list rl1 = ringlist(rp1);
     351      list rl1 = ring_list(rp1);
    352352      rl1[2] = list("s","t");
    353353      def RP1 = ring(rl1);
    … …  
    391391  def rp1 = invertBirMap(PROJ,If); // (ring, (J,psi))
    392392  setring rp1;
    393   list rl1 = ringlist(rp1);
     393  list rl1 = ring_list(rp1);
    394394  rl1[2] = list("s","t");
    395395  def RP1 = ring(rl1);
    … …  
    630630{
    631631  def Roriginal = basering;
    632   list rl = ringlist(Roriginal);
     632  list rl = ring_list(Roriginal);
    633633  rl[3] = list(list("dp",1:nvars(Roriginal)),list("C",0));
    634634  def RP2 = ring(rl);
    … …  
    663663  }
    664664  int j,k;
    665   list rl = ringlist(RP2);
     665  list rl = ring_list(RP2);
    666666  rl[2] = list(var(1), var(2));
    667667  rl[3] = list(list("dp",1:2),list("C",0));
    … …  
    794794  poly dhf = subst(f,var(3),1);
    795795  def Roriginal = basering;
    796   list rl = ringlist(Roriginal);
     796  list rl = ring_list(Roriginal);
    797797  rl[2] = list(var(1), var(2));
    798798  rl[3] = list(list("dp",1:2),list("C",0));
    … …  
    803803  list DATA = imap(Roriginal,choices);
    804804  /* Creating rings for later use */
    805   list rl = ringlist(Rdummy);
     805  list rl = ring_list(Rdummy);
    806806  rl[2] = list(var(2), var(1));
    807807  rl[3] = list(list("lp",1:2),list("C",0));
    808808  def Rred = ring(rl);   // make var(2) > var(1)
    809   rl = ringlist(Rdummy);
     809  rl = ring_list(Rdummy);
    810810  rl[1] = list(0,list(var(1)),list(list("dp",1)),ideal(0));
    811811  rl[2] = list(var(2));
    … …  
    901901  poly dhf = subst(f,var(3),1);
    902902  def Roriginal = basering;
    903   list rl = ringlist(Roriginal);
     903  list rl = ring_list(Roriginal);
    904904  rl[2] = list(var(1), var(2));
    905905  rl[3] = list(list("dp",1:2),list("C",0));
    … …  
    955955   def Roriginal = basering;
    956956   ideal IC = f;
    957    list rl = ringlist(Roriginal);
     957   list rl = ring_list(Roriginal);
    958958   /* begin workaround elimination*/
    959959   for(k = 1; k <= 3; k++)
    … …  
    979979   intvec HJ = hilb(SJ,1);
    980980   ideal RNC = eliminate(J,x(1)*x(2)*x(3),HJ);
    981    list rl = ringlist(Relim);
     981   list rl = ring_list(Relim);
    982982   list rl2 = rl[2];
    983983   rl[2] = list(rl2[4..n+3]);
    … …  
    10231023{
    10241024  def Roriginal = basering;
    1025   list rl = ringlist(Roriginal);
     1025  list rl = ring_list(Roriginal);
    10261026  rl[3] = list(list("dp",1:nvars(Roriginal)),list("C",0));
    10271027  def RoriginalDP = ring(rl);
    … …  
    10691069  if((n mod 2) == 1){ERROR("Pn has even dimension");}
    10701070  def Roriginal = basering;
    1071   list rlo = ringlist(Roriginal);
     1071  list rlo = ring_list(Roriginal);
    10721072  rlo[3]= list(list("dp",1:n),list("C",0));
    10731073  int k;
    … …  
    10941094     {
    10951095        ideal PR = rncAntiCanonicalMap(J);
    1096         list rl = ringlist(Rold);
     1096        list rl = ring_list(Rold);
    10971097        Rbig = Rold + RoriginalCopy;
    10981098        setring Rbig;
    … …  
    11331133        HJJ = hilb(SJJ,1);
    11341134        J = eliminate(JJ,pvar,HJJ);
    1135         list rl = ringlist(Relim);
     1135        list rl = ring_list(Relim);
    11361136        rl2 = rl[2];
    11371137        rl[2] = list(rl2[n+1..2*n-2]);
    … …  
    11851185  if((n mod 2) == 0){ERROR("Pn has odd dimension");}
    11861186  def Roriginal = basering;
    1187   list rlo = ringlist(Roriginal);
     1187  list rlo = ring_list(Roriginal);
    11881188  rlo[3]= list(list("dp",1:n),list("C",0));
    11891189  int k;
    … …  
    12101210     {
    12111211        ideal PR = rncAntiCanonicalMap(J);
    1212         list rl = ringlist(Rold);
     1212        list rl = ring_list(Rold);
    12131213        Rbig = Rold + RoriginalCopy;
    12141214        setring Rbig;
    … …  
    12491249        HJJ = hilb(SJJ,1);
    12501250        J = eliminate(JJ,pvar,HJJ);
    1251         list rl = ringlist(Relim);
     1251        list rl = ring_list(Relim);
    12521252        rl2 = rl[2];
    12531253        rl[2] = list(rl2[n+1..2*n-2]);
    … …  
    13081308  poly dhf = subst(f,var(3),1);
    13091309  def Roriginal = basering;
    1310   list rl = ringlist(Roriginal);
     1310  list rl = ring_list(Roriginal);
    13111311  rl[2] = list(var(1), var(2));
    13121312  rl[3] = list(list("dp",1:2),list("C",0));
    … …  
    18001800  def rp1 = invertBirMap(Ipoint, ideal(fetch(Roriginal,q)));
    18011801  setring rp1;
    1802   list rl = ringlist(rp1);
     1802  list rl = ring_list(rp1);
    18031803  rl[2] = list("s","t");
    18041804  def RP1 = ring(rl);
    … …  
    18481848{
    18491849  def Roriginal = basering;
    1850   list rl = ringlist(Roriginal);
     1850  list rl = ring_list(Roriginal);
    18511851  rl[3] = list(list("dp",1:3),list("C",0));
    18521852  def RP20 = ring(rl);
    … …  
    18581858                                     //  field
    18591859  setring RP21;
    1860   list rl1 = ringlist(RP21);
     1860  list rl1 = ring_list(RP21);
    18611861  rl1[2] = list("u","v","w");
    18621862  rl1[3] = list(list("dp",1:3),list("C",0));
    … …  
    23812381  /* X^2 + br*bs^2*Y^2 + cr*cs^2*Z^2 = 0 */
    23822382  def bRing = basering;
    2383   list L = ringlist(bRing);
     2383  list L = ring_list(bRing);
    23842384
    23852385  if (b != 0)
    … …  
    26892689  /* begin workaround elimination*/
    26902690  int k;
    2691   list rl = ringlist(rTT);
     2691  list rl = ring_list(rTT);
    26922692  rl[2] = list("s","t","x","y","z");
    26932693  rl[3]= list(list("dp",1:5),list("C",0));

  • Singular/LIB/primdecint.lib

    r4c83c98 r52d301  
    11//////////////////////////////////////////////////////////////////////////////
    2 version="version primdecint.lib 4.1.2.0 Feb_2019 "; // $Id$
     2version="version primdecint.lib 4.3.2.2 Nov_2022 "; // $Id$
    33category = "Commutative Algebra";
    44info="
    … …  
    8383   def R=basering;
    8484   number s;
    85    list rl=ringlist(R);
     85   list rl=ring_list(R);
    8686   int i,j,p,m,ex,nu,k_link;
    8787   list P,B,IS;
    … …  
    415415   ideal K;
    416416   def R=basering;
    417    list rl=ringlist(R);
     417   list rl=ring_list(R);
    418418   int i,j,p,m;
    419419   list P,B;
    … …  
    552552   ideal K=1;
    553553   def R=basering;
    554    list rl=ringlist(R);
     554   list rl=ring_list(R);
    555555   int i,j,p,m;
    556556   list P;
    … …  
    645645   ideal K=1;
    646646   def R=basering;
    647    list rl=ringlist(R);
     647   list rl=ring_list(R);
    648648   int i,j,p,m;
    649649   list P;
    … …  
    750750   def R=basering;
    751751   bigint s;
    752    list rl=ringlist(R);
     752   list rl=ring_list(R);
    753753   int i,j,p,m,ex;
    754754   list P,IS,B;
    … …  
    963963//=== decomposition (else) of J in Z/p and maps the result back to the basering
    964964   def R = basering;
    965    list rp = ringlist(R);
     965   list rp = ring_list(R);
    966966   rp[1] = p;
    967967   def Rp = ring(rp);
    … …  
    11151115         ideal I=imap(R,I);
    11161116         I=stdZ(I);
    1117          list rl=ringlist(S);
     1117         list rl=ring_list(S);
    11181118         rl[1]=0;
    11191119         def Shelp =ring(rl);
    … …  
    11651165            C[i+1]=I[i];
    11661166         }
    1167          list rl=ringlist(R);
     1167         list rl=ring_list(R);
    11681168         rl[1]=0;
    11691169         def Shelp =ring(rl);
    … …  
    13991399   if(size(B)==1){return(M);}
    14001400   I=std(I);
    1401    list rl=ringlist(R);
     1401   list rl=ring_list(R);
    14021402   if(deg(I[1])==0)
    14031403   {
    … …  
    14381438         module I=imap(R,I);
    14391439         I=std(I);
    1440          list rl=ringlist(S);
     1440         list rl=ring_list(S);
    14411441         rl[1]=0;
    14421442         def Shelp =ring(rl);
    … …  
    14701470            C[i]=I[i];
    14711471         }
    1472          list rl=ringlist(R);
     1472         list rl=ring_list(R);
    14731473         rl[1]=0;
    14741474         def Shelp =ring(rl);

  • Singular/LIB/ring.lib

    r4c83c98 r52d301  
    11/////////////////////////////////////////////////////////////////////////////
    2 version="version ring.lib 4.1.2.0 Feb_2019 "; // $Id$
     2version="version ring.lib 4.3.1.2 Nov_2022 "; // $Id$
    33category="General purpose";
    44info="
    … …  
    917917  setring OldRing;
    918918
    919   list rl = ringlist( OldRing);
     919  list rl = ring_list( OldRing);
    920920  while ( j<=@sized )
    921921  {

  • Singular/LIB/sagbi.lib

    r4c83c98 r52d301  
    11///////////////////////////////////////////////////////////////////////////
    2 version="version sagbi.lib 4.1.2.0 Feb_2019 "; // $Id$
     2version="version sagbi.lib 4.3.1.2 Nov_2022 "; // $Id$
    33category="Commutative Algebra";
    44info="
    … …  
    7676  // one for each new element in ideal algebra  -------------
    7777  setring r;
    78   list l = ringlist(r);
     78  list l = ring_list(r);
    7979  for (i=nvars(r)-nvars(br)+1; i<=numTotalAdditionalVars;i++)
    8080  {
    … …  
    234234  //Create the preimage ring K[@y(1),...,@y(m)], where m=ncols(algebra).
    235235  string variableName=uniqueVariableName("@y");
    236   list l = ringlist(basering);
     236  list l = ring_list(basering);
    237237  for (i=1; i<=m;i++)
    238238  {
    … …  
    918918
    919919  string extendVarName=uniqueVariableName("@c");
    920   list l2 = ringlist(basering);
     920  list l2 = ring_list(basering);
    921921  for (i=1; i<=ncols(I);i++)
    922922  {

  • Singular/LIB/scheme.lib

    r4c83c98 r52d301  
    11//
    2 version="version scheme.lib 1.0.0.0 Apr_2021 "; // $Id$
     2version="version scheme.lib 4.3.1.2 Nov_2022 "; // $Id$
    33category="Algebraic geometry";
    44info="
    … …  
    753753    for(i=1;i<=n;i=i+1)
    754754    {
    755        list rl=ringlist(R);
     755       list rl=ring_list(R);
    756756       rl[2]=delete(rl[2],i);
    757757       rl[3]=list(list("dp",1:(n-1)),list("C",0));
    … …  
    17021702   {   ERROR("Wrong number of arguments!!!");}
    17031703
    1704    list rl=ringlist(S);
     1704   list rl=ring_list(S);
    17051705   list newvars=list();
    17061706   for(int k=1; k<=n; k=k+1)
Note: See TracChangeset for help on using the changeset viewer.