Changeset 56ff8ef in git


Ignore:
Timestamp:
May 13, 2019, 4:15:31 PM (4 years ago)
Author:
Karim Abou Zeid <karim23697@…>
Branches:
(u'spielwiese', '8e0ad00ce244dfd0756200662572aef8402f13d5')
Children:
d906dc5d406b00b056fb825f5c5c8988ebcaceb3
Parents:
d0ca0b8ae05c9cfcf2578b78e43825144b88299c7ea5de9643c52c85381a5d31f1c56130fc656ff9
Message:
Merge branch 'lpGkDim_dynmodule' into stable
Files:
6 added
24 edited

Legend:

Unmodified
Added
Removed

  • Singular/LIB/GND.lib

    r7ea5de r56ff8ef  
    12921292      "And this is the map:";
    12931293    }
    1294     //execute("ideal themap = vidjet[nrx+1..size(vidjet)],"+t+",invssp;");
    12951294    invssp = 1/invssp;
    12961295    if(debug)
    … …  
    13001299    string zz = "Z";
    13011300    def newvar2 = findnewvar(zz);
    1302     //execute("ring Efinalbase = (0,"+parstr(E)+"),("+varstr(E)+","+newvar2+"),dp;");
    13031301    def q = imap(E,e2);
    13041302    poly teta = var(nvars(Efinalbase)) * imap(E,ss)*imap(E,ssp) - 1;

  • Singular/LIB/ainvar.lib

    r7ea5de r56ff8ef  
    215215  //------------- changes the basering bsr to bsr[@(0),...,@(z)] ----------
    216216  execute("ring s="+charstr(basering)+",("+varstr(basering)+",@(0..z)),dp;");
    217 // Ev hier die Reihenfolge der Vars aendern. Dazu muss unten aber entsprechend
    218 // geaendert werden:
    219 //  execute("ring s="+charstr(basering)+",(@(0..z),"+varstr(basering)+"),dp;");
    220217
    221218  //constructs the leading ideal of dom=(p-@(0),dom[1]-@(1),...,dom[z]-@(z))

  • Singular/LIB/brnoeth.lib

    r7ea5de r56ff8ef  
    916916    execute("string sdatum=string("+datum+");");
    917917    ring auxring=char(basering),(a,b,x,y,t),lp;
    918 //  execute("poly pdatum="+datum+";");
    919918    execute("poly pdatum="+sdatum+";");
    920919    execute("poly prel=b-("+rel+");");

  • Singular/LIB/deform.lib

    r7ea5de r56ff8ef  
    845845    for (l=1;l<=t1;l=l+1)
    846846    {
    847 // old:   execute("l1= "+columnes[2*l-1]+";");
    848847      l1=vvvv[l];
    849848      B[l] = A[l1];

  • Singular/LIB/dmod.lib

    r7ea5de r56ff8ef  
    526526}
    527527
    528 // JM+VL: output ring restructured into "normal"
    529 
    530 // proc Sannfslog (poly F, list #)
    531 // "USAGE:  Sannfslog(f [,eng]);  f a poly, eng an optional int
    532 // RETURN:  ring
    533 // PURPOSE: compute the D-module structure of basering[1/f]*f^s
    534 // NOTE:    activate the output ring with the @code{setring} command.
    535 // @*   In the output ring D[s], the ideal LD1 is generated by the elements
    536 // @*   in Ann F^s in D[s], coming from logarithmic derivations.
    537 // @*       If eng <>0, @code{std} is used for Groebner basis computations,
    538 // @*       otherwise, and by default @code{slimgb} is used.
    539 // DISPLAY: If @code{printlevel}=1, progress debug messages will be printed,
    540 // @*          if @code{printlevel}>=2, all the debug messages will be printed.
    541 // EXAMPLE: example Sannfslog; shows examples
    542 // "
    543 // {
    544 //   int eng = 0;
    545 //   if ( size(#)>0 )
    546 //   {
    547 //     if ( typeof(#[1]) == "int" )
    548 //     {
    549 //       eng = int(#[1]);
    550 //     }
    551 //   }
    552 //   int ppl = printlevel-voice+2;
    553 //   def save = basering;
    554 //   int N = nvars(basering);
    555 //   int Nnew = 2*N+1;
    556 //   int i;
    557 //   string s;
    558 //   list RL = ringlist(basering);
    559 //   list L, Lord;
    560 //   list tmp;
    561 //   intvec iv;
    562 //   L[1] = RL[1]; // char
    563 //   L[4] = RL[4]; // char, minpoly
    564 //   // check whether vars have admissible names
    565 //   list Name = RL[2];
    566 //   for (i=1; i<=N; i++)
    567 //   {
    568 //     if (Name[i] == "s")
    569 //     {
    570 //       ERROR("Variable names should not include s");
    571 //     }
    572 //   }
    573 //   // the ideal I
    574 //   ideal I = -F, jacob(F);
    575 //   dbprint(ppl,"// -1-1- starting the computation of syz(-F,_Dx(F))");
    576 //   dbprint(ppl-1, I);
    577 //   matrix M = syz(I);
    578 //   M = transpose(M);  // it is more usefull working with columns
    579 //   dbprint(ppl,"// -1-2- the module syz(-F,_Dx(F)) has been computed");
    580 //   dbprint(ppl-1, M);
    581 //   // ------------ the ring @R ------------
    582 //   // _x, _Dx, s;  elim.ord for _x,_Dx.
    583 //   // now, create the names for new vars
    584 //   list DName;
    585 //   for (i=1; i<=N; i++)
    586 //   {
    587 //     DName[i] = "D"+Name[i]; // concat
    588 //   }
    589 //   tmp[1] = "s";
    590 //   list NName;
    591 //   for (i=1; i<=N; i++)
    592 //   {
    593 //     NName[2*i-1] = Name[i];
    594 //     NName[2*i] = DName[i];
    595 //     //NName[2*i-1] = DName[i];
    596 //     //NName[2*i] = Name[i];
    597 //   }
    598 //   NName[Nnew] = tmp[1];
    599 //   L[2] = NName;
    600 //   tmp = 0;
    601 //   // block ord (a(1,1),a(0,0,1,1),...,dp);
    602 //   //list("a",intvec(1,1)), list("a",intvec(0,0,1,1)), ...
    603 //   tmp[1] = "a";  // string
    604 //   for (i=1; i<=N; i++)
    605 //   {
    606 //     iv[2*i-1] = 1;
    607 //     iv[2*i]   = 1;
    608 //     tmp[2]    = iv;  iv = 0;  // intvec
    609 //     Lord[i]   = tmp;
    610 //   }
    611 //   //list("dp",intvec(1,1,1,1,1,...))
    612 //   s = "iv=";
    613 //   for (i=1; i<=Nnew; i++)
    614 //   {
    615 //     s = s+"1,";
    616 //   }
    617 //   s[size(s)]=";";
    618 //   execute(s);
    619 //   kill s;
    620 //   tmp[1] = "dp";  // string
    621 //   tmp[2] = iv;    // intvec
    622 //   Lord[N+1] = tmp;
    623 //   //list("C",intvec(0))
    624 //   tmp[1] = "C";  // string
    625 //   iv = 0;
    626 //   tmp[2] = iv;   // intvec
    627 //   Lord[N+2] = tmp;
    628 //   tmp = 0;
    629 //   L[3]    = Lord;
    630 //   // we are done with the list. Now add a Plural part
    631 //   def @R@ = ring(L);
    632 //   setring @R@;
    633 //   matrix @D[Nnew][Nnew];
    634 //   for (i=1; i<=N; i++)
    635 //   {
    636 //     @D[2*i-1,2*i]=1;
    637 //     //@D[2*i-1,2*i]=-1;
    638 //   }
    639 //   def @R = nc_algebra(1,@D);
    640 //   setring @R;
    641 //   kill @R@;
    642 //   dbprint(ppl,"// -2-1- the ring @R(_x,_Dx,s) is ready");
    643 //   dbprint(ppl-1, @R);
    644 //   matrix M = imap(save,M);
    645 //   // now, create the vector [-s,_Dx]
    646 //   vector v = [-s];  // now s is a variable
    647 //   for (i=1; i<=N; i++)
    648 //   {
    649 //     v = v + var(2*i)*gen(i+1);
    650 //     //v = v + var(2*i-1)*gen(i+1);
    651 //   }
    652 //   ideal J = ideal(M*v);
    653 //   // make leadcoeffs positive
    654 //   for (i=1; i<= ncols(J); i++)
    655 //   {
    656 //     if ( leadcoef(J[i])<0 )
    657 //     {
    658 //       J[i] = -J[i];
    659 //     }
    660 //   }
    661 //   ideal LD1 = J;
    662 //   kill J;
    663 //   export LD1;
    664 //   return(@R);
    665 // }
    666 // example
    667 // {
    668 //   "EXAMPLE:"; echo = 2;
    669 //   ring r = 0,(x,y),Dp;
    670 //   poly F = x^4+y^5+x*y^4;
    671 //   printlevel = 0;
    672 //   def A  = Sannfslog(F);
    673 //   setring A;
    674 //   LD1;
    675 // }
     528
    676529
    677530
    … …  
    30472900  tmp[2]    = iv;
    30482901  Lord[2]   = tmp;
    3049   // extra block for s
    3050   // tmp[1] = "dp"; iv = 1;
    3051   //  s[size(s)]= ",";  s = s + "1,1,1;";  execute(s);  tmp[2]    = iv;
    3052   //  Lord[3]   = tmp;
    30532902  kill s;
    30542903  tmp[1]    = "C";   iv  = 0; tmp[2] = iv;
    … …  
    34293278  tmp[2]    = iv;
    34303279  Lord[2]   = tmp;
    3431   // extra block for s
    3432   // tmp[1] = "dp"; iv = 1;
    3433   //  s[size(s)]= ",";  s = s + "1,1,1;";  execute(s);  tmp[2]    = iv;
    3434   //  Lord[3]   = tmp;
    34353280  kill s;
    34363281  tmp[1]    = "C";   iv  = 0; tmp[2] = iv;
    … …  
    49444789}
    49454790
    4946 // proc annfsgms(poly F, list #)
    4947 // "USAGE:  annfsgms(f [,eng]);  f a poly, eng an optional int
    4948 // ASSUME:  f has an isolated critical point at 0
    4949 // RETURN:  ring
    4950 // PURPOSE: compute the D-module structure of basering[1/f]*f^s
    4951 // NOTE:    activate the output ring with the @code{setring} command. In this ring,
    4952 // @*       - the ideal LD is the needed D-mod structure,
    4953 // @*       - the ideal BS is the list of roots of a Bernstein polynomial of f.
    4954 // @*       If eng <>0, @code{std} is used for Groebner basis computations,
    4955 // @*       otherwise (and by default) @code{slimgb} is used.
    4956 // @*       If printlevel=1, progress debug messages will be printed,
    4957 // @*       if printlevel>=2, all the debug messages will be printed.
    4958 // EXAMPLE: example annfsgms; shows examples
    4959 // "
    4960 // {
    4961 //   LIB "gmssing.lib";
    4962 //   int eng = 0;
    4963 //   if ( size(#)>0 )
    4964 //   {
    4965 //     if ( typeof(#[1]) == "int" )
    4966 //     {
    4967 //       eng = int(#[1]);
    4968 //     }
    4969 //   }
    4970 //   int ppl = printlevel-voice+2;
    4971 //   // returns a ring with the ideal LD in it
    4972 //   def save = basering;
    4973 //   // compute the Bernstein polynomial from gmssing.lib
    4974 //   list RL = ringlist(basering);
    4975 //   // in the descr. of the ordering, replace "p" by "s"
    4976 //   list NL = convloc(RL);
    4977 //   // create a ring with the ordering, converted to local
    4978 //   def @LR = ring(NL);
    4979 //   setring @LR;
    4980 //   poly F  = imap(save, F);
    4981 //   ideal B = bernstein(F)[1];
    4982 //   // since B may not contain (s+1) [following gmssing.lib]
    4983 //   // add it!
    4984 //   B = B,-1;
    4985 //   B = simplify(B,2+4); // erase zero and repeated entries
    4986 //   // find the minimal integer value
    4987 //   int   S = minIntRoot(B,0);
    4988 //   dbprint(ppl,"// -0- minimal integer root found");
    4989 //   dbprint(ppl-1,S);
    4990 //   setring save;
    4991 //   int N = nvars(basering);
    4992 //   int Nnew = 2*(N+2);
    4993 //   int i,j;
    4994 //   string s;
    4995 //   //  list RL = ringlist(basering);
    4996 //   list L, Lord;
    4997 //   list tmp;
    4998 //   intvec iv;
    4999 //   L[1] = RL[1]; // char
    5000 //   L[4] = RL[4]; // char, minpoly
    5001 //   // check whether vars have admissible names
    5002 //   list Name  = RL[2];
    5003 //   list RName;
    5004 //   RName[1] = "u";
    5005 //   RName[2] = "v";
    5006 //   RName[3] = "t";
    5007 //   RName[4] = "Dt";
    5008 //   for(i=1;i<=N;i++)
    5009 //   {
    5010 //     for(j=1; j<=size(RName);j++)
    5011 //     {
    5012 //       if (Name[i] == RName[j])
    5013 //       {
    5014 //         ERROR("Variable names should not include u,v,t,Dt");
    5015 //       }
    5016 //     }
    5017 //   }
    5018 //   // now, create the names for new vars
    5019 //   //  tmp[1]     = "u";  tmp[2]     = "v";  tmp[3]     = "t";  tmp[4]     = "Dt";
    5020 //   list UName = RName;
    5021 //   list DName;
    5022 //   for(i=1;i<=N;i++)
    5023 //   {
    5024 //     DName[i] = "D"+Name[i]; // concat
    5025 //   }
    5026 //   list NName = UName + Name + DName;
    5027 //   L[2]       = NName;
    5028 //   tmp        = 0;
    5029 //   // Name, Dname will be used further
    5030 //   kill UName;
    5031 //   kill NName;
    5032 //   // block ord (a(1,1),dp);
    5033 //   tmp[1]  = "a"; // string
    5034 //   iv      = 1,1;
    5035 //   tmp[2]  = iv; //intvec
    5036 //   Lord[1] = tmp;
    5037 //   // continue with dp 1,1,1,1...
    5038 //   tmp[1]  = "dp"; // string
    5039 //   s       = "iv=";
    5040 //   for(i=1; i<=Nnew; i++) // need really all vars!
    5041 //   {
    5042 //     s = s+"1,";
    5043 //   }
    5044 //   s[size(s)]= ";";
    5045 //   execute(s);
    5046 //   tmp[2]    = iv;
    5047 //   Lord[2]   = tmp;
    5048 //   tmp[1]    = "C";
    5049 //   iv        = 0;
    5050 //   tmp[2]    = iv;
    5051 //   Lord[3]   = tmp;
    5052 //   tmp       = 0;
    5053 //   L[3]      = Lord;
    5054 //   // we are done with the list
    5055 //   def @R = ring(L);
    5056 //   setring @R;
    5057 //   matrix @D[Nnew][Nnew];
    5058 //   @D[3,4] = 1; // t,Dt
    5059 //   for(i=1; i<=N; i++)
    5060 //   {
    5061 //     @D[4+i,4+N+i]=1;
    5062 //   }
    5063 //   //  L[5] = matrix(UpOneMatrix(Nnew));
    5064 //   //  L[6] = @D;
    5065 //   nc_algebra(1,@D);
    5066 //   dbprint(ppl,"// -1-1- the ring @R is ready");
    5067 //   dbprint(ppl-1,@R);
    5068 //   // create the ideal
    5069 //   poly F  = imap(save,F);
    5070 //   ideal I = u*F-t,u*v-1;
    5071 //   poly p;
    5072 //   for(i=1; i<=N; i++)
    5073 //   {
    5074 //     p = u*Dt; // u*Dt
    5075 //     p = diff(F,var(4+i))*p;
    5076 //     I = I, var(N+4+i) + p; // Dx, Dy
    5077 //   }
    5078 //   // add the relations between t,Dt and s
    5079 //   //  I = I, t*Dt+1+S;
    5080 //   // -------- the ideal I is ready ----------
    5081 //   dbprint(ppl,"// -1-2- starting the elimination of u,v in @R");
    5082 //   ideal J = engine(I,eng);
    5083 //   ideal K = nselect(J,1..2);
    5084 //   dbprint(ppl,"// -1-3- u,v are eliminated in @R");
    5085 //   dbprint(ppl-1,K); // without u,v: not yet our answer
    5086 //   //----- create a ring with elim.ord for t,Dt -------
    5087 //   setring save;
    5088 //   // ------------ new ring @R2 ------------------
    5089 //   // without u,v and with the elim.ord for t,Dt
    5090 //   // keep: N, i,j,s, tmp, RL
    5091 //   Nnew = 2*N+2;
    5092 //   //  list RL = ringlist(save); // is defined earlier
    5093 //   kill Lord,tmp,iv, RName;
    5094 //   L = 0;
    5095 //   list Lord, tmp;
    5096 //   intvec iv;
    5097 //   L[1] = RL[1]; // char
    5098 //   L[4] = RL[4]; // char, minpoly
    5099 //   // check whether vars have admissible names -> done earlier
    5100 //   //  list Name  = RL[2];
    5101 //   list RName;
    5102 //   RName[1] = "t";
    5103 //   RName[2] = "Dt";
    5104 //   // DName is defined earlier
    5105 //   list NName = RName + Name + DName;
    5106 //   L[2]   = NName;
    5107 //   tmp    = 0;
    5108 //   // block ord (a(1,1),dp);
    5109 //   tmp[1]  = "a"; // string
    5110 //   iv      = 1,1;
    5111 //   tmp[2]  = iv; //intvec
    5112 //   Lord[1] = tmp;
    5113 //   // continue with dp 1,1,1,1...
    5114 //   tmp[1]  = "dp"; // string
    5115 //   s       = "iv=";
    5116 //   for(i=1;i<=Nnew;i++)
    5117 //   {
    5118 //     s = s+"1,";
    5119 //   }
    5120 //   s[size(s)]= ";";
    5121 //   execute(s);
    5122 //   kill s;
    5123 //   kill NName;
    5124 //   tmp[2]    = iv;
    5125 //   Lord[2]   = tmp;
    5126 //   tmp[1]    = "C";
    5127 //   iv        = 0;
    5128 //   tmp[2]    = iv;
    5129 //   Lord[3]   = tmp;
    5130 //   tmp       = 0;
    5131 //   L[3]      = Lord;
    5132 //   // we are done with the list
    5133 //   // Add: Plural part
    5134 //   def @R2 = ring(L);
    5135 //   setring @R2;
    5136 //   matrix @D[Nnew][Nnew];
    5137 //   @D[1,2]=1;
    5138 //   for(i=1; i<=N; i++)
    5139 //   {
    5140 //     @D[2+i,2+N+i]=1;
    5141 //   }
    5142 //   nc_algebra(1,@D);
    5143 //   dbprint(ppl,"// -2-1- the ring @R2 is ready");
    5144 //   dbprint(ppl-1,@R2);
    5145 //   ideal MM = maxideal(1);
    5146 //   MM = 0,0,MM;
    5147 //   map R01 = @R, MM;
    5148 //   ideal K2 = R01(K);
    5149 //   // add the relations between t,Dt and s
    5150 //   //  K2       = K2, t*Dt+1+S;
    5151 //   poly G = t*Dt+S+1;
    5152 //   K2 = NF(K2,std(G)),G;
    5153 //   dbprint(ppl,"// -2-2- starting elimination for t,Dt in @R2");
    5154 //   ideal J  = engine(K2,eng);
    5155 //   ideal K  = nselect(J,1..2);
    5156 //   dbprint(ppl,"// -2-3- t,Dt are eliminated");
    5157 //   dbprint(ppl-1,K);
    5158 //   //  "------- produce a final result --------";
    5159 //   // ----- create the ordinary Weyl algebra and put
    5160 //   // ----- the result into it
    5161 //   // ------ create the ring @R5
    5162 //   // keep: N, i,j,s, tmp, RL
    5163 //   setring save;
    5164 //   Nnew = 2*N;
    5165 //   //  list RL = ringlist(save); // is defined earlier
    5166 //   kill Lord, tmp, iv;
    5167 //   //  kill L;
    5168 //   L = 0;
    5169 //   list Lord, tmp;
    5170 //   intvec iv;
    5171 //   L[1] = RL[1]; // char
    5172 //   L[4] = RL[4]; // char, minpoly
    5173 //   // check whether vars have admissible names -> done earlier
    5174 //   //  list Name  = RL[2];
    5175 //   // DName is defined earlier
    5176 //   list NName = Name + DName;
    5177 //   L[2]   = NName;
    5178 //   // dp ordering;
    5179 //   string   s       = "iv=";
    5180 //   for(i=1;i<=2*N;i++)
    5181 //   {
    5182 //     s = s+"1,";
    5183 //   }
    5184 //   s[size(s)]= ";";
    5185 //   execute(s);
    5186 //   tmp     = 0;
    5187 //   tmp[1]  = "dp"; // string
    5188 //   tmp[2]  = iv; //intvec
    5189 //   Lord[1] = tmp;
    5190 //   kill s;
    5191 //   tmp[1]    = "C";
    5192 //   iv        = 0;
    5193 //   tmp[2]    = iv;
    5194 //   Lord[2]   = tmp;
    5195 //   tmp       = 0;
    5196 //   L[3]      = Lord;
    5197 //   // we are done with the list
    5198 //   // Add: Plural part
    5199 //   def @R5 = ring(L);
    5200 //   setring @R5;
    5201 //   matrix @D[Nnew][Nnew];
    5202 //   for(i=1; i<=N; i++)
    5203 //   {
    5204 //     @D[i,N+i]=1;
    5205 //   }
    5206 //   nc_algebra(1,@D);
    5207 //   dbprint(ppl,"// -3-1- the ring @R5 is ready");
    5208 //   dbprint(ppl-1,@R5);
    5209 //   ideal K5 = imap(@R2,K);
    5210 //   option(redSB);
    5211 //   dbprint(ppl,"// -3-2- the final cosmetic std");
    5212 //   K5 = engine(K5,eng); // std does the job too
    5213 //   // total cleanup
    5214 //   kill @R;
    5215 //   kill @R2;
    5216 //   ideal LD = K5;
    5217 //   ideal BS = imap(@LR,B);
    5218 //   kill @LR;
    5219 //   export BS;
    5220 //   export LD;
    5221 //   return(@R5);
    5222 // }
    5223 // example
    5224 // {
    5225 //   "EXAMPLE:"; echo = 2;
    5226 //   ring r = 0,(x,y,z),Dp;
    5227 //   poly F = x^2+y^3+z^5;
    5228 //   def A = annfsgms(F);
    5229 //   setring A;
    5230 //   LD;
    5231 //   print(matrix(BS));
    5232 // }
     4791
    52334792
    52344793

  • Singular/LIB/finvar.lib

    r7ea5de r56ff8ef  
    15171517  def T = br+tmpR;
    15181518  setring T;
    1519   // execute("ring T=("+charstr(br)+"),("+varstr(br)+",p(1..m)),lp;");
    1520   // p(1..m) are the general coefficients of the general polynomial of degree g
    15211519  ideal vars = fetch(br,vars);
    15221520  map f;

  • Singular/LIB/fpaprops.lib

    rd0ca0b r56ff8ef  
    877877}
    878878
    879 proc lpGkDim(ideal G)
     879proc lpGkDim_lib(ideal G)
    880880"USAGE: lpGkDim(G); G an ideal in a letterplace ring
    881881RETURN: int

  • Singular/LIB/freegb.lib

    r7ea5de r56ff8ef  
    34813481  int i, j, k, sm, sv;
    34823482  vector v;
    3483   //  execute("setring "+lpring);
    34843483  setring lpring;
    34853484  poly @@p;

  • Singular/LIB/involut.lib

    r7ea5de r56ff8ef  
    821821    execute("ring @@KK=(0,"+Par+"),("+@ss+"), dp;");
    822822  }
    823   //  execute("setring @@KK;");
    824823  //  basering;
    825824  ideal J = imap(@@K,J); // ideal, considered in @@KK now

  • Singular/LIB/maxlike.lib

    r7ea5de r56ff8ef  
    300300  }
    301301
    302   //execute("ring outR =(complex,"+string(prec)+"),(x(1.."+string(n)+")),dp;");
    303302  ring outR=(complex,prec),x(1..n),dp;
    304303  list MPOINTS = imap(R,L2);
    … …  
    497496  }
    498497
    499   //execute("ring outR =(complex,"+string(prec)+"),(x(1.."+string(n)+")),dp;");
    500498  ring outR=(complex,prec),x(1..n),dp;
    501499  list MPOINTS = imap(R,L2);

  • Singular/LIB/normal.lib

    r7ea5de r56ff8ef  
    29862986      }
    29872987      ker=simplify(interred(ker),15);
    2988       //execute ("ring R0="+charstr(R)+",("+varstr(R)+"),("+ordstr(R)+");");
    29892988      // Rlist may be not defined in this new ring, so we define it again.
    29902989      list Rlist2 = ringlist(R);
    … …  
    33023301             setring S(k);
    33033302
    3304              //execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",
    3305              //          Z(1.."+string(ncols(phi))+")),(dp("+string(nvars(R(k)))
    3306              //          +"),dp("+string(ncols(phi))+"));");
    3307 
    33083303              ideal phi = imap(R(k),phi);
    33093304              ideal J = imap (R(k),ker);
    … …  
    33373332              //  mapstr=mapstr+"0,";
    33383333              //}
    3339               //execute (mapstr+"maxideal(1);");
    33403334              poly p;
    33413335          }
    … …  
    34903484         setring S(k);
    34913485
    3492         // execute ("ring S(k) = "+charstr(R(k))+",("+varstr(R(k))+",
    3493         //           Z(1.."+string(ncols(phi))+")),(dp("+string(nvars(R(k)))
    3494         //           +"),dp("+string(ncols(phi))+"));");
    3495 
    34963486          ideal phi = imap(R(k),phi);
    34973487          ideal J = imap (R(k),ker);
    … …  
    35233513           //  mapstr=mapstr+"0,";
    35243514           //}
    3525            //execute (mapstr+"maxideal(1);");
    35263515
    35273516           poly p;

  • Singular/LIB/primdec.lib

    r7ea5de r56ff8ef  
    11351135      else                   { @qh=groebner(@qh); }
    11361136
    1137 //=============================================================
    1138 //       if(npars(@P)>0)
    1139 //       {
    1140 //          @ri= "ring @Phelp ="
    1141 //                  +string(char(@P))+",
    1142 //                   ("+varstr(@P)+","+parstr(@P)+",@t),(C,dp);";
    1143 //       }
    1144 //       else
    1145 //       {
    1146 //          @ri= "ring @Phelp ="
    1147 //                  +string(char(@P))+",("+varstr(@P)+",@t),(C,dp);";
    1148 //       }
    1149 //       execute(@ri);
    1150 //       ideal @qh=homog(imap(@P,@qht),@t);
    1151 //
    1152 //       ideal @qh1=std(@qh);
    1153 //       @hilb=hilb(@qh1,1);
    1154 //       @ri= "ring @Phelp1 ="
    1155 //                  +string(char(@P))+",("+varstr(@Phelp)+"),(C,lp);";
    1156 //       execute(@ri);
    1157 //       ideal @qh=homog(imap(@P,@qh),@t);
    1158 //       kill @Phelp;
    1159 //       @qh=std(@qh,@hilb);
    1160 //       @qh=subst(@qh,@t,1);
    1161 //       setring @P;
    1162 //       @qh=imap(@Phelp1,@qh);
    1163 //       kill @Phelp1;
    1164 //       @qh=clearSB(@qh);
    1165 //       attrib(@qh,"isSB",1);
    1166 //=============================================================
    1167 
    11681137      ser1=phi1(ser);
    11691138      @lh=zero_decomp (@qh,phi(ser1),@wr);
    … …  
    12091178      primary=primary+lres0;
    12101179
    1211 //=============================================================
    1212 //       if(npars(@P)>0)
    1213 //       {
    1214 //          @ri= "ring @Phelp ="
    1215 //                  +string(char(@P))+",
    1216 //                   ("+varstr(@P)+","+parstr(@P)+",@t),(C,dp);";
    1217 //       }
    1218 //       else
    1219 //       {
    1220 //          @ri= "ring @Phelp ="
    1221 //                  +string(char(@P))+",("+varstr(@P)+",@t),(C,dp);";
    1222 //       }
    1223 //       execute(@ri);
    1224 //       list @lvec;
    1225 //       list @lr=imap(@P,lres0);
    1226 //       ideal @lr1;
    1227 //
    1228 //       if(size(@lr)==2)
    1229 //       {
    1230 //          @lr[2]=homog(@lr[2],@t);
    1231 //          @lr1=std(@lr[2]);
    1232 //          @lvec[2]=hilb(@lr1,1);
    1233 //       }
    1234 //       else
    1235 //       {
    1236 //          for(@n=1;@n<=size(@lr) div 2;@n++)
    1237 //          {
    1238 //             if(specialIdealsEqual(@lr[2*@n-1],@lr[2*@n])==1)
    1239 //             {
    1240 //                @lr[2*@n-1]=homog(@lr[2*@n-1],@t);
    1241 //                @lr1=std(@lr[2*@n-1]);
    1242 //                @lvec[2*@n-1]=hilb(@lr1,1);
    1243 //                @lvec[2*@n]=@lvec[2*@n-1];
    1244 //             }
    1245 //             else
    1246 //             {
    1247 //                @lr[2*@n-1]=homog(@lr[2*@n-1],@t);
    1248 //                @lr1=std(@lr[2*@n-1]);
    1249 //                @lvec[2*@n-1]=hilb(@lr1,1);
    1250 //                @lr[2*@n]=homog(@lr[2*@n],@t);
    1251 //                @lr1=std(@lr[2*@n]);
    1252 //                @lvec[2*@n]=hilb(@lr1,1);
    1253 //
    1254 //             }
    1255 //         }
    1256 //       }
    1257 //       @ri= "ring @Phelp1 ="
    1258 //                  +string(char(@P))+",("+varstr(@Phelp)+"),(C,lp);";
    1259 //       execute(@ri);
    1260 //       list @lr=imap(@Phelp,@lr);
    1261 //
    1262 //       kill @Phelp;
    1263 //       if(size(@lr)==2)
    1264 //      {
    1265 //          @lr[2]=std(@lr[2],@lvec[2]);
    1266 //          @lr[2]=subst(@lr[2],@t,1);
    1267 //       }
    1268 //       else
    1269 //       {
    1270 //          for(@n=1;@n<=size(@lr) div 2;@n++)
    1271 //          {
    1272 //             if(specialIdealsEqual(@lr[2*@n-1],@lr[2*@n])==1)
    1273 //             {
    1274 //                @lr[2*@n-1]=std(@lr[2*@n-1],@lvec[2*@n-1]);
    1275 //                @lr[2*@n-1]=subst(@lr[2*@n-1],@t,1);
    1276 //                @lr[2*@n]=@lr[2*@n-1];
    1277 //                attrib(@lr[2*@n],"isSB",1);
    1278 //             }
    1279 //             else
    1280 //             {
    1281 //                @lr[2*@n-1]=std(@lr[2*@n-1],@lvec[2*@n-1]);
    1282 //                @lr[2*@n-1]=subst(@lr[2*@n-1],@t,1);
    1283 //                @lr[2*@n]=std(@lr[2*@n],@lvec[2*@n]);
    1284 //                @lr[2*@n]=subst(@lr[2*@n],@t,1);
    1285 //             }
    1286 //          }
    1287 //       }
    1288 //       kill @lvec;
    1289 //       setring @P;
    1290 //       lres0=imap(@Phelp1,@lr);
    1291 //       kill @Phelp1;
    1292 //       for(@n=1;@n<=size(lres0);@n++)
    1293 //       {
    1294 //          lres0[@n]=clearSB(lres0[@n]);
    1295 //          attrib(lres0[@n],"isSB",1);
    1296 //       }
    1297 //
    1298 //       primary[2*@k-1]=lres0[1];
    1299 //       primary[2*@k]=lres0[2];
    1300 //       @s=size(primary) div 2;
    1301 //       for(@n=1;@n<=size(lres0) div 2-1;@n++)
    1302 //       {
    1303 //         primary[2*@s+2*@n-1]=lres0[2*@n+1];
    1304 //         primary[2*@s+2*@n]=lres0[2*@n+2];
    1305 //       }
    1306 //       @k--;
    1307 //=============================================================
    1308     }
     1180   }
    13091181  }
    13101182  return(primary);
    … …  
    20441916   option( redSB );
    20451917   list @pr=facstd(i);
    2046    //if(size(@pr)==1)
    2047 //   {
    2048 //      attrib(@pr[1],"isSB",1);
    2049 //      if((dim(@pr[1])==0)&&(homog(@pr[1])==1))
    2050 //      {
    2051 //         setring @P;
    2052 //         list @res=maxideal(1);
    2053 //         return(phi(@res));
    2054 //      }
    2055 //      if(dim(@pr[1])>1)
    2056 //      {
    2057 //         setring @P;
    2058 //        // kill gnir;
    2059 //         execute ("ring gnir1 = ("+charstr(basering)+"),
    2060 //                              ("+varstr(basering)+"),(C,lp);");
    2061 //         ideal i=fetch(@P,i);
    2062 //         list @pr=facstd(i);
    2063 //        // ideal ser;
    2064 //         setring gnir;
    2065 //         @pr=fetch(gnir1,@pr);
    2066 //         kill gnir1;
    2067 //      }
    2068 //   }
     1918
    20691919   // option( noredSB );
    20701920   option( set, op );
    … …  
    92859135      else                   { @qh=groebner(@qh); }
    92869136
    9287 //=============================================================
    9288 //       if(npars(@P)>0)
    9289 //       {
    9290 //          @ri= "ring @Phelp ="
    9291 //                  +string(char(@P))+",
    9292 //                   ("+varstr(@P)+","+parstr(@P)+",@t),(C,dp);";
    9293 //       }
    9294 //       else
    9295 //       {
    9296 //          @ri= "ring @Phelp ="
    9297 //                  +string(char(@P))+",("+varstr(@P)+",@t),(C,dp);";
    9298 //       }
    9299 //       execute(@ri);
    9300 //       ideal @qh=homog(imap(@P,@qht),@t);
    9301 //
    9302 //       ideal @qh1=std(@qh);
    9303 //       @hilb=hilb(@qh1,1);
    9304 //       @ri= "ring @Phelp1 ="
    9305 //                  +string(char(@P))+",("+varstr(@Phelp)+"),(C,lp);";
    9306 //       execute(@ri);
    9307 //       ideal @qh=homog(imap(@P,@qh),@t);
    9308 //       kill @Phelp;
    9309 //       @qh=std(@qh,@hilb);
    9310 //       @qh=subst(@qh,@t,1);
    9311 //       setring @P;
    9312 //       @qh=imap(@Phelp1,@qh);
    9313 //       kill @Phelp1;
    9314 //       @qh=clearSB(@qh);
    9315 //       attrib(@qh,"isSB",1);
    9316 //=============================================================
    9317 
    93189137      ser1=phi1(ser);
    93199138      @lh=newZero_decomp (@qh,phi(ser1),@wr, list("nest", nestLevel + 1));
    … …  
    93699188      primary=primary+lres0;
    93709189
    9371 //=============================================================
    9372 //       if(npars(@P)>0)
    9373 //       {
    9374 //          @ri= "ring @Phelp ="
    9375 //                  +string(char(@P))+",
    9376 //                   ("+varstr(@P)+","+parstr(@P)+",@t),(C,dp);";
    9377 //       }
    9378 //       else
    9379 //       {
    9380 //          @ri= "ring @Phelp ="
    9381 //                  +string(char(@P))+",("+varstr(@P)+",@t),(C,dp);";
    9382 //       }
    9383 //       execute(@ri);
    9384 //       list @lvec;
    9385 //       list @lr=imap(@P,lres0);
    9386 //       ideal @lr1;
    9387 //
    9388 //       if(size(@lr)==2)
    9389 //       {
    9390 //          @lr[2]=homog(@lr[2],@t);
    9391 //          @lr1=std(@lr[2]);
    9392 //          @lvec[2]=hilb(@lr1,1);
    9393 //       }
    9394 //       else
    9395 //       {
    9396 //          for(@n=1;@n<=size(@lr) div 2;@n++)
    9397 //          {
    9398 //             if(specialIdealsEqual(@lr[2*@n-1],@lr[2*@n])==1)
    9399 //             {
    9400 //                @lr[2*@n-1]=homog(@lr[2*@n-1],@t);
    9401 //                @lr1=std(@lr[2*@n-1]);
    9402 //                @lvec[2*@n-1]=hilb(@lr1,1);
    9403 //                @lvec[2*@n]=@lvec[2*@n-1];
    9404 //             }
    9405 //             else
    9406 //             {
    9407 //                @lr[2*@n-1]=homog(@lr[2*@n-1],@t);
    9408 //                @lr1=std(@lr[2*@n-1]);
    9409 //                @lvec[2*@n-1]=hilb(@lr1,1);
    9410 //                @lr[2*@n]=homog(@lr[2*@n],@t);
    9411 //                @lr1=std(@lr[2*@n]);
    9412 //                @lvec[2*@n]=hilb(@lr1,1);
    9413 //
    9414 //             }
    9415 //         }
    9416 //       }
    9417 //       @ri= "ring @Phelp1 ="
    9418 //                  +string(char(@P))+",("+varstr(@Phelp)+"),(C,lp);";
    9419 //       execute(@ri);
    9420 //       list @lr=imap(@Phelp,@lr);
    9421 //
    9422 //       kill @Phelp;
    9423 //       if(size(@lr)==2)
    9424 //      {
    9425 //          @lr[2]=std(@lr[2],@lvec[2]);
    9426 //          @lr[2]=subst(@lr[2],@t,1);
    9427 //
    9428 //       }
    9429 //       else
    9430 //       {
    9431 //          for(@n=1;@n<=size(@lr) div 2;@n++)
    9432 //          {
    9433 //             if(specialIdealsEqual(@lr[2*@n-1],@lr[2*@n])==1)
    9434 //             {
    9435 //                @lr[2*@n-1]=std(@lr[2*@n-1],@lvec[2*@n-1]);
    9436 //                @lr[2*@n-1]=subst(@lr[2*@n-1],@t,1);
    9437 //                @lr[2*@n]=@lr[2*@n-1];
    9438 //                attrib(@lr[2*@n],"isSB",1);
    9439 //             }
    9440 //             else
    9441 //             {
    9442 //                @lr[2*@n-1]=std(@lr[2*@n-1],@lvec[2*@n-1]);
    9443 //                @lr[2*@n-1]=subst(@lr[2*@n-1],@t,1);
    9444 //                @lr[2*@n]=std(@lr[2*@n],@lvec[2*@n]);
    9445 //                @lr[2*@n]=subst(@lr[2*@n],@t,1);
    9446 //             }
    9447 //          }
    9448 //       }
    9449 //       kill @lvec;
    9450 //       setring @P;
    9451 //       lres0=imap(@Phelp1,@lr);
    9452 //       kill @Phelp1;
    9453 //       for(@n=1;@n<=size(lres0);@n++)
    9454 //       {
    9455 //          lres0[@n]=clearSB(lres0[@n]);
    9456 //          attrib(lres0[@n],"isSB",1);
    9457 //       }
    9458 //
    9459 //       primary[2*@k-1]=lres0[1];
    9460 //       primary[2*@k]=lres0[2];
    9461 //       @s=size(primary) div 2;
    9462 //       for(@n=1;@n<=size(lres0) div 2-1;@n++)
    9463 //       {
    9464 //         primary[2*@s+2*@n-1]=lres0[2*@n+1];
    9465 //         primary[2*@s+2*@n]=lres0[2*@n+2];
    9466 //       }
    9467 //       @k--;
    9468 //=============================================================
    94699190    }
    94709191  }

  • Singular/LIB/sagbi.lib

    r7ea5de r56ff8ef  
    11121112    //------------- change the basering bsr to bsr[@(0),...,@(z)] ----------
    11131113    def s=addNvarsTo(basering,z+1,,"@",0); setring s;
    1114     // Ev hier die Reihenfolge der Vars aendern. Dazu muss unten aber entsprechend
    1115     // geaendert werden:
    1116     //  execute("ring s="+charstr(basering)+",(@(0..z),"+varstr(basering)+"),dp;");
    11171114
    11181115    //constructs the leading ideal of dom=(p-@(0),dom[1]-@(1),...,dom[z]-@(z))

  • Singular/LIB/tropicalNewton.lib

    r7ea5de r56ff8ef  
    11001100// disabled routines to check characteristic-freeness of tropical points
    11011101
    1102 // proc saturateWithRespectToVariable(ideal I, int k)
    1103 // {
    1104 //   ASSUME(1,k>=1);
    1105 //   ASSUME(1,k<=nvars(basering));
    1106 
    1107 //   def origin = basering;
    1108 //   int n = nvars(basering);
    1109 //   intvec weightVector = ringlist(origin)[3][1][2];
    1110 
    1111 //   string newVars;
    1112 //   for (int i=1; i<k; i++)
    1113 //   {
    1114 //     newVars = newVars+string(var(i))+",";
    1115 //   }
    1116 //   for (i=k+1; i<=n; i++)
    1117 //   {
    1118 //     newVars = newVars+string(var(i))+",";
    1119 //   }
    1120 //   newVars = newVars+string(var(k));
    1121 //   execute("ring ringForSaturation = ("+charstr(origin)+"),("+newVars+"),dp;");
    1122 
    1123 //   ideal I = satstd(imap(origin,I));
    1124 //   if (I==-1)
    1125 //   {
    1126 //     return (-1);
    1127 //   }
    1128 //   I = simplify(I,2+4+32);
    1129 
    1130 //   setring origin;
    1131 //   I = imap(ringForSaturation,I);
    1132 //   return (I);
    1133 // }
     1102
    11341103
    11351104// proc stepwiseSaturation(ideal I)
    … …  
    11581127
    11591128
    1160 // proc checkForContainmentInTropicalVariety(ideal I, intvec w, int charInt)
    1161 // {
    1162 //   def origin = basering;
    1163 //   intvec wOne = oneVector(nvars(origin));
    1164 //   execute("ring rInitialIdeal = ("+string(charInt)+"),("+varstr(origin)+"),(a(wOne),wp(w));");
    1165 
    1166 //   ideal I = imap(origin,I);
    1167 //   int tinI = timer;
    1168 //   option(redSB);
    1169 //   ideal stdI = satstd(I);
    1170 //   attrib(stdI,"isSB",1);
    1171 //   ideal inI = initial(stdI,w);
    1172 //   tinI = timer-tinI;
    1173 //   dbprint("time used computing initial ideal: "+string(tinI));
    1174 
    1175 //   int tsat = timer;
    1176 //   ideal satinI = stepwiseSaturation(inI);
    1177 //   tsat = timer-tsat;
    1178 //   dbprint("time used computing saturation: "+string(tsat));
    1179 
    1180 
    1181 //   export(I);
    1182 //   export(stdI);
    1183 //   export(inI);
    1184 //   export(satinI);
    1185 //   return (rInitialIdeal);
    1186 // }

  • Singular/dyn_modules/freealgebra/freealgebra.cc

    rd0ca0b r56ff8ef  
    11#include "Singular/libsingular.h"
     2#include <vector>
    23
    34#ifdef HAVE_SHIFTBBA
    … …  
    8081}
    8182
     83static BOOLEAN p_LPDivisibleBy(ideal I, poly p, ring r)
     84{
     85  for(int i = 0; i < IDELEMS(I); i++)
     86  {
     87    if (p_LPDivisibleBy(I->m[i], p, r))
     88    {
     89      return TRUE;
     90    }
     91  }
     92  return FALSE;
     93}
     94
    8295static BOOLEAN lpLmDivides(leftv res, leftv h)
    8396{
    … …  
    97110    poly q=(poly)h->next->Data();
    98111    res->rtyp = INT_CMD;
    99     for(int i=0;i<IDELEMS(I);i++)
    100     {
    101       if (p_LPDivisibleBy(I->m[i],q, currRing))
    102       {
    103         res->data=(void*)(long)1;
    104         return FALSE;
    105       }
    106     }
    107     res->data=(void*)(long)0;
     112    res->data=(void*)(long) p_LPDivisibleBy(I, q, currRing);
    108113    return FALSE;
    109114  }
    … …  
    124129  else return TRUE;
    125130}
     131
     132static void _computeStandardWords(ideal words, int n, ideal M, int& last)
     133{
     134  if (n <= 0){
     135    words->m[0] = pOne();
     136    last = 0;
     137    return;
     138  }
     139
     140  _computeStandardWords(words, n - 1, M, last);
     141
     142  int nVars = currRing->isLPring;
     143
     144  for (int j = nVars - 1; j >= 0; j--)
     145  {
     146    for (int i = last; i >= 0; i--)
     147    {
     148      int index = (j * (last + 1)) + i;
     149
     150      if (words->m[i] != NULL)
     151      {
     152        if (j > 0) {
     153          words->m[index] = pCopy(words->m[i]);
     154        }
     155
     156        int varOffset = ((n - 1) * nVars) + 1;
     157        pSetExp(words->m[index], varOffset + j, 1);
     158        pSetm(words->m[index]);
     159        pTest(words->m[index]);
     160
     161        if (p_LPDivisibleBy(M, words->m[index], currRing))
     162        {
     163          pDelete(&words->m[index]);
     164          words->m[index] = NULL;
     165        }
     166      }
     167    }
     168  }
     169
     170  last = nVars * last + nVars - 1;
     171}
     172
     173static ideal computeStandardWords(int n, ideal M)
     174{
     175  int nVars = currRing->isLPring;
     176
     177  int maxElems = 1;
     178  for (int i = 0; i < n; i++) // maxElems = nVars^n
     179    maxElems *= nVars;
     180  ideal words = idInit(maxElems);
     181  int last;
     182  _computeStandardWords(words, n, M, last);
     183  idSkipZeroes(words);
     184  return words;
     185}
     186
     187// NULL if graph is undefined
     188static intvec* ufnarovskiGraph(ideal G)
     189{
     190  long l = 0;
     191  for (int i = 0; i < IDELEMS(G); i++)
     192    l = si_max(pTotaldegree(G->m[i]), l);
     193  l--;
     194  if (l <= 0)
     195  {
     196    WerrorS("Ufnarovski graph not implemented for l <= 0");
     197    return NULL;
     198  }
     199  int lV = currRing->isLPring;
     200
     201  ideal standardWords = computeStandardWords(l, G);
     202
     203  int n = IDELEMS(standardWords);
     204  intvec* UG = new intvec(n, n, 0);
     205  for (int i = 0; i < n; i++)
     206  {
     207    for (int j = 0; j < n; j++)
     208    {
     209      poly v = standardWords->m[i];
     210      poly w = standardWords->m[j];
     211
     212      // check whether v*x1 = x2*w (overlap)
     213      bool overlap = true;
     214      for (int k = 1; k <= (l - 1) * lV; k++)
     215      {
     216        if (pGetExp(v, k + lV) != pGetExp(w, k)) {
     217          overlap = false;
     218          break;
     219        }
     220      }
     221
     222      if (overlap)
     223      {
     224        // create the overlap
     225        poly p = pMult(pCopy(v), p_LPVarAt(w, l, currRing));
     226
     227        // check whether the overlap is normal
     228        bool normal = true;
     229        for (int k = 0; k < IDELEMS(G); k++)
     230        {
     231          if (p_LPDivisibleBy(G->m[k], p, currRing))
     232          {
     233            normal = false;
     234            break;
     235          }
     236        }
     237
     238        if (normal)
     239        {
     240          IMATELEM(*UG, i + 1, j + 1) = 1;
     241        }
     242      }
     243    }
     244  }
     245  return UG;
     246}
     247
     248static std::vector<int> countCycles(const intvec* _G, int v, std::vector<int> path, std::vector<BOOLEAN> visited, std::vector<BOOLEAN> cyclic, std::vector<int> cache)
     249{
     250  intvec* G = ivCopy(_G); // modifications must be local
     251
     252  if (cache[v] != -2) return cache; // value is already cached
     253
     254  visited[v] = TRUE;
     255  path.push_back(v);
     256
     257  int cycles = 0;
     258  for (int w = 0; w < G->cols(); w++)
     259  {
     260    if (IMATELEM(*G, v + 1, w + 1)) // edge v -> w exists in G
     261    {
     262      if (!visited[w])
     263      { // continue with w
     264        cache = countCycles(G, w, path, visited, cyclic, cache);
     265        if (cache[w] == -1)
     266        {
     267          cache[v] = -1;
     268          return cache;
     269        }
     270        cycles = si_max(cycles, cache[w]);
     271      }
     272      else
     273      { // found new cycle
     274        int pathIndexOfW = -1;
     275        for (int i = path.size() - 1; i >= 0; i--) {
     276          if (cyclic[path[i]] == 1) { // found an already cyclic vertex
     277            cache[v] = -1;
     278            return cache;
     279          }
     280          cyclic[path[i]] = TRUE;
     281
     282          if (path[i] == w) { // end of the cycle
     283            assume(IMATELEM(*G, v + 1, w + 1) != 0);
     284            IMATELEM(*G, v + 1, w + 1) = 0; // remove edge v -> w
     285            pathIndexOfW = i;
     286            break;
     287          } else {
     288            assume(IMATELEM(*G, path[i - 1] + 1, path[i] + 1) != 0);
     289            IMATELEM(*G, path[i - 1] + 1, path[i] + 1) = 0; // remove edge vi-1 -> vi
     290          }
     291        }
     292        assume(pathIndexOfW != -1); // should never happen
     293        for (int i = path.size() - 1; i >= pathIndexOfW; i--) {
     294          cache = countCycles(G, path[i], path, visited, cyclic, cache);
     295          if (cache[path[i]] == -1)
     296          {
     297            cache[v] = -1;
     298            return cache;
     299          }
     300          cycles = si_max(cycles, cache[path[i]] + 1);
     301        }
     302      }
     303    }
     304  }
     305  cache[v] = cycles;
     306
     307  delete G;
     308  return cache;
     309}
     310
     311// -1 is infinity
     312static int graphGrowth(const intvec* G)
     313{
     314  // init
     315  int n = G->cols();
     316  std::vector<int> path;
     317  std::vector<BOOLEAN> visited;
     318  std::vector<BOOLEAN> cyclic;
     319  std::vector<int> cache;
     320  visited.resize(n, FALSE);
     321  cyclic.resize(n, FALSE);
     322  cache.resize(n, -2);
     323
     324  // get max number of cycles
     325  int cycles = 0;
     326  for (int v = 0; v < n; v++)
     327  {
     328    cache = countCycles(G, v, path, visited, cyclic, cache);
     329    if (cache[v] == -1)
     330      return -1;
     331    cycles = si_max(cycles, cache[v]);
     332  }
     333  return cycles;
     334}
     335
     336// -1 is infinity, -2 is error
     337static int gkDim(const ideal _G)
     338{
     339  if (rField_is_Ring(currRing)) {
     340      WerrorS("GK-Dim not implemented for rings");
     341      return -2;
     342  }
     343
     344  for (int i=IDELEMS(_G)-1;i>=0; i--)
     345  {
     346    if (pGetComp(_G->m[i]) != 0)
     347    {
     348      WerrorS("GK-Dim not implemented for modules");
     349      return -2;
     350    }
     351  }
     352
     353  ideal G = id_Head(_G, currRing); // G = LM(G) (and copy)
     354  idSkipZeroes(G); // remove zeros
     355  id_DelLmEquals(G, currRing); // remove duplicates
     356
     357  // get the max deg
     358  long maxDeg = 0;
     359  for (int i = 0; i < IDELEMS(G); i++)
     360  {
     361    maxDeg = si_max(maxDeg, pTotaldegree(G->m[i]));
     362
     363    // also check whether G = <1>
     364    if (pIsConstantComp(G->m[i]))
     365    {
     366      WerrorS("GK-Dim not defined for 0-ring");
     367      return -2;
     368    }
     369  }
     370
     371  // early termination if G \subset X
     372  if (maxDeg <= 1)
     373  {
     374    int lV = currRing->isLPring;
     375    if (IDELEMS(G) == lV) // V = {1} no edges
     376      return 0;
     377    if (IDELEMS(G) == lV - 1) // V = {1} with loop
     378      return 1;
     379    if (IDELEMS(G) <= lV - 2) // V = {1} with more than one loop
     380      return -1;
     381  }
     382
     383  intvec* UG = ufnarovskiGraph(G);
     384  if (errorreported || UG == NULL) return -2;
     385  return graphGrowth(UG);
     386}
     387
     388
     389static BOOLEAN lpGkDim(leftv res, leftv h)
     390{
     391  const short t[]={1,IDEAL_CMD};
     392  if (iiCheckTypes(h,t,1))
     393  {
     394    assumeStdFlag(h);
     395    ideal G = (ideal) h->Data();
     396    res->rtyp = INT_CMD;
     397    res->data = (void*)(long) gkDim(G);
     398    if (errorreported) return TRUE;
     399    return FALSE;
     400  }
     401  else return TRUE;
     402}
    126403#endif
    127404
    … …  
    134411  p->iiAddCproc("freealgebra.so","lpLmDivides",FALSE,lpLmDivides);
    135412  p->iiAddCproc("freealgebra.so","lpVarAt",FALSE,lpVarAt);
     413  p->iiAddCproc("freealgebra.so","lpGkDim",FALSE,lpGkDim);
     414
    136415  p->iiAddCproc("freealgebra.so","stest",TRUE,stest);
    137416  p->iiAddCproc("freealgebra.so","btest",TRUE,btest);

  • Singular/dyn_modules/systhreads/thread.h

    r7ea5de r56ff8ef  
    55#include <pthread.h>
    66#include <stdint.h>
    7 #include <alloca.h>
     7#include <stdlib.h>
    88#include <cstddef>
    99#include <exception>

  • Singular/iplib.cc

    r7ea5de r56ff8ef  
    644644  return NULL;
    645645}
    646 /// args: NULL terminated arry of arguments
     646
     647// return NULL on failure
     648ideal ii_CallProcId2Id(const char *lib,const char *proc, ideal arg, const ring R)
     649{
     650  char *plib = iiConvName(lib);
     651  idhdl h=ggetid(plib);
     652  omFree(plib);
     653  if (h==NULL)
     654  {
     655    BOOLEAN bo=iiLibCmd(omStrDup(lib),TRUE,TRUE,FALSE);
     656    if (bo) return NULL;
     657  }
     658  ring oldR=currRing;
     659  rChangeCurrRing(R);
     660  BOOLEAN err;
     661  ideal I=(ideal)iiCallLibProc1(proc,idCopy(arg),IDEAL_CMD,err);
     662  rChangeCurrRing(oldR);
     663  if (err) return NULL;
     664  return I;
     665}
     666
     667int ii_CallProcId2Int(const char *lib,const char *proc, ideal arg, const ring R)
     668{
     669  char *plib = iiConvName(lib);
     670  idhdl h=ggetid(plib);
     671  omFree(plib);
     672  if (h==NULL)
     673  {
     674    BOOLEAN bo=iiLibCmd(omStrDup(lib),TRUE,TRUE,FALSE);
     675    if (bo) return 0;
     676  }
     677  BOOLEAN err;
     678  ring oldR=currRing;
     679  rChangeCurrRing(R);
     680  int I=(int)(long)iiCallLibProc1(proc,idCopy(arg),IDEAL_CMD,err);
     681  rChangeCurrRing(oldR);
     682  if (err) return 0;
     683  return I;
     684}
     685
     686/// args: NULL terminated array of arguments
    647687/// arg_types: 0 terminated array of corresponding types
    648688void* iiCallLibProcM(const char*n, void **args, int* arg_types, BOOLEAN &err)

  • Singular/ipshell.h

    r7ea5de r56ff8ef  
    195195  BOOLEAN isring = FALSE, BOOLEAN init_b=TRUE);
    196196BOOLEAN iiMake_proc(idhdl pn, package pack, leftv sl);
    197 void* iiCallLibProc1(const char*n, void *arg, int arg_type, BOOLEAN &err);
    198 void* iiCallLibProcM(const char*n, void **args, int *arg_types, BOOLEAN &err);
     197void* iiCallLibProc1(const char* n, void *arg, int arg_type, BOOLEAN &err);
     198void* iiCallLibProcM(const char* n, void **args, int *arg_types, BOOLEAN &err);
     199ideal ii_CallProcId2Id(const char* lib,const char* proc, ideal arg,const ring R);
     200int ii_CallProcId2Int(const char* lib,const char* proc, ideal arg,const ring R);
    199201// from misc.cc:
    200202char *  showOption();

  • Tst/Letterplace.lst

    rd0ca0b r56ff8ef  
    99Manual/makeLetterplaceRing.tst
    1010Manual/serreRelations.tst
     11Manual/lpGkDim.tst
    1112Manual/lpKDim.tst
    1213Manual/lpMonomialPrinting.tst
    … …  
    1819Manual/lpSickleDim.tst
    1920Manual/lpHilbert.tst
     21Manual/lpLmDivisible.tst

  • Tst/Manual/letterplace_std.res.gz.uu

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

  • Tst/Manual/letterplace_std.stat

    rd0ca0b r56ff8ef  
    1 1 >> tst_memory_0 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:331856
    2 1 >> tst_memory_1 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:2150160
    3 1 >> tst_memory_2 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:2191264
    4 1 >> tst_timer_1 :: 1548675018:4114, 64 bit:4.1.1:x86_64-Linux:nepomuck:6
     11 >> tst_memory_0 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:20013576
     21 >> tst_memory_1 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:21011760
     31 >> tst_memory_2 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:21068800
     41 >> tst_timer_1 :: 1556191877:4120, 64 bit:4.1.2:x86_64-Darwin:Karims-MBP.localdomain:22

  • Tst/Manual/letterplace_std.tst

    rd0ca0b r56ff8ef  
    11LIB "tst.lib"; tst_init();
    22LIB "freegb.lib";
     3
     4// 1
    35ring r = 0,(x,y,z),Dp;
    46int degree_bound = 5;
    … …  
    68setring R;
    79ideal I = -x*y-7*y*y+3*x*x, x*y*x-y*x*y;
    8 ideal J = std(I);
    9 J;
     10std(I);
     11
     12kill r;
     13kill R;
     14
     15// 2 (c_4_1_7_W)
     16ring r = 0,(x4,x3,x2,x1),Dp;
     17def R = freeAlgebra(r, 7);
     18setring(R);
     19ideal I = x4*x4-25*x4*x2-x1*x4-6*x1*x3-9*x1*x2+x1*x1,
     20x4*x3+13*x4*x2+12*x4*x1-9*x3*x4+4*x3*x2+41*x3*x1-7*x1*x4-x1*x2,
     21x3*x3-9*x3*x2+2*x1*x4+x1*x1,
     2217*x4*x2-5*x2*x2-41*x1*x4,
     23x2*x2-13*x2*x1-4*x1*x3+2*x1*x2-x1*x1,
     24x2*x1+4*x1*x2-3*x1*x1;
     25std(I);
     26
    1027tst_status(1);$

  • libpolys/polys/shiftop.cc

    rd0ca0b r56ff8ef  
    1313 * -> wait until the new interface is released
    1414*/
    15 #define SHIFT_MULT_COMPAT_MODE
     15/* #define SHIFT_MULT_COMPAT_MODE */
    1616
    1717#ifdef SHIFT_MULT_DEBUG
    … …  
    718718BOOLEAN _p_LPLmDivisibleByNoComp(poly a, poly b, const ring r)
    719719{
    720   if(p_LmIsConstantComp(a, r))
    721     return TRUE;
    722720#ifdef SHIFT_MULT_COMPAT_MODE
    723721  a = p_Head(a, r);
    … …  
    726724  p_mLPunshift(b, r);
    727725#endif
    728   int i = (r->N / r->isLPring) - p_LastVblock(a, r);
    729   do {
    730     int j = r->N - (i * r->isLPring);
     726  for (int i = (r->N / r->isLPring) - p_LastVblock(a, r); i >= 0; i--)
     727  {
    731728    bool divisible = true;
    732     do
     729    for (int j = r->N - (i * r->isLPring); j >= 0; j--)
    733730    {
    734731      if (p_GetExp(a, j, r) > p_GetExp(b, j + (i * r->isLPring), r))
    … …  
    737734        break;
    738735      }
    739       j--;
    740     }
    741     while (j);
     736    }
    742737    if (divisible) return TRUE;
    743     i--;
    744   }
    745   while (i > -1);
     738  }
    746739#ifdef SHIFT_MULT_COMPAT_MODE
    747740  p_Delete(&a, r);

  • ppcc/autosetup/cc-lib.tcl

    r7ea5de r56ff8ef  
    167167proc cc-check-alloca {} {
    168168        cc-check-some-feature alloca {
    169                 cctest -includes alloca.h -code { alloca (2 * sizeof (int)); }
     169                cctest -includes stdlib.h -code { alloca (2 * sizeof (int)); }
    170170        }
    171171}
Note: See TracChangeset for help on using the changeset viewer.