Changeset 7161aca – Singular

Singular/LIB/JMBTest.lib

-                      rd4cec6a
+                      r7161aca
 int aJ=deg(f.h);
 // minimal degree of polynomials in G
-//print(aJ);
 list V=list();
 V[1]=Terns(G,1);
 …
 //Compare degrees;
       d=-1;
-      //print("Per Grado");
+     }
   if(deg(P.h)==deg(Q.h))
 …
 //head=tail
                d=0;
-               //print("Uguali");
+              }
+         }
 …
+       }
    I=M[1..size(M)];
-//print("IdealOfV");
   //I=std(I);
+  }
 …
 EXAMPLE:  example NewWeight; shows an example"
+{
+//multiply and reduce, degree by degree
+intvec u=NewWeight(nvars(r)+1);
+list L=ringlist(r);
+L[2]=insert(L[2],"t",size(L[2]));
+//print(L[2]);
+list ordlist="a",u;
+L[3]=insert(L[3],ordlist,0);
+def H=ring(L);
+//print(V1);
+//print(G1);
+list M=list();
+jmp p;
+list N;
+poly q;
+poly s;
+int i;
+int j;
+for(i=1; i<=size(G1); i++)
+   {
+           N=list();
+           for(j=1; j<=size(G1[i]); j++)
+              {
+                p=G1[i][j];
+                q=p.h;
+                s=p.t;
+                N[j]=list(q,s);
+               }
+           M[i]=N;
+    }
+p.h=poly(0);
+p.t=poly(0);
+setring H;
+list R=list();
+list S=list();
+//print("anello definito");
+def V=imap(r,V1);
+//def G=imap(r,G1);
+//print(V);
+def MM=imap(r,M);
+list G=list();
+list N=list();
+for(i=1; i<=size(MM); i++)
+   {
+           for(j=1; j<=size(MM[i]); j++)
+              {
+                p.h=MM[i][j][1];
+                p.t=MM[i][j][2];
+                N[j]=p;
+               }
+           G[i]=N;
+    }
+ideal I=0;
+jmp LL;
+jmp UU;
+ for(i=1; i<=size(V);i++)
+    {
+       R[i]=list();
+       S[i]=list();
+       I=0;
+       for(j=1;j<=size(V[i]); j++)
+          {
+            LL=Multiply(V[i][j],G);
+            LL.t=reduce(t*LL.t,I);
+//I only reduce the tail
+              LL.t=subst(LL.t,t,1);
+              S[i]=insert(S[i],LL,size(S[i]));
+              LL.h=t*LL.h;
+            R[i]=insert(R[i],LL,size(R[i]));
+             UU=R[i][j];
+              I=I+ideal(UU.h+UU.t);
+              attrib(I,"isSB",1);
+          }
+    }
+list M=list();
+poly q;
+poly s;
+for(i=1; i<=size(S); i++)
+   {
+           N=list();
+           for(j=1; j<=size(S[i]); j++)
+              {
+                p=S[i][j];
+                q=p.h;
+                s=p.t;
+                N[j]=list(q,s);
+               }
+           M[i]=N;
+    }
+p.h=poly(0);
+p.t=poly(0);
+setring r;
+def MM=imap(H,M);
+list MMM=list();
+for(i=1; i<=size(MM); i++)
+   {
+           N=list();
+           for(j=1; j<=size(MM[i]); j++)
+              {
+                p.h=MM[i][j][1];
+                p.t=MM[i][j][2];
+                N[j]=p;
+               }
+           MMM[i]=N;
+    }
+return(MMM);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring r=0, (x,y,z), rp;
+jmp r1;
+r1.h=z^3;
+r1.t=poly(0);
+jmp r2;
+r2.h=z^2*y;
+r2.t=poly(0);
+jmp r3;
+r3.h=z*y^2 ;
+r3.t=-x^2*y;
+jmp r4;
+r4.h=y^5;
+r4.t=poly(0);
+list G2F=list(list(r1,r2,r3),list(r4));
+  //multiply and reduce, degree by degree
+  intvec u=NewWeight(nvars(r)+1);
+  list L=ringlist(r);
+  L[2]=insert(L[2],"t",size(L[2]));
+  list ordlist="a",u;
+  L[3]=insert(L[3],ordlist,0);
+  def H=ring(L);
+  list M=list();
+  jmp p;
+  list N;
+  poly q;
+  poly s;
+  int i;
+  int j;
+  for(i=1; i<=size(G1); i++)
+  {
+    N=list();
+    for(j=1; j<=size(G1[i]); j++)
+    {
+      p=G1[i][j];
+      q=p.h;
+      s=p.t;
+      N[j]=list(q,s);
+    }
+    M[i]=N;
+  }
+  p.h=poly(0);
+  p.t=poly(0);
+  setring H;
+  list R=list();
+  list S=list();
+  //print("anello definito");
+  def V=imap(r,V1);
+  //def G=imap(r,G1);
+  //print(V);
+  def MM=imap(r,M);
+  list G=list();
+  list N=list();
+  for(i=1; i<=size(MM); i++)
+  {
+    for(j=1; j<=size(MM[i]); j++)
+    {
+      p.h=MM[i][j][1];
+      p.t=MM[i][j][2];
+      N[j]=p;
+    }
+    G[i]=N;
+  }
+  ideal I=0;
+  jmp LL;
+  jmp UU;
+  for(i=1; i<=size(V);i++)
+  {
+    R[i]=list();
+    S[i]=list();
+    I=0;
+    for(j=1;j<=size(V[i]); j++)
+    {
+      LL=Multiply(V[i][j],G);
+      LL.t=reduce(t*LL.t,I);
+      //I only reduce the tail
+      LL.t=subst(LL.t,t,1);
+      S[i]=insert(S[i],LL,size(S[i]));
+      LL.h=t*LL.h;
+      R[i]=insert(R[i],LL,size(R[i]));
+      UU=R[i][j];
+      I=I+ideal(UU.h+UU.t);
+      attrib(I,"isSB",1);
+    }
+  }
+  list M=list();
+  poly q;
+  poly s;
+  for(i=1; i<=size(S); i++)
+  {
+    N=list();
+    for(j=1; j<=size(S[i]); j++)
+    {
+      p=S[i][j];
+      q=p.h;
+      s=p.t;
+      N[j]=list(q,s);
+    }
+    M[i]=N;
+  }
+  p.h=poly(0);
+  p.t=poly(0);
+  setring r;
+  def MM=imap(H,M);
+  list MMM=list();
+  for(i=1; i<=size(MM); i++)
+  {
+    N=list();
+    for(j=1; j<=size(MM[i]); j++)
+    {
+      p.h=MM[i][j][1];
+      p.t=MM[i][j][2];
+      N[j]=p;
+    }
+    MMM[i]=N;
+  }
+  return(MMM);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring r=0, (x,y,z), rp;
+ jmp r1;
+ r1.h=z^3;
+ r1.t=poly(0);
+ jmp r2;
+ r2.h=z^2*y;
+ r2.t=poly(0);
+ jmp r3;
+ r3.h=z*y^2 ;
+ r3.t=-x^2*y;
+ jmp r4;
+ r4.h=y^5;
+ r4.t=poly(0);
+ list G2F=list(list(r1,r2,r3),list(r4));
  FinalVm(VConst(G2F,6,r) , G2F, r);
+}
 …
 list V=list();
 V= VConst(G,c);
-//print("VConst");
 //V non ordered
 list L=list();
 …
 //L will contain results
 poly h=Minimus(variables(A.h));
-//print(h);
 int l=findvars(h,1)[2][1];
 if(l!=nvars(basering))
+ {
-//print("vero");
-//print(l);
   for(int j=l+1;j<=nvars(basering); j++)
+   {
-    //print("entrata");
-    //print(var(j));
     E=var(j)*A.h/B.h;
 //Candidate for * product
-    //print(E);
     if(E!=0)
+      {
 …
 //Loop on polynomials
                         C=EKCouples(G[i][j], G[k][l]);
-//print("coppia");
                         if(C[2]!=0)
+                          {
 …
 True=1/False=0
 EXAMPLE:  example TestJMark; shows an example"
+{int flag=1;
+if(size(G1)==1 && size(G1[1])==1)
+ {
+  //Hypersurface
+  print("Only One Polynomial");
+  flag=1;
+ }
+else
+  {
+   int d=0;
+   list EK,D=EKPolys(G1);
+//print("PolysEK");
+   //I found EK couples
+   int massimo=Max(D);
+   list V1=ConstructorMain(G1,massimo,r);
+//print("Costruttore");
+//print(V1);
+   jmp mi=V1[1][1];
+   int minimo=Min(deg(mi.h));
+   intvec u=NewWeight(nvars(r)+1);
+list L=ringlist(r);
+L[2]=insert(L[2],"t",size(L[2]));
+//print(L[2]);
+list ordlist="a",u;
+L[3]=insert(L[3],ordlist,0);
+def H=ring(L);
+list JJ=list();
+jmp pp;
+jmp qq;
+int i;
+int j;
+list NN;
+for(i=size(V1);i>0;i--)
+    {
+     NN=list();
+     for(j=size(V1[i]);j>0;j--)
+         {
+          //print(j);
+          pp=V1[i][j];
+          NN[j]=list(pp.h,pp.t);
+          }
+//print(NN);
+JJ[i]=NN;
+//print(JJ[i]);
+//print(i);
+    }
+//print(JJ);
+list KK=list();
+list UU=list();
+//jmp qq;
+for(i=size(G1);i>0;i--)
+    {
+     for(j=size(G1[i]);j>0;j--)
+         {
+          //print(j);
+          qq=G1[i][j];
+          UU[j]=list(qq.h,qq.t);
+          }
+//print(UU);
+KK[i]=UU;
+    }
+setring H;
+//I defined the new ring with the weighted
+//variable t
+poly p;
+//print("anello definito");
+def JJJ=imap(r,JJ);
+def EK=imap(r,EK);
+//print(flag);
+//imap(r,D);
+list V=list();
+jmp fp;
+//int i;
+//int j;
+list N;
+for(i=size(JJJ); i>0; i--)
+   {
+           N=list();
+           for(j=size(JJJ[i]); j>0; j--)
+              {
+                fp.h=JJJ[i][j][1];
+                fp.t=JJJ[i][j][2];
+                N[j]=fp;
+               }
+           V[i]=N;
+            }
+//print(V);
+def KKJ=imap(r,KK);
+list G=list();
+list U=list();
+for(i=1; i<=size(KKJ); i++)
+   {
+           for(j=1; j<=size(KKJ[i]); j++)
+              {
+                fp.h=KKJ[i][j][1];
+                fp.t=KKJ[i][j][2];
+                U[j]=fp;
+               }
+           G[i]=U;
+    }
+// print(V);
+//print(G);
+//I imported in H everithing I need
+poly q;
+ideal I;
+   for(j=1; j<=size(EK);j++)
+{
+  int flag=1;
+  if(size(G1)==1 && size(G1[1])==1)
+  {
+    //Hypersurface
+    print("Only One Polynomial");
+    flag=1;
+  }
+  else
+  {
+    int d=0;
+    list EK,D=EKPolys(G1);
+    //I found EK couples
+    int massimo=Max(D);
+    list V1=ConstructorMain(G1,massimo,r);
+    jmp mi=V1[1][1];
+    int minimo=Min(deg(mi.h));
+    intvec u=NewWeight(nvars(r)+1);
+    list L=ringlist(r);
+    L[2]=insert(L[2],"t",size(L[2]));
+    list ordlist="a",u;
+    L[3]=insert(L[3],ordlist,0);
+    def H=ring(L);
+    list JJ=list();
+    jmp pp;
+    jmp qq;
+    int i;
+    int j;
+    list NN;
+    for(i=size(V1);i>0;i--)
+    {
+      NN=list();
+      for(j=size(V1[i]);j>0;j--)
+      {
+       d=D[j];
+       p=EKPolynomials(EK[j],G);
+       //print("arrivo");
+       I=IdealOfV(V[d-minimo+1]);
+attrib(I,"isSB",1);
+//print(I);
+q=reduce(t*p,I);
+//print(I[1]);
+//print(t*p);
+q=subst(q,t,1);
+//I reduce all the EK polynomials
+//       q=RiduzPoly(V[d-minimo+1], p);
+       if(q!=0)
+         {
+//check whether reduction is 0
+          print("NOT A BASIS");
+         flag=0;
+          break;
+         }
+     }
+  }
+//print(flag);
+setring r;
+//typeof(flag);
+return(flag);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring r=0, (x,y,z), rp;
+jmp r1;
+r1.h=z^3;
+r1.t=poly(0);
+jmp r2;
+r2.h=z^2*y;
+r2.t=poly(0);
+jmp r3;
+r3.h=z*y^2 ;
+r3.t=-x^2*y;
+jmp r4;
+r4.h=y^5;
+r4.t=poly(0);
+list G2F=list(list(r1,r2,r3),list(r4));
+TestJMark(G2F,r);
+}
+        pp=V1[i][j];
+        NN[j]=list(pp.h,pp.t);
+      }
+      JJ[i]=NN;
+    }
+    list KK=list();
+    list UU=list();
+    //jmp qq;
+    for(i=size(G1);i>0;i--)
+    {
+      for(j=size(G1[i]);j>0;j--)
+      {
+        qq=G1[i][j];
+        UU[j]=list(qq.h,qq.t);
+      }
+      KK[i]=UU;
+    }
+    setring H;
+    //I defined the new ring with the weighted
+    //variable t
+    poly p;
+    //print("anello definito");
+    def JJJ=imap(r,JJ);
+    def EK=imap(r,EK);
+    list V=list();
+    jmp fp;
+    //int i;
+    //int j;
+    list N;
+    for(i=size(JJJ); i>0; i--)
+    {
+      N=list();
+      for(j=size(JJJ[i]); j>0; j--)
+      {
+        fp.h=JJJ[i][j][1];
+        fp.t=JJJ[i][j][2];
+        N[j]=fp;
+      }
+      V[i]=N;
+    }
+    def KKJ=imap(r,KK);
+    list G=list();
+    list U=list();
+    for(i=1; i<=size(KKJ); i++)
+    {
+      for(j=1; j<=size(KKJ[i]); j++)
+      {
+        fp.h=KKJ[i][j][1];
+        fp.t=KKJ[i][j][2];
+        U[j]=fp;
+      }
+      G[i]=U;
+    }
+    //I imported in H everithing I need
+    poly q;
+    ideal I;
+    for(j=1; j<=size(EK);j++)
+    {
+      d=D[j];
+      p=EKPolynomials(EK[j],G);
+      I=IdealOfV(V[d-minimo+1]);
+      attrib(I,"isSB",1);
+      q=reduce(t*p,I);
+      q=subst(q,t,1);
+      //I reduce all the EK polynomials
+      //       q=RiduzPoly(V[d-minimo+1], p);
+      if(q!=0)
+      {
+        //check whether reduction is 0
+        print("NOT A BASIS");
+        flag=0;
+        break;
+      }
+    }
+  }
+  setring r;
+  //typeof(flag);
+  return(flag);
+}
+example
+{ "EXAMPLE:"; echo = 2;
+ ring r=0, (x,y,z), rp;
+ jmp r1;
+ r1.h=z^3;
+ r1.t=poly(0);
+ jmp r2;
+ r2.h=z^2*y;
+ r2.t=poly(0);
+ jmp r3;
+ r3.h=z*y^2 ;
+ r3.t=-x^2*y;
+ jmp r4;
+ r4.h=y^5;
+ r4.t=poly(0);
+ list G2F=list(list(r1,r2,r3),list(r4));
+ TestJMark(G2F,r);
+}

Singular/LIB/JMSConst.lib

-                      rd4cec6a
+                      r7161aca
 int minimo=deg(m.h);
 int massimo=deg(M.h);
-//print(minimo);
-//print(massimo);
 int i=2;
 jmp qi;
 while(i<=size(Q))
+     {
-       //print("entro nel ciclo");
-       //print(i);
        qi=Q[i][1];
        if(deg(qi.h)!=minimo+1)
+         {
-          //print("qui riempire");
-          //print(i);
           Q=insert(Q,list(),i-1);//Insert empty list for all intermediate degree between the minimum and the maximum, not having polynomials.
-          //print(Q);
+         }
        minimo=minimo+1;
        i=i+1;
-       //print("ora ho");
-       //print(minimo);
-       //print(i);
+     }
 return(Q);
 …
           Q[i][j]=pp;
           s=s+M[2];
-          //print(s);
+        }
+    }
 …
 int aJ=deg(f.h);
 // minimal degree of polynomials in G
-//print(aJ);
 list V=list();
 V[1]=Terns(G,1);
 …
+             {
                    p=G[V[m-1][j][2]][V[m-1][j][3]];
-                  //print(p.h);
-                  //print(p.t);
-                  //print(var(i));
-                  //print(Minimus(V[m-1][j][1]*p.h));
                if(var(i)<=Minimus(variables(V[m-1][j][1]*p.h)))
+                  {
 //Can I multiply by the current variable?
-                    //print("minoremin");
-                    //print("fin qui ci sono");
-                     //print(V[m-1][j][1]);
                      OO=list(var(i)*V[m-1][j][1],V[m-1][j][2],V[m-1][j][3]);
                     V[m]=insert(V[m], OO ,size(V[m]));
 …
 EXAMPLE:  example FinalVm; shows an example"
+{
+//multiply and reduce, degree by degree
+intvec u=NewWeight(nvars(r)+1);
+list L=ringlist(r);
+L[2]=insert(L[2],"t",size(L[2]));
+//print(L[2]);
+list ordlist="a",u;
+L[3]=insert(L[3],ordlist,0);
+def H=ring(L);
+//print(V1);
+//print(G1);
+list M=list();
+jmp p;
+list N;
+poly q;
+poly s;
+int i;
+int j;
+for(i=1; i<=size(G1); i++)
+   {
+           N=list();
+           for(j=1; j<=size(G1[i]); j++)
+              {
+                p=G1[i][j];
+                q=p.h;
+                s=p.t;
+                N[j]=list(q,s);
+               }
+           M[i]=N;
+    }
+//print("M is");
+//print(M);
+p.h=poly(0);
+p.t=poly(0);
+setring H;
+list R=list();
+list S=list();
+//print("anello definito");
+list V=imap(r,V1);
+//def G=imap(r,G1);
+//print(V);
+list MM=imap(r,M);
+list G=list();
+list N=list();
+for(i=1; i<=size(MM); i++)
+   {
+           for(j=1; j<=size(MM[i]); j++)
+              {
+                p.h=MM[i][j][1];
+                p.t=MM[i][j][2];
+                N[j]=p;
+               }
+           G[i]=N;
+    }
+ideal I=0;
+jmp LL;
+jmp UU;
+//print("pronta x ridurre");
+ for(i=1; i<=size(V);i++)
+    {
+//print("sono a V di");
+//print(i);
+       R[i]=list();
+       S[i]=list();
+       I=0;
+              attrib(I,"isSB",1);
+       for(j=1;j<=size(V[i]); j++)
+          {
+//print(j);
+//print("esimo elem");
+            LL=MultiplyJmP(V[i][j],G);
+              LL.t=reduce(t*LL.t,I);
+//I only reduce the tail
+//print(LL.t);
+              LL.t=subst(LL.t,t,1);
+              S[i]=insert(S[i],LL,size(S[i]));
+              LL.h=t*LL.h;
+            R[i]=insert(R[i],LL,size(R[i]));
+             UU=R[i][j];
+              I=I+ideal(UU.h+UU.t);
+              attrib(I,"isSB",1);
+          }
+    }
+//print("ho ridotto");
+list M=list();
+poly q;
+poly s;
+for(i=1; i<=size(S); i++)
+   {
+           N=list();
+           for(j=1; j<=size(S[i]); j++)
+              {
+                p=S[i][j];
+                q=p.h;
+                s=p.t;
+                N[j]=list(q,s);
+               }
+           M[i]=N;
+    }
+p.h=poly(0);
+p.t=poly(0);
+setring r;
+def MM=imap(H,M);
+list MMM=list();
+for(i=1; i<=size(MM); i++)
+   {
+           N=list();
+           for(j=1; j<=size(MM[i]); j++)
+              {
+                p.h=MM[i][j][1];
+                p.t=MM[i][j][2];
+                N[j]=p;
+               }
+           MMM[i]=N;
+    }
+return(MMM);
+  //multiply and reduce, degree by degree
+  intvec u=NewWeight(nvars(r)+1);
+  list L=ringlist(r);
+  L[2]=insert(L[2],"t",size(L[2]));
+  list ordlist="a",u;
+  L[3]=insert(L[3],ordlist,0);
+  def H=ring(L);
+  list M=list();
+  jmp p;
+  list N;
+  poly q;
+  poly s;
+  int i;
+  int j;
+  for(i=1; i<=size(G1); i++)
+  {
+    N=list();
+    for(j=1; j<=size(G1[i]); j++)
+    {
+      p=G1[i][j];
+      q=p.h;
+      s=p.t;
+      N[j]=list(q,s);
+    }
+    M[i]=N;
+  }
+  p.h=poly(0);
+  p.t=poly(0);
+  setring H;
+  list R=list();
+  list S=list();
+  //print("anello definito");
+  list V=imap(r,V1);
+  list MM=imap(r,M);
+  list G=list();
+  list N=list();
+  for(i=1; i<=size(MM); i++)
+  {
+    for(j=1; j<=size(MM[i]); j++)
+    {
+      p.h=MM[i][j][1];
+      p.t=MM[i][j][2];
+      N[j]=p;
+    }
+    G[i]=N;
+  }
+  ideal I=0;
+  jmp LL;
+  jmp UU;
+  //print("pronta x ridurre");
+  for(i=1; i<=size(V);i++)
+  {
+    //print("sono a V di");
+    //print(i);
+    R[i]=list();
+    S[i]=list();
+    I=0;
+    attrib(I,"isSB",1);
+    for(j=1;j<=size(V[i]); j++)
+    {
+      //print(j);
+      //print("esimo elem");
+      LL=MultiplyJmP(V[i][j],G);
+      LL.t=reduce(t*LL.t,I);
+      //I only reduce the tail
+      //print(LL.t);
+      LL.t=subst(LL.t,t,1);
+      S[i]=insert(S[i],LL,size(S[i]));
+      LL.h=t*LL.h;
+      R[i]=insert(R[i],LL,size(R[i]));
+      UU=R[i][j];
+      I=I+ideal(UU.h+UU.t);
+      attrib(I,"isSB",1);
+    }
+  }
+  //print("ho ridotto");
+  list M=list();
+  poly q;
+  poly s;
+  for(i=1; i<=size(S); i++)
+  {
+    N=list();
+    for(j=1; j<=size(S[i]); j++)
+    {
+      p=S[i][j];
+      q=p.h;
+      s=p.t;
+      N[j]=list(q,s);
+    }
+    M[i]=N;
+  }
+  p.h=poly(0);
+  p.t=poly(0);
+  setring r;
+  def MM=imap(H,M);
+  list MMM=list();
+  for(i=1; i<=size(MM); i++)
+  {
+    N=list();
+    for(j=1; j<=size(MM[i]); j++)
+    {
+      p.h=MM[i][j][1];
+      p.t=MM[i][j][2];
+      N[j]=p;
+    }
+    MMM[i]=N;
+  }
+  return(MMM);
+}
 example
 { "EXAMPLE:"; echo = 2;
  ring r=0, (x,y,z), rp;
 jmp r1;
 r1.h=z^3;
 r1.t=poly(0);
 jmp r2;
 r2.h=z^2*y;
 r2.t=poly(0);
 jmp r3;
 r3.h=z*y^2 ;
 r3.t=-x^2*y;
 jmp r4;
 r4.h=y^5;
 r4.t=poly(0);
 list G2F=list(list(r1,r2,r3),list(r4));
+ jmp r1;
+ r1.h=z^3;
+ r1.t=poly(0);
+ jmp r2;
+ r2.h=z^2*y;
+ r2.t=poly(0);
+ jmp r3;
+ r3.h=z*y^2 ;
+ r3.t=-x^2*y;
+ jmp r4;
+ r4.h=y^5;
+ r4.t=poly(0);
+ list G2F=list(list(r1,r2,r3),list(r4));
  FinalVm(VConst(G2F,6,r) , G2F, r);
+}
 …
 EXAMPLE:  example SchemeEq; shows an example"
+{
+list Jms=list();
+//ideal I;
+list M=list();
+jmp mini;
+mini=W[1][1];
+int minimo=deg(mini.h);
+//multiply variables
+poly pd=poly(1);
+for(int i=1;i<=nvars(r);i++)
+{pd=pd*var(i);}
+//CHANGE RING
+intvec u=NewWeight(nvars(r)+1);
+list L=ringlist(r);
+L[2]=insert(L[2],"t",size(L[2]));
+//print(L[2]);
+list ordlist="a",u;
+L[3]=insert(L[3],ordlist,0);
+def H=ring(L);
+//list
+M=list();
+jmp pu;
+list N;
+poly q;
+poly s;
+i=0;
+int j;
+for(i=1; i<=size(Q); i++)
+   {
+           N=list();
+           for(j=1; j<=size(Q[i]); j++)
+              {
+                pu=Q[i][j];
+                q=pu.h;
+                s=pu.t;
+                N[j]=list(q,s);
+               }
+           M[i]=N;
+    }
+list O;
+pu.h=poly(0);
+pu.t=poly(0);
+for(i=1; i<=size(W); i++)
+   {
+           N=list();
+           for(j=1; j<=size(W[i]); j++)
+              {
+                pu=W[i][j];
+                q=pu.h;
+                s=pu.t;
+                N[j]=list(q,s);
+               }
+           O[i]=N;
+    }
+pu.h=poly(0);
+pu.t=poly(0);
+setring H;
+list R=list();
+list S=list();
+//print("anello definito");
+def EK=imap(r,EK);
+def MM=imap(r,M);
+def OO=imap(r,O);
+def pd=imap(r,pd);
+list G=list();
+list N=list();
+for(i=1; i<=size(MM); i++)
+   {
+           for(j=1; j<=size(MM[i]); j++)
+              {
+                pu.h=MM[i][j][1];
+                pu.t=MM[i][j][2];
+                N[j]=pu;
+               }
+           G[i]=N;
+    }
+list V;
+for(i=1; i<=size(OO); i++)
+   {
+           for(j=1; j<=size(OO[i]); j++)
+              {
+                pu.h=OO[i][j][1];
+                pu.t=OO[i][j][2];
+                N[j]=pu;
+               }
+           V[i]=N;
+    }
+//print(V);
+//print(G);
+matrix C;
+list COEFF;
+poly p=0;
+poly q=0;
+ideal I;
+list M;
+i=0;
+jmp g;
+int k;
+for(j=1; j<=size(EK);j++)
+  list Jms=list();
+  //ideal I;
+  list M=list();
+  jmp mini;
+  mini=W[1][1];
+  int minimo=deg(mini.h);
+  //multiply variables
+  poly pd=poly(1);
+  for(int i=1;i<=nvars(r);i++)
+  { pd=pd*var(i);}
+  //CHANGE RING
+  intvec u=NewWeight(nvars(r)+1);
+  list L=ringlist(r);
+  L[2]=insert(L[2],"t",size(L[2]));
+  //print(L[2]);
+  list ordlist="a",u;
+  L[3]=insert(L[3],ordlist,0);
+  def H=ring(L);
+  //list
+  M=list();
+  jmp pu;
+  list N;
+  poly q;
+  poly s;
+  i=0;
+  int j;
+  for(i=1; i<=size(Q); i++)
+  {
+    N=list();
+    for(j=1; j<=size(Q[i]); j++)
+    {
+      pu=Q[i][j];
+      q=pu.h;
+      s=pu.t;
+      N[j]=list(q,s);
+    }
+    M[i]=N;
+  }
+  list O;
+  pu.h=poly(0);
+  pu.t=poly(0);
+  for(i=1; i<=size(W); i++)
+  {
+    N=list();
+    for(j=1; j<=size(W[i]); j++)
+    {
+      pu=W[i][j];
+      q=pu.h;
+      s=pu.t;
+      N[j]=list(q,s);
+    }
+    O[i]=N;
+  }
+  pu.h=poly(0);
+  pu.t=poly(0);
+  setring H;
+  list R=list();
+  list S=list();
+  //print("anello definito");
+  def EK=imap(r,EK);
+  def MM=imap(r,M);
+  def OO=imap(r,O);
+  def pd=imap(r,pd);
+  list G=list();
+  list N=list();
+  for(i=1; i<=size(MM); i++)
+  {
+    for(j=1; j<=size(MM[i]); j++)
+    {
+      pu.h=MM[i][j][1];
+      pu.t=MM[i][j][2];
+      N[j]=pu;
+    }
+    G[i]=N;
+  }
+  list V;
+  for(i=1; i<=size(OO); i++)
+  {
+    for(j=1; j<=size(OO[i]); j++)
+    {
+      pu.h=OO[i][j][1];
+      pu.t=OO[i][j][2];
+      N[j]=pu;
+    }
+    V[i]=N;
+  }
+  //print(V);
+  //print(G);
+  matrix C;
+  list COEFF;
+  poly p=0;
+  poly q=0;
+  ideal I;
+  list M;
+  i=0;
+  jmp g;
+  int k;
+  for(j=1; j<=size(EK);j++)
+  {
+    //print("arrivo");
+    //print(j);
+    p=MultEKPolys(EK[j],G);
+    //ideal
+    I=0;
+    if (size(V[D[j]-minimo+1])!=0)
+    {
+      M=list();
+      //  jmp g;
+      for(i=1; i<= size(V[D[j]-minimo+1]); i++)
+      {
+       //print("arrivo");
+       //print(j);
+       p=MultEKPolys(EK[j],G);
+       //ideal
+        I=0;
+       if (size(V[D[j]-minimo+1])!=0)
+           {
+            M=list();
+          //  jmp g;
+       for(i=1; i<= size(V[D[j]-minimo+1]); i++)
+           {
+            g=V[D[j]-minimo+1][i];
+            g.h=(g.h)*t;
+            M[i]=g.h+g.t;
+          }
+        g=V[D[j]-minimo+1][i];
+        g.h=(g.h)*t;
+        M[i]=g.h+g.t;
+      }
       I=M[1..size(M)];
      attrib(I,"isSB",1);
 //print(I);
+  }
 //print(I);
 q=reduce(t*p,I);
 q=subst(q,t,1);
        C=coef(q,pd);
        COEFF=C[2,1..ncols(C)];
        for(k=1;k<=size(COEFF);k++)
+          {
             if(COEFF[k]!=0)
            { Jms=insert(Jms,COEFF[k],size(Jms));}
+          }
+      }
 setring r;
 def Jms=imap(H,Jms);
 return(Jms);
+      attrib(I,"isSB",1);
+      //print(I);
+    }
+    //print(I);
+    q=reduce(t*p,I);
+    q=subst(q,t,1);
+    C=coef(q,pd);
+    COEFF=C[2,1..ncols(C)];
+    for(k=1;k<=size(COEFF);k++)
+    {
+      if(COEFF[k]!=0)
+      { Jms=insert(Jms,COEFF[k],size(Jms));}
+    }
+  }
+  setring r;
+  def Jms=imap(H,Jms);
+  return(Jms);
+}
 example
 …
  ring r=0, (x,y,z),rp;
  ideal Borid=y^2*z,y*z^2,z^3,y^5;
+attrib(Borid,"isSB",1);
+    list B=ArrangeBorel(Borid);
+    list NumN;
+    list N;
+    int i;
+    int d;
+    for(i=1;i<=size(B);i++)
+       {
+        d=deg(B[i][1]);
+        N[i]=kbase(Borid,d);
+        NumN[i]=size(N[i]);
+       }
+int qc=NumNewVar(B, NumN);
+//Now I must define the NEW RING,
+//putting the c parameters inside.
+list L=ringlist(r);
+list L2;
+L2[1]=L[1];
+L2[2]=list();
+for(i=qc;i>=1;i--)
+    {
+     L2[2][i]="c("+string(i)+")";
+    }
+L2[3]=list(list("rp",qc));
+L2[4]=L[4];
+L[1]=L2;
+if(defined(K)){kill K;}
+def K=ring(L);
+export K;
+setring(K);
+def Borid=imap(r,Borid);
+def N=imap(r,N);
+def B=imap(r,B);
+//NumN contains only scalars so I do not imap it
+int j;
+list Q;
+int s;
+list M;
+jmp pp;
+for(i=1;i<=size(B);i++)
+    {
+      Q[i]=list();
+     for(j=1;j<=size(B[i]);j++)
+        {
+          M=NewTails(N[i],s);
+          pp.h=B[i][j];
+          pp.t=M[1];
+          Q[i][j]=pp;
+          s=s+M[2];
+          //print(s);
+        }
+    }
+list P=ArrangeTails(Q);
+list EK,D= EKPolynomials(P);
+     int massimo=Max(D);
+//list V=VConst(P, massimo);
+//pause();
+list V=VmConstructor(P,massimo,r);
+list W=FinalVm(V,P,K);
+//print("I V ridotti in ordine sono");
+//print(W);
+list Jms=SchemeEq(W,EK,D,P,K);
+Jms;}
+ attrib(Borid,"isSB",1);
+ list B=ArrangeBorel(Borid);
+ list NumN;
+ list N;
+ int i;
+ int d;
+ for(i=1;i<=size(B);i++)
+ {
+   d=deg(B[i][1]);
+   N[i]=kbase(Borid,d);
+   NumN[i]=size(N[i]);
+ }
+ int qc=NumNewVar(B, NumN);
+ //Now I must define the NEW RING,
+ //putting the c parameters inside.
+ list L=ringlist(r);
+ list L2;
+ L2[1]=L[1];
+ L2[2]=list();
+ for(i=qc;i>=1;i--)
+ {
+   L2[2][i]="c("+string(i)+")";
+ }
+ L2[3]=list(list("rp",qc));
+ L2[4]=L[4];
+ L[1]=L2;
+ if(defined(K)){kill K;}
+ def K=ring(L);
+ export K;
+ setring(K);
+ def Borid=imap(r,Borid);
+ def N=imap(r,N);
+ def B=imap(r,B);
+ //NumN contains only scalars so I do not imap it
+ int j;
+ list Q;
+ int s;
+ list M;
+ jmp pp;
+ for(i=1;i<=size(B);i++)
+ {
+   Q[i]=list();
+   for(j=1;j<=size(B[i]);j++)
+   {
+     M=NewTails(N[i],s);
+     pp.h=B[i][j];
+     pp.t=M[1];
+     Q[i][j]=pp;
+     s=s+M[2];
+     //print(s);
+   }
+ }
+ list P=ArrangeTails(Q);
+ list EK,D= EKPolynomials(P);
+ int massimo=Max(D);
+ //list V=VConst(P, massimo);
+ //pause();
+ list V=VmConstructor(P,massimo,r);
+ list W=FinalVm(V,P,K);
+ //print("I V ridotti in ordine sono");
+ //print(W);
+ list Jms=SchemeEq(W,EK,D,P,K);
+ Jms;
+}
 //////////////////////////////////////////////////////////////////////
 …
 EXAMPLE:  example JMarkedScheme; shows an example"
+{
 list Jms;
 if(BorelCheck(Borid,r))
+  {
    if(size(Borid)==1)
      { Jms=list();}
   else{
     //print("Input is OK");
     attrib(Borid,"isSB",1);
     list B=ArrangeBorel(Borid);
     list NumN;
     list N;
     int i;
     int d;
     for(i=1;i<=size(B);i++)
+       {
+  list Jms;
+  if(BorelCheck(Borid,r))
+  {
+    if(size(Borid)==1) { Jms=list();}
+    else
+    {
+      //print("Input is OK");
+      attrib(Borid,"isSB",1);
+      list B=ArrangeBorel(Borid);
+      list NumN;
+      list N;
+      int i;
+      int d;
+      for(i=1;i<=size(B);i++)
+      {
         d=deg(B[i][1]);
         N[i]=kbase(Borid,d);
         NumN[i]=size(N[i]);
+       }
+int qc=NumNewVar(B, NumN);
+if(qc==0)
+{Jms=list(0);}
+else
+ {
+//Now I must define the NEW RING,
+//putting the c parameters inside.
+list L=ringlist(r);
+list L2;
+L2[1]=L[1];
+L2[2]=list();
+for(i=qc;i>=1;i--)
+    {
+     L2[2][i]="c("+string(i)+")";
+    }
+L2[3]=list(list("rp",qc));
+L2[4]=L[4];
+L[1]=L2;
+if(defined(K)){kill K;}
+def K=ring(L);
+export K;
+setring(K);
+def Borid=imap(r,Borid);
+def N=imap(r,N);
+def B=imap(r,B);
+//NumN contains only scalars so I do not imap it
+int j;
+list Q;
+int s;
+list M;
+jmp pp;
+for(i=1;i<=size(B);i++)
+    {
+      Q[i]=list();
+     for(j=1;j<=size(B[i]);j++)
+      }
+      int qc=NumNewVar(B, NumN);
+      if(qc==0) {Jms=list(0);}
+      else
+      {
+        //Now I must define the NEW RING,
+        //putting the c parameters inside.
+        list L=ringlist(r);
+        list L2;
+        L2[1]=L[1];
+        L2[2]=list();
+        for(i=qc;i>=1;i--)
+        {
+          M=NewTails(N[i],s);
+          pp.h=B[i][j];
+          pp.t=M[1];
+          Q[i][j]=pp;
+          s=s+M[2];
+          //print(s);
+          L2[2][i]="c("+string(i)+")";
+        }
+    }
+list P=ArrangeTails(Q);
+list EK,D= EKPolynomials(P);
+     int massimo=Max(D);
+//list V=VConst(P, massimo);
+//pause();
+list V=VmConstructor(P,massimo,r);
+list W=FinalVm(V,P,K);
+//print("I V ridotti in ordine sono");
+//print(W);
+//list
+Jms=SchemeEq(W,EK,D,P,K);
+keepring K;}
+}
+  }
+else
+   {
+        L2[3]=list(list("rp",qc));
+        L2[4]=L[4];
+        L[1]=L2;
+        if(defined(K)){kill K;}
+        def K=ring(L);
+        export K;
+        setring(K);
+        def Borid=imap(r,Borid);
+        def N=imap(r,N);
+        def B=imap(r,B);
+        //NumN contains only scalars so I do not imap it
+        int j;
+        list Q;
+        int s;
+        list M;
+        jmp pp;
+        for(i=1;i<=size(B);i++)
+        {
+          Q[i]=list();
+          for(j=1;j<=size(B[i]);j++)
+          {
+            M=NewTails(N[i],s);
+            pp.h=B[i][j];
+            pp.t=M[1];
+            Q[i][j]=pp;
+            s=s+M[2];
+            //print(s);
+          }
+        }
+        list P=ArrangeTails(Q);
+        list EK,D= EKPolynomials(P);
+        int massimo=Max(D);
+        //list V=VConst(P, massimo);
+        //pause();
+        list V=VmConstructor(P,massimo,r);
+        list W=FinalVm(V,P,K);
+        //print("I V ridotti in ordine sono");
+        //print(W);
+        //list
+        Jms=SchemeEq(W,EK,D,P,K);
+        keepring K;
+      }
+    }
+  }
+  else
+  {
     print("WRONG IDEAL IN INPUT");
     print("It is NOT BOREL");
+   }
 return(Jms);
+  }
+  return(Jms);
+}
 example
 …
  ring r=0, (x,y,z),rp;
  ideal Borid=y^2*z,y*z^2,z^3,y^5;
 JMarkedScheme(Borid,r);
+}
 ////////////////////////////////////////////////////////////////////
+ JMarkedScheme(Borid,r);
+}
+////////////////////////////////////////////////////////////////////

Singular/LIB/algebra.lib

-                      rd4cec6a
+                      r7161aca
+  }
   // --------------------- change of variable names -------------------------
+  execute("ring @bsr = ("+charstr(bsr)+"),y(1..m),("+os+");");
+  list l2;
+  for (int ii = 1; ii <= m; ii++)
+  {
+    l2[ii] = "y("+string(ii)+")";
+  }
+  ring @bsr = create_ring(ringlist(bsr)[1], l2, "("+os+")", "no_minpoly");
   ideal J = fetch(bsr,J);
   ideal PHI = fetch(bsr,PHI);

Singular/LIB/assprimeszerodim.lib

-                      rd4cec6a
+                      r7161aca
+{
    def R = basering;
    execute("ring QT = ("+charstr(R)+"), "+varstr(R, nvars(R))+", dp;");
+   ring QT = create_ring(ringlist(R)[1], varstr(R, nvars(R)), "dp", "no_minpoly");
    setring(R);
    map phi = QT, f;
 …
      M[1..d, j] = coeffs(reduce(f*basis[j], J), basis, vars);
+   }
    execute("ring QT = ("+charstr(R)+"), "+varstr(R, nvars(R))+", dp;");
+   ring QT = create_ring(ringlist(R)[1], varstr(R, nvars(R)), "dp", "no_minpoly");
    matrix M = imap(R, M);
    ideal F = det(M-var(1)*freemodule(d));
 …
 //=== mapping T to p and test if d=deg(F)
    def R = basering;
    execute("ring Rhelp = ("+charstr(R)+"), T, dp;");
+   ring Rhelp = create_ring(ringlist(R)[1], "T", "dp", "no_minpoly");
    setring R;
    map phi = Rhelp,p;

Singular/LIB/chern.lib

rd4cec6a	r7161aca
3305	3305	int n=nvars(basering);
3306	3306	def br@=basering; // remember the base ring
3307		~~execute("ring r@=("+ charstr(basering) +"),("+varstr(basering)+",homvar@), dp;~~");
	3307	ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+",homvar@)", "dp", "no_minpoly");
3308	3308	execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
3309	3309	ideal I=F(I);

Singular/LIB/classify.lib

rd4cec6a	r7161aca
256	256	PhiG = MapReduce(PhiG);
257	257
258		~~execute("ring RingB="+charstr(basering)+",("+A_Z("x",corank)+"),(c,ds);~~");
	258	ring RingB = create_ring(ringlist(basering)[1], "("+A_Z("x",corank)+")", "(c,ds)", "no_minpoly");
259	259	export RingB;
260	260	setring ring_rest;

Singular/LIB/ellipticcovers.lib

-                      rd4cec6a
+                      r7161aca
+proc mod_init()
+{
+newstruct("graph","list vertices, list edges");
+newstruct("Net","list rows");
+system("install","graph","print",printGraph,1);
+system("install","Net","print",printNet,1);
+system("install","Net","+",catNet,2);
+}
+static proc mod_init()
+{
+  newstruct("graph","list vertices, list edges");
+  newstruct("Net","list rows");
+  system("install","graph","print",printGraph,1);
+  system("install","Net","print",printNet,1);
+  system("install","Net","+",catNet,2);
+}
 static proc catNet(Net N, Net M)
+{
 list L;
 list LN=N.rows;
 list LM=M.rows;
 int widthN=size(LN[1]);
 int widthM=size(LM[1]);
 int nm=max(size(LN),size(LM));
 for (int j=1; j<=nm; j++)
+{
+  list L;
+  list LN=N.rows;
+  list LM=M.rows;
+  int widthN=size(LN[1]);
+  int widthM=size(LM[1]);
+  int nm=max(size(LN),size(LM));
+  for (int j=1; j<=nm; j++)
+  {
     if (j>size(LN)){LN[j]=emptyString(widthN);}
     if (j>size(LM)){LM[j]=emptyString(widthM);}
     L[j]=LN[j]+LM[j];
+}
+Net NM;
+NM.rows=L;
+return(NM);}
+  }
+  Net NM;
+  NM.rows=L;
+  return(NM);
+}
 …
 static proc printNet(Net N)
+{
+list L = N.rows;
+for (int j=1; j<=size(L); j++)
+{
+   print(L[j]);
+}
+}
+static proc net(def M){
+  if (typeof(M)=="list"){
+  list L = N.rows;
+  for (int j=1; j<=size(L); j++)
+  {
+    print(L[j]);
+  }
+}
+static proc net(def M)
+{
+  if (typeof(M)=="list")
+  {
     return(netList(M));
+  }
 …
   L[1]=string(M);
   N.rows=L;
+return(N);}
+  return(N);
+}
 …
   G;
+}
 proc makeGraph(list v, list e)
 …
   G;
+}
 proc propagator(def xy, def d)
 …
+"
+{
+  if ((typeof(xy)=="list")||(typeof(d)=="int")) {
+  if ((typeof(xy)=="list")||(typeof(d)=="int"))
+  {
     number x = xy[1];
     number y = xy[2];
 …
     if (d==0) {return(x^2*y^2/(x^2-y^2)^2);}
     number p=0;
+    for (int j=1; j<=d; j++){
+    for (int j=1; j<=d; j++)
+    {
        if (d%j==0){p=p+(j*x^(4*j)+j*y^(4*j))/(x*y)^(2*j);}
+    }
     return(p);
+  }
+  if ((typeof(xy)=="graph")||(typeof(d)=="list"))  {
+  if ((typeof(xy)=="graph")||(typeof(d)=="list"))
+  {
     list xl = ringlist(basering)[1][2];
     list ed = xy.edges;
     number f=1;
+    for (int j=1; j<=size(ed); j++){
+    for (int j=1; j<=size(ed); j++)
+    {
        execute("number xx1 = "+xl[ed[j][1]]);
        execute("number xx2 = "+xl[ed[j][2]]);
 …
     return(f);
+  }
+  if ((typeof(xy)=="graph")||(typeof(d)=="int"))  {
+  }
+ERROR("wrong input type");}
+  if ((typeof(xy)=="graph")||(typeof(d)=="int"))
+  {
+  }
+  ERROR("wrong input type");
+}
 example
 { "EXAMPLE:"; echo=2;
 …
   propagator(G,list(1,1,1,0,0,0));
+}
 proc computeConstant(number f,number xx)
 …
 RETURN:  number, the constant coefficient of the Laurent series of f in the variable x.
 THEORY:  Computes the constant coefficient of the Laurent series by iterative differentiation.
 KEYWORDS: Laurent series
 EXAMPLE:  example computeConstant; shows an example
 …
   int j;
   poly de;
+  while (tst==0){
+     ff=f*xx^k;
+     for (j=1; j<=k; j++){
+        ff=diff(ff,xx)/j;
+     }
+  de = subst(denominator(ff),xx,0);
+  if (de!=0){
+     poly nu = subst(numerator(ff),xx,0);
+     return(number(nu/de));
+  }
+  k=k+1;
+  }
+ERROR("error in computeConstant");}
+  while (tst==0)
+  {
+    ff=f*xx^k;
+    for (j=1; j<=k; j++)
+    {
+      ff=diff(ff,xx)/j;
+    }
+    de = subst(denominator(ff),xx,0);
+    if (de!=0)
+    {
+      poly nu = subst(numerator(ff),xx,0);
+      return(number(nu/de));
+    }
+    k++;
+  }
+  ERROR("error in computeConstant");
+}
 example
 { "EXAMPLE:"; echo=2;
 …
   computeConstant(P,x2);
+}
 proc evaluateIntegral(number P, list xL)
 …
+{
   number p = P;
+  for(int j=1; j<=size(xL); j++){
+  for(int j=1; j<=size(xL); j++)
+  {
      p=computeConstant(p,xL[j]);
+  }
+return(p);}
+  return(p);
+}
 example
 { "EXAMPLE:"; echo=2;
 …
   evaluateIntegral(p,list(x1,x3,x4,x2));
+}
 proc permute (list N)
 …
+"
+{
+   int i,j,k;
+   list L,L1;
+   if (size(N)==1){
+     return(list(N));
+   } else {
+     k=1;
+     for (i=1; i<=size(N); i++){
+       L=permute(delete(N,i));
+       for (j=1; j<=size(L); j++){
+          L1[k]=L[j]+list(N[i]);
+          k=k+1;
+       }
+     }
+   }
+return(L1);}
+  int i,j,k;
+  list L,L1;
+  if (size(N)==1)
+  {
+    return(list(N));
+  }
+  else
+  {
+    k=1;
+    for (i=1; i<=size(N); i++)
+    {
+      L=permute(delete(N,i));
+      for (j=1; j<=size(L); j++)
+      {
+        L1[k]=L[j]+list(N[i]);
+        k=k+1;
+      }
+    }
+  }
+  return(L1);
+}
 example
 { "EXAMPLE:"; echo=2;
 …
+"
+{
+ring R = 2,(x(1..n)),dp;
+ideal I = maxideal(a);
+list L;
+for (int j=1;j<=size(I);j++){
+  L[j]=leadexp(I[j]);
+}
+return(L);}
+  ring R = 2,(x(1..n)),dp;
+  ideal I = maxideal(a);
+  list L;
+  for (int j=1;j<=size(I);j++)
+  {
+    L[j]=leadexp(I[j]);
+  }
+  return(L);
+}
 example
 { "EXAMPLE:"; echo=2;
   partitions(3,7);
+}
 proc gromovWitten(def P,list #)
 …
+"
+{
+  if (typeof(P)=="number") {
+  list xl = ringlist(basering)[1][2];
+  int j;
+  for(j=1; j<=size(xl); j++){
+     execute("number n= "+xl[j]);
+     xl[j]=n;
+     kill n;
+  }
+  list pxl = permute(xl);
+  number p = 0;
+  for(j=1; j<=size(pxl); j++){
+     p=p+evaluateIntegral(P,pxl[j]);
+  }
+  return(p);
+  }
+  if (typeof(P)=="graph"){
+     if (size(#)>1){
+       return(gromovWitten(propagator(P,#)));
+     } else {
+  if (typeof(P)=="number")
+  {
+    list xl = ringlist(basering)[1][2];
+    int j;
+    for(j=1; j<=size(xl); j++)
+    {
+      execute("number n= "+xl[j]);
+      xl[j]=n;
+      kill n;
+    }
+    list pxl = permute(xl);
+    number p = 0;
+    for(j=1; j<=size(pxl); j++)
+    {
+      p=p+evaluateIntegral(P,pxl[j]);
+    }
+    return(p);
+  }
+  if (typeof(P)=="graph")
+  {
+    if (size(#)>1)
+    {
+      return(gromovWitten(propagator(P,#)));
+    }
+    else
+    {
       int d =#[1];
       list pa = partitions(size(P.edges),d);
       list re;
       int ti;
+      for (int j=1; j<=size(pa); j++) {
+       ti=timer;
+       re[j]=gromovWitten(propagator(P,pa[j]));
+       ti=timer-ti;
+       //print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(sum(re))+"     "+string(ti));
+      for (int j=1; j<=size(pa); j++)
+      {
+        ti=timer;
+        re[j]=gromovWitten(propagator(P,pa[j]));
+        ti=timer-ti;
+        //print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(sum(re))+"     "+string(ti));
+      }
      return(lsum(re));
+     }
+      return(lsum(re));
+    }
+  }
+}
 …
   gromovWitten(G,2);
+}
 proc computeGromovWitten(graph P,int d, int st, int en, list #)
 …
+"
+{
+     number s =0;
+     list pararg;
+     list re;
+     list pa = partitions(size(P.edges),d);
+     int vb=0;
+     if (size(#)>0){vb=#[1];}
+     int ti;
+     if (vb>0){print(size(pa));}
+     for (int j=1; j<=size(pa); j++) {
+      if ((j>=st)&(j<=en)){
+       ti=timer;
+       //pararg[j]=list(propagator(G,pa[j]));
+       re[j]=gromovWitten(propagator(P,pa[j]));
+       ti=timer-ti;
+       if (vb>0){print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(lsum(re))+"     "+string(ti));}
+      } else {re[j]=s;}
+     }
+     //list re = parallelWaitAll("gromovWitten", pararg, list(list(list(2))));
+     return(re);
+  number s =0;
+  list pararg;
+  list re;
+  list pa = partitions(size(P.edges),d);
+  int vb=0;
+  if (size(#)>0){vb=#[1];}
+  int ti;
+  if (vb>0){print(size(pa));}
+  for (int j=1; j<=size(pa); j++)
+  {
+    if ((j>=st)&(j<=en))
+    {
+      ti=timer;
+      //pararg[j]=list(propagator(G,pa[j]));
+      re[j]=gromovWitten(propagator(P,pa[j]));
+      ti=timer-ti;
+      if (vb>0){print(string(j)+" / "+string(size(pa))+"    "+string(pa[j])+"     "+string(re[j])+"      "+string(lsum(re))+"     "+string(ti));}
+    }
+    else
+    {re[j]=s;}
+  }
+  //list re = parallelWaitAll("gromovWitten", pararg, list(list(list(2))));
+  return(re);
+}
 example
 …
   computeGromovWitten(G,2,3,7,1);
+}
 proc lsum(list L)
 …
+{
   execute(typeof(L[1])+" s");
+  for(int j=1; j<=size(L); j++){
+     s=s+L[j];
+  }
+return(s);}
+  for(int j=1; j<=size(L); j++)
+  {
+    s=s+L[j];
+  }
+  return(s);
+}
 example
 { "EXAMPLE:"; echo=2;
 …
   lsum(L);
+}
 proc generatingFunction(graph G, int d)
 …
   int j,jj;
   list pa,L;
+  for (j=1; j<=d; j++){
+  for (j=1; j<=d; j++)
+  {
     pa = partitions(size(G.edges),j);
     L = computeGromovWitten(G,j,1,size(pa));
+    for (jj=1; jj<=size(pa); jj++) {
+       s=s+L[jj]*monomial(pa[jj]);
+    }
+  }
+return(s);}
+    for (jj=1; jj<=size(pa); jj++)
+    {
+      s=s+L[jj]*monomial(pa[jj]);
+    }
+  }
+  return(s);
+}
 example
 { "EXAMPLE:"; echo=2;

Singular/LIB/equising.lib

rd4cec6a	r7161aca
1399	1399
1400	1400	def old_ring=basering;
1401		~~execute("ring @myRing=("+charstr(basering)+"),("+varstr(basering)+"),ds;~~");
	1401	ring @myRing = create_ring(ringlist(basering)[1], "("+varstr(basering)+")", "ds", "no_minpoly");
1402	1402	poly f=imap(old_ring,f);
1403	1403

Singular/LIB/finvar.lib

rd4cec6a	r7161aca
1390	1390	poly A(1)=M[1,2]; // denominator of Molien series (for now)
1391	1391	string mp=string(minpoly);
1392		~~execute("ring R=("+charstr(br)+"),("+varstr(br)+"),ds;~~");
	1392	ring R = create_ring(ringlist(br)[1], "("+varstr(br)+")", "ds", "no_minpoly");
1393	1393	if (mp!="0")
1394	1394	{

Singular/LIB/fpaprops.lib

rb258e2a	r7161aca
877	877	}
878	878
879		proc lpGkDim(ideal G)
	879	proc lpGkDim_lib(ideal G)
880	880	"USAGE: lpGkDim(G); G an ideal in a letterplace ring
881	881	RETURN: int

Singular/LIB/gmssing.lib

-                      rd4cec6a
+                      r7161aca
+  }
+  execute("ring G="+string(charstr(@R))+",("+s+","+varstr(@R)+"),(ws("+
+    string(deg(highcorner(g))+2*gmsmaxdeg)+"),"+os+",c);");
+  ring G = create_ring(string(charstr(@R)), "("+s+","+varstr(@R)+")", "(ws("+string(deg(highcorner(g))+2*gmsmaxdeg)+"),"+os+",c)");
   poly gmspoly=imap(@R,t);

Singular/LIB/goettsche.lib

-                      rd4cec6a
+                      r7161aca
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   // compute the generating function by the Goettsche's formula up to degree n in t@
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   // compute the generating function by the Goettsche's formula up to degree n in t@
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=1;
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   // compute the generating function by the Nakajima-Yoshioka formula up to degree n in t@
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   // compute the generating function by the Nakajima-Yoshioka formula up to degree n in t@
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=1;
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=1;
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=1;
 …
   def br@=basering; // remember the base ring
   // add additional variables z@, t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", z@, t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", z@, t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=1;
 …
   def br@=basering; // remember the base ring
   // add additional variable t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=(1-t@^2)*PPolyW(q, m, n, t@, d);
 …
   def br@=basering; // remember the base ring
   // add additional variable t@ to the base ring
   execute("ring r@= (" + charstr(basering) + "),("+varstr(basering)+", t@), dp;" );
+  ring r@ = create_ring(ringlist(basering)[1], "("+varstr(basering)+", t@)", "dp", "no_minpoly");
   execute( "map F= br@,"+varstr(br@)+";" ); // define the corresponding inclusion of rings
   poly rez=(1-t@^2)*PPolyW(q, m, n, t@, d);

Singular/LIB/graal.lib

-                      rd4cec6a
+                      r7161aca
+  {
     def origin = basering;
     execute("ring ringForGeneralPosition = ("+charstr(basering)+"),("+varstr(basering)+"),lp;");
+    ring ringForGeneralPosition = create_ring(ringlist(basering)[1], "("+varstr(basering)+")", "lp", "no_minpoly");
     ideal m = fetch(origin,m);
     newRing = 1;
 …
   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;

Singular/LIB/mprimdec.lib

-                      rd4cec6a
+                      r7161aca
+  {
     def BAS=basering;
     execute("ring Rloc=("+charstr(basering)+","+varstr(basering)+"),dummy,(C,dp);");
+    ring Rloc = create_ring("("+charstr(basering)+","+varstr(basering)+")", "dummy", "(C,dp)");
     module @N=imap(BAS, @N);
     poly @q=prepareSat(@N);
 …
   if(size(ann)==0)
+  {
     execute("ring Rloc=("+charstr(basering)+","+varstr(basering)+"),dummy,(C,dp);");
+    ring Rloc = create_ring("("+charstr(basering)+","+varstr(basering)+")", "dummy", "(C,dp)");
     module @N=imap(BAS, @N);
     poly @q=prepareSat(@N);
 …
   if(size(ann)==0)      //check, whether ann=0
+  {
    execute("ring Rloc=("+charstr(basering)+","+varstr(basering)+"),dummy,(C,dp);");
+   ring Rloc = create_ring("("+charstr(basering)+","+varstr(basering)+")", "dummy", "(C,dp)");
    module @N=clrSBmod(imap(BAS, @N));
    module @M=freemodule(nrows(@N));
 …
       ring RAU = create_ring(ringlist(basering)[1], "("+indep[@k1][@k2][1]+","+indep[@k1][@k2][2]+")", indep[@k1][@k2][3], "no_minpoly");
       module @N=std(imap(BAS,@N)); // the standard basis in (R[U])[A]
       execute("ring Rloc=("+charstr(basering)+","+indep[@k1][@k2][2]+"),("+indep[@k1][@k2][1]+"),(C,dp);");
+      ring Rloc = create_ring("("+charstr(basering)+","+indep[@k1][@k2][2]+")", "("+indep[@k1][@k2][1]+")", "(C,dp)");
       module @N=imap(RAU,@N); //std in lokalisierung
       @N=clrSBmod(@N);

Singular/LIB/numerAlg.lib

-                      rd4cec6a
+                      r7161aca
  setring W1;
  number j1=jj;
  execute("ring q=(real,0),("+varstr(S)+"),dp;");
+ ring q = create_ring("(real,0)", "("+varstr(S)+")", "dp");
  ideal I=imap(W1,I);
  ideal J=imap(W1,J);
  execute("ring qq=0,("+varstr(S)+"),dp;");
+ ring qq = create_ring(0, "("+varstr(S)+")", "dp");
  ideal I=imap(S,I);
  ideal J=imap(S,J);
 …
  if((u^2)==0)
+ {
   execute("ring A=(real,e-1),("+varstr(S)+",I),ds;");
+  ring A = create_ring("(real,e-1)", "("+varstr(S)+",I)", "ds");
   ideal II=imap(S,J);
   list rw=imap(S,rw);
 …
+ {
   int d=dim(std(J));
   execute("ring R=(complex,e-1,I),("+varstr(S)+"),ds;");
+  ring R = create_ring("(complex,e-1,I)", "("+varstr(S)+")", "ds");
   list w=imap(S,w);
   ideal II=imap(S,J);
 …
   if(tt==d)
+  {
    execute("ring A=(complex,e,I),("+varstr(S)+"),dp;");
+   ring A = create_ring("(complex,e,I)", "("+varstr(S)+")", "dp");
    t=tt;
+  }
   else
+  {
    execute("ring RR=(real,e-2),("+varstr(S)+",I),dp;");
+   ring RR = create_ring("(real,e-2)", "("+varstr(S)+",I)", "dp");
    ideal II=imap(S,J);
    list rw=imap(S,rw);
 …
     setring M;
     sz1=size(SOL);
     execute("ring RRRQ=(real,e-1),("+varstr(S)+",I),dp;");
+    ring RRRQ = create_ring("(real,e-1)", "("+varstr(S)+",I)", "dp");
     ideal HH=imap(RR,HH);
     if(dim(std(HH))==0)
 …
    if(sz1==sz2)
+   {
     execute("ring A=(complex,e,I),("+varstr(S)+"),dp;");
+    ring A = create_ring("(complex,e,I)", "("+varstr(S)+")", "dp");
     t=d;
+   }
    else
+   {
     execute("ring RQ=(real,e-1),("+varstr(S)+"),dp;");
+    ring RQ = create_ring("(real,e-1)", "("+varstr(S)+")", "dp");
     ideal II=imap(S,J);
     def RW=WitSet(II);
 …
         if((ni+nr)<1/10^(2*e-3))
+        {
          execute("ring A=(complex,e,I),("+varstr(S)+"),dp;");
+         ring A = create_ring("(complex,e,I)", "("+varstr(S)+")", "dp");
          list W(ii)=imap(RW,W(ii));
          t=0;
 …
+      {
        def SS=Singular2bertini(W(ii));
        execute("ring D=(complex,e,I),("+varstr(S)+",s,gamma),dp;");
+       ring D = create_ring("(complex,e,I)", "("+varstr(S)+",s,gamma)", "dp");
        string nonsin;
        ideal H,L;
 …
          if(tr<=1/10^(2*e-3))
+         {
           execute("ring A=(complex,e,I),("+varstr(S)+"),dp;");
+          ring A = create_ring("(complex,e,I)", "("+varstr(S)+")", "dp");
           t=ii;
           ii=d+1;

Singular/LIB/numerDecom.lib

-                      rd4cec6a
+                      r7161aca
    if((n-rn)!=dd)
+   {
+    execute("ring R=0,("+varstr(S)+",z(1..dd)),dp;");
+    list l2 = ringlist(S)[2];
+    for (int ii = 1; ii <= dd; ii++)
+    {
+     l2[size(l2)+1] = "z("+string(ii)+")";
+    }
+    ring R = create_ring(0, l2, "dp");
     ideal I=imap(rs,I);
     ideal H(0..n),L,LL,L(1..dd),LL(1..dd),h(1..dd),N(0..dd);
 …
+     {
       int w(q-1)=0;
+      execute("ring D(q)=(0,s,gamma),("+varstr(S)+",z(1..q)),dp;");
+      list l2 = ringlist(S)[2];
+      for (int ii = 1; ii <= q; ii++)
+      {
+       l2[size(l2)+1] = "z("+string(ii)+")";
+      }
+      ring D(q) = create_ring("(0,s,gamma)", l2, "dp");
       string nonsin(q),stnonsin(q);
       ideal H(1..q);
 …
          for(qq=q-1;qq>=1;qq--)
+         {
+          execute("ring T(qq)=(complex,16,I),("+varstr(S)+",z(1..qq)),dp;");
+          list l2 = ringlist(S)[2];
+          for (int ii = 1; ii <= qq; ii++)
+          {
+           l2[size(l2)+1] = "z("+string(ii)+")";
+          }
+          ring T(qq) = create_ring("(complex,16,I)", l2, "dp");
           list W(qq-1)=var(1);
+         }
 …
+       {
         int w(qq-1);
+        execute("ring T(qq)=(complex,16,I),("+varstr(S)+",z(1..qq)),dp;");
+        list l2 = ringlist(S)[2];
+        for (int ii = 1; ii <= qq; ii++)
+        {
+         l2[size(l2)+1] = "z("+string(ii)+")";
+        }
+        ring T(qq) = create_ring("(complex,16,I)", l2, "dp");
         list W(qq-1)=var(1);
+       }
 …
       for(qq=q;qq>=1;qq--)
+      {
+       execute("ring T(qq)=(complex,16,I),("+varstr(S)+",z(1..qq)),dp;");
+       list l2 = ringlist(S)[2];
+       for (int ii = 1; ii <= qq; ii++)
+       {
+        l2[size(l2)+1] = "z("+string(ii)+")";
+       }
+       ring T(qq) = create_ring("(complex,16,I)", l2, "dp");
        list W(qq-1)=var(1);
+      }
 …
   export(J(i));
+ }
+ execute("ring RR=0,(x(1..n),"+varstr(S)+"),dp;");
+ list l2;
+ for (int ii = 1; ii <= n; ii++)
+ {
+  l2[ii] = "x("+string(ii)+")";
+ }
+ l2 = l2+ringlist(S)[2];
+ ring RR = create_ring(0, l2, "dp");
  for(i=1;i<=d;i++)
+ {
 …
  int zc=size(D(d));
  export(zc);
+ execute("ring DR=0,("+varstr(S)+",x(1..zc)),dp;");
+ list l2 = ringlist(S)[2];
+ for (int ii = 1; ii <= zc; ii++)
+ {
+  l2[size(l2)+1] = "x("+string(ii)+")";
+ }
+ ring DR = create_ring(0, l2, "dp");
  matrix TT(d)=imap(R,TT(d));
  ideal I=imap(S,I);

Singular/LIB/paraplanecurves.lib

rd4cec6a	r7161aca
1616	1616	poly p=beta(p);
1617	1617
1618		~~execute("ring C=("+charstr(S)+",a),("+varstr(S)+"),ds;~~");
	1618	ring C = create_ring("("+charstr(S)+",a)", "("+varstr(S)+")", "ds");
1619	1619	number p=number(imap(B,p));
1620	1620	minpoly=p;

Singular/LIB/polymake.lib

rd4cec6a	r7161aca
135	135	LIB "customstd.so";
136	136	LIB "gfanlib.so";
137		~~LIB "polymake.so"~~;
	137	load("polymake.so","try");
138	138	option(set,save);
139	139	}

Singular/LIB/primitiv.lib

-                      rd4cec6a
+                      r7161aca
   //---------------- Minimalpolynom in ein Polynom umwandeln: -----------------
   execute("ring splt2="+charakt+","+algname+",dp;");
+  ring splt2 = create_ring(charakt, algname, "dp");
   execute("poly mipol="+minp+";");
   // f ist Polynom in algname und einer weiteren Variablen -> mache f bivariat:
   execute("ring splt3="+charakt+",("+algname+","+varnames+"),dp;");
+  ring splt3 = create_ring(charakt, "("+algname+","+varnames+")", "dp");
   poly f=imap(altring,f);
   //-------------- Vorbereitung des Aufrufes von primitive: -------------------
   execute("ring splt1="+charakt+",(x,y),dp;");
+  ring splt1 = create_ring(charakt, "(x,y)", "dp");
   ideal abbnach=x;
   for (i=1; i<=anzvar; i++) { abbnach=abbnach,y; }
 …
   if (printlevel > -1) { "// new minimal polynomial:",minp; }
   //--------------------- definiere den neuen Ring: ---------------------------
+  execute("ring neuring = ("+charakt+","+algname+"),("+varnames+"),("
+          +ordstr(altring)+");");
+  ring neuring = create_ring("("+charakt+","+algname+")", "("+varnames+")", "("+ordstr(altring)+")");
   execute("minpoly="+minp+";");

Singular/LIB/resolve.lib

-                      rd4cec6a
+                      r7161aca
             laM=subst(laM,var(templist[4][j]),0);
+         }
          execute("ring Rnew=("+charstr(basering)+"),("+string(templist[1])+"),dp;");
+         ring Rnew = create_ring(ringlist(basering)[1], "("+string(templist[1])+")", "dp", "no_minpoly");
          ideal Jnew=imap(R,Jsub);
          ideal eD=imap(R,Esub);
 …
          v=N[4];
          for(j=1;j<=size(v);j++){BO[5]=subst(BO[5],var(v[j]),0);}
          execute("ring R1=("+charstr(R0)+"),("+newvar+"),dp;");
+         ring R1 = create_ring(ringlist(R0)[1], "("+newvar+")", "dp", "no_minpoly");
          list BO=imap(R0,BO);
          ideal C=imap(R0,C);
 …
               laM=subst(laM,var(v[j]),0);
+           }
            execute("ring R2=("+charstr(S)+"),("+newvar+"),dp;");
+           ring R2 = create_ring(ringlist(S)[1], "("+newvar+")", "dp", "no_minpoly");
            list BO=imap(S,B);
            ideal laM=imap(S,laM);
 …
 //--- hypersurface is V(@f)
        @f=Jb[fvec[i]];
        execute("ring R1=("+charstr(R)+"),(@y,"+varstr(R)+"),dp;");
+       ring R1 = create_ring(ringlist(R)[1], "(@y,"+varstr(R)+")", "dp", "no_minpoly");
        poly p=imap(R,@p);
        poly f=imap(R,@f);
 …
              kill tr,L;
+          }
           execute("ring R1=("+charstr(S)+"),(@z,"+varstr(S)+"),dp;");
+          ring R1 = create_ring(ringlist(S)[1], "(@z,"+varstr(S)+")", "dp", "no_minpoly");
           poly p=imap(S,@p);
           list BO=imap(S,BO);
 …
+      {
          string newvar=string(N[1]);
          execute("ring R1=("+charstr(R)+"),("+newvar+"),dp;");
+         ring R1 = create_ring(ringlist(R)[1], "("+newvar+")", "dp", "no_minpoly");
          list BO=imap(R,BO);
          ideal cent=imap(R,cent);

Singular/LIB/rinvar.lib

-                      rd4cec6a
+                      r7161aca
           minPoly = string(minpoly);
+        }
         execute("ring RA1=0,(" + varstr(basering) + "," + parName + "), lp;");
+        ring RA1 = create_ring(0, "(" + varstr(basering) + "," + parName + ")", "lp");
         if (minPoly!="0") { execute("ideal mpoly = std(" + minPoly + ");"); }
         ideal I = imap(RIRR,invarsGens);
 …
     minPoly = string(minpoly);
+  }
   execute("ring RA1=0,(" + varstr(basering) + "," + parName + "), lp;");
+  ring RA1 = create_ring(0, "(" + varstr(basering) + "," + parName + ")", "lp");
   if (minPoly!="0") { execute("ideal mpoly = std(" + minPoly + ");"); }
   ideal Grp = imap(ROBR,Grp);

Singular/LIB/rwalk.lib

-                      rd4cec6a
+                      r7161aca
 int printout=0;
 def xR = basering;
 execute("ring ostR = "+charstr(xR)+",("+varstr(xR)+"),"+ord_str+";");
+ring ostR = create_ring(ringlist(xR)[1], "("+varstr(xR)+")", ord_str, "no_minpoly");
 def old_ring = basering;
 …
 int printout=0;
 def xR = basering;
 execute("ring ostR = ("+charstr(xR)+"),("+varstr(xR)+"),"+ord_str+";");
+ring ostR = create_ring(ringlist(xR)[1], "("+varstr(xR)+")", ord_str, "no_minpoly");
 def old_ring = basering;
 …
    def xR = basering;
    execute("ring ostR = ("+charstr(xR)+"),("+varstr(xR)+"),"+ord_str+";");
+   ring ostR = create_ring(ringlist(xR)[1], "("+varstr(xR)+")", ord_str, "no_minpoly");
    def old_ring = basering;
    //print("//** help ring = " + string(basering));

Singular/LIB/sing.lib

-                      rd4cec6a
+                      r7161aca
   int ii;
   def bas = basering;
+  execute("ring  @r_locstd
+     =("+charstr(bas)+"),(@t@,"+varstr(bas)+"),(dp(1),dp);");
+  ring @r_locstd = create_ring(ringlist(bas)[1], "(@t@,"+varstr(bas)+")", "(dp(1),dp)", "no_minpoly");
   ideal @id = imap(bas,id);
   ideal @hid = homog(@id,@t@);

Singular/LIB/solve.lib

-                      rd4cec6a
+                      r7161aca
     if (oldr!=1)
+    {
+      execute("ring rinC =(complex,"+string(outprec)+
+                 "),("+varstr(basering)+"),lp;");
+      ring rinC = create_ring("(complex,"+string(outprec)+")", "("+varstr(basering)+")", "lp");
       list SOL;
       if (mu==0){SOL[1] = zerolist(nv);}
 …
       if (oldr!=1)
+      {
         execute("ring rinC =(complex,"+string(outprec)+"),("+varstr(basering)+"),lp;");
+        ring rinC = create_ring("(complex,"+string(outprec)+")", "("+varstr(basering)+")", "lp");
         list SOL;
         for (ii=1; ii<=size(L); ii++ ) { execute("SOL[ii]=number("+L[ii]+");"); }
 …
     else
+    {
       execute("ring internC=(complex,"+string(prec)+"),("+varstr(basering)+"),lp;");
+      ring internC = create_ring("(complex,"+string(prec)+")", "("+varstr(basering)+")", "lp");
       ideal H = imap(hr,H);
       list sp = splittolist(splitsqrfree(H[1],var(1)));
 …
       if (oldr!=1)
+      {
         execute("ring rinC =(complex,"+string(outprec)+"),("+varstr(basering)+"),lp;");
+        ring rinC = create_ring("(complex,"+string(outprec)+")", "("+varstr(basering)+")", "lp");
         list SOL;
         list sp=imap(internC,sp);
 …
   if (outprec<prec)
+  {
     execute("ring internC=(complex,"+string(prec)+"),("+varstr(hr)+"),lp;");
+    ring internC = create_ring("(complex,"+string(prec)+")", "("+varstr(hr)+")", "lp");
+  }
   else
+  {
     execute("ring rinC =(complex,"+string(outprec)+"),("+varstr(basering)+"),lp;");
+    ring rinC = create_ring("(complex,"+string(outprec)+")", "("+varstr(basering)+")", "lp");
+  }
   list triC = imap(hr,sp);
 …
     if (oldr!=1)
+    {
       execute("ring rinC =(complex,"+string(outprec)+"),("+varstr(basering)+"),lp;");
+      ring rinC = create_ring("(complex,"+string(outprec)+")", "("+varstr(basering)+")", "lp");
       list SOL=imap(internC,ret1);
       export SOL;
 …
     int ii,jj;
     int nv=size(LL[1]);
+    execute("ring rinC =(complex,"+string(prec)+",I),("
+                           +varstr(basering)+"),lp;");
+    ring rinC = create_ring("(complex,"+string(prec)+",I)", "("+varstr(basering)+")", "lp");
     list SOL,SOLnew;
     for (ii=1; ii<=sizeLL; ii++)

Singular/LIB/standard.lib

-                      rd4cec6a
+                      r7161aca
 static proc parse_L1(string l1)
+{
+  if (find(l1, "(", 1) == 0)   // no parentheses
+  {
+      return(int(l1));
+  }
+  list tokens = tuple_to_tokens(l1);
+  list tokens;
+  if (l1[1] != "(")
+  {
+    tokens[1] = l1;
+  }
+  else
+  {
+    tokens = tuple_to_tokens(l1);
+  }
+  if (tokens[1] == "real")
+  {
+    int p1 = 6;
+    int p2 = 6;
+    if (size(tokens) > 1)
+    {
+      p1 = int(tokens[2]);
+      p2 = p1;
+    }
+    if (size(tokens) > 2)
+    {
+      p2 = int(tokens[3]);
+    }
+    return(list(0, list(p1, p2)));
+  }
+  if (tokens[1] == "complex")
+  {
+    int p1 = 6;
+    int p2 = 6;
+    string imag_unit = "i";
+    if (int(tokens[size(tokens)]) == 0)   // not an integer
+    {
+      imag_unit = tokens[size(tokens)];
+      tokens = delete(tokens, size(tokens));
+    }
+    if (size(tokens) > 1)
+    {
+      p1 = int(tokens[2]);
+      p2 = p1;
+    }
+    if (size(tokens) > 2)
+    {
+      p2 = int(tokens[3]);
+    }
+    return(list(0, list(p1, p2), imag_unit));
+  }
   if (size(tokens) == 1)
+  {
       return(int(tokens[1]));
+    return(int(tokens[1]));
+  }
   list L = int(tokens[1]);
 …
   if (v[1, 4] == "var(" && defined(basering))
+  {
       int i = int(v[5,size(v)-5]);
       v = ringlist(basering)[2][i];
+    int i = int(v[5,size(v)-5]);
+    v = ringlist(basering)[2][i];
+  }
   return(v);
 …
 static proc parse_L2(string l2)
+{
   if (find(l2, "(", 1) == 0)   // no parentheses
+  {
       return(list(parse_var(l2)));
+  if (l2[1] != "(")
+  {
+    return(list(parse_var(l2)));
+  }
   list V = tuple_to_tokens(l2);
   for (int i = size(V); i > 0; i--)
+  {
       V[i] = parse_var(V[i]);
+    V[i] = parse_var(V[i]);
+  }
   return(V);
 …
+{
   string name;
-  intvec w;
   int b1 = find(ordering, "(", 1);
   if (b1 == 0)   // no parentheses
 …
     if (name == "C" || name == "c")
+    {
       w = intvec(0);
+      intvec w = intvec(0);
+    }
     else
+    {
       w = 1:n_vars;
+      intvec w = 1:n_vars;
+    }
+  }
 …
     if (c == 0)
+    {
+      w = 1:int(ordering[b1+1, b2-b1-1]);
+      if (name == "L")
+      {
+        int w = int(ordering[b1+1, b2-b1-1]);
+      }
+      if (name == "wp" || name == "Wp" || name == "ws" || name == "Ws"
+          || name == "a")
+      {
+        intvec w = int(ordering[b1+1, b2-b1-1]);
+      }
+      if (!defined(w))   // else
+      {
+        intvec w = 1:int(ordering[b1+1, b2-b1-1]);
+      }
+    }
     else
+    {
       list W = tuple_to_tokens(ordering[b1, b2-b1+1]);
       w = intvec(int(W[1..size(W)]));
+      intvec w = intvec(int(W[1..size(W)]));
+    }
+  }

Singular/LIB/surfex/Singular/surfex.lib

-                      rd4cec6a
+                      r7161aca
                                     string str_num_mp = "number "+parstr(1)+"="+
                                         decstr2ratstr(rootminpoly())+";";
+                                    execute("ring Iring = 0,("
+//                                          +string(coords)+","+str_para+"),dp;");
+                                            +string(coords)+"),dp;");
+                                    ring Iring = create_ring(0, "("+string(coords)+")", "dp");
                                     basering;
                                     execute(str_num_mp);
 …
                             string str_tmp_l = "ideal eqd_tmp = "+string(tmp_l)+";";
                             def cur_ring = basering;
                             execute("ring Iring = (real,30),("+string(coords)+"),("+ordstr(oring)+");");
+                            ring Iring = create_ring("(real,30)", "("+string(coords)+")", "("+ordstr(oring)+")");
 //                          basering;
                             execute(str_I);
 …
                     if(minp==1) {
                         // switch to a ring without minimal polynomial:
                         execute("ring rr = (real,30,30),("+varstr(base)+"), dp;");
+                        ring rr = create_ring("(real,30,30)", "("+varstr(base)+")", "dp");
 //                      rr;
 //                      "str_I",str_I;
 …
                 if(n-params==3) {
                     p=cleardenom(p);
                     execute("ring rr = (real,30,30),("+varstr(base)+","+parstr(base)+"), dp;");
+                    ring rr = create_ring("(real,30,30)", "("+varstr(base)+","+parstr(base)+")", "dp");
                     rr;
                     "str_I",str_I;

Singular/LIB/tropical.lib

-                      rd4cec6a
+                      r7161aca
   if (nvars(basering)==2)
+  {
     ring BASERING = create_ring(ringlist(ALTERRING)[1], "(t,x(1))", "("+ordstr(ALTERRING)+")", "no_minpoly");
+    execute("ring BASERING=("+charstr(ALTERRING)+"),(t,x(1)),("+ordstr(ALTERRING)+");");
+  }
   else
 …
     variablen=variablen+var(j);
+  }
   ring GRUNDRING = create_ring(ringlist(basering)[1], "("+string(variablen)+",t)", "(dp("+string(nvars(basering)-1)+"),lp(1))", "no_minpoly");
+  execute("ring GRUNDRING=("+charstr(basering)+"),("+string(variablen)+",t),(dp("+string(nvars(basering)-1)+"),lp(1));");
   ideal variablen;
   for (j=1;j<=nvars(basering)-1;j++)
 …
         // from LIFTRING are present,
         // and where also the variables of CUTDOWNRING live
         ring REPLACEMENTRING = create_ring(ringlist(LIFTRING)[1], "("+varstr(CUTDOWNRING)+")", "dp", "no_minpoly");
+        execute("ring REPLACEMENTRING=("+charstr(LIFTRING)+"),("+varstr(CUTDOWNRING)+"),dp;");
         list repl=imap(CUTDOWNRING,repl); // get the replacement rules
                                           // from CUTDOWNRING
 …
       poly mp=minpoly;
       def OLDRING=basering;
       ring NEWRING = create_ring(0, "("+varstr(basering)+","+parstr(basering)+")", "ds");
+      execute("ring NEWRING=0,("+varstr(basering)+","+parstr(basering)+"),ds;");
       ideal I=imap(OLDRING,mp),imap(OLDRING,f);
+    }
 …
+    {
       string polynomstring=string(f);
       ring drawring = create_ring("(0,"+parstr(basering)+")", "("+varstr(basering)+")", "dp");
+      execute("ring drawring=(0,"+parstr(basering)+"),("+varstr(basering)+"),dp;");
       execute("poly f="+polynomstring+";");
+    }
 …
+  }
   // we want to homogenise the ideal i ....
   ring HOMOGRING = create_ring(ringlist(basering)[1], "(@s,"+string(variablen)+")", "dp", "no_minpoly");
+  execute("ring HOMOGRING=("+charstr(basering)+"),(@s,"+string(variablen)+"),dp;");
   ideal i=homog(std(imap(BASERING,i)),@s);
   // ... and compute a standard basis with
 …
+  }
   intmat O=weightVectorToOrderMatrix(whomog);
   ring WEIGHTRING = create_ring(ringlist(basering)[1], "("+varstr(basering)+")", "(M("+string(O)+"))", "no_minpoly");
+  execute("ring WEIGHTRING=("+charstr(basering)+"),("+varstr(basering)+"),(M("+string(O)+"));");
   // map i to the new ring and compute a GB of i, then dehomogenise i,
   // so that we can be sure, that the
 …
   // compute the w-initial ideal with the help of the procedure tInitialForm;
   setring BASERING;
   ring COMPINIRING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "dp", "no_minpoly");
+  execute("ring COMPINIRING=("+charstr(basering)+"),("+string(variablen)+"),dp;");
   ideal i=imap(WEIGHTRING,i);
   ideal ini;
 …
   def BASERING=basering;
   intmat O=weightVectorToOrderMatrix(w);
   ring INITIALRING = create_ring(ringlist(BASERING)[1], "("+varstr(basering)+")", "M("+string(O)+")", "no_minpoly");
+  execute("ring INITIALRING=("+charstr(BASERING)+"),("+varstr(basering)+"),M("+string(O)+");");
   poly f=imap(BASERING,f);
   int GRAD=deg(f);
 …
   def BASERING=basering;
   intmat O=weightVectorToOrderMatrix(w);
   ring INITIALRING = create_ring(ringlist(BASERING)[1], "("+varstr(basering)+")", "M("+string(O)+")", "no_minpoly");
+  execute("ring INITIALRING=("+charstr(BASERING)+"),("+varstr(basering)+"),M("+string(O)+");");
   ideal i=imap(BASERING,i);
   i=std(i);
 …
+  }
   def BASERING=basering;
   ring PARAMETERRING = create_ring("("+string(char(basering))+")", "("+parstr(basering)+")", "ds");
+  execute("ring PARAMETERRING=("+string(char(basering))+"),("+parstr(basering)+"),ds;");
   poly den=imap(BASERING,den);
   poly num=imap(BASERING,num);
 …
+{
   def BASERING=basering;
   ring RADRING = create_ring(ringlist(basering)[1], "(@T,"+varstr(basering)+")", "(dp(1),"+ordstr(basering)+")", "no_minpoly");
+  execute("ring RADRING=("+charstr(basering)+"),(@T,"+varstr(basering)+"),(dp(1),"+ordstr(basering)+");");
   ideal I=ideal(imap(BASERING,i))+ideal(1-@T*imap(BASERING,f));
   if (reduce(1,std(I))==0)
 …
         // return pideal, the initial and the list ergl which tells us
         // which variables we replaced by which form
         ring BASERINGLESS1 = create_ring(ringlist(BASERING)[1], "("+string(variablen)+",t)", "(dp("+string(ncols(variablen))+"),lp(1))", "no_minpoly");
+        execute("ring BASERINGLESS1=("+charstr(BASERING)+"),("+string(variablen)+",t),(dp("+string(ncols(variablen))+"),lp(1));");
         ideal i=imap(BASERING,pideal);
         ideal ini=imap(BASERING,pini); //ideal ini2=tInitialIdeal(i,wvecp,1);
 …
+  }
   setring BASERING;
   ring BASERINGLESS2 = create_ring(ringlist(BASERING)[1], "("+string(variablen)+",t)", "(dp("+string(ncols(variablen))+"),lp(1))", "no_minpoly");
+  execute("ring BASERINGLESS2=("+charstr(BASERING)+"),("+string(variablen)+",t),(dp("+string(ncols(variablen))+"),lp(1));");
   // using the 0/1-vector which tells us which variables belong
   // to the set of smallest entries of wvec
 …
   if ((numberdeletedvariables>0) and (anzahlvariablen>1)) // if only t remains,
   { // all true variables are gone
     ring NEURING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "(dp("+string(size(variablen)-1)+"),lp(1))", "no_minpoly");
+    execute("ring NEURING=("+charstr(basering)+"),("+string(variablen)+"),(dp("+string(size(variablen)-1)+"),lp(1));");
     ideal i=imap(BASERING,i);
     ideal gesamt_m=imap(BASERING,gesamt_m);
 …
+    {
       // pass to a ring which has variables which are suitable for gfan
       ring GFANRING = create_ring(ringlist(basering)[1], "(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z)", "dp", "no_minpoly");
+      execute("ring GFANRING=("+charstr(basering)+"),(a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z),dp;");
       ideal phiideal=b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z;
       phiideal[nvars(PREGFANRING)]=a; // map t to a
 …
     else
+    {
       ring PARARing = create_ring(ringlist(basering)[1], "t", "ls", "no_minpoly");
+      execute("ring PARARing=("+charstr(basering)+"),t,ls;");
+    }
     ideal PARA; // will contain the parametrisation
 …
     variablen=variablen+var(j);
+  }
   ring INITIALRING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "dp", "no_minpoly");
+  execute("ring INITIALRING=("+charstr(basering)+"),("+string(variablen)+"),dp;");
   ideal ini=imap(BASERING,ini);
   // compute the associated primes of the initialideal
 …
   else
+  {
     ring TINRING = create_ring(ringlist(basering)[1], "("+string(variablen)+")", "dp", "no_minpoly");
+    execute("ring TINRING=("+charstr(basering)+"),("+string(variablen)+"),dp;");
+  }
   ideal tin=imap(BASERING,tin);
 …
     if (size(#)>0) // noAbs was used
+    {
       ring NOQRing = create_ring("("+string(char(LIFTRing))+")", "("+varstr(basering)+","+parstr(LIFTRing)+")", "dp");
+      execute("ring NOQRing=("+string(char(LIFTRing))+"),("+varstr(basering)+","+parstr(LIFTRing)+"),dp;");
       execute("qring TESTRing=std("+#[1]+");");
       ideal i=imap(BASERING,i);

Singular/LIB/tropicalNewton.lib

rd4cec6a	r7161aca
125	125	number c_denom = denominator(c);
126	126	number c_num = numerator(c);
127		~~execute("ring r_Val=0,"+string(uniformizingParameter)+",~~ds");
	127	ring r_Val = create_ring(0, string(uniformizingParameter), "ds");
128	128	poly c_denom = imap(origin,c_denom);
129	129	poly c_num = imap(origin,c_num);

Singular/dyn_modules/freealgebra/freealgebra.cc

-                      rd4cec6a
+                      r7161aca
+{
   const short t1[]={2,RING_CMD,INT_CMD};
+  if (iiCheckTypes(args,t1,1))
+  const short t2[]={3,RING_CMD,INT_CMD,INT_CMD};
+  if (iiCheckTypes(args, t2, 0) || iiCheckTypes(args, t1, 1))
+  {
     ring r=(ring)args->Data();
 …
       return TRUE;
+    }
+    ring R=freeAlgebra(r,d);
+    int ncGenCount = 0;
+    if (iiCheckTypes(args,t2,0))
+      ncGenCount = (int)(long) args->next->next->Data();
+    ring R=freeAlgebra(r,d,ncGenCount);
     res->rtyp=RING_CMD;
     res->data=R;

Singular/dyn_modules/python/Makefile.am

rd4cec6a	r7161aca
51	51	python_moduledir = ${datadir}/singular/LIB
52	52	python_module_DATA = cart.py interpreter.py perf.py symm.py util.py
	53	EXTRA_DIST=cart.py interpreter.py perf.py symm.py util.py

Singular/dyn_modules/systhreads/Makefile.am

rd4cec6a	r7161aca
18	18	endif
19	19
20		SOURCES = shared.cc lintree.cc bytebuf.cc thread.cc bytebuf.h lintree.h channel.h syncvar.h threadconf.h
	20	SOURCES = shared.cc lintree.cc bytebuf.cc thread.cc bytebuf.h lintree.h channel.h syncvar.h threadconf.h thread.h singthreads.h
21	21	systhreads_la_SOURCES = $(SOURCES)
22	22	systhreads_la_CPPFLAGS = ${MYINCLUDES} ${P_PROCS_CPPFLAGS_COMMON}

Singular/iparith.cc

-                      rd4cec6a
+                      r7161aca
   ideal v_id=(ideal)v->Data();
   tHomog hom=testHomog;
+#ifdef HAVE_SHIFTBBA
+  if (rIsLPRing(currRing))
+  {
+    if (currRing->LPncGenCount < IDELEMS(v_id))
+    {
+      Werror("At least %d ncgen variables are needed for this computation.", IDELEMS(v_id));
+      return TRUE;
+    }
+  }
+#endif
   if (ww!=NULL)
+  {

Singular/ipshell.cc

-                      rd4cec6a
+                      r7161aca
 //  R->cf->ch=0;
   // ----------------------------------------
   // 1:
+  // 0, (r1,r2) [, "i" ]
   if (L->m[1].rtyp!=LIST_CMD)
+  {
 …
+  }
   lists LL=(lists)L->m[1].data;
   if (((LL->nr!=2)
+  if ((LL->nr!=1)
     || (LL->m[0].rtyp!=INT_CMD)
     || (LL->m[1].rtyp!=INT_CMD))
+  && ((LL->nr!=1)
+    || (LL->m[0].rtyp!=INT_CMD)))
+  {
+    WerrorS("invalid coeff. field description list");
+  {
+    WerrorS("invalid coeff. field description list, expected list(`int`,`int`)");
     return;
+  }
   int r1=(int)(long)LL->m[0].data;
   int r2=(int)(long)LL->m[1].data;
+  r1=si_min(r1,32767);
+  r2=si_min(r2,32767);
+  LongComplexInfo par; memset(&par, 0, sizeof(par));
+  par.float_len=r1;
+  par.float_len2=r2;
   if (L->nr==2) // complex
+    R->cf = nInitChar(n_long_C, NULL);
+  else if ((r1<=SHORT_REAL_LENGTH)
+  && (r2<=SHORT_REAL_LENGTH))
+    R->cf = nInitChar(n_R, NULL);
+  else
+  {
+    LongComplexInfo* p = (LongComplexInfo *)omAlloc0(sizeof(LongComplexInfo));
+    p->float_len=r1;
+    p->float_len2=r2;
+    R->cf = nInitChar(n_long_R, p);
+  }
+  if ((r1<=SHORT_REAL_LENGTH)   // should go into nInitChar
+  && (r2<=SHORT_REAL_LENGTH))
+  {
+    R->cf->float_len=SHORT_REAL_LENGTH/2;
+    R->cf->float_len2=SHORT_REAL_LENGTH;
+  }
+  else
+  {
+    R->cf->float_len=si_min(r1,32767);
+    R->cf->float_len2=si_min(r2,32767);
+  }
+  // ----------------------------------------
+  // 2: list (par)
+  if (L->nr==2)
+  {
+    //R->cf->extRing->N=1;
+  {
     if (L->m[2].rtyp!=STRING_CMD)
+    {
 …
       return;
+    }
+    //(rParameter(R))=(char**)omAlloc0(rPar(R)*sizeof(char_ptr));
+    rParameter(R)[0]=omStrDup((char *)L->m[2].data);
+  }
+  // ----------------------------------------
+    par.par_name=(char*)L->m[2].data;
+    R->cf = nInitChar(n_long_C, &par);
+  }
+  else if ((r1<=SHORT_REAL_LENGTH) && (r2<=SHORT_REAL_LENGTH)) /* && L->nr==1*/
+    R->cf = nInitChar(n_R, NULL);
+  else /* && L->nr==1*/
+  {
+    R->cf = nInitChar(n_long_R, &par);
+  }
+}

Singular/table.h

-                      rd4cec6a
+                      r7161aca
 ,{D(jjSTD),        STD_CMD,         SMATRIX_CMD,    SMATRIX_CMD   , ALLOW_NC |ALLOW_RING}
 ,{D(jjDUMMY),      STRING_CMD,      STRING_CMD,     STRING_CMD    , ALLOW_NC |ALLOW_RING}
 ,{D(jjSYZYGY),     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD     , ALLOW_PLURAL |ALLOW_RING}
 ,{D(jjSYZYGY),     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD     , ALLOW_PLURAL |ALLOW_RING}
+,{D(jjSYZYGY),     SYZYGY_CMD,      MODUL_CMD,      IDEAL_CMD     , ALLOW_NC |ALLOW_RING}
+,{D(jjSYZYGY),     SYZYGY_CMD,      MODUL_CMD,      MODUL_CMD     , ALLOW_NC |ALLOW_RING}
 #ifdef HAVE_PLURAL
 ,{D(jjENVELOPE),   ENVELOPE_CMD,    RING_CMD,       RING_CMD      , ALLOW_PLURAL |NO_RING}

Tst/Letterplace.lst

-                      rb258e2a
+                      r7161aca
 Manual/makeLetterplaceRing.tst
 Manual/serreRelations.tst
+Manual/lpGkDim.tst
 Manual/lpKDim.tst
 Manual/lpMonomialPrinting.tst
 …
 Manual/lpSickleDim.tst
 Manual/lpHilbert.tst
+Manual/lpLmDivisible.tst

Tst/Manual/letterplace_std.res.gz.uu

-                      rb258e2a
+                      r7161aca
+begin 640 letterplace_std.res.gz
+M'XL(",KG3EP"`VQE='1E<G!L86-E7W-T9"YR97,`39%=:X,P%(;O_16'L@N-
+M6HS6?B`&-GIC&;MH=S>DZ$Q%$%<T97&_?B?1-KT0S7N>]SD$3Y_[[`,`*(/W
+M[`T68A#+MBD7">#7N>D:83N)I=[`&+1<"-Y?V^*;GP=1+3O^NQQ$(:S3K`EG
+MS:7GO"XGTV,8,>B;KH8>4@@\6WJC]^=X^ZLA5@R:3D#%:^R?RY];5R$;&R!F
+M.+S`$5.UXK6M>=D7=N_%CH'6#`8N]*JC23?HKGC10H9E7Y+1WY"1C&Y$))$>
+M8$"DCP\936=[[QRP@Q>VLZ<U.P:'Q#I\T3S5#N/$,,S3,%0RS"*BM7Y(U9%(
+M5T,:BZ:N6GW'W3OF&VRE;-L@F@(TT%T4S&,-Q'F*T327RK&)J8'7]`E=Y^GX
+:.,YWH0'3_UO]R]M@4R=YL?X!*I4F?1H"````
+begin 644 letterplace_std.res.gz
+M'XL("(6:P5P"`VQE='1E<G!L86-E7W-T9"YR97,`?9M)CQQ7=H7W^A6)AA=4
+M)9/]Y@$""=CHC0##"[4!+PR"D%IL@3`A-ZAJN.A?[^][.41&RG:SR:J,C'C#
+M'<XY][[0G__U3]__R^%PB.\.__S]/QW^\/S;\YO/GW[ZPW<'?OOPZ==/SZ^^
+M_>X;?Q[>O3M\_OC\_/'+WS[_^)>/'WY[_OG-KQ__Z\UOSS\^?_/GRS#I,LQ?
+MOWS\^,M/YY%N7^9WA]OOY<WACW\\Q-OG^N;PY=.OOQR^'-X>PNM7+Z^_OO[O
+M;U__Z6_;T^W=X=.OSX>?/_["V!]^^L^___HS]];MAOZ.+_]Z^(&K3O^/GW_Y
+M^-.7'U]]>5V_W6X:[PZ_?7Q>4_VP79V,_?/''S\?ON?AT\O3UU-_^OKT]9B?
+M7IY>7A^X\/1RXN_3U]LS,3#2\\^OOF?P#_\>W[]=]V[/<C&]?YN2#W$M/ZW'
+M3RGZ\>GEN&Y:M^7SLTYQO?UXO>VTW58<;81\OL`(<>9P^7K=4-^_Y=+Y^Q?'
+MZ#5N-[=X=VM[__;K[>-U0W%S3TQO#O_QZ?/GPY=MOWAO7=K,%LO=$W4Y-!U>
+M_>5#^1`_]`__]NWMN_;@W/+Z);]^2:]?XL[%\?_TX*%O+HR;"U_]<'=YY\.7
+M\O123JD^^4LZO40_MB=_YM-</]/1?^/KZP`IO%F/Y6/,Y\>.,:U?HD]X[5C6
+MSW0L<?T2<<]YZ#7@-E1DJ'R9:CV0SO<]3HF98[^LD;4F?SJV]VYW949;7[DP
+M1SJ5\TXNPY[W=S=L.3\0C^7R?5X_X\U8J3X$[_]Z^SF$+ZNZS%BO]Y1PNXD`
+M_G]V>P[=VS:OVSNE<-U$#Y<Q4]@&K;=GN".4BR-BS1=7M'&9K,U^=@9>*9>)
+M4[L,?LHU]8N[N;@-WV[#EU,,Y;+B4POILJI69[]N=8[-(OW]VXLM7$\[_[Z>
+M8)C;IW3JN5X_^-@@>Z^/I>,XW^0":VG;$#WTN`U1T\5&ES$F0!':>8BUQ+,)
+MUL)C#+%=/[*6,OKV.:VOT^US/(YXGG49M<7;TC3&V%9WS#&GZQ(*^1#JO"TI
+MGV*/:6SK-V'R''&W\1@PV"PUS5+JN"[>!3/43".%=K>+%FLI+2^C7/>29BJY
+MQQI&O]L1M@FAII%3'MN^8LRM])##V+:71J^ISG&YMJ*'SS-D]Q.NFR4B9RZU
+MS%KNKA)!O0V6V6>K=Y9H?;("K%QJV&(`>*^ML8;&WMKF/2Q39PTAY=IRBR7O
+M+$3^I8EY&/*\E?.R0XJ)*(KE9C2V5]H8/5RNK:440IRU5+DC7Q&NQL"(;=GA
+M8C&"*T2R(:;M3I!DY-GQQ643:^8Z6IACYK;9*^:<:HYSC+39"V\';FR]I;2%
+M3,R#_Y41YYV]VFRY,U>;H]P%T)AQAC"P52WWUB+YR+DY8\._<6<L$(D8"?F<
+MO&L/!&&]>F=M@$?CN/,VL[04Q[;R08"5?-GS\G+K>*;,;<6X%K*=,6_I>6I`
+MR`C8<4L*N``KP\1Q/G@55#1!KWA9XVW!QRL&^GM.=_8`P>ZL0++O4TD)D*^D
+MM,)MS&U4MASG-G#JZ3Z*<]L2^93;V&8]$I5AF]:L?IA7+(ZCW.82?6>,F]-/
+M/?;1YMT$^+GWDK9)B$ARIN>[B7+'Q"6T'<A%D/EE[W(@EU`C&\CK-$:.;<9:
+M6Z@DPIP]D"*D[(B%9,Q`36XY\Q5I"T;DVMEZ!YQS:9&'"K?WF+N.G#,!?J&G
+M`D3-.@K)`*!Q>V2241%8D5L8O>78Y^9@EP_Q1+)_Q#1[6T;C]R98Y9);SZ.)
+M9&#9#(/L9)S0B/Y!6(]&?O)P9@*P35T7@9G.K;!A"8XVB4A`@[LZN2@DECJE
+MJE!J9<*"OF.8IP=C#8W501/7`W;-+-*QTQGB2(5,`.58@_B5&""Q3]AAEIXG
+MN.=T3,@"@"H`(X*R';0DU3/VJ0#Q&(VX8W23E^6'EA/_!Y=PP[Q;#P1!G`'P
+MV"E6`!1W]3'88\/>G9]I1%"X59W+2C)3L^8$6'`#:^BES0*MUL9204?2D;\%
+MS,^%=8VN=1TKUH&I6FM:-F'D#.#?>VM1$RA4E_')C5HR[I9$V";C8%C,R@\P
+M5EH`P0AAAAQR2A\U@.O\PW:ADXRQ(+H\(K[!:Z7@8)<6ZL)WJ`ZD;C@]CHX[
+M'KT$E1.-F+LG8P,[81<,/J8AD(UQ.$1S`XS$WB1(6V%K$UMW8")%PWU@UTF:
+MM0XY5L)5VFFAL[`4!3@@`<O"Z2'=+0&=HYWG\@CXB^NF&8(WV>FH8",6Q_O,
+MBI_X-;$9K`W]L"-0O/!L-1%U!+\V/)M8C\MJ5;$!-Z?6.DO#V&7320L,)K@^
+M_5+@GZ0!ZU4*P"9E5)['_CD!*?H:N!\XC]C(F1!FSY.O8&"BA"S6WVR0_&Q5
+M_612:\FA9]BW:19B?TC=R0I-102$8W0-#&T3F4F?+&P@R4A`HQ<;X!?N`E.R
+MWC'N!EDHSQ("U03E<7U*Z!)_"(DDV^,V2"3D\1`!"5DTPA()'1R46!DQ,0FI
+M9!2!4PF^QL*U,P:K&$4'D7GZ&C1)4Y0B>DD%MDD*8XD63.1$FL*_P,#<@'ZQ
+M,Z,:[`1$(+0#""6DX",`E#P#N=AMJ@0^:&-DLV?"04$@@I*5$'X3,[0\L:[8
+M@=>)=9`<__`K2[P/MJ-I6;KN-FF;F8_Q"!C2!(@FW)L0`L6,N0PPD!N4LI,0
+M;2*ANBSP''#)\DFS5*,X&8TPC(>7^'(78<U<CGU],;4AT$\D:$CF"\0O.U#5
+M%%P'@$<A.)%C9#>X1'*;'F"*#(&A15RB3$!FV7UYCLAM;1=7)$,?XAAX0)BP
+M6>*)U;-R2&C9:.`<S15<#R.X(3"B+G@-?!X(59`_*6V5S6"`/H>(,!(H60G0
+M1SQ)43P!`,'.:.P4,8`T9$`21H'"MX._6%#EHSYCL5"`6%Z!#O:#";#41*CB
+M=@`N+\1LFP*Z:%"(Q`2%T/$`[F%F8D/,DD.'XV,9890L5<G581)/0TNC,!$A
+M0(@"=9`XM<K00R-L$F7%*C?#F=*G4@SH(=:7*@8S`3R(12)GFR#Q9)!!OFM$
+MK,YFY)(B72:V$PB3X'T!;#B71G=H2,DA36$$H%4&Z`(FR!.0&18OH.B:*:KM
+M)6T`D5QIV(TM:?61F#EI0LR][*(I"-^Q"\O5LY'*HP*W5A=G:B!/9>FBFP@J
+MJ6GEA'PH$V(:HH(1V340RPB$%?LWA%451755PBX8EX29ZE)2J6DEXM[L@6Z)
+M<ZXT,1A=SV"=:RB7Q?.$J%A#L0`^=F-:<,-NKI[AB-9X5^1=0G`)<T8%++$T
+M*V07C$9.F;":7;*"V]FGJ*&"P+RZ-G>1&D2>IB!&A%"[J-W&S7SGXK2[?5P)
+M`I,_I#ZDO7@WFG,@(-L$*8%R-#J!719[2JOJ4Q:FR[+B40D!WHZXBVYJ_6J8
+M9=2`'*-\3*"JA@`-V`H,I;)JJYX3^P!*XHD_X$%<0"5U)05=5=[TL(_JZ<#D
+M#,8DMC*A,M43A!N7*=I0%UB7[['A5'Z1/<:,FY$QUK:C;%BL3Z#].'9PR_=#
+MDJ+<<H6)VX/@Q542!D0J:J71634$!2@AUJO[!=]A60:>HI[215%2DSO<$_B)
+MU;)FY3<Y9LFO"I0XAGEMH%"5`M8D(J;+`!HN9R.&5-3VXCE[[^JC0A@NG173
+M7K)!YZ23#,ENDH\"D^#,7(^:'/(*!L1:Q<B49YS"!4P9.!!P,+P)*V`@[$?X
+M'7A2J<FZ-PM:/>&37>21JCLF+93ZQ,#>M]1C(%W8>0,!1:"4O?E,/7-XAT-4
+MZ*0SYJGY<87EVG2Z5.Y'TFDW,9FR(UV*.B[U/3L1SB7]+F_KM3.5K@VUL),,
+MIYWK*>WJR&$W%?`)(>R)D!3(Z7$J2CO<0L"1@.U^0UB3E"%]VV:1<Q,D+[8U
+MQK<R\=S!@6@(55@1Y']@J(!T4RFKRLO>02@'Z'ZIY#9W^Q*NSYH.L5/B;H?P
+M-Y[M%!GZ+.W"U`X>J3:L8@I_XN.N*5\)2`M452<%ZC+`Q!6DG::@T!">JGAC
+MX0;[5B43Z$-Z6OU1Z5B2P3)AZV*L/AYU#)@'0`U[5UUZ+-(!P('X@7:[VF/`
+M*@H<N%T%"7\.R9OTQTO@L6*P[)$V.**CH;#6H^I^S$/&HMRFM)Y,:TJ-*3P.
+M>-$R/%N:!.OHN9)615UVB6-O`#XN2TC8HF*9"R)@EFH:(TG(<Z#0\CJ[(7-?
+M!0Q9<'M73"W*(.4W\#OW.9@2MK0;H![%S(IKUJBEE`=P3+;,0.=9NJ('B`5K
+M3<S!DK*J&G6H`,ICKV.M8?F#D[(=2="9C014ET6ZX`*1*_PLNN4NV$$>LT@M
+MX!"4D(T[0!#^PO-C[#$5C2<ARCOL&&X05_DX5//$,W^3YL;=[#XJS6$/=DJ=
+M3*A,:^!0UK0I+PVSAU/L/&U,8#0L;$_4VHNB@=#&/%6%!6:`KG9;F:$9<NS)
+M-:L4+#&E-,.8*=OOD-3F`R2/69@"QR%^W;Z*4,ECX3T7!C,-,I4$M=XR@PF3
+MJ3C0N)`WL]UZE.<^.RED`2'C*`497GD(`K/`G@4.C6Z?UT*""\D,(G/D/$J!
+M060B/^ZSYZ3JGM3G2E>7C:.P*CIH29YH!XNOIZUCPE5/(*I!,)-J=:XQ49;I
+M=BKEN`K_9J\\:R\$,J)O552&"RJ(@"$(<>O4Q,/^$W)`_"`(L2XXT"Q)RXYQ
+MCGQM/5<M0]0'D-LB'"MO##[TZKI0;"(4R\-ASXC?[%OR$.,C[IN1N],D3&I)
+M$VV.V8<8]JG($(3):I4`\(5457@!%DMGD?#3F@63&^!(2RQDVN]`=2`SFMZU
+MH]/-OZY$D[J#+5_W7RQPK95'7(+6=+1,*VJN;&;*^4BX/>O$U4QB3>1L,1-9
+M)EQAL4IY;$.(/+=D!SN()]/.LH`%HP6ROPT['$/9!6*4':8/ZY]IK82P#+8<
+MA)!L/X3`L@"F9,R6L/C2>@;!OJI8U,>P[]A+,IR&9QR_Y]Q)GJ@LF_V49M$"
+M('@Z`/:8R>A_0955)&LFH@PG0DTM61!X[%+LU)2['$DGE)#-$C*[NEI[&>AY
+M_)Y5KU9X^B"N8JO9=XJB6%!!>7F6M)T6K(8R<TNOEBK]7'_WU2JP4*"2M@T"
+MN!JZ:LJN23PU(*V3[#9'V66;!SX=]&``#6^P%GLL"+.V0H.PP&CV.P1P:DA,
+MD>6)8FM^/E8#1PJS8D=`65C2@G%K&78)>]J$`A%;//<);4TFZ<CZ&;EIJ470
+MC+WXMY-"=@X?E"BC(I],CK9+U1I6RM4U,M$P0;D-@;=*:3M/81UGW646Q*L4
+MM1PN%D3^0]2**-PN/(##:?41VUD*H#^:#:YY[BR9+3L64CQ;6;95./*\>HRL
+MA#'4$X`)&=.:-9O\:)K!;-VZ`>"DH*;LLJ&UYQY+)@*DK>82HEQXI<PS/(07
+MA!%Q9)-V!35,!+DB!5;Y296-.A-;'@2\ZD$*MB'7XU(9=OQM/Q0S5?FF7X/I
+MVUBY=9\B0^LF0ZK9H\W](7]R0$BNWANJ`9=*]+)KM0\*S`Y(RC86O]O]P]'6
+M,LF:<+:[$/?`!5JV4B)S$>6V(FQJF2[=0Z4RUZ$!WY?UM1TATK#V^V&2ASCV
+MC(!BS6B!BPA)(CO`G^6GU4C5`,Y#<25/*ZQV+&>_)Q(+V`O):T:N)"OV$.<Z
+M5$1\>E06Z[GC1P3./:<=53?$;;1)G"WF;`1FR1HW$M/=DPCD!`A"/LJ,P5)]
+M7^W@Y>$)!F%FL`7//Z.%%[N$(:.)K@9824S!F^P-CC!VZ815A'1@4>YP%7V=
+M2`ZC:X%T#PLVH&RN-`NB9NH_%,S8TA!6`MB#MS`%.>QS1J-&38L:I`2)-A'#
+MRDD(K>ZJE'+JUF%RL(<7LK?M9'&,8AS&M518.E&("^N\>G4^[-L]\,ZJH2TI
+M04)E.:1),G@VQ?KF.CM)'L?7:4_8O)+^U['HGF3(QVZ%HTH%$J+-3//$+N-<
+MR[,Q2;9:*`\)@F3!ACD^5HAY-0"MZ:T@SPT5NWVV04$F]!S;UCC5>C\JU>\B
+MKQR'66^OT1,#6*\D-:1GH"TLQ>LF]'5,\DXKNRP2:E7^"#P"=O35(E7HV21C
+M+=D/4_6^FD^YQ7WZV+!H]M64'JS6(R(!TJ[I-#FG:AZ,QV!$8M]E7SS9L4EJ
+M@&J,*Z`!GF0G14PEXFQAJV;K.HYX**"4SW-U1DP9/![M$())=L3SVC"?F@HF
+MIO!0)/5U@"'"P5R>`F'V2*+*@MU.$(R.S\[UR%U/8>6'HJ18M\65`U-.)S7!
+M=)Z-UD8L;`JUR2.$NV;S6;0M5K3!UST'P?C8S?K:E5"KJK7Q0]=V5GEU7\='
+MJPQ<7-8)F!W5J`?-C&K&>MCFN=HZ?JMN-;:'7J8G)AY46#^LW@II*K$&+6`A
+ME06]8JWKBCR.W#<DLHT?,M>QLZAG7QZ@-G"QNXW"8E_2YC?!%ZS<'R/?ON.0
+M6O4<&(+-TC)CL7_JV52XO0.QNA7$6;:YM1I"VA6`)[B0':7>!]9Z30"+-OO&
+MJPG!DC"(Y,W6QI(C^?[]'VR%I"!NL`Q.46MT6\68T$.H%'9ZC80G2CWHZ[8T
+M@5,%E<?"\/:2^3LU!OYU3[]E%O+`3BY%`F+0MO4>OX^^*^-K"D5)7%=7&4'?
+M[=81"WE7CQ^[M=.TUP=T*M@]EF$J]FHEW/=A=TJV(8I:E7$]&$I*Y2DNXT"D
+MSKZMXIF@*;].[:VK;0_F:M_?&CF8S[NPP@]](0%TX'FF;F?E'M58M]K>;?L&
+MC"?[1$J,ZY"^VAHD*0PJ#<93+<7R&#;Y_=MDZ6@_&HI.ZYV.?-?>0TUE6_2K
+MB-U>M5HV(!IL+TA[1-C802D)'X0`0-]@F#N.!RM-`_4E1(-8&_M*ERJ=`GJ]
+MI:"<\HR^A'T8-"6^0$CP]O;0'[?[RG:M>E=K?=^R!%ILI)`2+L%CMOWA()K#
+M5R;.YZQJWX?^A_6D?9YI+G3Q]J&%`8(4@<1""'JW/9_;PSD\P(H_@F=3MH`,
+MI_Y8(&7?&/2]C(`-2EGD9^MJLU6^+&AFNS*6@G;@+=,7RN9[^>#!B3TZSQ*#
+M?09[AKM$]]!%\*VK11I\=6.%9]@E>%N]KFH_76S'2YX!SM5GN<OKXALDI:PF
+M%^'AV6%:DGG'6D<T</)PRY<P1"R+R+EO<I[6D9HZT$;\ZH#AG=+W[<X,UGM0
+MC?.(>JM\*'L=D.Y;Q$L\V;2P%S4\(O>4I(Z]3$)R$AH`RRCKZ-?"CRR=H<;]
+M&7[R#).5@8V>QK3S09Q=\=SW^;GTFKTEK>$A>5WHC._K^)V0\5TC]8:"M?K6
+M&+!5[G7[N98<RKF\R@3/VV"6<BXX\SU2K;,<9X8]H(5U4K;/5IPH>J));3MV
+M:\75JMDGK?U(6[(.(JEY,&^IM]-!Z6B1%ZR75EFL\BG3PY2=V(I'SSN'[1.%
+M.`+)/*^E['M(>-,W7SP78\;I>S1S[@^KCE!=]_P(`0*5K^X^(I'@VY]*+#%?
+M/9+R;1!%DIH_UOTK(=E>D3RU#NK7^Y&RU_"ECWV[?V3?5%CUJ:]LV,FK=E9'
+M?1"X^-M^H\=;S5/7ZBM0OGB!-?>.O[Z7W+8WRE-_L_X;!/_[@K__]BI^^]T_
++?/,_T)H[0:XP````
+`
 end

Tst/Manual/letterplace_std.stat

-                      rb258e2a
+                      r7161aca
 >> tst_memory_0 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:331856
 >> tst_memory_1 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:2150160
 >> tst_memory_2 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:2191264
 >> tst_timer_1 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:6
+>> tst_memory_0 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:20013576
+>> tst_memory_1 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:21011760
+>> tst_memory_2 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:21068800
+>> tst_timer_1 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:22

Tst/Manual/letterplace_std.tst

-                      rb258e2a
+                      r7161aca
 LIB "tst.lib"; tst_init();
 LIB "freegb.lib";
+// 1
 ring r = 0,(x,y,z),Dp;
 int degree_bound = 5;
 …
 setring R;
 ideal I = -x*y-7*y*y+3*x*x, x*y*x-y*x*y;
+ideal J = std(I);
+J;
+std(I);
+kill r;
+kill R;
+// 2 (c_4_1_7_W)
+ring r = 0,(x4,x3,x2,x1),Dp;
+def R = freeAlgebra(r, 7);
+setring(R);
+ideal I = x4*x4-25*x4*x2-x1*x4-6*x1*x3-9*x1*x2+x1*x1,
+x4*x3+13*x4*x2+12*x4*x1-9*x3*x4+4*x3*x2+41*x3*x1-7*x1*x4-x1*x2,
+x3*x3-9*x3*x2+2*x1*x4+x1*x1,
+*x4*x2-5*x2*x2-41*x1*x4,
+x2*x2-13*x2*x1-4*x1*x3+2*x1*x2-x1*x1,
+x2*x1+4*x1*x2-3*x1*x1;
+std(I);
 tst_status(1);$

Tst/Manual/makeLetterplaceRing.res.gz.uu

-                      rd4cec6a
+                      r7161aca
 begin 640 makeLetterplaceRing.res.gz
+M'XL("$:J*%T"`VUA:V5,971T97)P;&%C95)I;F<N<F5S`*U476O;,!1]]Z\X
+MA#[88-+::;HN9H:XH5`(@RYCKT..KSU1QS:2TC;Y];NR,[LM*8&N`EN7JZ-S
+M/XZDU<_%W7<`08SE78*1T69<RG04@:W?LI+&]2+'SHAC;,0#+<D84DTIUO1#
+M5L6XHJ>Q-L(XJP-5>*#*%5&1=FS]XB2&XEU0^(8+WWWV=_[>\Q?-@+B,D5&.
+M.0..A'-#;X!.8V@R+=\\`G_.^3G6->6Y7$NJC)[A_M[ZJNTF)84ZQZ-0&C-<
+M6>]AI&6]?K`M8'^M,FKY%LT+Q#!FJ,2&M#6?L<.^^Q\A"U^2W5A`.132M<#M
+ML%KN"1.O+^HJAM2WW+MY65"JA#OGBH-^^4N,LEE0D=3;*K-K`)-G5/`.I-;I
+MA#WXVH)_"9782"L.U&YXVQ`ITI)KDA7,'^*FL]&FYDQZHJ__9`M?Z>9FC1MX
+M/G@*O4&8X&(01H51JV?RGIY^T*5D:I9NTPA%LYXG&'@2+C3Y1(&STP*?DO4T
+FQ?&S,?G_/"X_(X_I1\]HP%?</@_VVF\UGX#HS/D+5_+6`4D$````
+M'XL(".*-25T"`VUA:V5,971T97)P;&%C95)I;F<N<F5S`*U476O;,!1]]Z\X
+ME#W88-+8:;LM9H9X85`H@S:CKT.VKSU11S:2LK7Y];NR,[LK&7E8!+;$U;GG
+M?IR+-M_6MU\!1"GN;C-<6&-GC<PO$O#INU32^D'BN1UIBJUXHCNREG37B((>
+MI*IGBG[-C!76VQRHX@-5I8GJ?&`;+Q<I-'M!XQ/FH?\<OH3[(%QW$^(J14D5
+M5@PX$LZ/@PEZG<*0[?E6"?CS+B]1M%15LI"DK%GB_M[9U&Z;DT9;X:?0!DO<
+M..MAY4U;/+D6L+W5)?5\Z^X58EI+*+$EXX[/>,%^^!\ABU^3?7:`9BID:($_
+M8(W<$Q8A5%&3XNQWRF(>C#7>I)#F"[=RU=24:^&ON`'1>/T^1=.MJ<[8KW1W
+M`,<JJ68/Y,[HQ2/X@P,_"IVYP!N.VSN\[8\4><,E2@7[@U@#/O29>HN1Z.,?
+M%>._9/3+SH^"$+S%P:13-)]TTG'2RYO]2]XP&E*R+?=BVPE-RY$GFG@R+C0[
+MH][E:;U/J7R:XOBH+/X_CZMSY'%]II&-^`%PCX=[%':&!R)YY_T&_C-LQ&<$
+"````
+`
 end

Tst/Manual/makeLetterplaceRing.stat

-                      rd4cec6a
+                      r7161aca
 >> tst_memory_0 :: 1562946118:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:232280
 >> tst_memory_1 :: 1562946118:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2151640
 >> tst_memory_2 :: 1562946118:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2192744
 >> tst_timer_1 :: 1562946118:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:7
+>> tst_memory_0 :: 1565101538:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:232264
+>> tst_memory_1 :: 1565101538:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2151640
+>> tst_memory_2 :: 1565101538:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2192744
+>> tst_timer_1 :: 1565101538:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:6

Tst/Short/absfact.res.gz.uu

-                      rd4cec6a
+                      r7161aca
 begin 640 absfact.res.gz
 M'XL("`O%'%T"`V%B<V9A8W0N<F5S`.V<6V_;.!;'W_,IB&*`D2PI(0]OX@3V
 MP^QB%P,L]J'IVZ`IY-2>&IM-@EC=2/WT>VC9)%W1M]:=+K9*45OFS1+/__QX
 M1)&^>?/7W_Y)"&$3\H_??B6OZF5]>;^8OKJ^N%GGP(1@XKO%PZ).TNL+^TXF
 M$U)-E_/JKKY\F+U<+NNJ=N7YA+AC<=FUNBF\W;(,2JI+\KQX^(.\)F.2T#0G
 M29.W^';_Y,OK"5E^>'RNQX3ZQ')"GA[O6_)D*Q9ZU-P"R0B,FE&[.E*C!E_;
 M6X&O3*P3A4Y'B6P@:R&]Y:.D*=KT5OA&S82\G\W)#;:)I_XW//7'Y\6G6?*4
 MDNN+BZLK\G.8_#.Y>YY5]>P]J587D9/%`WGYL+C[@`GWBV5M&WF\_UC/WLU7
 M=98DJ3_,;#N;#++.2,EB299X-'M_:?/?/)+J[FZV7!*LT+7U.._5RDG=/LU(
 MLIBOBCU4_Y[AN;]42U(MEXL_'F;O;5OUXRKW>59_?'X@_ZGN/\[27VS&^F\Y
 MJ^W9)S?I=>^$KR^(LQ6CD["L2V81\S"81-KZG;W]!1LD[_!@S*Z`,9#=9W@[
 M3@HT4Y4QDXZ:C'%KL<P:MLJ,2+M2_.U88F92I:.V2Q%OQVC#"ZR_:ICE+.>Y
 MN,"2_HNPN/\2;.\6"C6J"M2":S7!Q$RFKDU;!=^[-L%=%'<=0%[[2Q6=:-YL
 M:^;7O_R=H&XBLL&<'TTYTG?<&]]Q*B8<?5@XSII%D[7>AD5EE>.%D0!:F?%5
 MHM62M:G3B4"=L#TZJ?:)`Q6TTJJ54$0FI><;,Y?D7XO[^T`O@&YT"'D0\RF`
 M$'EKBOE<OH]=:+/1"`V))1#D^.4W)-E9.OWA40<BBCJ0,;.H@XJ5H:Y&GP%K
 MGP@[X6TDYA0&.@8B*/>#J*>!-YT&=I1/!W)AGYH8N3B-Z("S$\CE8/5U0N#@
 M4<-Y#S5<'$8-CVF:JWVHX1VC`VCD6EO*5'B6>=%469M7KG`YB<C+5KB^2&R%
 M--]T1E#)^.L2M'==@AV^+@&1ZQ)\^[I$@=<67IH0`T7/YCQ"1BDJ8N.^.#SN
 M%QZC%J&;X3D<\INM2)#E<.P('P_]A#N[,@9<80;@GELSDL:`*V/QD(23)!.$
 MBL6?H1D9W!!+L;[-?1[3'%E5I_E[CRHI-U0:-[<B2^I;7D"-02;4R$7\@"G2
 MIHBB2RV837>C@,2;:/=G"ZM"8(T,*V0*&\ML8Y:P/LLVE@F;9[/\F>A=^,M?
 M+5^EIQ"PJS!`4)91"$IS6+P^7&B@EEE3JZ+A-2^8&F&"*!@%,6IJ6=0JPP->
 M`Y81V2H94QN1@4TML#!D8&MUE;$JV!9LI1IOAK$TQT)%#7O"D67@!LO@MF=S
 M02IPW&=WF8KM0B0JA.S0U$Y,NCH#*FW?0@R5BO^_"4MXCBJYC@4#A:E)B-8M
 ML"KMP.J'#57N#/%.BO`&MA%EHFS3]*`$J1=$?[C=2("Z!EF,+1IVL^5$K`Q$
 MZ7J4QXBBQ;G-&3P`T*KGT5KO]FCMIOW'^HHQGVX&ISZ3",KX-']Y>'K#6N0D
 M(900\^N2#WY]9I.*F%^7\AM85'G7+G7/M<O2N79"\RJ?IGDW<Q.X>&DB@[:A
 M@W^?20R&1?W;P%=0_BXB!<-CSFW$X-QGMF?TX9I1YS:G]IYMRIYG&W/0LQFE
 MSK.3*F/IU=1GL<&_SZ,'O$F+^3>CA^\+.Z,DT_0483`J(G[.J!S\_,QV51$_
 M9U1_*[/ZI]B,FL_]G3%ZV-_MRI!M?Q\U/A.&J<8S*R18GQ)Z/A,G2,1-#'WY
 MC`T+EWL$BE%[I@*_8"9PF`AT/:MC9&#EGVUV_]"6`>T1`]AA8O@E+IX8=OV>
 M+\`':IQ9/?&U+@SD$2OX0NFL#&8?,H4#S<DB`A5C!^B!'=_(^F6,'6"^B_'M
 MNAIWS'H$L:M=#A&$\RA!6E]`#`0YLX9X=)T'X^K+131JOT9&.L807@X,^4;V
 MCRV28X)^)_/;U6'N&#;["UBW\F*;%FX]V'R<!+L"^.I(XI'(1'H+OOP&'HR,
 MMU@P3W_X_0%L:[D7\QP0ZH2%D6C^(EAE$WX4JX]^[;_$S]92@50`__%<[EO!
 M`P54&83K>"`+4D27PE+W'5M[`8R[J'`)KH]/Q6[(S$\#S'R`2]>C4;A(>HJF
 M5BK9N4\@U)AT'[VH)$H*CE\6YL4C>NJ2H0+[HI(!N:0C%\?`@[HEK@&]I*.7
 M+=)`*[)69=#P%K^T:46AD5_:+G#-F,!,A1VA&OPD,!%?6@\VN0';%M9(,N?[
 M(J)(X2$:DL'LQXWOX&."(:9,"$*/.A26W1%E-T0QL=DCE12ZVQNUM7YQ+_N<
 M-*U2-2I1=?N@/E^\R&2(-^ZOPN&MMX`UKA3'MVCY`7"V3Z.`4Z<`;B4,A`K3
 MG2[P2*9]X!VODX*I*E/0PUI/)RH@EMH0ZQG6L5;^*7_9BK?4Y_%6]@D#+<A>
 MA"_B[\]Z$=:>6[//RPX<4O&[,G4,B(03@UW/EX%%#XP^H<Q@%:2_P)$;5P3J
 M!H$5V;O"5'B7YD<BM0<Q)Q)F`$S7HU'`:'K4@!10H5"I%4-WT&X.4!3B>#U8
 MM*"$)$0$H0.6:,<2MGNN1X=S/;RH8)J!KJ:\`#T5Z17>3T[E^I11OGK*\;1]
 M93$\<3Z3P'2<-%H=\0!B;9BUL4*U3=>F6QEQWWS`75#M+C(?H$/0^%LUO1LT
 M3Z>!9GA"O>[1*&A*^K\A@S+`2^GPPG>%*F4T5!'92^F+B.XG,NS/8'Q<)E[Y
 MI1QBF+,HRBXGC/>PCB*G+(\8U+@T*`"A``0S4$HN)#=24E-247*C*0.A%?YG
 M#*-1J03F2$&I4D`1:O[7!P3'NA0H5L*P2@L4:C^MC:390$H+)4JI..#(I:AF
 M`O`K5L,CU4H8#8:656:KEH*6"D^.E>:$R`NDJD1A7WFAN?T>C."-890:.P*#
 MPC:5+!4#$XGKR\"5G_W]GUV&&;6'84/4=E[I&]C5U;%%^LR(4W:?HR;,BKD5
 MQDIKP&XGM?TD5.WQ<9ZP<1[/I+"2MDHN(2(SXW<",!/^%-!ZOBO_M)[QZ@GH
 M-4EV%4Y=BYOM/W,LU`H$>-'"*&%%`T%W[MH.-#\E#AQH;;O21&:^@)XT56LG
 M*UM1K(;;8[76'^R!LLB&;:`P4.JL)@<:@Q%0\3U,[ED"%%D2P).EUS]=_!>^
 '1X0-\DP`````
+M'XL("+=525T"`V%B<V9A8W0N<F5S`.V<6V_;.!;'W_,IB&*`D2PI(0]OX@3V
+MP^QB%P,L]J'IVZ`IY-2>&IM-@EC=2/WT>RC9)%W3M]:=+K9*45OFS1+/__QX
+M1)&^>?/7W_Y)"&$3\H_??B6OZF5]>;^8OKJ^N%GEP(1@XKO%PZ).TNL+^TXF
+M$U)-E_/JKKY\F+U<+NNJ=N7YA+AC<=FWNBZ\V;(,2JI+\KQX^(.\)F.2T#0G
+M29.W^';_Y,OK"5E^>'RNQX3ZQ')"GA[O6_)D*Q9ZU-P"R0B,FE';':E1@Z_M
+MK<!7)E:)0J>C1#:0M9#>\E'2%&UZ*WRC9D+>S^;D!MO$4_\;GOKC\^+3+'E*
+MR?7%Q=45^3E,_IG</<^J>O:>5-U%Y&3Q0%X^+.X^8,+]8EG;1A[O/]:S=_.N
+MSI(D]8>9;6>=0589*5DLR1*/9N\O;?Z;1U+=W<V62X(5^K8>YUNU<E*W3S.2
+M+.9=L8?JWS,\]Y=J2:KE<O''P^R];:M^['*?9_7'YP?RG^K^XRS]Q6:L_I:S
+MVIY]<I->;YWP]05QMF)T$I9UR2QB'@:32%N_L[>_8(/D'1Z,V14P!K+_#&_'
+M28%FJC)FTE&3,6XMEEG#5ID1:5^*OQU+S$RJ=-3V*>+M&&UX@?6[AEG.<IZ+
+M"RSIOPB+^R_!]FZA4*.J0"VX5A-,S&3JVK15\+UO$]Q%<=<!Y+6_5-&+YLVF
+M9G[]R]\)ZB8B&\SYT90C?<>]\1VG8L+1AX7CK%DT6>MM6%16.5X8":"5&>\2
+MK9:L39U.!.J$[=%)M4\<J*!.JU9"$9F4GF_,7))_+>[O`[T`NM$AY$',IP!"
+MY*THYG/Y/G:AS48C-"260)#CE]^09&?I](=''8@HZD#&S*(.*E:&NAI]!JQ]
+M(NR%MY:84QCH&(B@W`^B+0V\Z36PHWPZD`O[U,3(Q6E$!YR=0"X'JZ\3`@>/
+M&LZW4,/%8=3PF*:YVH<:WC,Z@$:NM:5,A6>9%TV5M7GE"I>3B+QLA>N+Q%9(
+M\W5G!)6,ORY!MZY+L,/7)2!R78)O7I<H\-K"2Q-BH.C9G$?(*$5%;-P7A\?]
+MPF/4(G0]/(=#?K,1";(<CAWAXZ&?<&=7QH`KS`#<<VM&TAAP92P>DG"29()0
+ML?@S-".#&V(I5K>YSV.:(ZOJ-'_O427EFDKCYE9D27W+"Z@QR(0:N8@?,$7:
+M%%'TJ06SZ6X4D'@3[?YL854(K)%AA4QA8YEMS!+69]G&,F'S;)8_$[T+?_FK
+MY:OT%`+V%08(RC(*06D.B]>'"PW4,FMJ532\Y@53(TP0!:,@1DTMBUIE>,!K
+MP#(BZY(QM1$9V-0""T,&ME9?&:N";<%6JO%F&$MS+%34L"<<609NL`QN>]87
+MI`+'?7:7J=@N1*)"R`Y-[<2DJS.@TO8MQ%"I^/^;L(3GJ)*K6#!0F)J$:-T`
+MJ](.K'[84.7.$.^D"&]@&U$FRC9-#TJ0>D%L#[=K"5#7((NQ1<-NMIR(E8$H
+M?8_R&%&T.+<Y@P<`6FUYM-:[/5J[:?^QOF+,IYO!J<\D@C(^S5\>GMZP%CE)
+M""7$_+KD@U^?V:0BYM>E_`865=ZU2[WEVF7I7#NA>95/T[R?N0E<O#210=O0
+MP;_/)`;#HOYMX"LH?Q>1@N$QYS9B<.XSVS/Z<,VH<YM3>\\VY99G&W/0LQFE
+MSK.3*F/IU=1GL<&_SZ,'O$F+^3>CA^\+>Z,DT_0483`J(G[.J!S\_,QV51$_
+M9U1_*[/ZI]B,FL_]G3%ZV-_MRI!-?Q\U/A.&J<8S*R18GQ)Z/A,G2,1-#'WY
+MC`T+EWL$BE%[I@*_8"9PF`AT/:MC9&#EGVUV_]"6`=TB!K##Q/!+7#PQ[/H]
+M7X`/U#BS>N)K71C((U;PA=+I#&8?,H4#S<DB`A5C!^B!'=_(^F6,'6"^B_'M
+MNAIWS+8(8E>['"((YU&"M+Z`&`AR9@WQZ#H/QM67BVC4?HV,=(PAO!P8\HWL
+M'ULDQP3]3N:WJ\/<,:SW%[!^Y<4F+=QZL/DX"78%\.Y(XI'(1'H+OOP:'HR,
+M-U@P3W_X_0%L8[D7\QP0ZH2%D6C^(EAE$WX4W4>_]E_B9VNI0"J`_W@N]ZW@
+M@0*J#,)U/)`%*:)/8:G[CHV]`,9=5+@$U\>G8C=DYJ<!9C[`I>_1*%PD/453
+MG4IV[A,(-2;=1R\JB9*"XY>%>?&(+77)4(';HI(!N:0C%\?`@[HEK@&]I*.7
+M+=)`*[)69=#P%K^T:46AD5_:+G#-F,!,A1VA&OPD,!%?6@\VN0;;!M9(,N?[
+M(J)(X2$:DL'LQXWOX&."(:9,"$*/.A26W1%E-T0QL=XCE12ZWQNUL7YQ+_N<
+M-*U2-2I1]?N@/E^\R&2(-^ZOPN%M:P%K7"F.;]'R`^!LGT8!ITX!G!4&K/<Z
+M;=`HLLW@@$0Z@6WNC>MDLR41%<!*K6'U#*LP*_^4OVR$6NKS4"O[A#$69"_"
+M%_&W9EO!U9Z[LL_+#@A2\1LR=0R#A!.#7<J7@:4.C#YU"K/Q^0L<N6=%H&Y0
+M2I%M*TR%-VA^$%)[Z'(B7`:V]#T:98NF1XU%`16*;L2Q>RB[H]8=H2[$\9)`
+MNO"RRKC6$5'H@"?:\83MGNK1X50/+RJ89J"K*2]`3T5ZA;>34[DZ:Y2PGB(=
+M_320%L,#YS.)3,=IH]41SQ]6AED9*U3<=&6ZSHC[I@/N@FIWD>D`'<+&WZGI
+MW;!Y.@TVPP/J58]&85/2_PT9E`%>2H<7OBM<*:/ABLA>2E]$]+^087\%X^,R
+M\<HOY1#'G$51=C5AO(=U%#EE><3`QJ5!`0@%()B!4G(AN9&2FI**DAM-&0BM
+M\#]C&)%*)3!'"DJ5`HI0\S\^(#C6I4"Q$H966J!0M]/:2)H-IK10HI2*`XY<
+MBFHF`+_"1M]`M1)&@Z$X4MJJI:"EPI-CI3DA^@*I*E'85UYH;K\'HWAC&*6&
+MV>D'A6TJ62H&)A+;EX$K/_O;/[L*,VH/PX;([;S2-["KJV-K])D1IVP^1TV8
+MCKD5QDHKP&XFM=M)J-KC`SV!0JYX)H65M%5R"1&9&;\1@)GPEX!6TUWYI]6$
+MUY:`7I-D5^'4M;C>_3/'0JU`@!<MC!)6-!!TYZ[=0/-3XL"!UK8K363B"^A)
+M,[5VKK(513?<'JNU[<$>*(OLUP8*`Z7.:G*@,1@!%=_#Y)XE0)$E`3Q9>OW3
++Q7\!?:#A?_%,````
+`
 end

Tst/Short/absfact.stat

-                      rd4cec6a
+                      r7161aca
 >> tst_memory_0 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:190632
 >> tst_memory_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2486272
 >> tst_memory_2 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2486272
 >> tst_timer :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:18
 >> tst_memory_0 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:195048
 >> tst_memory_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_memory_2 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_timer :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:50
 >> tst_memory_0 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:195048
 >> tst_memory_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_memory_2 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_timer :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:1
 >> tst_memory_0 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:196464
 >> tst_memory_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_memory_2 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_timer :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:9
 >> tst_memory_0 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:195968
 >> tst_memory_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_memory_2 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2740224
 >> tst_timer_1 :: 1562166539:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:83
+>> tst_memory_0 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:192208
+>> tst_memory_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2506752
+>> tst_memory_2 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2506752
+>> tst_timer :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:18
+>> tst_memory_0 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:197648
+>> tst_memory_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_memory_2 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_timer :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:50
+>> tst_memory_0 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:197648
+>> tst_memory_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_memory_2 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_timer :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2
+>> tst_memory_0 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:202280
+>> tst_memory_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_memory_2 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_timer :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:9
+>> tst_memory_0 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:201784
+>> tst_memory_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_memory_2 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:2637824
+>> tst_timer_1 :: 1565087159:4122, 64 bit:4.1.2:x86_64-Linux:nepomuck:83

Tst/Short/bug_zp.res.gz.uu

-                      rd4cec6a
+                      r7161aca
 begin 640 bug_zp.res.gz
 M'XL("-%LPED"`V)U9U]Z<"YR97,`E5!-3\)`$+WW5[P0#B6I"[O(AQ#6Q'@A
 M,5[P1K19RK9.`FTSNX3*KW>KI.K1T[QY;U[FS6Q>'M?/`*3&T_H!/>^\.-"N
 MMXPV5T5I!#*EDGP\6$9MA=;8G8KT4HO2GH7SQG?C8XT.WPH,AS@;+A-0CIKI
 M:$$.OJIP,%Q8Y!4C-YFO^&/1V28"3&4!7DW&T_E,CD8R:9)]_9-IJJ\NNEC$
 MC;J1(5G@[Y&]&PZ*97*>LC_+XJ-I6D*]J;O!/Z>W\G716M(`5C+:JN]6=HEF
 O\Z>BZ^/M6\YN3A$ZT>?0,1X.V<!````
+M'XL("$.:.5T"`V)U9U]Z<"YR97,`55#+;L(P$+S[*T:(0Y""P>99$$:J>D&J
+M>H$;:B.3.F$E2"+;B)2OK].BM)QV=V9'L[/;W<OF#8!0>-T\H^.=YR<Z=)9L
+M>V>D0@`3*LA'O25K*I3"X9(GMXH7YLJ=U[Y='RFT_9AC,,!5VR(&9:@LG0W(
+MP9<E3MKF!EEID>G4E_9KT<HF'):*''8U&4WG,S$<BKB./ZN_FZ;JKJ*;053+
+MO@B7!7R-]*AM8(PEYRE],(O.NFX`^2&?>FPOWA>-)`G-2K"]_!U%ZS'[%V3.
+?W[0!+VX*)AUV3<,'@((.0$`````
+`
 end

Tst/Short/bug_zp.stat

-                      rd4cec6a
+                      r7161aca
 >> tst_memory_0 :: 1505914065:4103, 64 bit:4.1.0:x86_64-Linux:nepomuck:83592
 >> tst_memory_1 :: 1505914065:4103, 64 bit:4.1.0:x86_64-Linux:nepomuck:2215936
 >> tst_memory_2 :: 1505914065:4103, 64 bit:4.1.0:x86_64-Linux:nepomuck:2215936
 >> tst_timer_1 :: 1505914065:4103, 64 bit:4.1.0:x86_64-Linux:nepomuck:0
+>> tst_memory_0 :: 1564056131:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:85680
+>> tst_memory_1 :: 1564056131:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2150192
+>> tst_memory_2 :: 1564056131:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:2191296
+>> tst_timer_1 :: 1564056131:4120, 64 bit:4.1.2:x86_64-Linux:nepomuck:5

doc/NEWS.texi

-                      rd4cec6a
+                      r7161aca
 @heading News for version @value{VERSION}
+Changes in the kernel/build system:
+@itemize
+@item improved gcd and multiplication via FLINT
+@end itemize
+@heading News for version 4-1-2
 New libraries:
 @itemize

emacs/Makefile.am

-                      rd4cec6a
+                      r7161aca
 EMACS = \
-    ChangeLog \
     COPYING \
-    NEWS \
     singular.el \
     singular.xpm  .emacs-general  .emacs-singular \

factory/FLINTconvert.cc

-                      rd4cec6a
+                      r7161aca
 #include "singext.h"
 #include "cf_algorithm.h"
+#ifdef HAVE_OMALLOC
+#define Alloc(L) omAlloc(L)
+#define Free(A,L) omFreeSize(A,L)
+#else
+#define Alloc(L) malloc(L)
+#define Free(A,L) free(A)
+#endif
 #ifdef HAVE_FLINT
 …
 #include <flint/fq_nmod_mat.h>
 #endif
+#if ( __FLINT_RELEASE >= 20503)
+#include <flint/fmpq_mpoly.h>
+#endif
 #ifdef __cplusplus
+}
 …
   if (f.isImm ())
+  {
+    fmpz_set_si (fmpq_numref (result), f.num().intval());
+    fmpz_set_si (fmpq_denref (result), f.den().intval());
+  }
+  else
+    fmpq_set_si (result, f.intval(), 1);
+  }
+  else if(f.inQ())
+  {
     mpz_t gmp_val;
 …
     mpz_clear (gmp_val);
+  }
+  else if(f.inZ())
+  {
+    mpz_t gmp_val;
+    f.mpzval(gmp_val);
+    fmpz_set_mpz (fmpq_numref (result), gmp_val);
+    mpz_clear (gmp_val);
+    fmpz_one(fmpq_denref(result));
+  }
+  else
+  {
+    printf("wrong type\n");
+  }
+}
 …
   CanonicalForm result;
+  if (mpz_is_imm (nnum) && mpz_is_imm (nden))
+  {
+    num= CanonicalForm (mpz_get_si(nnum));
+    den= CanonicalForm (mpz_get_si(nden));
+    mpz_clear (nnum);
+    mpz_clear (nden);
+    result= num/den;
+    if (!isRat)
+      Off (SW_RATIONAL);
+    return result;
+  if (mpz_is_imm (nden))
+  {
+    if (mpz_is_imm(nnum))
+    {
+      num= CanonicalForm (mpz_get_si(nnum));
+      den= CanonicalForm (mpz_get_si(nden));
+      mpz_clear (nnum);
+      mpz_clear (nden);
+      result= num/den;
+    }
+    else if (mpz_cmp_si(nden,1)==0)
+    {
+      result= CanonicalForm( CFFactory::basic(nnum));
+      mpz_clear (nden);
+    }
+    else
+      result= CanonicalForm( CFFactory::rational( nnum, nden, false));
+  }
   else
+  {
     result= make_cf (nnum, nden, false);
     if (!isRat)
       Off (SW_RATIONAL);
     return result;
+  }
+    result= CanonicalForm( CFFactory::rational( nnum, nden, false));
+  }
+  if (!isRat)
+    Off (SW_RATIONAL);
+  return result;
+}
 …
+}
 #endif
+#endif
+#if __FLINT_RELEASE >= 20503
+static void convFlint_RecPP ( const CanonicalForm & f, ulong * exp, nmod_mpoly_t result, nmod_mpoly_ctx_t ctx, int N )
+{
+  // assume f!=0
+  if ( ! f.inCoeffDomain() )
+  {
+    int l = f.level();
+    for ( CFIterator i = f; i.hasTerms(); i++ )
+    {
+      exp[N-l] = i.exp();
+      convFlint_RecPP( i.coeff(), exp, result, ctx, N );
+    }
+    exp[N-l] = 0;
+  }
+  else
+  {
+    int c=f.intval(); // with Off(SW_SYMMETRIC_FF): 0<=c<p
+    nmod_mpoly_push_term_ui_ui(result,c,exp,ctx);
+  }
+}
+static void convFlint_RecPP ( const CanonicalForm & f, ulong * exp, fmpq_mpoly_t result, fmpq_mpoly_ctx_t ctx, int N )
+{
+  // assume f!=0
+  if ( ! f.inBaseDomain() )
+  {
+    int l = f.level();
+    for ( CFIterator i = f; i.hasTerms(); i++ )
+    {
+      exp[N-l] = i.exp();
+      convFlint_RecPP( i.coeff(), exp, result, ctx, N );
+    }
+    exp[N-l] = 0;
+  }
+  else
+  {
+    fmpq_t c;
+    fmpq_init(c);
+    convertCF2Fmpq(c,f);
+    fmpq_mpoly_push_term_fmpq_ui(result,c,exp,ctx);
+    fmpq_clear(c);
+  }
+}
+void convFactoryPFlintMP ( const CanonicalForm & f, nmod_mpoly_t res, nmod_mpoly_ctx_t ctx, int N )
+{
+  if (f.isZero()) return;
+  ulong * exp = (ulong*)Alloc(N*sizeof(ulong));
+  memset(exp,0,N*sizeof(ulong));
+  bool save_sym_ff= isOn (SW_SYMMETRIC_FF);
+  if (save_sym_ff) Off (SW_SYMMETRIC_FF);
+  convFlint_RecPP( f, exp, res, ctx, N );
+  if (save_sym_ff) On(SW_SYMMETRIC_FF);
+  Free(exp,N*sizeof(ulong));
+}
+void convFactoryPFlintMP ( const CanonicalForm & f, fmpq_mpoly_t res, fmpq_mpoly_ctx_t ctx, int N )
+{
+  if (f.isZero()) return;
+  ulong * exp = (ulong*)Alloc(N*sizeof(ulong));
+  memset(exp,0,N*sizeof(ulong));
+  convFlint_RecPP( f, exp, res, ctx, N );
+  fmpq_mpoly_reduce(res,ctx);
+  Free(exp,N*sizeof(ulong));
+}
+CanonicalForm convFlintMPFactoryP(nmod_mpoly_t f, nmod_mpoly_ctx_t ctx, int N)
+{
+  CanonicalForm result;
+  int d=nmod_mpoly_length(f,ctx)-1;
+  ulong* exp=(ulong*)Alloc(N*sizeof(ulong));
+  for(int i=d; i>=0; i--)
+  {
+    ulong c=nmod_mpoly_get_term_coeff_ui(f,i,ctx);
+    nmod_mpoly_get_term_exp_ui(exp,f,i,ctx);
+    CanonicalForm term=(int)c;
+    for ( int i = 0; i <N; i++ )
+    {
+      if (exp[i]!=0) term*=CanonicalForm( Variable( N-i ), exp[i] );
+    }
+    result+=term;
+  }
+  Free(exp,N*sizeof(ulong));
+  return result;
+}
+CanonicalForm convFlintMPFactoryP(fmpq_mpoly_t f, fmpq_mpoly_ctx_t ctx, int N)
+{
+  CanonicalForm result;
+  int d=fmpq_mpoly_length(f,ctx)-1;
+  ulong* exp=(ulong*)Alloc(N*sizeof(ulong));
+  fmpq_t c;
+  fmpq_init(c);
+  for(int i=d; i>=0; i--)
+  {
+    fmpq_mpoly_get_term_coeff_fmpq(c,f,i,ctx);
+    fmpq_mpoly_get_term_exp_ui(exp,f,i,ctx);
+    CanonicalForm term=convertFmpq_t2CF(c);
+    for ( int i = 0; i <N; i++ )
+    {
+      if (exp[i]!=0) term*=CanonicalForm( Variable( N-i ), exp[i] );
+    }
+    result+=term;
+  }
+  fmpq_clear(c);
+  Free(exp,N*sizeof(ulong));
+  return result;
+}
+// stolen from:
+// https://graphics.stanford.edu/~seander/bithacks.html#IntegerLog
+static inline int SI_LOG2(int v)
+{
+  const unsigned int b[] = {0x2, 0xC, 0xF0, 0xFF00, 0xFFFF0000};
+  const unsigned int S[] = {1, 2, 4, 8, 16};
+  unsigned int r = 0; // result of log2(v) will go here
+  if (v & b[4]) { v >>= S[4]; r |= S[4]; }
+  if (v & b[3]) { v >>= S[3]; r |= S[3]; }
+  if (v & b[2]) { v >>= S[2]; r |= S[2]; }
+  if (v & b[1]) { v >>= S[1]; r |= S[1]; }
+  if (v & b[0]) { v >>= S[0]; r |= S[0]; }
+  return (int)r;
+}
+CanonicalForm mulFlintMP_Zp(const CanonicalForm& F,int lF, const CanonicalForm& G, int lG,int m)
+{
+  int bits=SI_LOG2(m)+1;
+  int N=F.level();
+  nmod_mpoly_ctx_t ctx;
+  nmod_mpoly_ctx_init(ctx,N,ORD_LEX,getCharacteristic());
+  nmod_mpoly_t f,g,res;
+  nmod_mpoly_init3(f,lF,bits,ctx);
+  nmod_mpoly_init3(g,lG,bits,ctx);
+  convFactoryPFlintMP(F,f,ctx,N);
+  convFactoryPFlintMP(G,g,ctx,N);
+  nmod_mpoly_init(res,ctx);
+  nmod_mpoly_mul(res,f,g,ctx);
+  nmod_mpoly_clear(g,ctx);
+  nmod_mpoly_clear(f,ctx);
+  CanonicalForm RES=convFlintMPFactoryP(res,ctx,N);
+  nmod_mpoly_clear(res,ctx);
+  nmod_mpoly_ctx_clear(ctx);
+  return RES;
+}
+CanonicalForm mulFlintMP_QQ(const CanonicalForm& F,int lF, const CanonicalForm& G, int lG, int m)
+{
+  int bits=SI_LOG2(m)+1;
+  int N=F.level();
+  fmpq_mpoly_ctx_t ctx;
+  fmpq_mpoly_ctx_init(ctx,N,ORD_LEX);
+  fmpq_mpoly_t f,g,res;
+  fmpq_mpoly_init3(f,lF,bits,ctx);
+  fmpq_mpoly_init3(g,lG,bits,ctx);
+  convFactoryPFlintMP(F,f,ctx,N);
+  convFactoryPFlintMP(G,g,ctx,N);
+  fmpq_mpoly_init(res,ctx);
+  fmpq_mpoly_mul(res,f,g,ctx);
+  fmpq_mpoly_clear(g,ctx);
+  fmpq_mpoly_clear(f,ctx);
+  CanonicalForm RES=convFlintMPFactoryP(res,ctx,N);
+  fmpq_mpoly_clear(res,ctx);
+  fmpq_mpoly_ctx_clear(ctx);
+  return RES;
+}
+CanonicalForm gcdFlintMP_Zp(const CanonicalForm& F, const CanonicalForm& G)
+{
+  int N=F.level();
+  int lf,lg,m=1<<MPOLY_MIN_BITS;
+  lf=size_maxexp(F,m);
+  lg=size_maxexp(G,m);
+  int bits=SI_LOG2(m)+1;
+  nmod_mpoly_ctx_t ctx;
+  nmod_mpoly_ctx_init(ctx,N,ORD_LEX,getCharacteristic());
+  nmod_mpoly_t f,g,res;
+  nmod_mpoly_init3(f,lf,bits,ctx);
+  nmod_mpoly_init3(g,lg,bits,ctx);
+  convFactoryPFlintMP(F,f,ctx,N);
+  convFactoryPFlintMP(G,g,ctx,N);
+  nmod_mpoly_init(res,ctx);
+  int ok=nmod_mpoly_gcd(res,f,g,ctx);
+  nmod_mpoly_clear(g,ctx);
+  nmod_mpoly_clear(f,ctx);
+  CanonicalForm RES=1;
+  if (ok)
+  {
+    RES=convFlintMPFactoryP(res,ctx,N);
+  }
+  nmod_mpoly_clear(res,ctx);
+  nmod_mpoly_ctx_clear(ctx);
+  return RES;
+}
+static CanonicalForm b_content ( const CanonicalForm & f )
+{
+    if ( f.inCoeffDomain() )
+        return f;
+    else
+    {
+        CanonicalForm result = 0;
+        CFIterator i;
+        for ( i = f; i.hasTerms() && (!result.isOne()); i++ )
+            result=bgcd( b_content(i.coeff()) , result );
+        return result;
+    }
+}
+CanonicalForm gcdFlintMP_QQ(const CanonicalForm& F, const CanonicalForm& G)
+{
+  int N=F.level();
+  fmpq_mpoly_ctx_t ctx;
+  fmpq_mpoly_ctx_init(ctx,N,ORD_LEX);
+  fmpq_mpoly_t f,g,res;
+  fmpq_mpoly_init(f,ctx);
+  fmpq_mpoly_init(g,ctx);
+  convFactoryPFlintMP(F,f,ctx,N);
+  convFactoryPFlintMP(G,g,ctx,N);
+  fmpq_mpoly_init(res,ctx);
+  int ok=fmpq_mpoly_gcd(res,f,g,ctx);
+  fmpq_mpoly_clear(g,ctx);
+  fmpq_mpoly_clear(f,ctx);
+  CanonicalForm RES=1;
+  if (ok)
+  {
+    // Flint normalizes the gcd to be monic.
+    // Singular wants a gcd defined over ZZ that is primitive and has a positive leading coeff.
+    if (!fmpq_mpoly_is_zero(res, ctx))
+    {
+      fmpq_t content;
+      fmpq_init(content);
+      fmpq_mpoly_content(content, res, ctx);
+      fmpq_mpoly_scalar_div_fmpq(res, res, content, ctx);
+      fmpq_clear(content);
+    }
+    RES=convFlintMPFactoryP(res,ctx,N);
+    // gcd(2x,4x) should be 2x, so RES should also have the gcd(lc(F),lc(G))
+    RES*=bgcd(b_content(F),b_content(G));
+  }
+  fmpq_mpoly_clear(res,ctx);
+  fmpq_mpoly_ctx_clear(ctx);
+  return RES;
+}
+#endif
+#endif

factory/FLINTconvert.h

-                      rd4cec6a
+                      r7161aca
+#endif
+#endif
+#if __FLINT_RELEASE >= 20503
+CanonicalForm mulFlintMP_Zp(const CanonicalForm& F,int lF, const CanonicalForm& Gi, int lG, int m);
+CanonicalForm mulFlintMP_QQ(const CanonicalForm& F,int lF, const CanonicalForm& Gi, int lG, int m);
+CanonicalForm gcdFlintMP_Zp(const CanonicalForm& F, const CanonicalForm& G);
+CanonicalForm gcdFlintMP_QQ(const CanonicalForm& F, const CanonicalForm& G);
+#endif
+#endif
+#endif

factory/Makefile.am

-                      rd4cec6a
+                      r7161aca
 libfactory_includedir = ${includedir}/factory
+nodist_libfactory_include_HEADERS = factory.h factoryconf.h globaldefs.h
+nodist_libfactory_include_HEADERS = factory.h factoryconf.h
+libfactory_include_HEADERS = globaldefs.h

factory/NTLconvert.cc

-                      rd4cec6a
+                      r7161aca
 #include "NTLconvert.h"
+#ifdef HAVE_OMALLOC
+#define Alloc(L) omAlloc(L)
+#define Free(A,L) omFreeSize(A,L)
+#else
 #define Alloc(L) malloc(L)
 #define Free(A,L) free(A)
+#endif
 void out_cf(const char *s1,const CanonicalForm &f,const char *s2);

factory/canonicalform.cc

-                      rd4cec6a
+                      r7161aca
 #include "gfops.h"
 #include "facMul.h"
+#include "facAlgFuncUtil.h"
 #include "FLINTconvert.h"
 …
     else  if ( value->level() == cf.value->level() ) {
 #if (HAVE_NTL && HAVE_FLINT && __FLINT_RELEASE >= 20400)
+#if (__FLINT_RELEASE >= 20503)
+        int l_this,l_cf,m=1;
+        if ((getCharacteristic()>0)
+        && (CFFactory::gettype() != GaloisFieldDomain)
+        &&(!hasAlgVar(*this))
+        &&(!hasAlgVar(cf))
+        &&((l_cf=size_maxexp(cf,m))>10)
+        &&((l_this=size_maxexp(*this,m))>10)
+        )
+        {
+          *this=mulFlintMP_Zp(*this,l_this,cf,l_cf,m);
+        }
+        else
+        /*-----------------------------------------------------*/
+        if ((getCharacteristic()==0)
+        &&(!hasAlgVar(*this))
+        &&(!hasAlgVar(cf))
+        &&((l_cf=size_maxexp(cf,m))>10)
+        &&((l_this=size_maxexp(*this,m))>10)
+        )
+        {
+          *this=mulFlintMP_QQ(*this,l_this,cf,l_cf,m);
+        }
+        else
+#endif
         if (value->levelcoeff() == cf.value->levelcoeff() && cf.isUnivariate() && (*this).isUnivariate())
+        {

factory/cf_char.cc

-                      rd4cec6a
+                      r7161aca
         theDegree = 1;
         CFFactory::settype( FiniteFieldDomain );
+        ff_big = c > cf_getSmallPrime( cf_getNumSmallPrimes()-1 );
+        if (c!=theCharacteristic)
+        {
+          if (c > 536870909) factoryError("characteristic is too large(max is 2^29)");
+          ff_setprime( c );
+        }
         theCharacteristic = c;
-        ff_big = c > cf_getSmallPrime( cf_getNumSmallPrimes()-1 );
-        if (c > 536870909) factoryError("characteristic is too large(max is 2^29)");
-        ff_setprime( c );
+    }
+}

factory/cf_gcd.cc

-                      rd4cec6a
+                      r7161aca
 #include "cfSubResGcd.h"
 #include "cfModGcd.h"
+#include "FLINTconvert.h"
 #include "facAlgFuncUtil.h"
 …
   if ( getCharacteristic() != 0 )
+  {
+    #if defined(HAVE_FLINT) && ( __FLINT_RELEASE >= 20503)
+    if ( isOn( SW_USE_FL_GCD_P)
+    && (CFFactory::gettype() != GaloisFieldDomain)
+    && (getCharacteristic()>10)
+    &&(!hasAlgVar(fc)) && (!hasAlgVar(gc)))
+    {
+      return gcdFlintMP_Zp(fc,gc);
+    }
+    #endif
     #ifdef HAVE_NTL
     if ((!fc_and_gc_Univariate) && (isOn( SW_USE_EZGCD_P )))
 …
     fc = subResGCD_p( fc, gc );
+  }
   else if (!fc_and_gc_Univariate)
+  else if (!fc_and_gc_Univariate) /* && char==0*/
+  {
+    #if defined(HAVE_FLINT) && ( __FLINT_RELEASE >= 20503)
+    if (( isOn( SW_USE_FL_GCD_0) )
+    &&(!hasAlgVar(fc)) && (!hasAlgVar(gc)))
+    {
+      return gcdFlintMP_QQ(fc,gc);
+    }
+    else
+    #endif
     if ( isOn( SW_USE_EZGCD ) )
       fc= ezgcd (fc, gc);
 #ifdef HAVE_NTL
+    #ifdef HAVE_NTL
     else if (isOn(SW_USE_CHINREM_GCD))
       fc = modGCDZ( fc, gc);
 #endif
+    #endif
     else
+    {
 …
                 CanonicalForm cdF = bCommonDen( f );
                 CanonicalForm cdG = bCommonDen( g );
+                CanonicalForm F = f * cdF, G = g * cdG;
                 Off( SW_RATIONAL );
+                CanonicalForm l = lcm( cdF, cdG );
+                On( SW_RATIONAL );
+                CanonicalForm F = f * l, G = g * l;
+                Off( SW_RATIONAL );
+                l = gcd_poly( F, G );
+                CanonicalForm l = gcd_poly( F, G );
                 On( SW_RATIONAL );
                 return abs( l );

factory/cf_inline.cc

rd4cec6a	r7161aca
143	143	CF_INLINE
144	144	CanonicalForm::CanonicalForm ( const int i )
145		: value( CFFactory::basic( (~~const~~ long)i ) )
	145	: value( CFFactory::basic( (long)i ) )
146	146	{
147	147	}

factory/cf_switches.cc

-                      rd4cec6a
+                      r7161aca
 #ifdef HAVE_NTL
   On(SW_USE_CHINREM_GCD);
+  //Off(SW_USE_NTL_SORT);
+  On(SW_USE_NTL_SORT);
+#endif
+#ifdef HAVE_FLINT
   On(SW_USE_FL_GCD_P);
   //On(SW_USE_FL_GCD_0);
+  On(SW_USE_FL_GCD_0);
 #endif
   On(SW_USE_EZGCD);

factory/facFqBivar.cc

rd4cec6a	r7161aca
6883	6883	#ifdef HAVE_FLINT
6884	6884	nmod_mat_t FLINTN;
6885		#else
	6885	#endif
	6886
6886	6887	if (fac_NTL_char != getCharacteristic())
6887	6888	{
…	…
6890	6891	}
6891	6892	mat_zz_p NTLN;
6892		~~#endif~~
6893	6893
6894	6894	if (alpha.level() != 1)
…	…
6898	6898	}
6899	6899	mat_zz_pE NTLNe;
	6900
6900	6901	if (alpha.level() == 1)
6901	6902	{

factory/imm.h

-                      rd4cec6a
+                      r7161aca
+{
     if ( is_imm( op ) == FFMARK )
+    {
         if ( cf_glob_switches.isOn( SW_SYMMETRIC_FF ) )
             return ff_symmetric( imm2int( op ) );
         else
             return imm2int( op );
+    else  if ( is_imm( op ) == GFMARK ) {
+    }
+    else  if ( is_imm( op ) == GFMARK )
+    {
         ASSERT( gf_isff( imm2int( op ) ), "invalid conversion" );
         if ( cf_glob_switches.isOn( SW_SYMMETRIC_FF ) )
 …
             return gf_gf2ff( imm2int( op ) );
+    }
     else
+    /*else*/
         return imm2int( op );
+}

kernel/GBEngine/kstd1.cc

-                      rd4cec6a
+                      r7161aca
 #include "kernel/GBEngine/kInline.h"
+#ifdef HAVE_SHIFTBBA
+#include "polys/shiftop.h"
+#endif
 /* the list of all options which give a warning by test */
 …
 #ifdef HAVE_SHIFTBBA
   if(rIsLPRing(currRing)) return freegb(F, Q);
+  if(rIsLPRing(currRing)) return kStdShift(F, Q, h, w, hilb, syzComp, newIdeal, vw, FALSE);
 #endif
 …
                 int newIdeal, intvec *vw, BOOLEAN rightGB)
+{
+  assume(rIsLPRing(currRing));
+  assume(idIsInV(F));
   ideal r;
   BOOLEAN b=currRing->pLexOrder,toReset=FALSE;
 …
   delete(strat);
   if ((delete_w)&&(w!=NULL)&&(*w!=NULL)) delete *w;
+  assume(idIsInV(r));
   return r;
+}

kernel/GBEngine/kstd1.h

rd4cec6a	r7161aca
42	42	int syzComp=0, int newIdeal=0, intvec *vw=NULL, BOOLEAN rightGB=FALSE);
43	43
44		~~ideal freegb(ideal F, ideal Q);~~
45	44	ideal rightgb(ideal F, ideal Q);
46	45

kernel/GBEngine/kstd2.cc

-                      rd4cec6a
+                      r7161aca
+}
+ideal freegb(ideal F, ideal Q)
+{
+  assume(rIsLPRing(currRing));
+  assume(idIsInV(F));
+  ideal RS = kStdShift(F, Q, testHomog, NULL);
+  idSkipZeroes(RS); // is this even necessary?
+  assume(idIsInV(RS));
+  return(RS);
+}
+#ifdef HAVE_SHIFTBBA
 ideal rightgb(ideal F, ideal Q)
+{
 …
   return(RS);
+}
+#endif
 /*2

kernel/ideals.cc

-                      rd4cec6a
+                      r7161aca
     p = h2->m[j];
     q = pOne();
+#ifdef HAVE_SHIFTBBA
+    // non multiplicative variable
+    if (rIsLPRing(currRing))
+    {
+      pSetExp(q, currRing->isLPring - currRing->LPncGenCount + j + 1, 1);
+      p_Setm(q, currRing);
+    }
+#endif
     pSetComp(q,syzcomp+1+j);
     pSetmComp(q);
     if (p!=NULL)
+    {
+      while (pNext(p)) pIter(p);
+      p->next = q;
+#ifdef HAVE_SHIFTBBA
+      if (rIsLPRing(currRing))
+      {
+        h2->m[j] = pAdd(p, q);
+      }
+      else
+#endif
+      {
+        while (pNext(p)) pIter(p);
+        p->next = q;
+      }
+    }
     else
 …
   idTest(h2);
+#ifdef HAVE_SHIFTBBA
+  if (rIsLPRing(currRing)) alg = GbStd;
+#endif
   ideal h3=NULL;
   if (alg==GbDefault) alg=GbStd;

kernel/mod2.h

rd4cec6a	r7161aca
77	77	#endif
78	78
79		#define SINGULAR_PATCHLEVEL 0
	79	#define SINGULAR_PATCHLEVEL 2
80	80	#define SINGULAR_VERSION ((SINGULAR_MAJOR_VERSION1000 + SINGULAR_MINOR_VERSION100 + SINGULAR_SUB_VERSION*10)+SINGULAR_PATCHLEVEL)
81	81

kernel/preimage.cc

rd4cec6a	r7161aca
88	88	}
89	89
90		~~assume(n_SetMap(theImageRing->cf, dst_r->cf) == ndCopyMap);~~
91
92	90	if (theImageRing->cf != dst_r->cf)
93	91	{

libpolys/coeffs/Makefile.am

rd4cec6a	r7161aca
44	44	test_LDADD = libcoeffs.la $(libcoeffs_la_LIBADD)
45	45
46		EXTRA_DIST = rintegers2.cc rinteger3.cc
	46	EXTRA_DIST = rintegers2.cc rintegers3.cc

libpolys/coeffs/rintegers2.cc

-                      rd4cec6a
+                      r7161aca
+}
+static void nrzMPZ(mpz_t res, number &a, const coeffs)
+{
+  mpz_init_set(res, (mpz_ptr) a);
+}
 static number nrzFarey(number r, number N, const coeffs R)
+{
 …
   r->cfInit = nrzInit;
   r->cfInitMPZ = nrzInitMPZ;
+  r->cfMPZ = nrzMPZ;
   r->cfSize  = nrzSize;
   r->cfInt  = nrzInt;

libpolys/polys/clapconv.cc

-                      rd4cec6a
+                      r7161aca
   p1=p;
   l=l/2;
   while(l>0) { p=pNext(p); l--; }
+  while(l>1) { p=pNext(p); l--; }
   p2=pNext(p);
   pNext(p)=NULL;
 …
 #define MIN_CONV_LEN 7
 CanonicalForm convSingPFactoryP( poly p, const ring r )
+static CanonicalForm convSingPFactoryP_intern( poly p, int l, BOOLEAN & setChar,const ring r )
+{
   CanonicalForm result = 0;
   int e, n = rVar(r);
+  BOOLEAN setChar=TRUE;
+  int l;
+  if ((l=pLength(p))>MIN_CONV_LEN)
+  assume(l==pLength(p));
+  if (l>MIN_CONV_LEN)
+  {
     poly p1,p2;
     convPhalf(p,l,p1,p2);
     CanonicalForm P=convSingPFactoryP(p1,r);
     P+=convSingPFactoryP(p2,r);
+    CanonicalForm P=convSingPFactoryP_intern(p1,l/2,setChar,r);
+    P+=convSingPFactoryP_intern(p2,l-l/2,setChar,r);
     convPunhalf(p1,p2);
     return P;
+  }
+  BOOLEAN setChar_loc=setChar;
+  setChar=FALSE;
   while ( p!=NULL )
+  {
     CanonicalForm term=r->cf->convSingNFactoryN(pGetCoeff( p ),setChar, r->cf);
+    CanonicalForm term=r->cf->convSingNFactoryN(pGetCoeff( p ),setChar_loc, r->cf);
     if (errorreported) break;
     setChar=FALSE;
+    setChar_loc=FALSE;
     for ( int i = 1; i <=n; i++ )
+    {
 …
+ }
  return result;
+}
+CanonicalForm convSingPFactoryP( poly p, const ring r )
+{
+  BOOLEAN setChar=TRUE;
+  return convSingPFactoryP_intern(p,pLength(p),setChar,r);
+}

libpolys/polys/clapsing.cc

rd4cec6a	r7161aca
59	59	#ifdef HAVE_FLINT
60	60	#if __FLINT_RELEASE >= 20503
61		if (rField_is_Zp(r) && (r->cf->ch>500))
	61	if (rField_is_Zp(r) && (r->cf->ch>10))
62	62	{
63	63	nmod_mpoly_ctx_t ctx;

libpolys/polys/flint_mpoly.cc

-                      rd4cec6a
+                      r7161aca
 #if 1
 // memory allocation is not thread safe; singular polynomials must be constructed in serial
+/*
+    We agree the that result of a singular -> fmpq_mpoly conversion is
+    readonly. This restricts the usage of the result in flint functions to
+    const arguments. However, the real readonly conversion is currently only
+    implemented in the threaded conversion below since it requires a scan of
+    all coefficients anyways. The _fmpq_mpoly_clear_readonly_sing needs to
+    be provided for a consistent interface in the polynomial operations.
+*/
+static void _fmpq_mpoly_clear_readonly_sing(fmpq_mpoly_t a, fmpq_mpoly_ctx_t ctx)
+{
+    fmpq_mpoly_clear(a, ctx);
+}
 void convSingPFlintMP(fmpq_mpoly_t res, fmpq_mpoly_ctx_t ctx, poly p, int lp, const ring r)
 …
+}
+/*
+    In order that flint may sometimes borrow the large integer coeffs of
+    polynomials over QQ (borrow means: simply point to the same GMP structs
+    that singular has already allocated), we define the result of a
+    singular -> fmpq_mpoly conversion to be readonly. This means we agree
+    that
+        - it can only be used as an const argument to a flint function
+        - singular must not mutate the original coeffs while the readonly object is in use
+*/
+static void _fmpq_mpoly_clear_readonly_sing(fmpq_mpoly_t a, fmpq_mpoly_ctx_t ctx)
+{
+    if (fmpq_is_one(a->content))
+    {
+        if (a->zpoly->alloc > 0)
+        {
+            flint_free(a->zpoly->coeffs);
+            flint_free(a->zpoly->exps);
+        }
+        fmpq_clear(a->content);
+    }
+    else
+    {
+        fmpq_mpoly_clear(a, ctx);
+    }
+}
 /* singular -> fmpq_mpoly conversion */
 …
     std::vector<poly> markers;
     ring r;
+    convert_sing_to_fmpq_mpoly_base(slong num_threads_, fmpq_mpoly_struct * res_,
+                             const fmpq_mpoly_ctx_struct * ctx_, const ring r_, poly p)
+      : num_threads(num_threads_),
+    fmpq_t content;
+    convert_sing_to_fmpq_mpoly_base(fmpq_mpoly_struct * res_,
+                     const fmpq_mpoly_ctx_struct * ctx_, const ring r_, poly p)
+      : num_threads(0),
         res(res_),
         ctx(ctx_),
         r(r_)
+    {
+        fmpq_t c;
+        fmpq_init(c);
+        fmpq_init(content);
+        fmpq_zero(content);
         length = 0;
         while (1)
+        {
             if ((length % 4096) == 0)
+            {
+                my_convSingNFlintN_QQ(c, number(pGetCoeff(p)));
+                fmpq_gcd(content, content, c);
                 markers.push_back(p);
+            }
             if (p == NULL)
                 return;
 …
             pIter(p);
+        }
+        fmpq_clear(c);
+    }
+    ~convert_sing_to_fmpq_mpoly_base()
+    {
+        fmpq_clear(content);
+    }
 };
 …
     flint_bitcnt_t required_bits = MPOLY_MIN_BITS;
     fmpq_zero(arg->content);
+    fmpq_set(arg->content, base->content);
     while (idx < arg->end_idx)
+    {
+        my_convSingNFlintN_QQ(c, number(pGetCoeff(p)));
+        fmpq_gcd(arg->content, arg->content, c);
+        number n = number(pGetCoeff(p));
+        if (fmpq_is_one(arg->content) && (SR_HDL(n)&SR_INT || n->s >= 3))
+        {
+            /* content is 1 and n is an integer, nothing to do */
+        }
+        else
+        {
+            my_convSingNFlintN_QQ(c, n);
+            fmpq_gcd(arg->content, arg->content, c);
+        }
         #if SIZEOF_LONG==8
 …
+    }
+    slong N = mpoly_words_per_exp(base->res->zpoly->bits, base->ctx->zctx->minfo);
+    fmpz * res_coeffs = base->res->zpoly->coeffs;
+    ulong * res_exps = base->res->zpoly->exps;
+    flint_bitcnt_t res_bits = base->res->zpoly->bits;
     while (idx < arg->end_idx)
+    {
+        my_convSingNFlintN_QQ(c, number(pGetCoeff(p)));
+        FLINT_ASSERT(!fmpq_is_zero(base->res->content));
+        fmpq_div(t, c, base->res->content);
+        FLINT_ASSERT(fmpz_is_one(fmpq_denref(t)));
+        slong N = mpoly_words_per_exp(base->res->zpoly->bits, base->ctx->zctx->minfo);
+        fmpz_swap(base->res->zpoly->coeffs + idx, fmpq_numref(t));
+        if (fmpq_is_one(base->res->content))
+        {
+            // borrowing singular integers
+            // the entry res_coeffs[idx] is junk, we should just overwrite it
+            number n = number(pGetCoeff(p));
+            if (SR_HDL(n)&SR_INT)
+            {
+                // n is a singular-small integer
+                res_coeffs[idx] = SR_TO_INT(n);
+            }
+            else if (n->s<3)
+            {
+                // n is an element of QQ \ ZZ, should not happen
+                assume(false);
+            }
+            else
+            {
+                // n is a singular-large integer, n may be flint-small
+                res_coeffs[idx] = PTR_TO_COEFF(n->z);
+                if (fmpz_fits_si(res_coeffs + idx))
+                {
+                    slong val = fmpz_get_si(res_coeffs + idx);
+                    if (val >= COEFF_MIN && val <= COEFF_MAX)
+                        res_coeffs[idx] = val;
+                }
+            }
+        }
+        else
+        {
+            my_convSingNFlintN_QQ(c, number(pGetCoeff(p)));
+            FLINT_ASSERT(!fmpq_is_zero(base->res->content));
+            fmpq_div(t, c, base->res->content);
+            FLINT_ASSERT(fmpz_is_one(fmpq_denref(t)));
+            fmpz_swap(res_coeffs + idx, fmpq_numref(t));
+        }
         #if SIZEOF_LONG==8
         p_GetExpVL(p, (int64*)exp, base->r);
         mpoly_set_monomial_ui(base->res->zpoly->exps + N*idx, exp, base->res->zpoly->bits, base->ctx->zctx->minfo);
+        mpoly_set_monomial_ui(res_exps + N*idx, exp, res_bits, base->ctx->zctx->minfo);
         #else
         p_GetExpV(p, (int*)exp, base->r);
         mpoly_set_monomial_ui(base->res->zpoly->exps + N*idx, &(exp[1]), base->res->zpoly->bits, base->ctx->minfo);
+        mpoly_set_monomial_ui(res_exps + N*idx, &(exp[1]), res_bits, base->ctx->minfo);
         #endif
 …
     thread_pool_handle * handles;
     slong num_handles;
+    slong thread_limit = 1000;
+    /* get workers */
+    slong thread_limit = 1000; // TODO: should be paramter to this function
+    /* the constructor works out the length of p and sets some markers */
+    convert_sing_to_fmpq_mpoly_base base(res, ctx, r, p);
+    /* sensibly limit thread count and get workers */
+    thread_limit = FLINT_MIN(thread_limit, base.length/1024);
     handles = NULL;
     num_handles = 0;
 …
+    }
-    convert_sing_to_fmpq_mpoly_base base(num_handles + 1, res, ctx, r, p);
     /* fill in thread division points */
+    base.num_threads = 1 + num_handles;
     convert_sing_to_fmpq_mpoly_arg * args = new convert_sing_to_fmpq_mpoly_arg[base.num_threads];
     slong cur_idx = 0;
 …
+    {
         slong next_idx = i + 1 < base.num_threads ? (i + 1)*base.length/base.num_threads : base.length;
+        FLINT_ASSERT(cur_idx <= base.length);
         next_idx = FLINT_MAX(next_idx, cur_idx);
         next_idx = FLINT_MIN(next_idx, base.length);
 …
         required_bits = FLINT_MAX(required_bits, args[i].required_bits);
-    /* initialize res with optimal bits */
-    fmpq_mpoly_init3(res, base.length, mpoly_fix_bits(required_bits, ctx->zctx->minfo), ctx);
     /* sign of content should match sign of first coeff */
+    fmpq_zero(base.res->content);
+    fmpq_t content;
+    fmpq_init(content);
+    fmpq_zero(content);
     for (slong i = 0; i < base.num_threads; i++)
         fmpq_gcd(base.res->content, base.res->content, args[i].content);
+        fmpq_gcd(content, content, args[i].content);
     if (p != NULL)
+    {
 …
         my_convSingNFlintN_QQ(c, number(pGetCoeff(p)));
         if (fmpq_sgn(c) < 0)
             fmpq_neg(base.res->content, base.res->content);
+            fmpq_neg(content, content);
         fmpq_clear(c);
+    }
+    /* initialize res with optimal bits */
+    required_bits = mpoly_fix_bits(required_bits, ctx->zctx->minfo);
+    if (fmpq_is_one(content))
+    {
+        /* initialize borrowed coeffs */
+        slong N = mpoly_words_per_exp(required_bits, ctx->zctx->minfo);
+        slong alloc = base.length;
+        if (alloc != 0)
+        {
+            res->zpoly->coeffs = (fmpz *) flint_malloc(alloc*sizeof(fmpz));
+            res->zpoly->exps   = (ulong *) flint_malloc(alloc*N*sizeof(ulong));
+        }
+        else
+        {
+            res->zpoly->coeffs = NULL;
+            res->zpoly->exps = NULL;
+        }
+        res->zpoly->alloc = alloc;
+        res->zpoly->length = 0;
+        res->zpoly->bits = required_bits;
+        fmpq_init(res->content);
+        fmpq_one(res->content);
+    }
+    else
+    {
+        /* initialize coeffs that will be created and destroyed */
+        fmpq_mpoly_init3(res, base.length, required_bits, ctx);
+        fmpq_swap(res->content, content);
+    }
+    fmpq_clear(content);
     /* fill in res->zpoly */
 …
     thread_pool_handle * handles;
     slong num_handles;
+    slong thread_limit = 1000;
+    /* get workers */
+    slong thread_limit = 1000;// TODO: should be paramter to this function
+    /* sensibly limit threads and get workers */
+    thread_limit = FLINT_MIN(thread_limit, f->zpoly->length/1024);
     handles = NULL;
     num_handles = 0;
 …
     convert_fmpq_mpoly_to_sing_base base(num_handles + 1, f, ctx, r);
     convert_fmpq_mpoly_to_sing_arg * args = new convert_fmpq_mpoly_to_sing_arg[base.num_threads];
     slong cur_idx = 0;
 …
         slong next_idx = i + 1 < base.num_threads ? (i + 1)*base.f->zpoly->length/base.num_threads
                                                   : base.f->zpoly->length;
+        FLINT_ASSERT(cur_idx <= base.f->zpoly->length);
         next_idx = FLINT_MAX(next_idx, cur_idx);
         next_idx = FLINT_MIN(next_idx, base.f->zpoly->length);
 …
     ring r;
     convert_sing_to_nmod_mpoly_base(slong num_threads_, nmod_mpoly_struct * res_,
                             const nmod_mpoly_ctx_struct * ctx_, const ring r_, poly p)
       : num_threads(num_threads_),
+    convert_sing_to_nmod_mpoly_base(nmod_mpoly_struct * res_,
+                     const nmod_mpoly_ctx_struct * ctx_, const ring r_, poly p)
+      : num_threads(0),
         res(res_),
         ctx(ctx_),
 …
+    }
+    slong N = mpoly_words_per_exp(base->res->bits, base->ctx->minfo);
+    ulong * res_coeffs = base->res->coeffs;
+    ulong * res_exps = base->res->exps;
+    flint_bitcnt_t res_bits = base->res->bits;
     while (idx < arg->end_idx)
+    {
-        slong N = mpoly_words_per_exp(base->res->bits, base->ctx->minfo);
         #if SIZEOF_LONG==8
         p_GetExpVL(p, (int64*)exp, base->r);
         mpoly_set_monomial_ui(base->res->exps + N*idx, exp, base->res->bits, base->ctx->minfo);
+        mpoly_set_monomial_ui(res_exps + N*idx, exp, res_bits, base->ctx->minfo);
         #else
         p_GetExpV(p, (int*)exp, base->r);
         mpoly_set_monomial_ui(base->res->exps + N*idx, &(exp[1]), base->res->bits, base->ctx->minfo);
+        mpoly_set_monomial_ui(res_exps + N*idx, &(exp[1]), res_bits, base->ctx->minfo);
         #endif
         base->res->coeffs[idx] = (ulong)(number(pGetCoeff(p)));
+        res_coeffs[idx] = (ulong)(number(pGetCoeff(p)));
         pIter(p);
 …
     thread_pool_handle * handles;
     slong num_handles;
+    slong thread_limit = 1000;
+    /* get workers */
+    slong thread_limit = 1000; // TODO: should be paramter to this function
+    /* the constructor works out the length of p and sets some markers */
+    convert_sing_to_nmod_mpoly_base base(res, ctx, r, p);
+    /* sensibly limit thread count and get workers */
+    thread_limit = FLINT_MIN(thread_limit, base.length/1024);
     handles = NULL;
     num_handles = 0;
 …
+    }
-    convert_sing_to_nmod_mpoly_base base(num_handles + 1, res, ctx, r, p);
     /* fill in thread division points */
+    base.num_threads = 1 + num_handles;
     convert_sing_to_nmod_mpoly_arg * args = new convert_sing_to_nmod_mpoly_arg[base.num_threads];
     slong cur_idx = 0;
 …
         slong next_idx = i + 1 < base.num_threads ? (i + 1)*base.length/base.num_threads
                                                   : base.length;
+        FLINT_ASSERT(cur_idx <= base.length);
         next_idx = FLINT_MAX(next_idx, cur_idx);
         next_idx = FLINT_MIN(next_idx, base.length);
 …
     thread_pool_handle * handles;
     slong num_handles;
+    slong thread_limit = 1000;
+    /* get workers */
+    slong thread_limit = 1000; // TODO: should be paramter to this function
+    /* sensibly limit threads and get workers */
+    thread_limit = FLINT_MIN(thread_limit, f->length/1024);
     handles = NULL;
     num_handles = 0;
 …
     convert_nmod_mpoly_to_sing_base base(num_handles + 1, f, ctx, r);
     convert_nmod_mpoly_to_sing_arg * args = new convert_nmod_mpoly_to_sing_arg[base.num_threads];
     slong cur_idx = 0;
 …
         slong next_idx = i + 1 < base.num_threads ? (i + 1)*base.f->length/base.num_threads
                                                   : base.f->length;
+        FLINT_ASSERT(cur_idx <= base.f->length);
         next_idx = FLINT_MAX(next_idx, cur_idx);
         next_idx = FLINT_MIN(next_idx, base.f->length);
 …
+{
   fmpq_mpoly_t pp,qq,res;
   convSingPFlintMP(pp,ctx,p,lp,r);
   convSingPFlintMP(qq,ctx,q,lq,r);
+  convSingPFlintMP(pp,ctx,p,lp,r); // pp read only
+  convSingPFlintMP(qq,ctx,q,lq,r); // qq read only
   fmpq_mpoly_init(res,ctx);
   fmpq_mpoly_mul(res,pp,qq,ctx);
   poly pres=convFlintMPSingP(res,ctx,r);
   fmpq_mpoly_clear(res,ctx);
   fmpq_mpoly_clear(pp,ctx);
   fmpq_mpoly_clear(qq,ctx);
+  _fmpq_mpoly_clear_readonly_sing(pp,ctx);
+  _fmpq_mpoly_clear_readonly_sing(qq,ctx);
   fmpq_mpoly_ctx_clear(ctx);
   p_Test(pres,r);
 …
+{
   fmpq_mpoly_t pp,qq,res;
   convSingPFlintMP(pp,ctx,p,lp,r);
   convSingPFlintMP(qq,ctx,q,lq,r);
+  convSingPFlintMP(pp,ctx,p,lp,r); // pp read only
+  convSingPFlintMP(qq,ctx,q,lq,r); // qq read only
   fmpq_mpoly_init(res,ctx);
   fmpq_mpoly_divides(res,pp,qq,ctx);
   poly pres = convFlintMPSingP(res,ctx,r);
   fmpq_mpoly_clear(res,ctx);
   fmpq_mpoly_clear(pp,ctx);
   fmpq_mpoly_clear(qq,ctx);
+  _fmpq_mpoly_clear_readonly_sing(pp,ctx);
+  _fmpq_mpoly_clear_readonly_sing(qq,ctx);
   fmpq_mpoly_ctx_clear(ctx);
   p_Test(pres,r);
 …
+{
   fmpq_mpoly_t pp,qq,res;
   convSingPFlintMP(pp,ctx,p,lp,r);
   convSingPFlintMP(qq,ctx,q,lq,r);
+  convSingPFlintMP(pp,ctx,p,lp,r); // pp read only
+  convSingPFlintMP(qq,ctx,q,lq,r); // qq read only
   fmpq_mpoly_init(res,ctx);
   int ok=fmpq_mpoly_gcd(res,pp,qq,ctx);
 …
+  }
   fmpq_mpoly_clear(res,ctx);
   fmpq_mpoly_clear(pp,ctx);
   fmpq_mpoly_clear(qq,ctx);
+  _fmpq_mpoly_clear_readonly_sing(pp,ctx);
+  _fmpq_mpoly_clear_readonly_sing(qq,ctx);
   fmpq_mpoly_ctx_clear(ctx);
   return pres;

libpolys/polys/monomials/ring.cc

-                      rd4cec6a
+                      r7161aca
   if (rIsLPRing(r))
+  {
     Print("\n// letterplace ring (block size %d)",r->isLPring);
+    Print("\n// letterplace ring (block size %d, ncgen count %d)",r->isLPring, r->LPncGenCount);
+  }
 #endif
 …
 #ifdef HAVE_SHIFTBBA
   res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
+  res->LPncGenCount=r->LPncGenCount;
 #endif
 …
 #ifdef HAVE_SHIFTBBA
   res->isLPring=r->isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
+  res->LPncGenCount=r->LPncGenCount;
 #endif
 …
   #ifdef HAVE_SHIFTBBA
   if (r1->isLPring!=r2->isLPring) return FALSE;
+  if (r1->LPncGenCount!=r2->LPncGenCount) return FALSE;
   #endif

libpolys/polys/monomials/ring.h

rd4cec6a	r7161aca
312	312	#ifdef HAVE_SHIFTBBA
313	313	short isLPring; /* 0 for non-letterplace rings, otherwise the number of LP blocks, at least 1, known also as lV */
	314	short LPncGenCount;
314	315	#endif
315	316

libpolys/polys/operations/p_Mult_q.cc

-                      rd4cec6a
+                      r7161aca
+}
+static void pqLengthApprox(poly p, poly q, int &lp, int &lq, const int min)
+{
+  int l = 0;
+  do
+  {
+    if (p == NULL)
+    {
+      lp=l;
+      lq=l+(q!=NULL);
+      return;
+    }
+    if (q == NULL) /* && p!=NULL */
+    {
+      lp=l+1;
+      lq=l;
+      return;
+    }
+    if (l>min) /* && p,q!=NULL */
+    {
+      lp=l; lq=l;
+      return;
+    }
+    pIter(p);
+    pIter(q);
+    l++;
+  }
+  while (1);
+}
 static poly _p_Mult_q_Bucket(poly p, const int lp,
 …
   poly pt;
+  pqLength(p, q, lp, lq, MIN_LENGTH_FACTORY);
+  // MIN_LENGTH_FACTORY must be >= MIN_LENGTH_FACTORY_QQ, MIN_FLINT_QQ, MIN_FLINT_Zp 20
+  pqLengthApprox(p, q, lp, lq, MIN_LENGTH_FACTORY);
   if (lp < lq)
 …
     if (pure_polys && rField_is_Q(r) && !convSingRFlintR(ctx,r))
+    {
+      lp=pLength(p);
+      //printf("mul in flint\n");
+      poly res=Flint_Mult_MP(p,lp,q,lq,ctx,r);
+      // lq is a lower bound for the length of p and  q
+      poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
       if (!copy)
+      {
 …
     if (pure_polys && rField_is_Zp(r) && !convSingRFlintR(ctx,r))
+    {
+      lp=pLength(p);
+      //printf("mul in flint\n");
+      poly res=Flint_Mult_MP(p,lp,q,lq,ctx,r);
+      // lq is a lower bound for the length of p and  q
+      poly res=Flint_Mult_MP(p,lq,q,lq,ctx,r);
       if (!copy)
+      {
 …
+  {
     lp=pLength(p);
     assume(lq == pLength(q));
+    lq=pLength(q);
     return _p_Mult_q_Bucket(p, lp, q, lq, copy, r);
+  }

libpolys/polys/shiftop.cc

-                      rd4cec6a
+                      r7161aca
   PrintLn(); WriteLPExpV(m1ExpV, ri);
 #endif
+  assume(_p_mLPNCGenValid(m1ExpV, ri));
+}
 …
   PrintLn(); WriteLPExpV(m1ExpV, ri);
 #endif
+  assume(_p_mLPNCGenValid(m1ExpV, ri));
+}
 …
   assume(p_FirstVblock(m1,r) <= 1);
   assume(p_FirstVblock(m2,r) <= 1);
+}
+BOOLEAN _p_mLPNCGenValid(int *mExpV, const ring r)
+{
+  BOOLEAN hasNCGen = FALSE;
+  int lV = r->isLPring;
+  int degbound = r->N/lV;
+  int ncGenCount = r->LPncGenCount;
+  for (int i = 1; i <= degbound; i++)
+  {
+    for (int j = i*lV; j > (i*lV - ncGenCount); j--)
+    {
+      if (mExpV[j])
+      {
+        if (hasNCGen)
+        {
+          return FALSE;
+        }
+        hasNCGen = TRUE;
+      }
+    }
+  }
+  return TRUE;
+}
 …
     if (B[j]!=0) break;
+  }
+  /* do not need e anymore */
+  if (j==0)
+  {
+    omFreeSize((ADDRESS) e, (r->N+1)*sizeof(int));
+    omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
+    return 1;
+  }
+  if (!_p_mLPNCGenValid(e, r))
+  {
+    omFreeSize((ADDRESS) e, (r->N+1)*sizeof(int));
+    omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
+    return 0;
+  }
   omFreeSize((ADDRESS) e, (r->N+1)*sizeof(int));
-  if (j==0) goto ret_true;
 //   {
 //     /* it is a zero exp vector, which is in V */
 …
+    {
       omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
       return(0);
+    }
+  }
+ ret_true:
+      return 0;
+    }
+  }
   omFreeSize((ADDRESS) B, (b+1)*sizeof(int));
   return(1);
+  return 1;
+}
 …
+}
+ring freeAlgebra(ring r, int d)
+{
+ring freeAlgebra(ring r, int d, int ncGenCount)
+{
+  if (ncGenCount) r = rCopy0(r);
+  for (int i = 1; i <= ncGenCount; i++)
+  {
+    char *varname=(char *)omAlloc(256);
+    sprintf(varname, "ncgen(%d)", i);
+    ring save = r;
+    r = rPlusVar(r, varname, 0);
+    omFreeSize(varname, 256);
+    rDelete(save);
+  }
   ring R=rCopy0(r);
   int p;
 …
   R->N=r->N*d;
   R->isLPring=r->N;
+  R->LPncGenCount=ncGenCount;
   // create R->order
   BOOLEAN has_order_a=FALSE;
 …
   R->names=names;
+  if (ncGenCount) rDelete(r);
   rComplete(R,TRUE);
   return R;

libpolys/polys/shiftop.h

-                      rd4cec6a
+                      r7161aca
 BOOLEAN _p_LPLmDivisibleByNoComp(poly a, poly b, const ring r);
+BOOLEAN _p_mLPNCGenValid(int *mExpV, const ring r);
 poly p_LPVarAt(poly p, int pos, const ring r);
 /// create the letterplace ring corresponding to r up to degree d
 ring freeAlgebra(ring r, int d);
+ring freeAlgebra(ring r, int d, int LPncGenCount = 0);
 #endif
 #endif

Context Navigation

Changeset 7161aca in git

Legend:

Download in other formats: