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