Changeset 0a2f7d in git


Ignore:
Timestamp:
Sep 30, 2010, 9:58:57 PM (14 years ago)
Author:
Viktor Levandovskyy <levandov@…>
Branches:
(u'fieker-DuVal', '117eb8c30fc9e991c4decca4832b1d19036c4c65')(u'spielwiese', '648d28f488f6ff08f5607ff229b9ad9e4a5b93c2')
Children:
f4490f5c61db9f9a1ab08da7fe11fb449e09f040
Parents:
3576f6fb6a525ec1407b464179ffc8ad1f2c0ea7
Message:
*levandov: checklib changes of libs form Aachen

git-svn-id: file:///usr/local/Singular/svn/trunk@13356 2c84dea3-7e68-4137-9b89-c4e89433aadc
Location:
Singular/LIB
Files:
5 edited

Legend:

Unmodified
Added
Removed
  • Singular/LIB/dmod.lib

    r3576f6 r0a2f7d  
    77         Jorge Martin Morales,    jorge@unizar.es
    88
    9 THEORY: Let K be a field of characteristic 0. Given a polynomial ring
     9OVERVIEW:
     10Theory: Let K be a field of characteristic 0. Given a polynomial ring
    1011      R = K[x_1,...,x_n] and a polynomial F in R,
    1112      one is interested in the R[1/F]-module of rank one, generated by
     
    2829     PS*F^(s+1) = bs*F^s holds in K[x_1,...,x_n,1/F]*F^s.
    2930
    30 REFERENCES:
     31References:
    3132We provide the following implementations of algorithms:
    3233@*(OT) the classical Ann F^s algorithm from Oaku and Takayama (Journal of
     
    4142
    4243
    43 GUIDE:
     44Guide:
    4445@*- Ann F^s = I(F^s) = LD in D(R)[s] can be computed by Sannfs [BM, OT, LOT]
    4546@*- Ann^(1) F^s in D(R)[s] can be computed by Sannfslog
     
    5859
    5960PROCEDURES:
    60 
    6161annfs(F[,S,eng]);       compute Ann F^s0 in D and Bernstein polynomial for a poly F
    6262annfspecial(I, F, m, n);  compute Ann F^n from Ann F^s for a polynomial F and a number n
    6363Sannfs(F[,S,eng]);      compute Ann F^s in D[s] for a polynomial F
    6464Sannfslog(F[,eng]);     compute Ann^(1) F^s in D[s] for a polynomial F
    65 bernsteinBM(F[,eng]);   compute global Bernstein polynomial for a polynomial F (algorithm of Briancon-Maisonobe)
    66 bernsteinLift(I,F [,eng]);  compute a possible multiple of Bernstein polynomial via lift-like procedure
    67 operatorBM(F[,eng]);    compute Ann F^s, Ann F^s0, BS and PS for a polynomial F (algorithm of Briancon-Maisonobe)
     65bernsteinBM(F[,eng]);   compute global Bernstein-Sato polynomial of a poly F (alg of Briancon-Maisonobe)
     66bernsteinLift(I,F [,eng]);  compute a multiple of Bernstein-Sato polynomial via lift-like procedure
     67operatorBM(F[,eng]);    compute Ann F^s, Ann F^s0, BS and PS for a poly F (algorithm of Briancon-Maisonobe)
    6868operatorModulo(F, I, b); compute PS via the modulo approach
    6969annfsParamBM(F[,eng]);  compute the generic Ann F^s (algorithm by Briancon and Maisonobe) and exceptional parametric constellations for a polynomial F with parametric coefficients
     
    7575annfsRB(I,F [,eng]);          compute Ann F^s0 in D and Bernstein polynomial from the known Ann F^s in D[s] by using Jacobian ideal
    7676checkFactor(I,F,q[,eng]); check whether a polynomial q in K[s] is a factor of the global Bernstein polynomial of F from the known Ann F^s in D[s]
     77
    7778
    7879arrange(p);           create a poly, describing a full hyperplane arrangement
  • Singular/LIB/dmodapp.lib

    r3576f6 r0a2f7d  
    77@*       Daniel Andres,   daniel.andres@math.rwth-aachen.de
    88
    9 SUPPORT: DFG Graduiertenkolleg 1632 'Experimentelle und konstruktive Algebra'
    10 
    11 GUIDE: Let K be a field of characteristic 0, R = K[x1,...,xN] and
     9Support: DFG Graduiertenkolleg 1632 'Experimentelle und konstruktive Algebra'
     10
     11OVERVIEW: Let K be a field of characteristic 0, R = K[x1,...,xN] and
    1212@* D be the Weyl algebra in variables x1,...,xN,d1,...,dN.
    1313@* In this library there are the following procedures for algebraic D-modules:
     
    4242
    4343
    44 REFERENCES:
     44References:
    4545@* (SST) Saito, Sturmfels, Takayama 'Groebner Deformations of Hypergeometric
    4646@*         Differential Equations', Springer, 2000
     
    4949
    5050
    51 MAIN PROCEDURES:
     51PROCEDURES:
    5252
    5353annPoly(f);   annihilator of a polynomial f in the corr. Weyl algebra
     
    7474
    7575
    76 AUXILIARY PROCEDURES:
    7776
    7877appelF1();     create an ideal annihilating Appel F1 function
     
    103102D-module; D-integration; integration of D-module; characteristic variety;
    104103Appel function; Appel hypergeometric function
    105 
    106104";
    107105
  • Singular/LIB/fpadim.lib

    r3576f6 r0a2f7d  
    66AUTHORS: Grischa Studzinski,       grischa.studzinski@rwth-aachen.de
    77
    8 SUPPORT: Projects LE 2697/2-1; KR 1907/3-1 of the Priority Programme SPP 1489:
     8Support: Projects LE 2697/2-1; KR 1907/3-1 of the Priority Programme SPP 1489:
    99@* 'Algorithmische und Experimentelle Methoden in Algebra, Geometrie und Zahlentheorie'
    1010@* of the German DFG
     
    4141@*
    4242
    43 REFERENCES:
     43References:
    4444
    4545@*   [ufna] Ufnarovskij: Combinatorical and asymptotic methods in algebra, 1990
     
    4949                      associative algebras, Diploma thesis, RWTH Aachen, 2010
    5050
    51 ASSUMPTIONS:
     51Assumptions:
    5252@* - basering is always a Letterplace ring
    5353@* - all intvecs correspond to Letterplace monomials
  • Singular/LIB/freegb.lib

    r3576f6 r0a2f7d  
    66AUTHOR: Viktor Levandovskyy,     levandov@math.rwth-aachen.de
    77
    8 THEORY: See chapter 'LETTERPLACE' in the @sc{Singular} Manual.
     8OVERVIEW: For the theory, see chapter 'Letterplace' in the @sc{Singular} Manual.
    99
    1010PROCEDURES:
     
    1313setLetterplaceAttributes(R,d,b);  supplies ring R with the letterplace structure
    1414
    15 AUXILIARY PROCEDURES:
    1615
    1716lpMult(f,g);        letterplace multiplication of letterplace polynomials
     
    2827ademRelations(i,j);    compute the ideal of Adem relations for i<2j in char 0
    2928
    30 SEE ALSO: LETTERPLACE
    31 "
     29SEE ALSO: fpadim_lib, Letterplace
     30";
    3231
    3332// this library computes two-sided GB of an ideal
     
    907906RETURN:  ring
    908907PURPOSE: creates a ring with the ordering, used in letterplace computations
    909 NOTE: if h is given an nonzero, the pure homogeneous letterplace block ordering will be used.
     908NOTE: if h is given and nonzero, the pure homogeneous letterplace block ordering will be used.
    910909EXAMPLE: example makeLetterplaceRing; shows examples
    911910"
     
    11361135  attrib(A,"lV"); // number of variables in the main block
    11371136}
     1137
     1138
     1139proc makeLetterplaceRing3(int d)
     1140"USAGE:  makeLetterplaceRing1(d); d an integer
     1141RETURN:  ring
     1142PURPOSE: creates a ring with a special ordering, representing
     1143@* the original P[s,sigma] (adds d blocks of shifted s)
     1144ASSUME: basering is a letterplace ring as well
     1145NOTE: experimental status
     1146EXAMPLE: example makeLetterplaceRing1; shows examples
     1147"
     1148{
     1149  // d = up to degree, will be shifted to d+1
     1150  if (d<1) {"bad d"; return(0);}
     1151
     1152  int uptodeg = d; int lV = nvars(basering);
     1153
     1154  int ppl = printlevel-voice+2;
     1155  string err = "";
     1156
     1157  int i,j,s;
     1158  def save = basering;
     1159  int D = d-1;
     1160  list LR  = ringlist(save);
     1161  list L, tmp;
     1162  L[1] = LR[1]; // ground field
     1163  L[4] = LR[4]; // quotient ideal
     1164  tmp  = LR[2]; // varnames
     1165  tmp[size(tmp)+1] = "s";
     1166  // add s's
     1167  //  string newSname = "@s";
     1168  s = size(LR[2]);
     1169  for (i=1; i<=D; i++)
     1170  {
     1171    for (j=1; j<=s; j++)
     1172    {
     1173      tmp[i*s+j] = string(tmp[j])+"("+string(i+1)+")";
     1174    }
     1175  }
     1176  // the final index is D*s+s = (D+1)*s = degBound*s
     1177  for (i=1; i<=d; i++)
     1178  {
     1179    tmp[FIndex + i] =  string(newSname)+"("+string(i)+")";
     1180  }
     1181  L[2] = tmp;
     1182  list OrigNames = LR[2];
     1183  // ordering: d blocks of the MODIFIED ord on r
     1184  // try to get whether the ord on r is blockord itself
     1185  // TODO: make L(2) ordering! exponent is maximally 2
     1186  s = size(LR[3]);
     1187
     1188  // assume: basering was a letterplace, so get its block
     1189  tmp = LR[3][1]; // ASSUME: it's a nice block
     1190  // modify it
     1191  // add (0,..,0,1) ... as antiblock part
     1192  intvec iv; list ttmp, tmp1;
     1193  for (i=1; i<=d; i++)
     1194  {
     1195    // the position to hold 1:
     1196    iv = intvec( gen( i*(lV+1)-1 ) );
     1197    ttmp[1] = "a";
     1198    ttmp[2] = iv;
     1199    tmp1[i] = ttmp;
     1200  }
     1201  // finished: antiblock part //TOCONTINUE
     1202
     1203  if (s==2)
     1204  {
     1205    // not a blockord, 1 block + module ord
     1206    tmp = LR[3][s]; // module ord
     1207    for (i=1; i<=D; i++)
     1208    {
     1209      LR[3][s-1+i] = LR[3][1];
     1210    }
     1211    LR[3][s+D] = tmp;
     1212  }
     1213  if (s>2)
     1214  {
     1215    // there are s-1 blocks
     1216    int nb = s-1;
     1217    tmp = LR[3][s]; // module ord
     1218    for (i=1; i<=D; i++)
     1219    {
     1220      for (j=1; j<=nb; j++)
     1221      {
     1222        LR[3][i*nb+j] = LR[3][j];
     1223      }
     1224    }
     1225    //    size(LR[3]);
     1226    LR[3][nb*(D+1)+1] = tmp;
     1227  }
     1228  L[3] = LR[3];
     1229  def @R = ring(L);
     1230  //  setring @R;
     1231  //  int uptodeg = d; int lV = nvars(basering); // were defined before
     1232  def @@R = setLetterplaceAttributes(@R,uptodeg,lV);
     1233  return (@@R);
     1234}
     1235example
     1236{
     1237  "EXAMPLE:"; echo = 2;
     1238  ring r = 0,(x,y,z),(dp(1),dp(2));
     1239  def A = makeLetterplaceRing3(2);
     1240  setring A;
     1241  A;
     1242  attrib(A,"isLetterplaceRing");
     1243  attrib(A,"uptodeg");  // degree bound
     1244  attrib(A,"lV"); // number of variables in the main block
     1245}
     1246
     1247
    11381248
    11391249/* EXAMPLES:
  • Singular/LIB/ncfactor.lib

    r3576f6 r0a2f7d  
    1 ////////////////////////////////////////////////////////////////////////////////////////////////////
     1////////////////////////////////////////////////////////////
    22version = "$Id: ncfactor.lib, v 1.00 2010/02/15 10:06 heinle Exp $";
    33category="Noncommutative";
     
    66AUTHORS: Albert Heinle,     albert.heinle@rwth-aachen.de
    77
    8 MAIN PROCEDURES:
    9 homogfac(h);         computes one factorization of a homogeneous polynomial h
    10 homogfac_all(h);     computes all factorizations of a homogeneous polynomial h
    11 facwa(h);            computes all factorizations of an inhomogeneous polynomial h
    12 
     8PROCEDURES:
     9facfirstwa(h);     factorization in the first Weyl algebra
     10";
     11
     12LIB "general.lib";
     13LIB "nctools.lib";
     14LIB "involut.lib";
     15
     16//static homogfac(h);         computes one factorization of a homogeneous polynomial h
     17//static homogfac_all(h);     computes all factorizations of a homogeneous polynomial h
     18//static facwa(h);            computes all factorizations of an inhomogeneous polynomial h
    1319/* ring R = 0,(x,y),Ws(-1,1); */
    1420/* def r = nc_algebra(1,1); */
    1521/* setring(r); */
    16 ";
    17 LIB "general.lib";
    18 LIB "nctools.lib";
    19 LIB "involut.lib";
    2022
    2123////////////////////////////////////////////////////////////////////////////////////////////////////
     
    428430//one factorization of a homogeneous polynomial
    429431//in the first Weyl Algebra
    430 proc homogfac(poly h)
     432static proc homogfac(poly h)
    431433"USAGE: homogfac(h); h is a homogeneous polynomial in the first Weyl algebra with respect to the weight vector [-1,1]
    432434RETURN: list
     
    436438SEE ALSO: homogfac_all
    437439"{//proc homogfac
    438      if (!isWeyl())
    439      {//Our basering is not the Weyl algebra
    440           return(list());
    441      }//Our basering is not the Weyl algebra
    442      if(nvars(basering)!=2)
    443      {//Our basering is the Weyl algebra, but not the first
    444           return(list());
    445      }//Our basering is the Weyl algebra, but not the first
    446440     def r = basering;
    447441     poly hath;
     
    530524     return(result);
    531525}//proc homogfac
    532 example
    533 {
    534      "EXAMPLE:";echo=2;
    535      ring R = 0,(x,y),Ws(-1,1);
    536      def r = nc_algebra(1,1);
    537      setring(r);
    538      poly h = (x^2*y^2+1)*(x^4);
    539      homogfac(h);
    540 }
     526/* example */
     527/* { */
     528/*      "EXAMPLE:";echo=2; */
     529/*      ring R = 0,(x,y),Ws(-1,1); */
     530/*      def r = nc_algebra(1,1); */
     531/*      setring(r); */
     532/*      poly h = (x^2*y^2+1)*(x^4); */
     533/*      homogfac(h); */
     534/* } */
    541535
    542536//==================================================
    543537//Computes all possible homogeneous factorizations
    544 proc homogfac_all(poly h)
     538static proc homogfac_all(poly h)
    545539"USAGE: homogfac_all(h); h is a homogeneous polynomial in the first Weyl algebra with respect to the weight vector [-1,1]
    546540RETURN: list
     
    554548          return(list(list(h)));
    555549     }//h is a constant
    556      if (!isWeyl())
    557      {//Our basering is not the Weyl algebra
    558           return(list());
    559      }//Our basering is not the Weyl algebra
    560      if(nvars(basering)!=2)
    561      {//Our basering is the Weyl algebra, but not the first
    562           return(list());
    563      }//Our basering is the Weyl algebra, but not the first
    564550     def r = basering;
    565551     list one_hom_fac; //stands for one homogeneous factorization
     
    800786     return(result);
    801787}//proc HomogFacAll
    802 example
    803 {
    804      "EXAMPLE:";echo=2;
    805      ring R = 0,(x,y),Ws(-1,1);
    806      def r = nc_algebra(1,1);
    807      setring(r);
    808      poly h = (x^2*y^2+1)*(x^4);
    809      homogfac_all(h);
    810 }
     788/* example */
     789/* { */
     790/*      "EXAMPLE:";echo=2; */
     791/*      ring R = 0,(x,y),Ws(-1,1); */
     792/*      def r = nc_algebra(1,1); */
     793/*      setring(r); */
     794/*      poly h = (x^2*y^2+1)*(x^4); */
     795/*      homogfac_all(h); */
     796/* } */
    811797
    812798//==================================================*
     
    887873//==================================================
    888874//factorization of the first Weyl Algebra
    889 proc facwa(poly h)
     875
     876//The following procedure just serves the purpose to
     877//transform the input into an appropriate input for
     878//the procedure sfacwa, where the ring must contain the
     879//variables in a certain order.
     880proc facfirstwa(poly h)
     881{//proc facfirstwa
     882      //Redefine the ring in my standard form
     883     if (!isWeyl())
     884     {//Our basering is not the Weyl algebra
     885          return(list());
     886     }//Our basering is not the Weyl algebra
     887     if(nvars(basering)!=2)
     888     {//Our basering is the Weyl algebra, but not the first
     889          return(list());
     890     }//Our basering is the Weyl algebra, but not the first
     891     if (ringlist(basering)[6][1,2] == -1) //manual of ringlist will tell you why
     892     {
     893          def r = basering;
     894          ring tempRing = ringlist(r)[1][1],(x,y),Ws(-1,1);
     895          def tempRingnc = nc_algebra(1,1);
     896          setring(tempRingnc);
     897          map transf = r, var(2), var(1);
     898          list result = sfacwa(transf(h));
     899          setring(r);
     900          map transfback = tempRingnc, var(2),var(1);
     901          return(transfback(result));
     902     }
     903     else { return(sfacwa(h));}
     904}//proc facfirstwa
     905example
     906{
     907     "EXAMPLE:";echo=2;
     908     ring R = 0,(x,y),dp;
     909     def r = nc_algebra(1,1);
     910     setring(r);
     911     poly h = (x^2*y^2+x)*(y-1);
     912     facfirstwa(h);
     913}
     914
     915//This is the main program
     916static proc sfacwa(poly h)
    890917"USAGE: facwa(h); h is a polynomial in the first Weyl algebra
    891918RETURN: list
     
    894921EXAMPLE: example facwa; shows examples
    895922SEE ALSO: homogfac_all, homogfac
    896 "{//proc facwa
     923"{//proc sfacwa
    897924     if(homogwithorder(h,intvec(-1,1)))
    898925     {
    899926          return(homogfac_all(h));
    900927     }
    901      //Redefine the ring in my standard form
    902      if (!isWeyl())
    903      {//Our basering is not the Weyl algebra
    904           return(list());
    905      }//Our basering is not the Weyl algebra
    906      if(nvars(basering)!=2)
    907      {//Our basering is the Weyl algebra, but not the first
    908           return(list());
    909      }//Our basering is the Weyl algebra, but not the first
    910928     def r = basering;
    911929     map invo = basering,-var(1),var(2);
     
    10581076     result = delete_dublicates_noteval(result);
    10591077     return(result);
    1060 }//proc facwa
    1061 example
    1062 {
    1063      "EXAMPLE:";echo=2;
    1064      ring R = 0,(x,y),Ws(-1,1);
    1065      def r = nc_algebra(1,1);
    1066      setring(r);
    1067      poly h = (x^2*y^2+x)*x;
    1068      facwa(h);
    1069 }
     1078}//proc sfacwa
     1079
    10701080
    10711081//==================================================
     
    10901100     return(1);
    10911101}//proc homogwithorder
     1102
     1103//==================================================
     1104//Testfac: Given a list with different factorizations of
     1105// one polynomial, the following procedure checks
     1106// whether they all refer to the same polynomial.
     1107// If they do, the output will be a list, that contains
     1108// the product of each factorization. If not, the empty
     1109// list will be returned.
     1110// If the optional argument # is given (i.e. the polynomial
     1111// which is factorized by the elements of the given list),
     1112// then we look, if the entries are factorizations of p
     1113// and if not, a list with the products subtracted by p
     1114// will be returned
     1115proc testfac(list l, list #)
     1116"USAGE:  - testfac(l); l is a list, that contains lists with entries in the first Weyl algebra or
     1117         @*- testfac(l,p); l is a list, that contains lists with entries in the first Weyl algebra and p is a polynomial in the first Weyl algebra
     1118RETURN: list@*
     1119PURPOSE: Checks whether a list of factorizations contains factorizations of the same element in the first Weyl algebra@*
     1120THEORY: @code{testfac} multiplies out each factorization and checks whether each factorization was a factorization of the same element.
     1121@* - if there is only a list given, the output will be the empty list, if it does not contain factorizations of the same element. Otherwise it will multiply out all the factorizations and return a list of the length if the given one, in which each entry is the factorized polynomial
     1122@* - if there is a polynomial in the second argument, then the procedure checks whether the given list contains factorizations of this polynomial. If it does, then the output will be a list with the length of the given one and each entry contains this polynomial. If it does not, then the procedure returns a list, in which each entry is the given polynomial subtracted by the multiplied candidate for its factorization.
     1123EXAMPLE: example testfac; shows examples
     1124SEE ALSO: homogfac_all, homogfac, facwa
     1125"{//proc testfac
     1126     if (size(l)==0)
     1127     {//The empty list is given
     1128          return(list());
     1129     }//The empty list is given
     1130     if (size(#)>1)
     1131     {//We want max. one optional argument
     1132          return(list());
     1133     }//We want max. one optional argument
     1134     list result;
     1135     int i; int j;
     1136     if (size(#)==0)
     1137     {//No optional argument is given
     1138          int valid = 1;
     1139          for (i = size(l);i>=1;i--)
     1140          {//iterate over the elements of the given list
     1141               if (size(result)>0)
     1142               {
     1143                    if (product(l[i])!=result[size(l)-i])
     1144                    {
     1145                         valid = 0;
     1146                         break;
     1147                    }
     1148               }
     1149               result = insert(result, product(l[i]));
     1150          }//iterate over the elements of the given list
     1151          if (valid)
     1152          {
     1153               return(result);
     1154          }
     1155          return(list());
     1156     }//No optional argument is given
     1157     else
     1158     {
     1159          int valid = 1;
     1160          for (i = size(l);i>=1;i--)
     1161          {//iterate over the elements of the given list
     1162               if (product(l[i])!=#[1])
     1163               {
     1164                    valid = 0;
     1165               }
     1166               result = insert(result, product(l[i]));
     1167          }//iterate over the elements of the given list
     1168          if (valid)
     1169          {
     1170               return(result);
     1171          }
     1172          for (i = 1 ; i<= size(result);i++)
     1173          {//subtract p from every entry in result
     1174               result[i] = result[i] - #[1];
     1175          }//subtract p from every entry in result
     1176          return(result);
     1177     }
     1178}//proc testfac
     1179example
     1180{
     1181     "EXAMPLE:";echo=2;
     1182     ring R = 0,(x,y),Ws(-1,1);
     1183     def r = nc_algebra(1,1);
     1184     setring(r);
     1185     poly h = (x^2*y^2+1)*(x^4);
     1186     def t1 = facfirstwa(h);
     1187     //fist a correct list
     1188     testfac(t1);
     1189     //now a correct list with the factorized polynomial
     1190     testfac(t1,h);
     1191     //now we put in an incorrect list without a polynomial
     1192     t1[5][3] = y;
     1193     testfac(t1);
     1194     //and last but not least we take h as additional input
     1195     testfac(t1,h);
     1196}
     1197//==================================================
     1198//Procedure facsubwa:
     1199//This procedure serves the purpose to compute a
     1200//factorization of a given polynomial in a ring, whose subring
     1201//is the first Weyl algebra. The polynomial must only contain
     1202//the two arguments, which are also given by the user.
     1203proc facsubwa(poly h, X, D)
     1204"USAGE:  facsubwa(h,x,y) - h is a polynomial in the first Weyl algebra, X and D are the variables in h, which have the commutation rule DX = XD + 1@*
     1205RETURN: list@*
     1206PURPOSE: Given a polynomial in a Ring, which contains the first Weyl algebra as a subring. Furthermore let this polynomial be in the first Weyl algebra with the variables X and D with DX = XD +1.@*
     1207THEORY: @code{facsubwa} computes some factorizations of the given polynomial, which is a polynomial in the variables X and D@*
     1208EXAMPLE: example facsubwa; shows examples
     1209SEE ALSO: facfirstwa
     1210"{//proc facsubwa
     1211     if(!isWeyl())
     1212     {
     1213          return(list());
     1214     }
     1215     def r = basering;
     1216     //We begin to check the input
     1217     if (size(X)>1)
     1218     {
     1219          return(list());
     1220     }
     1221     if (size(D)>1)
     1222     {
     1223          return(list());
     1224     }
     1225     intvec lexpofX = leadexp(X);
     1226     intvec lexpofD = leadexp(D);
     1227     if (sum(lexpofX)!=1)
     1228     {
     1229          return(list());
     1230     }
     1231     if (sum(lexpofD)!=1)
     1232     {
     1233          return(list());
     1234     }
     1235     int varnumX=1;
     1236     int varnumD=1;
     1237     while(lexpofX[varnumX] != 1)
     1238     {
     1239          varnumX++;
     1240     }
     1241     while(lexpofD[varnumD] != 1)
     1242     {
     1243          varnumD++;
     1244     }
     1245     lexpofX = lexpofX +1;
     1246     lexpofX[varnumX] = 0;
     1247     lexpofX[varnumD] = 0;
     1248     if (deg(h,lexpofX)!=0)
     1249     {
     1250          return(list());
     1251     }
     1252     //Input successfully checked
     1253     ring firstweyl = 0,(var(varnumX),var(varnumD)),dp;
     1254     def Firstweyl = nc_algebra(1,1);
     1255     setring Firstweyl;
     1256     poly h = imap(r,h);
     1257     list result = facfirstwa(h);
     1258     setring r;
     1259     list result = imap(Firstweyl,result);
     1260     return(result);
     1261}//proc facsubwa
     1262example
     1263{
     1264     "EXAMPLE:";echo=2;
     1265     ring R = 0,(x,y),Ws(-1,1);
     1266     def r = nc_algebra(1,1);
     1267     setring(r);
     1268     poly h = (x^2*y^2+x)*x;
     1269     facsubwa(h,x,y);
     1270}
     1271//==================================================
    10921272/*
    10931273Example polynomials where one can find factorizations
Note: See TracChangeset for help on using the changeset viewer.