Changeset 97ec595 in git


Ignore:
Timestamp:
Jun 24, 2006, 9:55:31 PM (18 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', 'b52fc4b2495505785981d640dcf7eb3e456778ef')
Children:
52244141c88c9c3ec6aeafa249576679de032bce
Parents:
701f8c03960f57ad23cda43d78e36b7a31e07f7f
Message:
*levandov: annfsgms commented out and some minor cosmetics


git-svn-id: file:///usr/local/Singular/svn/trunk@9263 2c84dea3-7e68-4137-9b89-c4e89433aadc
File:
1 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/dmod.lib

    r701f8c0 r97ec595  
    11///////////////////////////////////////////////////////////////////////////////
    2 version="$Id: dmod.lib,v 1.6 2006-06-23 12:24:36 Singular Exp $";
     2version="$Id: dmod.lib,v 1.7 2006-06-24 19:55:31 levandov Exp $";
    33category="Noncommutative";
    44info="
     
    77@*       Jorge Martin Morales,    jorge@unizar.es
    88
    9 THEORY: Given a polynomial ring R = K[x_1,...,x_n] and a polynomial F in R, one is interested in the ring R[1/F^s] for a natural number s.
    10 @* In fact, the ring R[1/F^s] has a structure of a D(R)-module,
    11 where D(R) is a Weyl algebra K<x_1,...,x_n,d_1,...,d_n | d_j x_j = x_j d_j +1>.
    12 @* Constructively, one needs to find a left ideal I = I(F^s) in D(R),
    13 such that K[x_1,...,x_n,1/F^s] is isomorphic to D(R)/I as a D(R)-module.
     9THEORY: Given a polynomial ring R = K[x_1,...,x_n] and a polynomial F in R,
     10        one is interested in the ring R[1/F^s] for a natural number s.
     11@* In fact, the ring R[1/F^s] has a structure of a D(R)-module, where D(R)
     12@* is a Weyl algebra K<x_1,...,x_n,d_1,...,d_n | d_j x_j = x_j d_j +1>.
     13@* Constructively, one needs to find a left ideal I = I(F^s) in D(R), such
     14@* that K[x_1,...,x_n,1/F^s] is isomorphic to D(R)/I as a D(R)-module.
    1415@* We provide two implementations:
    15 @* 1) the classical Ann F^s algorithm from Oaku and Takayama
    16 (J. Pure Applied Math., 1999) and
    17 @* 2) the newer Ann F^s algorithm by Briancon and Maisonobe
    18 (Remarques sur l ideal de Bernstein associe a des polynomes, preprint, 2002).
     16@* 1) the classical Ann F^s algorithm from Oaku and Takayama (J. Pure
     17        Applied Math., 1999) and
     18@* 2) the newer Ann F^s algorithm by Briancon and Maisonobe (Remarques sur
     19        l'ideal de Bernstein associe a des polynomes, preprint, 2002).
    1920
    2021PROCEDURES:
     
    2223annfsBM(F[,eng]); compute Ann F^s for a poly F (algorithm of Briancon-Maisonobe)
    2324minIntRoot(P,fact); minimal integer root of a maximal ideal P
    24 reiffen(p,q);     create a polynomial, describing a Reiffen curve
     25reiffen(p,q);     create a poly, describing a Reiffen curve
    2526arrange(p);       create a poly, describing a generic hyperplane arrangement
    2627isHolonomic(M);   check whether a module is holonomic
    2728convloc(L);       replace global orderings with local in the ringlist L
    28 
    29 EXPERIMENTAL PROCEDURE:
    30 annfsgms(F[,eng]); compute Ann F^s for a poly F (modified Oaku-Takayama)
    31 
    32 // very experimental:
    33 // a new algorithm (by JMM), based on the computation of a Bernstein polynomial
    34 // first (with the help of algorithms by Mathias Schulze, see gmssing.lib) and
    35 // consequent eliminations like in Oaku and Takayama.
    3629";
    3730
     
    695688
    696689
    697 proc annfsgms(poly F, list #)
    698 "USAGE:  annfsgms(f [,eng]);  f a poly, eng an optional int
    699 ASSUME:  f has an isolated critical point at 0
    700 RETURN:  ring
    701 PURPOSE: compute the D-module structure of basering[f^s]
    702 NOTE:    activate this ring with the @code{setring} command. In this ring,
    703 @*       - the ideal LD is the needed D-mod structure,
    704 @*       - the ideal BS is the list of roots of a Bernstein polynomial of f.
    705 @*       If eng <>0, @code{std} is used for Groebner basis computations,
    706 @*       otherwise (and by default) @code{slimgb} is used.
    707 @*       If printlevel=1, progress debug messages will be printed,
    708 @*       if printlevel>=2, all the debug messages will be printed.
    709 EXAMPLE: example annfsgms; shows examples
    710 "
    711 {
    712   LIB "gmssing.lib";
    713   int eng = 0;
    714   if ( size(#)>0 )
    715   {
    716     if ( typeof(#[1]) == "int" )
    717     {
    718       eng = int(#[1]);
    719     }
    720   }
    721   int ppl = printlevel-voice+2;
    722   // returns a ring with the ideal LD in it
    723   def save = basering;
    724   // compute the Bernstein poly from gmssing.lib
    725   list RL = ringlist(basering);
    726   // in the descr. of the ordering, replace "p" by "s"
    727   list NL = convloc(RL);
    728   // create a ring with the ordering, converted to local
    729   def @LR = ring(NL);
    730   setring @LR;
    731   poly F  = imap(save, F);
    732   ideal B = bernstein(F)[1];
    733   // since B may not contain (s+1) [following gmssing.lib]
    734   // add it!
    735   B = B,-1;
    736   B = simplify(B,2+4); // erase zero and repeated entries
    737   // find the minimal integer value
    738   int   S = minIntRoot(B,0);
    739   dbprint(ppl,"// -0- minimal integer root found");
    740   dbprint(ppl-1,S);
    741   setring save;
    742   int N = nvars(basering);
    743   int Nnew = 2*(N+2);
    744   int i,j;
    745   string s;
    746   //  list RL = ringlist(basering);
    747   list L, Lord;
    748   list tmp;
    749   intvec iv;
    750   L[1] = RL[1]; // char
    751   L[4] = RL[4]; // char, minpoly
    752   // check whether vars have admissible names
    753   list Name  = RL[2];
    754   list RName;
    755   RName[1] = "u";
    756   RName[2] = "v";
    757   RName[3] = "t";
    758   RName[4] = "Dt";
    759   for(i=1;i<=N;i++)
    760   {
    761     for(j=1; j<=size(RName);j++)
    762     {
    763       if (Name[i] == RName[j])
    764       {
    765         ERROR("Variable names should not include u,v,t,Dt");
    766       }
    767     }
    768   }
    769   // now, create the names for new vars
    770   //  tmp[1]     = "u";  tmp[2]     = "v";  tmp[3]     = "t";  tmp[4]     = "Dt";
    771   list UName = RName;
    772   list DName;
    773   for(i=1;i<=N;i++)
    774   {
    775     DName[i] = "D"+Name[i]; // concat
    776   }
    777   list NName = UName + Name + DName;
    778   L[2]       = NName;
    779   tmp        = 0;
    780   // Name, Dname will be used further
    781   kill UName;
    782   kill NName;
    783   // block ord (a(1,1),dp);
    784   tmp[1]  = "a"; // string
    785   iv      = 1,1;
    786   tmp[2]  = iv; //intvec
    787   Lord[1] = tmp;
    788   // continue with dp 1,1,1,1...
    789   tmp[1]  = "dp"; // string
    790   s       = "iv=";
    791   for(i=1; i<=Nnew; i++) // need really all vars!
    792   {
    793     s = s+"1,";
    794   }
    795   s[size(s)]= ";";
    796   execute(s);
    797   tmp[2]    = iv;
    798   Lord[2]   = tmp;
    799   tmp[1]    = "C";
    800   iv        = 0;
    801   tmp[2]    = iv;
    802   Lord[3]   = tmp;
    803   tmp       = 0;
    804   L[3]      = Lord;
    805   // we are done with the list
    806   def @R = ring(L);
    807   setring @R;
    808   matrix @D[Nnew][Nnew];
    809   @D[3,4] = 1; // t,Dt
    810   for(i=1; i<=N; i++)
    811   {
    812     @D[4+i,4+N+i]=1;
    813   }
    814   //  L[5] = matrix(UpOneMatrix(Nnew));
    815   //  L[6] = @D;
    816   ncalgebra(1,@D);
    817   dbprint(ppl,"// -1-1- the ring @R is ready");
    818   dbprint(ppl-1,@R);
    819   // create the ideal
    820   poly F  = imap(save,F);
    821   ideal I = u*F-t,u*v-1;
    822   poly p;
    823   for(i=1; i<=N; i++)
    824   {
    825     p = u*Dt; // u*Dt
    826     p = diff(F,var(4+i))*p;
    827     I = I, var(N+4+i) + p; // Dx, Dy
    828   }
    829   // add the relations between t,Dt and s
    830   //  I = I, t*Dt+1+S;
    831   // -------- the ideal I is ready ----------
    832   dbprint(ppl,"// -1-2- starting the elimination of u,v in @R");
    833   ideal J = engine(I,eng);
    834   ideal K = nselect(J,1,2);
    835   dbprint(ppl,"// -1-3- u,v are eliminated in @R");
    836   dbprint(ppl-1,K); // without u,v: not yet our answer
    837   //----- create a ring with elim.ord for t,Dt -------
    838   setring save;
    839   // ------------ new ring @R2 ------------------
    840   // without u,v and with the elim.ord for t,Dt
    841   // keep: N, i,j,s, tmp, RL
    842   Nnew = 2*N+2;
    843   //  list RL = ringlist(save); // is defined earlier
    844   kill Lord,tmp,iv, RName;
    845   L = 0;
    846   list Lord, tmp;
    847   intvec iv;
    848   L[1] = RL[1]; // char
    849   L[4] = RL[4]; // char, minpoly
    850   // check whether vars have admissible names -> done earlier
    851   //  list Name  = RL[2];
    852   list RName;
    853   RName[1] = "t";
    854   RName[2] = "Dt";
    855   // DName is defined earlier
    856   list NName = RName + Name + DName;
    857   L[2]   = NName;
    858   tmp    = 0;
    859   // block ord (a(1,1),dp);
    860   tmp[1]  = "a"; // string
    861   iv      = 1,1;
    862   tmp[2]  = iv; //intvec
    863   Lord[1] = tmp;
    864   // continue with dp 1,1,1,1...
    865   tmp[1]  = "dp"; // string
    866   s       = "iv=";
    867   for(i=1;i<=Nnew;i++)
    868   {
    869     s = s+"1,";
    870   }
    871   s[size(s)]= ";";
    872   execute(s);
    873   kill s;
    874   kill NName;
    875   tmp[2]    = iv;
    876   Lord[2]   = tmp;
    877   tmp[1]    = "C";
    878   iv        = 0;
    879   tmp[2]    = iv;
    880   Lord[3]   = tmp;
    881   tmp       = 0;
    882   L[3]      = Lord;
    883   // we are done with the list
    884   // Add: Plural part
    885   def @R2 = ring(L);
    886   setring @R2;
    887   matrix @D[Nnew][Nnew];
    888   @D[1,2]=1;
    889   for(i=1; i<=N; i++)
    890   {
    891     @D[2+i,2+N+i]=1;
    892   }
    893   ncalgebra(1,@D);
    894   dbprint(ppl,"// -2-1- the ring @R2 is ready");
    895   dbprint(ppl-1,@R2);
    896   ideal MM = maxideal(1);
    897   MM = 0,0,MM;
    898   map R01 = @R, MM;
    899   ideal K2 = R01(K);
    900   // add the relations between t,Dt and s
    901   //  K2       = K2, t*Dt+1+S;
    902   poly G = t*Dt+S+1;
    903   K2 = NF(K2,std(G)),G;
    904   dbprint(ppl,"// -2-2- starting elimination for t,Dt in @R2");
    905   ideal J  = engine(K2,eng);
    906   ideal K  = nselect(J,1,2);
    907   dbprint(ppl,"// -2-3- t,Dt are eliminated");
    908   dbprint(ppl-1,K);
    909   //  "------- produce a final result --------";
    910   // ----- create the ordinary Weyl algebra and put
    911   // ----- the result into it
    912   // ------ create the ring @R5
    913   // keep: N, i,j,s, tmp, RL
    914   setring save;
    915   Nnew = 2*N;
    916   //  list RL = ringlist(save); // is defined earlier
    917   kill Lord, tmp, iv;
    918   //  kill L;
    919   L = 0;
    920   list Lord, tmp;
    921   intvec iv;
    922   L[1] = RL[1]; // char
    923   L[4] = RL[4]; // char, minpoly
    924   // check whether vars have admissible names -> done earlier
    925   //  list Name  = RL[2];
    926   // DName is defined earlier
    927   list NName = Name + DName;
    928   L[2]   = NName;
    929   // dp ordering;
    930   string   s       = "iv=";
    931   for(i=1;i<=2*N;i++)
    932   {
    933     s = s+"1,";
    934   }
    935   s[size(s)]= ";";
    936   execute(s);
    937   tmp     = 0;
    938   tmp[1]  = "dp"; // string
    939   tmp[2]  = iv; //intvec
    940   Lord[1] = tmp;
    941   kill s;
    942   tmp[1]    = "C";
    943   iv        = 0;
    944   tmp[2]    = iv;
    945   Lord[2]   = tmp;
    946   tmp       = 0;
    947   L[3]      = Lord;
    948   // we are done with the list
    949   // Add: Plural part
    950   def @R5 = ring(L);
    951   setring @R5;
    952   matrix @D[Nnew][Nnew];
    953   for(i=1; i<=N; i++)
    954   {
    955     @D[i,N+i]=1;
    956   }
    957   ncalgebra(1,@D);
    958   dbprint(ppl,"// -3-1- the ring @R5 is ready");
    959   dbprint(ppl-1,@R5);
    960   ideal K5 = imap(@R2,K);
    961   option(redSB);
    962   dbprint(ppl,"// -3-2- the final cosmetic std");
    963   K5 = engine(K5,eng); // std does the job too
    964   // total cleanup
    965   kill @R;
    966   kill @R2;
    967   ideal LD = K5;
    968   ideal BS = imap(@LR,B);
    969   kill @LR;
    970   export BS;
    971   export LD;
    972   return(@R5);
    973 }
    974 example
    975 {
    976   "EXAMPLE:"; echo = 2;
    977   ring r = 0,(x,y,z),Dp;
    978   poly F = x^2+y^3+z^5;
    979   def A = annfsgms(F);
    980   setring A;
    981   LD;
    982   print(matrix(BS));
    983 }
     690// proc annfsgms(poly F, list #)
     691// "USAGE:  annfsgms(f [,eng]);  f a poly, eng an optional int
     692// ASSUME:  f has an isolated critical point at 0
     693// RETURN:  ring
     694// PURPOSE: compute the D-module structure of basering[f^s]
     695// NOTE:    activate this ring with the @code{setring} command. In this ring,
     696// @*       - the ideal LD is the needed D-mod structure,
     697// @*       - the ideal BS is the list of roots of a Bernstein polynomial of f.
     698// @*       If eng <>0, @code{std} is used for Groebner basis computations,
     699// @*       otherwise (and by default) @code{slimgb} is used.
     700// @*       If printlevel=1, progress debug messages will be printed,
     701// @*       if printlevel>=2, all the debug messages will be printed.
     702// EXAMPLE: example annfsgms; shows examples
     703// "
     704// {
     705//   LIB "gmssing.lib";
     706//   int eng = 0;
     707//   if ( size(#)>0 )
     708//   {
     709//     if ( typeof(#[1]) == "int" )
     710//     {
     711//       eng = int(#[1]);
     712//     }
     713//   }
     714//   int ppl = printlevel-voice+2;
     715//   // returns a ring with the ideal LD in it
     716//   def save = basering;
     717//   // compute the Bernstein poly from gmssing.lib
     718//   list RL = ringlist(basering);
     719//   // in the descr. of the ordering, replace "p" by "s"
     720//   list NL = convloc(RL);
     721//   // create a ring with the ordering, converted to local
     722//   def @LR = ring(NL);
     723//   setring @LR;
     724//   poly F  = imap(save, F);
     725//   ideal B = bernstein(F)[1];
     726//   // since B may not contain (s+1) [following gmssing.lib]
     727//   // add it!
     728//   B = B,-1;
     729//   B = simplify(B,2+4); // erase zero and repeated entries
     730//   // find the minimal integer value
     731//   int   S = minIntRoot(B,0);
     732//   dbprint(ppl,"// -0- minimal integer root found");
     733//   dbprint(ppl-1,S);
     734//   setring save;
     735//   int N = nvars(basering);
     736//   int Nnew = 2*(N+2);
     737//   int i,j;
     738//   string s;
     739//   //  list RL = ringlist(basering);
     740//   list L, Lord;
     741//   list tmp;
     742//   intvec iv;
     743//   L[1] = RL[1]; // char
     744//   L[4] = RL[4]; // char, minpoly
     745//   // check whether vars have admissible names
     746//   list Name  = RL[2];
     747//   list RName;
     748//   RName[1] = "u";
     749//   RName[2] = "v";
     750//   RName[3] = "t";
     751//   RName[4] = "Dt";
     752//   for(i=1;i<=N;i++)
     753//   {
     754//     for(j=1; j<=size(RName);j++)
     755//     {
     756//       if (Name[i] == RName[j])
     757//       {
     758//         ERROR("Variable names should not include u,v,t,Dt");
     759//       }
     760//     }
     761//   }
     762//   // now, create the names for new vars
     763//   //  tmp[1]     = "u";  tmp[2]     = "v";  tmp[3]     = "t";  tmp[4]     = "Dt";
     764//   list UName = RName;
     765//   list DName;
     766//   for(i=1;i<=N;i++)
     767//   {
     768//     DName[i] = "D"+Name[i]; // concat
     769//   }
     770//   list NName = UName + Name + DName;
     771//   L[2]       = NName;
     772//   tmp        = 0;
     773//   // Name, Dname will be used further
     774//   kill UName;
     775//   kill NName;
     776//   // block ord (a(1,1),dp);
     777//   tmp[1]  = "a"; // string
     778//   iv      = 1,1;
     779//   tmp[2]  = iv; //intvec
     780//   Lord[1] = tmp;
     781//   // continue with dp 1,1,1,1...
     782//   tmp[1]  = "dp"; // string
     783//   s       = "iv=";
     784//   for(i=1; i<=Nnew; i++) // need really all vars!
     785//   {
     786//     s = s+"1,";
     787//   }
     788//   s[size(s)]= ";";
     789//   execute(s);
     790//   tmp[2]    = iv;
     791//   Lord[2]   = tmp;
     792//   tmp[1]    = "C";
     793//   iv        = 0;
     794//   tmp[2]    = iv;
     795//   Lord[3]   = tmp;
     796//   tmp       = 0;
     797//   L[3]      = Lord;
     798//   // we are done with the list
     799//   def @R = ring(L);
     800//   setring @R;
     801//   matrix @D[Nnew][Nnew];
     802//   @D[3,4] = 1; // t,Dt
     803//   for(i=1; i<=N; i++)
     804//   {
     805//     @D[4+i,4+N+i]=1;
     806//   }
     807//   //  L[5] = matrix(UpOneMatrix(Nnew));
     808//   //  L[6] = @D;
     809//   ncalgebra(1,@D);
     810//   dbprint(ppl,"// -1-1- the ring @R is ready");
     811//   dbprint(ppl-1,@R);
     812//   // create the ideal
     813//   poly F  = imap(save,F);
     814//   ideal I = u*F-t,u*v-1;
     815//   poly p;
     816//   for(i=1; i<=N; i++)
     817//   {
     818//     p = u*Dt; // u*Dt
     819//     p = diff(F,var(4+i))*p;
     820//     I = I, var(N+4+i) + p; // Dx, Dy
     821//   }
     822//   // add the relations between t,Dt and s
     823//   //  I = I, t*Dt+1+S;
     824//   // -------- the ideal I is ready ----------
     825//   dbprint(ppl,"// -1-2- starting the elimination of u,v in @R");
     826//   ideal J = engine(I,eng);
     827//   ideal K = nselect(J,1,2);
     828//   dbprint(ppl,"// -1-3- u,v are eliminated in @R");
     829//   dbprint(ppl-1,K); // without u,v: not yet our answer
     830//   //----- create a ring with elim.ord for t,Dt -------
     831//   setring save;
     832//   // ------------ new ring @R2 ------------------
     833//   // without u,v and with the elim.ord for t,Dt
     834//   // keep: N, i,j,s, tmp, RL
     835//   Nnew = 2*N+2;
     836//   //  list RL = ringlist(save); // is defined earlier
     837//   kill Lord,tmp,iv, RName;
     838//   L = 0;
     839//   list Lord, tmp;
     840//   intvec iv;
     841//   L[1] = RL[1]; // char
     842//   L[4] = RL[4]; // char, minpoly
     843//   // check whether vars have admissible names -> done earlier
     844//   //  list Name  = RL[2];
     845//   list RName;
     846//   RName[1] = "t";
     847//   RName[2] = "Dt";
     848//   // DName is defined earlier
     849//   list NName = RName + Name + DName;
     850//   L[2]   = NName;
     851//   tmp    = 0;
     852//   // block ord (a(1,1),dp);
     853//   tmp[1]  = "a"; // string
     854//   iv      = 1,1;
     855//   tmp[2]  = iv; //intvec
     856//   Lord[1] = tmp;
     857//   // continue with dp 1,1,1,1...
     858//   tmp[1]  = "dp"; // string
     859//   s       = "iv=";
     860//   for(i=1;i<=Nnew;i++)
     861//   {
     862//     s = s+"1,";
     863//   }
     864//   s[size(s)]= ";";
     865//   execute(s);
     866//   kill s;
     867//   kill NName;
     868//   tmp[2]    = iv;
     869//   Lord[2]   = tmp;
     870//   tmp[1]    = "C";
     871//   iv        = 0;
     872//   tmp[2]    = iv;
     873//   Lord[3]   = tmp;
     874//   tmp       = 0;
     875//   L[3]      = Lord;
     876//   // we are done with the list
     877//   // Add: Plural part
     878//   def @R2 = ring(L);
     879//   setring @R2;
     880//   matrix @D[Nnew][Nnew];
     881//   @D[1,2]=1;
     882//   for(i=1; i<=N; i++)
     883//   {
     884//     @D[2+i,2+N+i]=1;
     885//   }
     886//   ncalgebra(1,@D);
     887//   dbprint(ppl,"// -2-1- the ring @R2 is ready");
     888//   dbprint(ppl-1,@R2);
     889//   ideal MM = maxideal(1);
     890//   MM = 0,0,MM;
     891//   map R01 = @R, MM;
     892//   ideal K2 = R01(K);
     893//   // add the relations between t,Dt and s
     894//   //  K2       = K2, t*Dt+1+S;
     895//   poly G = t*Dt+S+1;
     896//   K2 = NF(K2,std(G)),G;
     897//   dbprint(ppl,"// -2-2- starting elimination for t,Dt in @R2");
     898//   ideal J  = engine(K2,eng);
     899//   ideal K  = nselect(J,1,2);
     900//   dbprint(ppl,"// -2-3- t,Dt are eliminated");
     901//   dbprint(ppl-1,K);
     902//   //  "------- produce a final result --------";
     903//   // ----- create the ordinary Weyl algebra and put
     904//   // ----- the result into it
     905//   // ------ create the ring @R5
     906//   // keep: N, i,j,s, tmp, RL
     907//   setring save;
     908//   Nnew = 2*N;
     909//   //  list RL = ringlist(save); // is defined earlier
     910//   kill Lord, tmp, iv;
     911//   //  kill L;
     912//   L = 0;
     913//   list Lord, tmp;
     914//   intvec iv;
     915//   L[1] = RL[1]; // char
     916//   L[4] = RL[4]; // char, minpoly
     917//   // check whether vars have admissible names -> done earlier
     918//   //  list Name  = RL[2];
     919//   // DName is defined earlier
     920//   list NName = Name + DName;
     921//   L[2]   = NName;
     922//   // dp ordering;
     923//   string   s       = "iv=";
     924//   for(i=1;i<=2*N;i++)
     925//   {
     926//     s = s+"1,";
     927//   }
     928//   s[size(s)]= ";";
     929//   execute(s);
     930//   tmp     = 0;
     931//   tmp[1]  = "dp"; // string
     932//   tmp[2]  = iv; //intvec
     933//   Lord[1] = tmp;
     934//   kill s;
     935//   tmp[1]    = "C";
     936//   iv        = 0;
     937//   tmp[2]    = iv;
     938//   Lord[2]   = tmp;
     939//   tmp       = 0;
     940//   L[3]      = Lord;
     941//   // we are done with the list
     942//   // Add: Plural part
     943//   def @R5 = ring(L);
     944//   setring @R5;
     945//   matrix @D[Nnew][Nnew];
     946//   for(i=1; i<=N; i++)
     947//   {
     948//     @D[i,N+i]=1;
     949//   }
     950//   ncalgebra(1,@D);
     951//   dbprint(ppl,"// -3-1- the ring @R5 is ready");
     952//   dbprint(ppl-1,@R5);
     953//   ideal K5 = imap(@R2,K);
     954//   option(redSB);
     955//   dbprint(ppl,"// -3-2- the final cosmetic std");
     956//   K5 = engine(K5,eng); // std does the job too
     957//   // total cleanup
     958//   kill @R;
     959//   kill @R2;
     960//   ideal LD = K5;
     961//   ideal BS = imap(@LR,B);
     962//   kill @LR;
     963//   export BS;
     964//   export LD;
     965//   return(@R5);
     966// }
     967// example
     968// {
     969//   "EXAMPLE:"; echo = 2;
     970//   ring r = 0,(x,y,z),Dp;
     971//   poly F = x^2+y^3+z^5;
     972//   def A = annfsgms(F);
     973//   setring A;
     974//   LD;
     975//   print(matrix(BS));
     976// }
    984977
    985978proc convloc(list @NL)
     
    10901083  minIntRoot(I2,0);
    10911084  // now we illustrate the behaviour of factorize
     1085  // together with a global ordering
    10921086  ring r2  = 0,x,dp;
    10931087  poly f3   = 9*(x+2/3)*(x+1)*(x+4/3); // b-poly of f1=x*y*(x+y)
Note: See TracChangeset for help on using the changeset viewer.