Changeset ea6e16e in git

Timestamp:

Mar 10, 2020, 1:07:42 PM (4 years ago)

Author:

Sachin <sachinkm308@…>

Branches:

(u'spielwiese', 'fe61d9c35bf7c61f2b6cbf1b56e25e2f08d536cc')

Children:

7d4e42fa110a07137b129906c42c08071beec039

Parents:

e7e39839d32320823bf9689c97c5071650497b8e

git-author:

Sachin <sachinkm308@gmail.com>2020-03-10 13:07:42+01:00

git-committer:

Sachin <sachinkm308@gmail.com>2020-03-10 13:17:18+01:00

Message:

replacing execute with create_ring(16)

Location:

Singular/LIB

Files:

• algebra.lib (modified) (10 diffs)
• finvar.lib (modified) (2 diffs)
• general.lib (modified) (2 diffs)
• gitfan.lib (modified) (2 diffs)
• graal.lib (modified) (5 diffs)
• realrad.lib (modified) (1 diff)
• ring.lib (modified) (3 diffs)
• rinvar.lib (modified) (3 diffs)
• surfex.lib (modified) (2 diffs)

Singular/LIB/algebra.lib

@@ -76 +76 @@
     //-----------------
     // ---------- create new ring with extra variables --------------------
-    execute ("ring R=("+charstr(br)+"),(x(1..n),y(1..m)),(dp(n),dp(m));");
+    list l3;  
+    for (int zz = 1; zz <= n; zz++)
+    {
+     l3[size(l3)+1] = "x("+string(zz)+")";
+    }
+    for (int yy = 1; yy <= m; yy++)
+    {
+     l3[size(l3)+1] = "y("+string(yy)+")";
+    }
+    ring R = create_ring(ringlist(br)[1], l3, "(dp("+string(n)+"),dp("+string(m)+"))", "no_minpoly"); 
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -179 +188 @@
     string mp=string(minpoly);
   // ---------- create new ring with extra variables --------------------
-    execute
-   ("ring R=("+charstr(br)+"),(x(1..n),y(1..m),z(1..n)),(lp(n),dp(m),lp(n));");
+    list l4;  
+    for (int xx = 1; xx <= n; xx++)
+    {
+     l4[size(l4)+1] = "x("+string(xx)+")";
+    }
+    for (int yy = 1; yy <= m; yy++)
+    {
+     l4[size(l4)+1] = "y("+string(yy)+")";
+    }
+    for (int zz = 1; zz <= n; zz++)
+    {
+     l4[size(l4)+1] = "z("+string(zz)+")";
+    }
+    ring R = create_ring(ringlist(br)[1], l4, "(lp("+string(n)+"),dp("+string(m)+"),lp("+string(n)+"))", "no_minpoly");
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -277 +298 @@
   //the intersection of ideal nett=(p-y(0),I[1]-y(1),...)
   //with the ring k[y(0),...,y(n)] is computed, the result is ker
-   execute ("ring r1= ("+charstr(basering)+"),(x(1..n),y(0..z)),lp;");
+  list l5;  
+  for (int xx = 1; xx <= n; xx++)
+  {
+   l5[size(l5)+1] = "x("+string(xx)+")";
+  }
+  for (int yy = 0; yy <= z; yy++)
+  {
+   l5[size(l5)+1] = "y("+string(yy)+")";
+  }
+  ring r1 = create_ring(ringlist(basering)[1], l5, "lp", "no_minpoly");
   if (mp!="0")
   { execute ("minpoly=number("+mp+");"); }
@@ -366 +396 @@
     if ( tt == 1 )
     {
-      execute ("ring R1=("+charstr(br)+"),y(1..m),dp;");
+      list l6;  
+      for (int xx = 1; xx <= m; xx++)
+      {
+       l6[size(l6)+1] = "y("+string(xx)+")";
+      }
+      ring R1 = create_ring(ringlist(br)[1], l6, "dp", "no_minpoly");
       if (mp!="0")
       { execute ("minpoly=number("+mp+");"); }
@@ -375 +410 @@
     }
  // ---------- create new ring with extra variables --------------------
-    execute ("ring R2=("+charstr(br)+"),(x(1..n),y(1..m)),(dp);");
+    list l7;  
+    for (int xx = 1; xx <= n; xx++)
+    {
+     l7[size(l7)+1] = "x("+string(xx)+")";
+    }
+    for (int yy = 1; yy <= m; yy++)
+    {
+     l7[size(l7)+1] = "y("+string(yy)+")";
+    }
+    ring R2 = create_ring(ringlist(br)[1], l7, "dp", "no_minpoly");
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -401 +445 @@
  // eliminate m variables x(i) from ideal A[i] - y(i) by choosing product
  // order
-       {execute ("ring R3=("+charstr(br)+"),(x(1..n),y(1..m)),(dp(n),dp(m));");
+       {
+        list l8;  
+        for (int xx = 1; xx <= n; xx++)
+        {
+         l8[size(l8)+1] = "x("+string(xx)+")";
+        }
+        for (int yy = 1; yy <= m; yy++)
+        {
+         l8[size(l8)+1] = "y("+string(yy)+")";
+        }
+        setring(br);
+        ring R3 = create_ring(ringlist(br)[1], l8, "(dp("+string(n)+"),dp("+string(m)+"))", "no_minpoly");
         if (mp!="0")
         { execute ("minpoly=number("+mp+");"); }
@@ -500 +555 @@
     // algDependent is called with "bestoption" if tt = 0
     def S = L[2];
-    execute ("ring R=("+charstr(basering)+"),(@(1..n),"+varstr(pr)+"),(dp);");
+    list l9;  
+    for (int xx = 1; xx <= n; xx++)
+    {
+     l9[size(l9)+1] = "@("+string(xx)+")";
+    }
+    ring R = create_ring(ringlist(basering)[1], "("+string(l9)+","+varstr(pr)+")", "dp", "no_minpoly");
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -651 +711 @@
     string mp=string(minpoly);
   // ------------ create new ring with extra variables ---------------------
-    execute ("ring R=("+charstr(br)+"),(x(1..n),y(1..m)),(dp(n),dp(m));");
+    list l10;  
+    for (int yy = 1; yy <= n; yy++)
+    {
+     l10[size(l10)+1] = "x("+string(yy)+")";
+    }
+    for (int zz = 1; zz <= m; zz++)
+    {
+     l10[size(l10)+1] = "y("+string(zz)+")";
+    }
+    ring R = create_ring(ringlist(br)[1], l10, "(dp("+string(n)+"),dp("+string(m)+"))", "no_minpoly");
+
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -724 +794 @@
     string mp=string(minpoly);
   // ------------ create new ring with extra variables ---------------------
-    execute ("ring R=("+charstr(br)+"),(x(1..n),y(1..m)),(dp(n),dp(m));");
+    list l11;  
+    for (int yy = 1; yy <= n; yy++)
+    {
+     l11[size(l11)+1] = "x("+string(yy)+")";
+    }
+    for (int zz = 1; zz <= m; zz++)
+    {
+     l11[size(l11)+1] = "y("+string(zz)+")";
+    }
+    ring R = create_ring(ringlist(br)[1], l11, "(dp("+string(n)+"),dp("+string(m)+"))", "no_minpoly");
     if (mp!="0")
     { execute ("minpoly=number("+mp+");"); }
@@ -1042 +1121 @@
 
   // --------------------------- enlarging ring -----------------------------
-  execute("ring @rr = ("+charstr(bsr)+"),(y(1..m),x(1..n)),(lp(m),dp);");
+  list l12;  
+  for (int yy = 1; yy <= m; yy++)
+  {
+   l12[size(l12)+1] = "y("+string(yy)+")";
+  }
+  for (int zz = 1; zz <= n; zz++)
+  {
+   l12[size(l12)+1] = "x("+string(zz)+")";
+  }
+  ring @rr = create_ring(ringlist(bsr)[1], l12, "(lp("+string(m)+"),dp)", "no_minpoly");
   ideal J = imap(@bsr,J);
   ideal PHI = imap(@bsr,PHI);

Singular/LIB/finvar.lib

@@ -712 +712 @@
     if (minpoly==0)
     { if (i>size(chst))
-      { execute("ring newring=0,("+varstr(br)+"),("+ordstr(br)+")");
+      {
+         ring newring = create_ring(0, "("+varstr(br)+")", "("+ordstr(br)+")");
       }
       else
@@ -718 +719 @@
         execute
         ("ring newring=(0"+chst+"),("+varstr(br)+"),("+ordstr(br)+")");
+        string  strr2 = "First else";     // comment by sachin
+        strr2;    // comment by sachin
+        ringlist(newring);
+        
       }
     }

Singular/LIB/general.lib

@@ -90 +90 @@
    A_Z("c",5);
    A_Z("Z",-5);
-   string sR = "ring R = (0,"+A_Z("A",6)+"),("+A_Z("a",10)+"),dp;";
-   sR;
-   execute(sR);
+   ring R = create_ring("(0,"+A_Z("A",6)+")", "("+A_Z("a",10)+")", "dp");
    R;
 }
@@ -1242 +1240 @@
    poly p=((x2+y3)^2+xy6)*((x3+y2)^2+x10y);
    p=p^2;
-   //timeFactorize(p,2);
+   timeFactorize(p,2);
    //timeFactorize(p,20);
 }

Singular/LIB/gitfan.lib

@@ -331 +331 @@
   }
 
-  string initNewRing = "ring Rgam0 = 0,(";
+  string initNewRing = "(";
 
   intvec w = ringlist(basering)[3][1][2];
@@ -343 +343 @@
   w0[size(gam0)] = w[gam0[size(gam0)]];
 
-  initNewRing = initNewRing + string(var(gam0[size(gam0)])) + "),wp(w0);";
+  initNewRing = initNewRing + string(var(gam0[size(gam0)])) + ")";
   def R = basering;
-  execute(initNewRing);
+//  execute(initNewRing);
+  initNewRing;
+  ring Rgam0 = create_ring(0, initNewRing, "wp("+string(w0)+")");
+  ringlist(Rgam0);
 
   ideal agam0 = imap(R,a);

Singular/LIB/graal.lib

@@ -1 @@
-////////////////////////////////////////////////////////////////////////////
+graalMixed////////////////////////////////////////////////////////////////////////////
 version="version graal.lib 4.1.2.0 Feb_2019 "; // $Id$
 category="Commutative Algebra";
@@ -332 +332 @@
    **/
   ideal H = ringlist(Gr.A)[4];
-  execute("ring Q = "+string(Gr.A)+";");
+  list l3 = ringlist(Gr.A);
+  def Q = ring(l3);
+  setring Q;
   ideal H = fetch(Gr.A,H); H = sort(std(H))[1];
   ideal J = fetch(Gr.A,L) + H; J = sort(std(J))[1];
@@ -358 +360 @@
   else
     { string pars; string vars = varstr(basering); }
-  execute("ring Q0 = ("+charstr(basering)+pars+"),("+vars+"),dp;");
+  ring Q0 = create_ring("("+charstr(basering)+pars+")", "("+vars+")", "dp");
   ideal J0 = imap(Q,J);
   Gr.Q0 = Q0;
@@ -404 +406 @@
   string ostring = ordstr(basering);
   ostring = ostring[1..size(ostring)-2];
-  list l2;
-  for (int ii = 1; ii <= s; ii++)
-  {
-   l2[ii] = "Y("+string(ii)+")";
-  }
-  l2[s+1] = ringlist(basering)[2];
-  execute("ring Q0y = ("+charstr(basering)+"),(Y(1..s),"+varstr(basering)+"),(ds(s),c,"+ostring+")");
+  list l4;
+  for (int zz = 1; zz <= s; zz++)
+  {
+   l4[zz] = "Y("+string(zz)+")";
+  }
+  ring Q0y = create_ring(ringlist(basering)[1], "("+string(l4)+","+varstr(basering)+")", "(ds("+string(s)+"),c,"+ostring+")", "no_minpoly");
   setring Q0y;
   ideal H = imap(Gr.A,H);
@@ -428 +429 @@
    * construct Ky and sigmainI
    **/
-  execute("ring KKy = ("+charstr(Q0)+"),(Y(1..s),"+varstr(Q0,nvars(Q0))+"),(c,dp(s),dp(1));");
+  ring KKy = create_ring(ringlist(Q0)[1], "("+string(l4)+","+varstr(Q0,nvars(Q0))+")", "(c,dp("+string(s)+"),dp(1))", "no_minpoly");
   poly minpolyOfK = imap(Q0,g(n));
   qring Ky = std(minpolyOfK);

Singular/LIB/realrad.lib

@@ -632 +632 @@
        l[zz,n-zz]=1;
      }
-     ri="ring rcoef="+"(0,@t,"+parvar+"),
-     ("+lessvar+"),M(l);";
-     execute(ri);
+     ring rcoef = create_ring("(0,@t,"+parvar+")", "("+lessvar+")", "M("+string((l))+")");
      kill l;
      poly e=imap(rh,e);

Singular/LIB/ring.lib

@@ -165 +165 @@
    setring @r;
    ideal i = ideal(@r); int @q = size(i);
-   if( @q!=0 )
-      { string @s = "Rnew1"; }
+   string @newring = "(";
+   string  strr1 = "printing vars";     // comment by sachin
+   strr1;    // comment by sachin
+   vars;
+   if( vars[size(vars)-1]=="(" and vars[size(vars)]==")" )
+   {
+//      @newring = @newring+vars[1,size(vars)-2]+"(1.."+string(nvars(@r))+")";
+      list l6;
+      for (int zz = 1; zz <= nvars(@r); zz++)
+      {    
+       l6[zz] = vars[1,size(vars)-2] + "("+string(zz)+")";
+      }
+   }
    else
-      { string @s = "Rnew"; }
-   string @newring = @s+"=("+charstr(@r)+"),(";
-   if( vars[size(vars)-1]=="(" and vars[size(vars)]==")" )
-   {
-      @newring = @newring+vars[1,size(vars)-2]+"(1.."+string(nvars(@r))+")";
-   }
-   else { @newring = @newring+vars; }
+   {
+//      @newring = @newring+vars;
+    list l6;
+    for(int zz=1 ; zz <= size(vars); zz++)
+    {    
+     if(vars[zz] != ","){ l6[size(l6)+1] = vars[zz]; }
+    }
+   }
    string ords=ordstr(@r);
    int l=size(ords);
@@ -192 +204 @@
      else { ords=string(ords[1..l1-1])+string(ords[l2+1..size(ords)]); }
    }
-   @newring = @newring+"),("+ords+");";
-   execute("ring "+@newring);
+   @newring = @newring+")";
+   string  strr1 = "printing newring";     // comment by sachin
+   strr1;    // comment by sachin
+   @newring;
+//   execute("ring "+@newring);
+   if( @q!=0 )
+      { ring Rnew1 = create_ring(ringlist(@r)[1], l6, "("+ords+")", "no_minpoly"); ringlist(Rnew1); }
+   else
+      { ring Rnew = create_ring(ringlist(@r)[1], l6, "("+ords+")", "no_minpoly"); ringlist(Rnew); }
    if( @q!=0 )
    {
@@ -202 +221 @@
    }
    return(Rnew);
+   
 }
 example

Singular/LIB/rinvar.lib

@@ -149 +149 @@
   // Gn (contians only z(1..newVars)) to this ring
 
-  ringSTR2 = "ring RIGS = (" + charstr(basering) + "), (s(1.."
-                     + string(newVars) + "), t(1.." + string(nrt) + ")), lp;";
-  execute(ringSTR2);
+  list l1;  
+  for (int zz = 1; zz <= newVars; zz++)
+  {
+   l1[size(l1)+1] = "s("+string(zz)+")";
+  }
+  for (int yy = 1; yy <= nrt; yy++)
+  {
+   l1[size(l1)+1] = "t("+string(yy)+")";
+  }
+  ring RIGS = create_ring(ringlist(basering)[1], l1, "lp", "no_minpoly");
   execute("minpoly = number(" + @mPoly + ");");
   ideal mapIdeal, groupid, actionid;
@@ -421 +428 @@
                    + " is not a linear combination of the elements of basis");
         nrt++;
-        str = charstr(basering) + ", (" + varstr(basering)
-                   + ",t(" + string(nrt) + ")),";
         if(defined(RLAB)) { kill RLAB;}
         def RLAB = basering;
         if(defined(RLAR)) { kill RLAR;}
-        execute("ring RLAR = " + str + "(" + order + ");");
+        ring RLAR = create_ring(ringlist(basering)[1], "(" + varstr(basering)+ ",t(" + string(nrt) + "))", "(" + order + ")", "no_minpoly");
         execute("minpoly = number(" + @mPoly + ");");
 
@@ -867 +872 @@
 
   nt = size(action);
-  order = "(dp(" + string(nvars(basering) - nt) + "), dp);";
-  vars = "(s(1.." + string(nvars(basering) - nt);
-  vars = vars +"),t(1.."+string(nt) + "), Y(1.." + string(nt) + "))," + order;
-  ringSTR = "ring RNCR = (" + charstr(basering) +  "),"  + vars;
+  order = "(dp(" + string(nvars(basering) - nt) + "), dp)";
   // ring for the computation
 
   string @minPoly = string(minpoly);
   offset =  size(G) + nt;
-  execute(ringSTR);
+  list l2;
+  for (int xx = 1; xx <= (nvars(basering) - nt); xx++)
+  {
+   l2[size(l2)+1] = "s("+string(xx)+")";
+  }
+  for (int yy = 1; yy <= nt; yy++)
+  {
+   l2[size(l2)+1] = "t("+string(yy)+")";
+  }
+  for (int zz = 1; zz <= nt; zz++)
+  {
+   l2[size(l2)+1] = "Y("+string(zz)+")";
+  }
+  ring RNCR = create_ring(ringlist(basering)[1], l2, order, "no_minpoly");
   execute("poly aaa = number(" + @minPoly + ");");
   if (aaa!=0) { minpoly = number(aaa); }

Singular/LIB/surfex.lib

@@ -1308 +1308 @@
     short = 0;
     string str_lag = sprintf("list lag = laguerre_solve(%s);", minpoly);
-    string str_ring = sprintf("ring r_sqrt = (complex,prec,I),(%s),lp;", parstr(basering));
-    execute(str_ring);
+    ring r_sqrt = create_ring("(complex,prec,I)", "(" + parstr(basering) +")", "lp");
     execute(str_lag);
 //    lag;
@@ -1371 +1370 @@
     short = 0;
     string str_lag = sprintf("list lag = laguerre_solve(%s);", minpoly);
-    string str_ring = sprintf("ring r_sqrt = (complex,prec,I),(%s),lp;", parstr(basering));
-    execute(str_ring);
+    ring r_sqrt = create_ring("(complex,prec,I)", "(" + parstr(basering) +")", "lp");
     execute(str_lag);