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