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