001/* 002 * $Id$ 003 */ 004 005package edu.jas.application; 006 007 008import java.io.IOException; 009import java.io.Reader; 010import java.io.StringReader; 011import java.util.ArrayList; 012import java.util.List; 013 014import edu.jas.arith.BigDecimal; 015import edu.jas.arith.BigInteger; 016import edu.jas.arith.BigRational; 017import edu.jas.arith.ModInteger; 018import edu.jas.arith.ModIntegerRing; 019import edu.jas.arith.Product; 020import edu.jas.arith.ProductRing; 021import edu.jas.gb.Cyclic; 022import edu.jas.gb.GroebnerBase; 023import edu.jas.gb.GroebnerBaseAbstract; 024import edu.jas.gbufd.GBFactory; 025import edu.jas.gbufd.RGroebnerBasePseudoSeq; 026import edu.jas.gbufd.RReductionSeq; 027import edu.jas.kern.ComputerThreads; 028import edu.jas.kern.Scripting; 029import edu.jas.poly.AlgebraicNumber; 030import edu.jas.poly.AlgebraicNumberRing; 031import edu.jas.poly.GenPolynomial; 032import edu.jas.poly.GenPolynomialRing; 033import edu.jas.poly.GenPolynomialTokenizer; 034import edu.jas.poly.PolynomialList; 035import edu.jas.poly.TermOrder; 036import edu.jas.ufd.Quotient; 037import edu.jas.ufd.QuotientRing; 038 039 040/** 041 * Examples for application usage. 042 * @author Christoph Zengler 043 * @author Heinz Kredel 044 */ 045 046public class Examples { 047 048 049 /** 050 * main. 051 */ 052 public static void main(String[] args) { 053 if (args.length > 0) { 054 example1(); 055 example2(); 056 example3(); 057 example4(); 058 } 059 example5(); 060 example6(); 061 example10(); 062 example11(); 063 example12(); 064 ComputerThreads.terminate(); 065 } 066 067 068 /** 069 * example1. cyclic n-th roots polynomial systems. 070 */ 071 public static void example1() { 072 int n = 4; 073 Cyclic cy = new Cyclic(n); 074 System.out.println("ring = " + cy.ring); 075 List<GenPolynomial<BigInteger>> cp = cy.cyclicPolys(); 076 System.out.println("cp = " + cp + "\n"); 077 078 List<GenPolynomial<BigInteger>> gb; 079 //GroebnerBase<BigInteger> sgb = new GroebnerBaseSeq<BigInteger>(); 080 GroebnerBase<BigInteger> sgb = GBFactory.getImplementation(cy.ring.coFac); 081 gb = sgb.GB(cp); 082 System.out.println("gb = " + gb); 083 } 084 085 086 /** 087 * example2. abstract types: 088 * List<GenPolynomial<Product<Residue<BigRational>>>>. 089 */ 090 public static void example2() { 091 List<GenPolynomial<Product<Residue<BigRational>>>> L = null; 092 L = new ArrayList<GenPolynomial<Product<Residue<BigRational>>>>(); 093 094 BigRational bfac = new BigRational(1); 095 String[] cvars = new String[] { "x", "y", "z" }; 096 GenPolynomialRing<BigRational> pfac = null; 097 pfac = new GenPolynomialRing<BigRational>(bfac, cvars); 098 099 List<GenPolynomial<BigRational>> F = null; 100 F = new ArrayList<GenPolynomial<BigRational>>(); 101 102 GenPolynomial<BigRational> p = null; 103 for (int i = 0; i < 2; i++) { 104 p = pfac.random(5, 4, 3, 0.4f); 105 if (!p.isConstant()) { 106 F.add(p); 107 } 108 } 109 //System.out.println("F = " + F); 110 111 Ideal<BigRational> id = new Ideal<BigRational>(pfac, F); 112 id.doGB(); 113 if (id.isONE() || id.isZERO()) { 114 System.out.println("id zero or one = " + id); 115 return; 116 } 117 ResidueRing<BigRational> rr = new ResidueRing<BigRational>(id); 118 System.out.println("rr = " + rr); 119 120 ProductRing<Residue<BigRational>> pr = null; 121 pr = new ProductRing<Residue<BigRational>>(rr, 3); 122 123 String[] vars = new String[] { "a", "b" }; 124 GenPolynomialRing<Product<Residue<BigRational>>> fac; 125 fac = new GenPolynomialRing<Product<Residue<BigRational>>>(pr, vars); 126 127 GenPolynomial<Product<Residue<BigRational>>> pp; 128 for (int i = 0; i < 1; i++) { 129 pp = fac.random(2, 4, 4, 0.4f); 130 if (!pp.isConstant()) { 131 L.add(pp); 132 } 133 } 134 System.out.println("L = " + L); 135 136 //PolynomialList<Product<Residue<BigRational>>> Lp = null; 137 //Lp = new PolynomialList<Product<Residue<BigRational>>>(fac,L); 138 //System.out.println("Lp = " + Lp); 139 140 GroebnerBase<Product<Residue<BigRational>>> bb = new RGroebnerBasePseudoSeq<Product<Residue<BigRational>>>( 141 pr); 142 143 System.out.println("isGB(L) = " + bb.isGB(L)); 144 145 List<GenPolynomial<Product<Residue<BigRational>>>> G = null; 146 147 G = bb.GB(L); 148 System.out.println("G = " + G); 149 System.out.println("isGB(G) = " + bb.isGB(G)); 150 } 151 152 153 /** 154 * example3. abstract types: GB of List<GenPolynomial<Residue<BigRational>>>. 155 */ 156 public static void example3() { 157 List<GenPolynomial<Residue<BigRational>>> L = null; 158 L = new ArrayList<GenPolynomial<Residue<BigRational>>>(); 159 160 BigRational bfac = new BigRational(1); 161 String[] cvars = new String[] { "x", "y", "z" }; 162 GenPolynomialRing<BigRational> pfac = null; 163 pfac = new GenPolynomialRing<BigRational>(bfac, cvars); 164 165 List<GenPolynomial<BigRational>> F = null; 166 F = new ArrayList<GenPolynomial<BigRational>>(); 167 168 GenPolynomial<BigRational> p = null; 169 for (int i = 0; i < 2; i++) { 170 p = pfac.random(5, 5, 5, 0.4f); 171 //p = pfac.parse("x0^2 -2" ); 172 if (!p.isConstant()) { 173 F.add(p); 174 } 175 } 176 //System.out.println("F = " + F); 177 178 Ideal<BigRational> id = new Ideal<BigRational>(pfac, F); 179 id.doGB(); 180 if (id.isONE() || id.isZERO()) { 181 System.out.println("id zero or one = " + id); 182 return; 183 } 184 ResidueRing<BigRational> rr = new ResidueRing<BigRational>(id); 185 System.out.println("rr = " + rr); 186 187 String[] vars = new String[] { "a", "b" }; 188 GenPolynomialRing<Residue<BigRational>> fac; 189 fac = new GenPolynomialRing<Residue<BigRational>>(rr, vars); 190 191 GenPolynomial<Residue<BigRational>> pp; 192 for (int i = 0; i < 2; i++) { 193 pp = fac.random(2, 4, 6, 0.2f); 194 if (!pp.isConstant()) { 195 L.add(pp); 196 } 197 } 198 System.out.println("L = " + L); 199 200 GroebnerBase<Residue<BigRational>> bb; 201 //bb = new GroebnerBasePseudoSeq<Residue<BigRational>>(rr); 202 bb = GBFactory.getImplementation(rr); 203 204 System.out.println("isGB(L) = " + bb.isGB(L)); 205 206 List<GenPolynomial<Residue<BigRational>>> G = null; 207 208 G = bb.GB(L); 209 System.out.println("G = " + G); 210 System.out.println("isGB(G) = " + bb.isGB(G)); 211 } 212 213 214 /** 215 * example4. abstract types: comprehensive GB of 216 * List<GenPolynomial<GenPolynomial<BigRational>>>. 217 */ 218 public static void example4() { 219 int kl = 2; 220 int ll = 3; 221 int el = 3; 222 float q = 0.2f; //0.4f 223 GenPolynomialRing<BigRational> cfac; 224 GenPolynomialRing<GenPolynomial<BigRational>> fac; 225 226 List<GenPolynomial<GenPolynomial<BigRational>>> L; 227 228 ComprehensiveGroebnerBaseSeq<BigRational> bb; 229 230 GenPolynomial<GenPolynomial<BigRational>> a, b, c; 231 232 BigRational coeff = new BigRational(kl); 233 String[] cv = { "a", "b" }; 234 cfac = new GenPolynomialRing<BigRational>(coeff, cv); 235 String[] v = { "x", "y" }; 236 fac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, v); 237 bb = new ComprehensiveGroebnerBaseSeq<BigRational>(coeff); 238 239 L = new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>(); 240 241 a = fac.random(kl, ll, el, q); 242 b = fac.random(kl, ll, el, q); 243 c = a; //c = fac.random(kl, ll, el, q ); 244 245 if (a.isZERO() || b.isZERO() || c.isZERO()) { 246 return; 247 } 248 249 L.add(a); 250 System.out.println("CGB exam L = " + L); 251 L = bb.GB(L); 252 System.out.println("CGB( L ) = " + L); 253 System.out.println("isCGB( L ) = " + bb.isGB(L)); 254 255 L.add(b); 256 System.out.println("CGB exam L = " + L); 257 L = bb.GB(L); 258 System.out.println("CGB( L ) = " + L); 259 System.out.println("isCGB( L ) = " + bb.isGB(L)); 260 261 L.add(c); 262 System.out.println("CGB exam L = " + L); 263 L = bb.GB(L); 264 System.out.println("CGB( L ) = " + L); 265 System.out.println("isCGB( L ) = " + bb.isGB(L)); 266 } 267 268 269 /** 270 * example5. comprehensive GB of 271 * List<GenPolynomial<GenPolynomial<BigRational>>> and GB for regular ring. 272 */ 273 public static void example5() { 274 int kl = 2; 275 int ll = 4; 276 int el = 3; 277 float q = 0.3f; //0.4f 278 GenPolynomialRing<BigRational> cfac; 279 GenPolynomialRing<GenPolynomial<BigRational>> fac; 280 281 List<GenPolynomial<GenPolynomial<BigRational>>> L; 282 283 ComprehensiveGroebnerBaseSeq<BigRational> bb; 284 285 GenPolynomial<GenPolynomial<BigRational>> a; 286 GenPolynomial<GenPolynomial<BigRational>> b; 287 GenPolynomial<GenPolynomial<BigRational>> c; 288 289 BigRational coeff = new BigRational(kl); 290 String[] cv = { "a", "b" }; 291 cfac = new GenPolynomialRing<BigRational>(coeff, cv); 292 String[] v = { "x", "y" }; 293 fac = new GenPolynomialRing<GenPolynomial<BigRational>>(cfac, v); 294 bb = new ComprehensiveGroebnerBaseSeq<BigRational>(coeff); 295 296 L = new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>(); 297 298 a = fac.random(kl, ll, el, q); 299 b = fac.random(kl, ll, el, q); 300 c = a; //c = fac.random(kl, ll, el, q ); 301 302 if (a.isZERO() || b.isZERO() || c.isZERO()) { 303 return; 304 } 305 306 L.add(a); 307 L.add(b); 308 L.add(c); 309 System.out.println("CGB exam L = " + L); 310 GroebnerSystem<BigRational> sys = bb.GBsys(L); 311 boolean ig = bb.isGB(sys.getCGB()); 312 System.out.println("CGB( L ) = " + sys.getCGB()); 313 System.out.println("isCGB( L ) = " + ig); 314 315 List<GenPolynomial<Product<Residue<BigRational>>>> Lr, bLr; 316 RReductionSeq<Product<Residue<BigRational>>> res = new RReductionSeq<Product<Residue<BigRational>>>(); 317 318 Lr = PolyUtilApp.<BigRational> toProductRes(sys.list); 319 bLr = res.booleanClosure(Lr); 320 321 System.out.println("booleanClosed(Lr) = " + bLr); 322 323 if (bLr.size() > 0) { 324 GroebnerBase<Product<Residue<BigRational>>> rbb = new RGroebnerBasePseudoSeq<Product<Residue<BigRational>>>( 325 bLr.get(0).ring.coFac); 326 System.out.println("isRegularGB(Lr) = " + rbb.isGB(bLr)); 327 } 328 } 329 330 331 /** 332 * Example GBase and real root. 333 */ 334 @SuppressWarnings("unchecked") 335 public static void example6() { 336 BigRational coeff = new BigRational(); 337 GroebnerBase<BigRational> gb = GBFactory.getImplementation(coeff); 338 339 String exam = "(x,y,z) L " + "( " + "( x^2 - 2 ), ( y^2 - 3 ), ( z^2 + x * y )" + ") "; 340 Reader source = new StringReader(exam); 341 GenPolynomialTokenizer parser = new GenPolynomialTokenizer(source); 342 PolynomialList<BigRational> F = null; 343 344 try { 345 F = (PolynomialList<BigRational>) parser.nextPolynomialSet(); 346 } catch (ClassCastException e) { 347 e.printStackTrace(); 348 return; 349 } catch (IOException e) { 350 e.printStackTrace(); 351 return; 352 } 353 System.out.println("F = " + F); 354 355 List<GenPolynomial<BigRational>> G = gb.GB(F.list); 356 357 PolynomialList<BigRational> Gp = new PolynomialList<BigRational>(F.ring, G); 358 System.out.println("G = " + Gp); 359 360 // compute real roots of the ideal 361 Ideal<BigRational> I = new Ideal<BigRational>(Gp); 362 List<IdealWithRealAlgebraicRoots<BigRational>> Ir = PolyUtilApp.<BigRational> realAlgebraicRoots(I); 363 for (IdealWithRealAlgebraicRoots<BigRational> R : Ir) { 364 R.doDecimalApproximation(); 365 for (List<BigDecimal> Dr : R.decimalApproximation()) { 366 System.out.println(Dr.toString()); 367 } 368 System.out.println(); 369 } 370 } 371 372 373 /** 374 * example7. Coefficients in Boolean residue class ring. 375 */ 376 public static void example7() { 377 String[] vars = { "v3", "v2", "v1" }; 378 379 ModIntegerRing z2 = new ModIntegerRing(2); 380 GenPolynomialRing<ModInteger> z2p = new GenPolynomialRing<ModInteger>(z2, vars.length, new TermOrder( 381 TermOrder.INVLEX), vars); 382 List<GenPolynomial<ModInteger>> fieldPolynomials = new ArrayList<GenPolynomial<ModInteger>>(); 383 384 //add v1^2 + v1, v2^2 + v2, v3^2 + v3 to fieldPolynomials 385 for (int i = 0; i < vars.length; i++) { 386 GenPolynomial<ModInteger> var = z2p.univariate(i); 387 fieldPolynomials.add(var.multiply(var).sum(var)); 388 } 389 390 391 Ideal<ModInteger> fieldPolys = new Ideal<ModInteger>(z2p, fieldPolynomials); 392 ResidueRing<ModInteger> ring = new ResidueRing<ModInteger>(fieldPolys); 393 String[] mvars = { "mv3", "mv2", "mv1" }; 394 GenPolynomialRing<Residue<ModInteger>> ringp = new GenPolynomialRing<Residue<ModInteger>>(ring, 395 mvars.length, mvars); 396 397 List<GenPolynomial<Residue<ModInteger>>> polynomials = new ArrayList<GenPolynomial<Residue<ModInteger>>>(); 398 399 GenPolynomial<Residue<ModInteger>> v1 = ringp.univariate(0); 400 GenPolynomial<Residue<ModInteger>> v2 = ringp.univariate(1); 401 GenPolynomial<Residue<ModInteger>> v3 = ringp.univariate(2); 402 GenPolynomial<Residue<ModInteger>> notV1 = v1.sum(ringp.ONE); 403 GenPolynomial<Residue<ModInteger>> notV2 = v2.sum(ringp.ONE); 404 GenPolynomial<Residue<ModInteger>> notV3 = v3.sum(ringp.ONE); 405 406 //v1*v2 407 GenPolynomial<Residue<ModInteger>> p1 = v1.multiply(v2); 408 409 //v1*v2 + v1 + v2 + 1 410 GenPolynomial<Residue<ModInteger>> p2 = notV1.multiply(notV2); 411 412 //v1*v3 + v1 + v3 + 1 413 GenPolynomial<Residue<ModInteger>> p3 = notV1.multiply(notV3); 414 415 polynomials.add(p1); 416 polynomials.add(p2); 417 polynomials.add(p3); 418 419 //GroebnerBase<Residue<ModInteger>> gb = new GroebnerBasePseudoSeq<Residue<ModInteger>>(ring); 420 GroebnerBase<Residue<ModInteger>> gb = GBFactory.getImplementation(ring); 421 List<GenPolynomial<Residue<ModInteger>>> G = gb.GB(polynomials); 422 423 System.out.println(G); 424 } 425 426 427 /** 428 * example8. Coefficients in Boolean residue class ring with cuppling of 429 * variables. 430 */ 431 public static void example8() { 432 String[] vars = { "v3", "v2", "v1" }; 433 434 ModIntegerRing z2 = new ModIntegerRing(2); 435 GenPolynomialRing<ModInteger> z2p = new GenPolynomialRing<ModInteger>(z2, vars.length, new TermOrder( 436 TermOrder.INVLEX), vars); 437 List<GenPolynomial<ModInteger>> fieldPolynomials = new ArrayList<GenPolynomial<ModInteger>>(); 438 439 //add v1^2 + v1, v2^2 + v2, v3^2 + v3 to fieldPolynomials 440 for (int i = 0; i < vars.length; i++) { 441 GenPolynomial<ModInteger> var = z2p.univariate(i); 442 fieldPolynomials.add(var.multiply(var).sum(var)); 443 } 444 445 446 Ideal<ModInteger> fieldPolys = new Ideal<ModInteger>(z2p, fieldPolynomials); 447 ResidueRing<ModInteger> ring = new ResidueRing<ModInteger>(fieldPolys); 448 String[] mvars = { "mv3", "mv2", "mv1" }; 449 GenPolynomialRing<Residue<ModInteger>> ringp = new GenPolynomialRing<Residue<ModInteger>>(ring, 450 mvars.length, mvars); 451 452 List<GenPolynomial<Residue<ModInteger>>> polynomials = new ArrayList<GenPolynomial<Residue<ModInteger>>>(); 453 454 GenPolynomial<Residue<ModInteger>> v1 = ringp.univariate(0); 455 GenPolynomial<Residue<ModInteger>> v2 = ringp.univariate(1); 456 GenPolynomial<Residue<ModInteger>> v3 = ringp.univariate(2); 457 GenPolynomial<Residue<ModInteger>> notV1 = v1.sum(ringp.ONE); 458 GenPolynomial<Residue<ModInteger>> notV2 = v2.sum(ringp.ONE); 459 GenPolynomial<Residue<ModInteger>> notV3 = v3.sum(ringp.ONE); 460 461 //v1*v2 462 GenPolynomial<Residue<ModInteger>> p1 = v1.multiply(v2); 463 464 //v1*v2 + v1 + v2 + 1 465 GenPolynomial<Residue<ModInteger>> p2 = notV1.multiply(notV2); 466 467 //v1*v3 + v1 + v3 + 1 468 GenPolynomial<Residue<ModInteger>> p3 = notV1.multiply(notV3); 469 470 polynomials.add(p1); 471 polynomials.add(p2); 472 polynomials.add(p3); 473 474 List<Residue<ModInteger>> gens = ring.generators(); 475 System.out.println("gens = " + gens); 476 GenPolynomial<Residue<ModInteger>> mv3v3 = v3.subtract(gens.get(1)); 477 GenPolynomial<Residue<ModInteger>> mv2v2 = v2.subtract(gens.get(2)); 478 GenPolynomial<Residue<ModInteger>> mv1v1 = v1.subtract(gens.get(3)); 479 480 System.out.println("mv3v3 = " + mv3v3); 481 System.out.println("mv2v2 = " + mv2v2); 482 System.out.println("mv1v1 = " + mv1v1); 483 484 polynomials.add(mv3v3); 485 polynomials.add(mv2v2); 486 polynomials.add(mv1v1); 487 488 //GroebnerBase<Residue<ModInteger>> gb = new GroebnerBasePseudoSeq<Residue<ModInteger>>(ring); 489 GroebnerBase<Residue<ModInteger>> gb = GBFactory.getImplementation(ring); 490 491 List<GenPolynomial<Residue<ModInteger>>> G = gb.GB(polynomials); 492 493 System.out.println(G); 494 } 495 496 497 /** 498 * example9. Groebner base and dimension. 499 */ 500 public static void example9() { 501 String[] vars = { "d1", "d2", "d3", "p1a", "p1b", "p1c", "p2a", "p2b", "p2c", "p3a", "p3b", "p3c", 502 "p4a", "p4b", "p4c", "A", "B", "C", "D" }; 503 504 BigRational br = new BigRational(); 505 GenPolynomialRing<BigRational> pring = new GenPolynomialRing<BigRational>(br, vars); 506 //GenPolynomialRing<BigRational> pring = new GenPolynomialRing<BigRational>(br, vars.length, new TermOrder(TermOrder.INVLEX), vars); 507 508 GenPolynomial<BigRational> e1 = pring.parse("A*p1a+B*p1b+C*p1c+D"); // (1) 509 GenPolynomial<BigRational> e2 = pring.parse("A*p2a+B*p2b+C*p2c+D"); // (2) 510 GenPolynomial<BigRational> e3 = pring.parse("A*p3a+B*p3b+C*p3c+D"); // (3) 511 GenPolynomial<BigRational> e4 = pring.parse("A*p4a+B*p4b+C*p4c+D"); // (4) 512 GenPolynomial<BigRational> e5 = pring.parse("p2a-p3a"); // (5) 513 GenPolynomial<BigRational> e6 = pring.parse("p2b-p3b"); // (6) 514 GenPolynomial<BigRational> e7 = pring.parse("p2c-p3c"); // (7) 515 GenPolynomial<BigRational> e8 = pring.parse("(p2a-p1a)^2+(p2b-p1b)^2+(p2c-p1c)^2-d1^2"); // (8) 516 GenPolynomial<BigRational> e9 = pring.parse("(p4a-p3a)^2+(p4b-p3b)^2+(p4c-p3c)^2-d2^2"); // (9) 517 518 List<GenPolynomial<BigRational>> cp = new ArrayList<GenPolynomial<BigRational>>(9); 519 cp.add(e1); 520 cp.add(e2); 521 cp.add(e3); 522 cp.add(e4); 523 cp.add(e5); 524 cp.add(e6); 525 cp.add(e7); 526 cp.add(e8); 527 cp.add(e9); 528 529 GenPolynomial<BigRational> e10 = pring.parse("(p4a-p1a)^2+(p4b-p1b)^2+(p4c-p1c)^2-d3^2"); // (10) 530 cp.add(e10); 531 532 List<GenPolynomial<BigRational>> gb; 533 GroebnerBase<BigRational> sgb = GBFactory.getImplementation(br); 534 gb = sgb.GB(cp); 535 //System.out.println("gb = " + gb); 536 537 PolynomialList<BigRational> pl = new PolynomialList<BigRational>(pring, gb); 538 Ideal<BigRational> id = new Ideal<BigRational>(pl, true); 539 System.out.println("cp = " + cp); 540 System.out.println("id = " + id); 541 542 Dimension dim = id.dimension(); 543 System.out.println("dim = " + dim); 544 } 545 546 547 /** 548 * example10. abstract types: GB of 549 * List<GenPolynomial<AlgebraicNumber<Quotient 550 * <AlgebraicNumber<BigRational>>>>>. 551 */ 552 public static void example10() { 553 Scripting.setLang(Scripting.Lang.Ruby); 554 BigRational bfac = new BigRational(1); 555 GenPolynomialRing<BigRational> pfac; 556 pfac = new GenPolynomialRing<BigRational>(bfac, new String[] { "w2" }); 557 System.out.println("pfac = " + pfac.toScript()); 558 559 // p = w2^2 - 2 560 GenPolynomial<BigRational> p = pfac.univariate(0, 2).subtract(pfac.fromInteger(2L)); 561 System.out.println("p = " + p.toScript()); 562 563 AlgebraicNumberRing<BigRational> afac; 564 afac = new AlgebraicNumberRing<BigRational>(p, true); 565 System.out.println("afac = " + afac.toScript()); 566 567 GenPolynomialRing<AlgebraicNumber<BigRational>> pafac; 568 pafac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(afac, new String[] { "x" }); 569 System.out.println("pafac = " + pafac.toScript()); 570 571 QuotientRing<AlgebraicNumber<BigRational>> qafac; 572 qafac = new QuotientRing<AlgebraicNumber<BigRational>>(pafac); 573 System.out.println("qafac = " + qafac.toScript()); 574 575 GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>> pqafac; 576 pqafac = new GenPolynomialRing<Quotient<AlgebraicNumber<BigRational>>>(qafac, new String[] { "wx" }); 577 System.out.println("pqafac = " + pqafac.toScript()); 578 List<GenPolynomial<Quotient<AlgebraicNumber<BigRational>>>> qgen = pqafac.generators(); 579 System.out.println("qgen = " + qgen); 580 581 // q = wx^2 - x 582 GenPolynomial<Quotient<AlgebraicNumber<BigRational>>> q; 583 q = pqafac.univariate(0, 2).subtract(qgen.get(2)); 584 System.out.println("q = " + q.toScript()); 585 586 AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>> aqafac; 587 aqafac = new AlgebraicNumberRing<Quotient<AlgebraicNumber<BigRational>>>(q, true); 588 System.out.println("aqafac = " + aqafac.toScript()); 589 590 GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> paqafac; 591 paqafac = new GenPolynomialRing<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>(aqafac, 592 new String[] { "y", "z" }); 593 System.out.println("paqafac = " + paqafac.toScript()); 594 595 List<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>> L; 596 L = new ArrayList<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>>(); 597 598 GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> pp; 599 /* 600 for (int i = 0; i < 2; i++) { 601 pp = paqafac.random(2, 3, 3, 0.2f); 602 System.out.println("pp = " + pp.toScript()); 603 if (pp.isConstant()) { 604 pp = paqafac.univariate(0,3); 605 } 606 L.add(pp); 607 } 608 */ 609 pp = paqafac.parse("(( y^2 - x )*( z^2 - 2 ) )"); 610 System.out.println("pp = " + pp.toScript()); 611 L.add(pp); 612 pp = paqafac.parse("( y^2 z - x^3 z - w2*wx )"); 613 System.out.println("pp = " + pp.toScript()); 614 L.add(pp); 615 //System.out.println("L = " + L); 616 617 GroebnerBaseAbstract<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> bb; 618 //bb = new GroebnerBaseSeq<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>(); //aqafac); 619 bb = GBFactory.getImplementation(aqafac); 620 //bb = GBFactory.getProxy(aqafac); 621 622 System.out.println("isGB(L) = " + bb.isGB(L)); 623 624 long t = System.currentTimeMillis(); 625 List<GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>>> G = bb.GB(L); 626 t = System.currentTimeMillis() - t; 627 System.out.println("time = " + t + " milliseconds"); 628 //System.out.println("G = " + G); 629 for (GenPolynomial<AlgebraicNumber<Quotient<AlgebraicNumber<BigRational>>>> g : G) { 630 System.out.println("g = " + g.toScript()); 631 } 632 System.out.println("isGB(G) = " + bb.isGB(G)); 633 bb.terminate(); 634 } 635 636 637 /** 638 * example11. abstract types: GB of List<GenPolynomial<BigRational>>>. 639 */ 640 public static void example11() { 641 Scripting.setLang(Scripting.Lang.Ruby); 642 BigRational bfac = new BigRational(1); 643 GenPolynomialRing<BigRational> pfac; 644 String[] vars = new String[] { "w2", "xi", "x", "wx", "y", "z" }; 645 TermOrder to = new TermOrder(TermOrder.INVLEX); 646 pfac = new GenPolynomialRing<BigRational>(bfac, vars, to); 647 System.out.println("pfac = " + pfac.toScript()); 648 649 List<GenPolynomial<BigRational>> L = new ArrayList<GenPolynomial<BigRational>>(); 650 GenPolynomial<BigRational> pp; 651 pp = pfac.parse("( w2^2 - 2 )"); 652 System.out.println("pp = " + pp.toScript()); 653 L.add(pp); 654 pp = pfac.parse("( wx^2 - x )"); 655 System.out.println("pp = " + pp.toScript()); 656 L.add(pp); 657 pp = pfac.parse("( xi * x - 1 )"); 658 System.out.println("pp = " + pp.toScript()); 659 L.add(pp); 660 pp = pfac.parse("(( y^2 - x )*( z^2 - 2 ) )"); 661 System.out.println("pp = " + pp.toScript()); 662 L.add(pp); 663 pp = pfac.parse("( y^2 z - x^3 z - w2*wx )"); 664 System.out.println("pp = " + pp.toScript()); 665 L.add(pp); 666 667 GroebnerBaseAbstract<BigRational> bb; 668 //bb = new GroebnerBaseSeq<BigRational>(); //bfac); 669 bb = GBFactory.getImplementation(bfac); 670 //bb = GBFactory.getProxy(bfac); 671 672 System.out.println("isGB(L) = " + bb.isGB(L)); 673 long t = System.currentTimeMillis(); 674 List<GenPolynomial<BigRational>> G = bb.GB(L); 675 t = System.currentTimeMillis() - t; 676 System.out.println("time = " + t + " milliseconds"); 677 for (GenPolynomial<BigRational> g : G) { 678 System.out.println("g = " + g.toScript()); 679 } 680 System.out.println("isGB(G) = " + bb.isGB(G)); 681 bb.terminate(); 682 } 683 684 685 /** 686 * example12. abstract types: GB of 687 * List<GenPolynomial<Quotient<BigRational>>>>. 688 */ 689 public static void example12() { 690 Scripting.setLang(Scripting.Lang.Ruby); 691 BigRational bfac = new BigRational(1); 692 GenPolynomialRing<BigRational> cfac; 693 String[] cvars = new String[] { "x" }; 694 TermOrder to = new TermOrder(TermOrder.INVLEX); 695 cfac = new GenPolynomialRing<BigRational>(bfac, cvars, to); 696 System.out.println("cfac = " + cfac.toScript()); 697 698 QuotientRing<BigRational> qfac; 699 qfac = new QuotientRing<BigRational>(cfac); 700 System.out.println("qfac = " + qfac.toScript()); 701 702 String[] vars = new String[] { "w2", "wx", "y", "z" }; 703 GenPolynomialRing<Quotient<BigRational>> pfac; 704 pfac = new GenPolynomialRing<Quotient<BigRational>>(qfac, vars, to); 705 System.out.println("pfac = " + pfac.toScript()); 706 707 List<GenPolynomial<Quotient<BigRational>>> L = new ArrayList<GenPolynomial<Quotient<BigRational>>>(); 708 GenPolynomial<Quotient<BigRational>> pp; 709 pp = pfac.parse("( w2^2 - 2 )"); 710 System.out.println("pp = " + pp.toScript()); 711 L.add(pp); 712 pp = pfac.parse("( wx^2 - x )"); 713 System.out.println("pp = " + pp.toScript()); 714 L.add(pp); 715 pp = pfac.parse("(( y^2 - x )*( z^2 - 2 ) )"); 716 System.out.println("pp = " + pp.toScript()); 717 L.add(pp); 718 pp = pfac.parse("( y^2 z - x^3 z - w2*wx )"); 719 System.out.println("pp = " + pp.toScript()); 720 L.add(pp); 721 722 GroebnerBaseAbstract<Quotient<BigRational>> bb; 723 //bb = new GroebnerBaseSeq<Quotient<BigRational>>(); //bfac); 724 725 // sequential 726 bb = GBFactory.getImplementation(qfac); 727 System.out.println("isGB(L) = " + bb.isGB(L)); 728 long t = System.currentTimeMillis(); 729 List<GenPolynomial<Quotient<BigRational>>> G = bb.GB(L); 730 t = System.currentTimeMillis() - t; 731 System.out.println("time = " + t + " milliseconds"); 732 for (GenPolynomial<Quotient<BigRational>> g : G) { 733 System.out.println("g = " + g.toScript()); 734 } 735 System.out.println("isGB(G) = " + bb.isGB(G)); 736 bb.terminate(); 737 738 // parallel 739 bb = GBFactory.getProxy(qfac); 740 System.out.println("isGB(L) = " + bb.isGB(L)); 741 t = System.currentTimeMillis(); 742 G = bb.GB(L); 743 t = System.currentTimeMillis() - t; 744 System.out.println("time = " + t + " milliseconds"); 745 for (GenPolynomial<Quotient<BigRational>> g : G) { 746 System.out.println("g = " + g.toScript()); 747 } 748 System.out.println("isGB(G) = " + bb.isGB(G)); 749 bb.terminate(); 750 751 // builder 752 bb = GBAlgorithmBuilder.polynomialRing(pfac).fractionFree().syzygyPairlist().parallel(3).build(); 753 System.out.println("isGB(L) = " + bb.isGB(L)); 754 t = System.currentTimeMillis(); 755 G = bb.GB(L); 756 t = System.currentTimeMillis() - t; 757 System.out.println("time = " + t + " milliseconds"); 758 for (GenPolynomial<Quotient<BigRational>> g : G) { 759 System.out.println("g = " + g.toScript()); 760 } 761 System.out.println("isGB(G) = " + bb.isGB(G)); 762 bb.terminate(); 763 } 764}