001/* 002 * $Id$ 003 */ 004 005package edu.jas.application; 006 007 008import java.util.ArrayList; 009import java.util.Arrays; 010import java.util.List; 011 012import org.apache.logging.log4j.LogManager; 013import org.apache.logging.log4j.Logger; 014 015import edu.jas.arith.BigDecimal; 016import edu.jas.arith.BigRational; 017import edu.jas.arith.ModInteger; 018import edu.jas.arith.ModIntegerRing; 019import edu.jas.gb.GroebnerBase; 020import edu.jas.gbufd.GBFactory; 021import edu.jas.kern.ComputerThreads; 022import edu.jas.poly.Complex; 023import edu.jas.poly.ComplexRing; 024import edu.jas.poly.GenPolynomial; 025import edu.jas.poly.GenPolynomialRing; 026import edu.jas.poly.PolyUtil; 027import edu.jas.poly.PolynomialList; 028import edu.jas.poly.TermOrder; 029import edu.jas.ufd.Quotient; 030import edu.jas.util.KsubSet; 031 032import junit.framework.Test; 033import junit.framework.TestCase; 034import junit.framework.TestSuite; 035 036 037/** 038 * Ideal tests with JUnit. 039 * @author Heinz Kredel 040 */ 041public class IdealTest extends TestCase { 042 043 044 private static final Logger logger = LogManager.getLogger(IdealTest.class); 045 046 047 /** 048 * main 049 */ 050 public static void main(String[] args) { 051 junit.textui.TestRunner.run(suite()); 052 } 053 054 055 /** 056 * Constructs a <CODE>IdealTest</CODE> object. 057 * @param name String. 058 */ 059 public IdealTest(String name) { 060 super(name); 061 } 062 063 064 /** 065 * suite. 066 */ 067 public static Test suite() { 068 TestSuite suite = new TestSuite(IdealTest.class); 069 return suite; 070 } 071 072 073 TermOrder to; 074 075 076 GenPolynomialRing<BigRational> fac; 077 078 079 List<GenPolynomial<BigRational>> L, M, G; 080 081 082 PolynomialList<BigRational> F; 083 084 085 GroebnerBase<BigRational> bb; 086 087 088 GenPolynomial<BigRational> a, b, c, d, e; 089 090 091 int rl = 3; //4; //3; 092 093 094 int kl = 4; //10 095 096 097 int ll = 5; //7 098 099 100 int el = 3; 101 102 103 float q = 0.2f; //0.4f 104 105 106 @Override 107 protected void setUp() { 108 BigRational coeff = new BigRational(17, 1); 109 to = new TermOrder( /*TermOrder.INVLEX*/); 110 String[] vars = new String[] { "x", "y", "z" }; 111 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 112 //bb = new GroebnerBaseSeq<BigRational>(); 113 bb = GBFactory.getImplementation(coeff); 114 a = b = c = d = e = null; 115 } 116 117 118 @Override 119 protected void tearDown() { 120 a = b = c = d = e = null; 121 fac = null; 122 bb = null; 123 ComputerThreads.terminate(); 124 } 125 126 127 /** 128 * Test Ideal sum. 129 */ 130 public void testIdealSum() { 131 Ideal<BigRational> I, J, K; 132 133 L = new ArrayList<GenPolynomial<BigRational>>(); 134 135 a = fac.random(kl, ll, el, q); 136 b = fac.random(kl, ll, el, q); 137 c = fac.random(kl, ll, el, q); 138 d = fac.random(kl, ll, el, q); 139 e = d; //fac.random(kl, ll, el, q ); 140 141 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 142 return; 143 } 144 145 assertTrue("not isZERO( a )", !a.isZERO()); 146 L.add(a); 147 148 I = new Ideal<BigRational>(fac, L, true); 149 assertTrue("not isZERO( I )", !I.isZERO()); 150 assertTrue("not isONE( I )", !I.isONE()); 151 assertTrue("isGB( I )", I.isGB()); 152 153 I = new Ideal<BigRational>(fac, L, false); 154 assertTrue("not isZERO( I )", !I.isZERO()); 155 assertTrue("not isONE( I )", !I.isONE()); 156 assertTrue("isGB( I )", I.isGB()); 157 158 159 L = bb.GB(L); 160 assertTrue("isGB( { a } )", bb.isGB(L)); 161 162 I = new Ideal<BigRational>(fac, L, true); 163 assertTrue("not isZERO( I )", !I.isZERO()); 164 //assertTrue("not isONE( I )", !I.isONE() ); 165 assertTrue("isGB( I )", I.isGB()); 166 167 I = new Ideal<BigRational>(fac, L, false); 168 assertTrue("not isZERO( I )", !I.isZERO()); 169 //assertTrue("not isONE( I )", !I.isONE() ); 170 assertTrue("isGB( I )", I.isGB()); 171 172 String s = I.toScript() + "\n" + I.toString(); 173 //System.out.println("#s = " + s.length() + ": " + s); 174 assertTrue("#s >= 90: ", s.length() >= 90); 175 176 K = I.getZERO(); 177 assertTrue("K == 0: " + K, K.isZERO()); 178 K = I.getONE(); 179 assertTrue("K == 1: " + K, K.isONE()); 180 181 182 assertTrue("not isZERO( b )", !b.isZERO()); 183 L.add(b); 184 //System.out.println("L = " + L.size() ); 185 186 I = new Ideal<BigRational>(fac, L, false); 187 assertTrue("not isZERO( I )", !I.isZERO()); 188 //assertTrue("not isONE( I )", !I.isONE() ); 189 //assertTrue("not isGB( I )", !I.isGB() ); 190 191 192 L = bb.GB(L); 193 assertTrue("isGB( { a, b } )", bb.isGB(L)); 194 195 I = new Ideal<BigRational>(fac, L, true); 196 assertTrue("not isZERO( I )", !I.isZERO()); 197 // assertTrue("not isONE( I )", !I.isONE() ); 198 assertTrue("isGB( I )", I.isGB()); 199 200 201 J = I; 202 K = J.sum(I); 203 assertTrue("not isZERO( K )", !K.isZERO()); 204 assertTrue("isGB( K )", K.isGB()); 205 assertTrue("equals( K, I )", K.equals(I)); 206 207 208 L = new ArrayList<GenPolynomial<BigRational>>(); 209 assertTrue("not isZERO( c )", !c.isZERO()); 210 L.add(c); 211 assertTrue("isGB( { c } )", bb.isGB(L)); 212 213 J = new Ideal<BigRational>(fac, L, true); 214 K = J.sum(I); 215 assertTrue("not isZERO( K )", !K.isZERO()); 216 assertTrue("isGB( K )", K.isGB()); 217 assertTrue("K contains(I)", K.contains(I)); 218 assertTrue("K contains(J)", K.contains(J)); 219 220 L = new ArrayList<GenPolynomial<BigRational>>(); 221 assertTrue("not isZERO( d )", !d.isZERO()); 222 L.add(d); 223 224 assertTrue("isGB( { d } )", bb.isGB(L)); 225 J = new Ideal<BigRational>(fac, L, true); 226 I = K; 227 K = J.sum(I); 228 assertTrue("not isZERO( K )", !K.isZERO()); 229 assertTrue("isGB( K )", K.isGB()); 230 assertTrue("K contains(I)", K.contains(I)); 231 assertTrue("K contains(J)", K.contains(J)); 232 233 234 L = new ArrayList<GenPolynomial<BigRational>>(); 235 assertTrue("not isZERO( e )", !e.isZERO()); 236 L.add(e); 237 238 assertTrue("isGB( { e } )", bb.isGB(L)); 239 J = new Ideal<BigRational>(fac, L, true); 240 I = K; 241 K = J.sum(I); 242 assertTrue("not isZERO( K )", !K.isZERO()); 243 assertTrue("isGB( K )", K.isGB()); 244 assertTrue("equals( K, I )", K.equals(I)); 245 assertTrue("K contains(J)", K.contains(I)); 246 assertTrue("I contains(K)", I.contains(K)); 247 } 248 249 250 /** 251 * Test Ideal product. 252 */ 253 public void testIdealProduct() { 254 Ideal<BigRational> I, J, K, H; 255 256 a = fac.random(kl, ll, el, q); 257 b = fac.random(kl, ll, el, q); 258 c = fac.random(kl, ll, el, q); 259 d = fac.random(kl, ll, el, q); 260 e = d; //fac.random(kl, ll, el, q ); 261 262 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 263 return; 264 } 265 266 L = new ArrayList<GenPolynomial<BigRational>>(); 267 assertTrue("not isZERO( a )", !a.isZERO()); 268 L.add(a); 269 270 I = new Ideal<BigRational>(fac, L, true); 271 assertTrue("not isZERO( I )", !I.isZERO()); 272 assertTrue("not isONE( I )", !I.isONE()); 273 assertTrue("isGB( I )", I.isGB()); 274 275 L = new ArrayList<GenPolynomial<BigRational>>(); 276 assertTrue("not isZERO( b )", !a.isZERO()); 277 L.add(b); 278 279 J = new Ideal<BigRational>(fac, L, true); 280 assertTrue("not isZERO( J )", !J.isZERO()); 281 assertTrue("not isONE( J )", !J.isONE()); 282 assertTrue("isGB( J )", J.isGB()); 283 284 K = I.product(J); 285 assertTrue("not isZERO( K )", !K.isZERO()); 286 assertTrue("isGB( K )", K.isGB()); 287 assertTrue("I contains(K)", I.contains(K)); 288 assertTrue("J contains(K)", J.contains(K)); 289 290 H = I.intersect(J); 291 assertTrue("not isZERO( H )", !H.isZERO()); 292 assertTrue("isGB( H )", H.isGB()); 293 assertTrue("I contains(H)", I.contains(H)); 294 assertTrue("J contains(H)", J.contains(H)); 295 assertTrue("H contains(K)", H.contains(K)); 296 //if (false /*! H.equals(K)*/) { 297 // System.out.println("I = " + I); 298 // System.out.println("J = " + J); 299 // System.out.println("K = " + K); 300 // System.out.println("H = " + H); 301 //} 302 303 304 L = new ArrayList<GenPolynomial<BigRational>>(); 305 assertTrue("not isZERO( a )", !a.isZERO()); 306 L.add(a); 307 assertTrue("not isZERO( c )", !c.isZERO()); 308 L.add(c); 309 L = bb.GB(L); 310 311 I = new Ideal<BigRational>(fac, L, true); 312 assertTrue("not isZERO( I )", !I.isZERO()); 313 //assertTrue("not isONE( I )", !I.isONE() ); 314 assertTrue("isGB( I )", I.isGB()); 315 316 K = I.product(J); 317 assertTrue("not isZERO( K )", !K.isZERO()); 318 assertTrue("isGB( K )", K.isGB()); 319 assertTrue("I contains(K)", I.contains(K)); 320 assertTrue("J contains(K)", J.contains(K)); 321 322 H = I.intersect(J); 323 assertTrue("not isZERO( H )", !H.isZERO()); 324 assertTrue("isGB( H )", H.isGB()); 325 assertTrue("I contains(H)", I.contains(H)); 326 assertTrue("J contains(H)", J.contains(H)); 327 assertTrue("H contains(K)", H.contains(K)); 328 //if (false /*! H.equals(K)*/) { 329 // System.out.println("I = " + I); 330 // System.out.println("J = " + J); 331 // System.out.println("K = " + K); 332 // System.out.println("H = " + H); 333 //} 334 335 336 L = new ArrayList<GenPolynomial<BigRational>>(); 337 assertTrue("not isZERO( b )", !b.isZERO()); 338 L.add(b); 339 assertTrue("not isZERO( d )", !d.isZERO()); 340 L.add(d); 341 L = bb.GB(L); 342 343 J = new Ideal<BigRational>(fac, L, true); 344 assertTrue("not isZERO( J )", !J.isZERO()); 345 //assertTrue("not isONE( J )", !J.isONE() ); 346 assertTrue("isGB( J )", J.isGB()); 347 348 K = I.product(J); 349 assertTrue("not isZERO( K )", !K.isZERO()); 350 assertTrue("isGB( K )", K.isGB()); 351 assertTrue("I contains(K)", I.contains(K)); 352 assertTrue("J contains(K)", J.contains(K)); 353 354 H = I.intersect(J); 355 assertTrue("not isZERO( H )", !H.isZERO()); 356 assertTrue("isGB( H )", H.isGB()); 357 assertTrue("I contains(H)", I.contains(H)); 358 assertTrue("J contains(H)", J.contains(H)); 359 assertTrue("H contains(K)", H.contains(K)); 360 //if (false /*! H.equals(K)*/) { 361 // System.out.println("I = " + I); 362 // System.out.println("J = " + J); 363 // System.out.println("K = " + K); 364 // System.out.println("H = " + H); 365 //} 366 } 367 368 369 /** 370 * Test Ideal quotient. 371 */ 372 public void testIdealQuotient() { 373 Ideal<BigRational> I, J, K, H; 374 375 a = fac.random(kl, ll, el, q); 376 b = fac.random(kl, ll, el, q); 377 c = fac.random(kl, ll, el, q); 378 d = fac.random(kl, ll, el, q); 379 e = d; //fac.random(kl, ll, el, q ); 380 381 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 382 return; 383 } 384 385 L = new ArrayList<GenPolynomial<BigRational>>(); 386 assertTrue("not isZERO( a )", !a.isZERO()); 387 L.add(a); 388 L = bb.GB(L); 389 390 I = new Ideal<BigRational>(fac, L, true); 391 assertTrue("not isZERO( I )", !I.isZERO()); 392 //assertTrue("not isONE( I )", !I.isONE() ); 393 assertTrue("isGB( I )", I.isGB()); 394 395 396 L = new ArrayList<GenPolynomial<BigRational>>(); 397 assertTrue("not isZERO( b )", !a.isZERO()); 398 L.add(b); 399 L = bb.GB(L); 400 401 J = new Ideal<BigRational>(fac, L, true); 402 assertTrue("not isZERO( J )", !J.isZERO()); 403 //assertTrue("not isONE( J )", !J.isONE() ); 404 assertTrue("isGB( J )", J.isGB()); 405 406 K = I.product(J); 407 assertTrue("not isZERO( K )", !K.isZERO()); 408 assertTrue("isGB( K )", K.isGB()); 409 assertTrue("I contains(K)", I.contains(K)); 410 assertTrue("J contains(K)", J.contains(K)); 411 412 H = K.quotient(J.getList().get(0)); 413 assertTrue("not isZERO( H )", !H.isZERO()); 414 assertTrue("isGB( H )", H.isGB()); 415 assertTrue("equals(H,I)", H.equals(I)); // GBs only 416 417 H = K.quotient(J); 418 assertTrue("not isZERO( H )", !H.isZERO()); 419 assertTrue("isGB( H )", H.isGB()); 420 assertTrue("equals(H,I)", H.equals(I)); // GBs only 421 422 423 L = new ArrayList<GenPolynomial<BigRational>>(); 424 assertTrue("not isZERO( b )", !b.isZERO()); 425 L.add(b); 426 assertTrue("not isZERO( c )", !c.isZERO()); 427 L.add(c); 428 L = bb.GB(L); 429 430 J = new Ideal<BigRational>(fac, L, true); 431 assertTrue("not isZERO( J )", !J.isZERO()); 432 //assertTrue("not isONE( J )", !J.isONE() ); 433 assertTrue("isGB( J )", J.isGB()); 434 435 K = I.product(J); 436 assertTrue("not isZERO( K )", !K.isZERO()); 437 assertTrue("isGB( K )", K.isGB()); 438 assertTrue("I contains(K)", I.contains(K)); 439 assertTrue("J contains(K)", J.contains(K)); 440 441 H = K.quotient(J); 442 assertTrue("not isZERO( H )", !H.isZERO()); 443 assertTrue("isGB( H )", H.isGB()); 444 assertTrue("equals(H,I)", H.equals(I)); // GBs only 445 446 447 L = new ArrayList<GenPolynomial<BigRational>>(); 448 assertTrue("not isZERO( a )", !a.isZERO()); 449 L.add(a); 450 assertTrue("not isZERO( d )", !d.isZERO()); 451 L.add(d); 452 L = bb.GB(L); 453 454 I = new Ideal<BigRational>(fac, L, true); 455 assertTrue("not isZERO( I )", !I.isZERO()); 456 //assertTrue("not isONE( J )", !J.isONE() ); 457 assertTrue("isGB( I )", I.isGB()); 458 459 K = I.product(J); 460 assertTrue("not isZERO( K )", !K.isZERO()); 461 assertTrue("isGB( K )", K.isGB()); 462 assertTrue("I contains(K)", I.contains(K)); 463 assertTrue("J contains(K)", J.contains(K)); 464 465 H = K.quotient(J); 466 assertTrue("not isZERO( H )", !H.isZERO()); 467 assertTrue("isGB( H )", H.isGB()); 468 assertTrue("equals(H,I)", H.equals(I)); // GBs only 469 } 470 471 472 /** 473 * Test Ideal infinite quotient. 474 */ 475 public void testIdealInfiniteQuotient() { 476 Ideal<BigRational> I, J, K; 477 478 a = fac.random(kl, ll, el, q); 479 b = fac.random(kl, ll, el, q); 480 c = fac.random(kl, ll, el, q); 481 d = fac.random(kl, ll, el, q); 482 e = d; //fac.random(kl, ll, el, q ); 483 484 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 485 return; 486 } 487 488 L = new ArrayList<GenPolynomial<BigRational>>(); 489 assertTrue("not isZERO( b )", !b.isZERO()); 490 L.add(b); 491 L = bb.GB(L); 492 I = new Ideal<BigRational>(fac, L, true); 493 assertTrue("not isZERO( I )", !I.isZERO()); 494 //assertTrue("not isONE( I )", !I.isONE() ); 495 assertTrue("isGB( I )", I.isGB()); 496 497 J = I.infiniteQuotient(a); 498 499 assertTrue("not isZERO( c )", !c.isZERO()); 500 L.add(c); 501 L = bb.GB(L); 502 I = new Ideal<BigRational>(fac, L, true); 503 assertTrue("not isZERO( I )", !I.isZERO()); 504 //assertTrue("not isONE( I )", !I.isONE() ); 505 assertTrue("isGB( I )", I.isGB()); 506 507 J = I.infiniteQuotient(a); 508 assertTrue("equals(J,I)", J.equals(I)); // GBs only 509 510 assertTrue("not isZERO( d )", !d.isZERO()); 511 L.add(d); 512 L = bb.GB(L); 513 I = new Ideal<BigRational>(fac, L, true); 514 assertTrue("not isZERO( I )", !I.isZERO()); 515 //assertTrue("not isONE( I )", !I.isONE() ); 516 assertTrue("isGB( I )", I.isGB()); 517 518 J = I.infiniteQuotient(a); 519 assertTrue("isGB( J )", J.isGB()); 520 assertTrue("equals(J,I)", J.equals(I)); // GBs only 521 522 523 G = new ArrayList<GenPolynomial<BigRational>>(); 524 assertTrue("not isZERO( a )", !a.isZERO()); 525 G.add(a); 526 G = bb.GB(G); 527 K = new Ideal<BigRational>(fac, G, true); 528 assertTrue("not isZERO( K )", !K.isZERO()); 529 //assertTrue("not isONE( I )", !I.isONE() ); 530 assertTrue("isGB( K )", K.isGB()); 531 532 J = I.infiniteQuotient(K); 533 assertTrue("equals(J,I)", J.equals(I)); // GBs only 534 535 536 assertTrue("not isZERO( e )", !e.isZERO()); 537 G.add(e); 538 G = bb.GB(G); 539 K = new Ideal<BigRational>(fac, G, true); 540 assertTrue("not isZERO( K )", !K.isZERO()); 541 //assertTrue("not isONE( I )", !I.isONE() ); 542 assertTrue("isGB( K )", K.isGB()); 543 544 J = I.infiniteQuotient(K); 545 assertTrue("equals(J,I)", J.equals(I)); // GBs only 546 } 547 548 549 /** 550 * Test Ideal infinite quotient with Rabinowich trick. 551 */ 552 public void testIdealInfiniteQuotientRabi() { 553 Ideal<BigRational> I; 554 Ideal<BigRational> J; 555 Ideal<BigRational> K; 556 Ideal<BigRational> JJ; 557 558 a = fac.random(kl - 1, ll - 1, el - 1, q / 2); 559 b = fac.random(kl - 1, ll - 1, el, q / 2); 560 c = fac.random(kl - 1, ll - 1, el, q / 2); 561 d = fac.random(kl - 1, ll - 1, el, q / 2); 562 e = a; //fac.random(kl, ll-1, el, q ); 563 564 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 565 return; 566 } 567 568 L = new ArrayList<GenPolynomial<BigRational>>(); 569 assertTrue("not isZERO( b )", !b.isZERO()); 570 L.add(b); 571 L = bb.GB(L); 572 I = new Ideal<BigRational>(fac, L, true); 573 assertTrue("not isZERO( I )", !I.isZERO()); 574 //assertTrue("not isONE( I )", !I.isONE() ); 575 assertTrue("isGB( I )", I.isGB()); 576 577 J = I.infiniteQuotientRab(a); 578 JJ = I.infiniteQuotient(a); 579 assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only 580 581 assertTrue("not isZERO( c )", !c.isZERO()); 582 L.add(c); 583 L = bb.GB(L); 584 I = new Ideal<BigRational>(fac, L, true); 585 assertTrue("not isZERO( I )", !I.isZERO()); 586 //assertTrue("not isONE( I )", !I.isONE() ); 587 assertTrue("isGB( I )", I.isGB()); 588 589 J = I.infiniteQuotientRab(a); 590 assertTrue("equals(J,I)", J.equals(I)); // GBs only 591 JJ = I.infiniteQuotient(a); 592 assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only 593 594 assertTrue("not isZERO( d )", !d.isZERO()); 595 L.add(d); 596 L = bb.GB(L); 597 I = new Ideal<BigRational>(fac, L, true); 598 assertTrue("not isZERO( I )", !I.isZERO()); 599 //assertTrue("not isONE( I )", !I.isONE() ); 600 assertTrue("isGB( I )", I.isGB()); 601 602 J = I.infiniteQuotientRab(a); 603 assertTrue("isGB( J )", J.isGB()); 604 assertTrue("equals(J,I)", J.equals(I)); // GBs only 605 JJ = I.infiniteQuotient(a); 606 assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only 607 608 609 G = new ArrayList<GenPolynomial<BigRational>>(); 610 assertTrue("not isZERO( a )", !a.isZERO()); 611 G.add(a); 612 G = bb.GB(G); 613 K = new Ideal<BigRational>(fac, G, true); 614 assertTrue("not isZERO( K )", !K.isZERO()); 615 //assertTrue("not isONE( I )", !I.isONE() ); 616 assertTrue("isGB( K )", K.isGB()); 617 618 J = I.infiniteQuotientRab(K); 619 assertTrue("equals(J,I)", J.equals(I)); // GBs only 620 JJ = I.infiniteQuotient(a); 621 assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only 622 623 624 assertTrue("not isZERO( e )", !e.isZERO()); 625 G.add(e); 626 G = bb.GB(G); 627 K = new Ideal<BigRational>(fac, G, true); 628 assertTrue("not isZERO( K )", !K.isZERO()); 629 //assertTrue("not isONE( I )", !I.isONE() ); 630 assertTrue("isGB( K )", K.isGB()); 631 632 J = I.infiniteQuotientRab(K); 633 assertTrue("equals(J,I)", J.equals(I)); // GBs only 634 JJ = I.infiniteQuotient(a); 635 assertTrue("equals(J,JJ)", J.equals(JJ)); // GBs only 636 } 637 638 639 /** 640 * Test Ideal radical membership. 641 */ 642 public void testIdealRadicalMember() { 643 Ideal<BigRational> I; 644 645 a = fac.random(kl - 1, ll, el - 1, q); 646 b = fac.random(kl - 1, ll, el, q); 647 c = fac.random(kl - 1, ll - 1, el, q / 2); 648 d = fac.random(kl - 1, ll - 1, el, q / 2); 649 e = a; //fac.random(kl, ll-1, el, q ); 650 651 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 652 return; 653 } 654 655 L = new ArrayList<GenPolynomial<BigRational>>(); 656 L.add(b); 657 L = bb.GB(L); 658 I = new Ideal<BigRational>(fac, L, true); 659 assertTrue("not isZERO( I )", !I.isZERO()); 660 //assertTrue("not isONE( I )", !I.isONE() ); 661 assertTrue("isGB( I )", I.isGB()); 662 663 //System.out.println("a = " + a); 664 //System.out.println("b = " + b); 665 //System.out.println("I = " + I); 666 667 if (!I.isONE()) { 668 assertFalse("a in radical(b)", I.isRadicalMember(a)); 669 assertTrue("b in radical(b)", I.isRadicalMember(b)); 670 } 671 672 L = new ArrayList<GenPolynomial<BigRational>>(); 673 L.add(b.multiply(b)); 674 L = bb.GB(L); 675 I = new Ideal<BigRational>(fac, L, true); 676 assertTrue("not isZERO( I )", !I.isZERO()); 677 //assertTrue("not isONE( I )", !I.isONE() ); 678 assertTrue("isGB( I )", I.isGB()); 679 680 //System.out.println("I = " + I); 681 682 if (!I.isONE()) { 683 assertFalse("a in radical(b*b)", I.isRadicalMember(a)); 684 assertTrue("b in radical(b*b)", I.isRadicalMember(b)); 685 } 686 687 //System.out.println("c = " + c); 688 L.add(c); 689 L = bb.GB(L); 690 I = new Ideal<BigRational>(fac, L, true); 691 assertTrue("not isZERO( I )", !I.isZERO()); 692 //assertTrue("not isONE( I )", !I.isONE() ); 693 assertTrue("isGB( I )", I.isGB()); 694 695 //System.out.println("I = " + I); 696 697 if (!I.isONE()) { 698 assertFalse("a in radical(b*b)", I.isRadicalMember(a)); 699 assertTrue("b in radical(b*b)", I.isRadicalMember(b)); 700 } 701 } 702 703 704 /** 705 * Test Ideal common zeros. 706 */ 707 @SuppressWarnings("unchecked") 708 public void testIdealCommonZeros() { 709 Ideal<BigRational> I; 710 L = new ArrayList<GenPolynomial<BigRational>>(); 711 712 I = new Ideal<BigRational>(fac, L, true); 713 assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1); 714 715 a = fac.getZERO(); 716 L.add(a); 717 I = new Ideal<BigRational>(fac, L, true); 718 assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1); 719 720 b = fac.getONE(); 721 L.add(b); 722 I = new Ideal<BigRational>(fac, L, true); 723 assertEquals("commonZeroTest( I )", I.commonZeroTest(), -1); 724 725 L = new ArrayList<GenPolynomial<BigRational>>(); 726 a = fac.random(kl, ll, el, q); 727 if (!a.isZERO() && !a.isConstant()) { 728 L.add(a); 729 I = new Ideal<BigRational>(fac, L, true); 730 assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1); 731 } 732 733 L = (List<GenPolynomial<BigRational>>) fac.univariateList(); 734 I = new Ideal<BigRational>(fac, L, true); 735 assertEquals("commonZeroTest( I )", I.commonZeroTest(), 0); 736 737 L.remove(0); 738 I = new Ideal<BigRational>(fac, L, true); 739 assertEquals("commonZeroTest( I )", I.commonZeroTest(), 1); 740 } 741 742 743 /** 744 * Test Ideal dimension. 745 */ 746 @SuppressWarnings("unchecked") 747 public void testIdealDimension() { 748 Ideal<BigRational> I; 749 L = new ArrayList<GenPolynomial<BigRational>>(); 750 Dimension dim; 751 752 I = new Ideal<BigRational>(fac, L, true); 753 assertEquals("dimension( I )", rl, I.dimension().d); 754 755 a = fac.getZERO(); 756 L.add(a); 757 I = new Ideal<BigRational>(fac, L, true); 758 assertEquals("dimension( I )", rl, I.dimension().d); 759 760 b = fac.getONE(); 761 L.add(b); 762 I = new Ideal<BigRational>(fac, L, true); 763 assertEquals("dimension( I )", -1, I.dimension().d); 764 765 L = new ArrayList<GenPolynomial<BigRational>>(); 766 a = fac.random(kl, ll, el, q); 767 if (!a.isZERO() && !a.isConstant()) { 768 L.add(a); 769 I = new Ideal<BigRational>(fac, L, true); 770 //System.out.println("a = " + a); 771 dim = I.dimension(); 772 //System.out.println("dim(I) = " + dim); 773 assertTrue("dimension( I )", dim.d >= 1); 774 } 775 776 L = (List<GenPolynomial<BigRational>>) fac.univariateList(); 777 I = new Ideal<BigRational>(fac, L, true); 778 dim = I.dimension(); 779 assertEquals("dimension( I )", 0, dim.d); 780 781 while (L.size() > 0) { 782 L.remove(0); 783 I = new Ideal<BigRational>(fac, L, true); 784 //System.out.println("I = " + I); 785 dim = I.dimension(); 786 //System.out.println("dim(I) = " + dim); 787 assertEquals("dimension( I )", rl - L.size(), dim.d); 788 } 789 790 L = (List<GenPolynomial<BigRational>>) fac.univariateList(); 791 I = new Ideal<BigRational>(fac, L, true); 792 I = I.product(I); 793 //System.out.println("I = " + I); 794 dim = I.dimension(); 795 //System.out.println("dim(I) = " + dim); 796 assertEquals("dimension( I )", 0, dim.d); 797 798 L = I.getList(); 799 while (L.size() > 0) { 800 L.remove(0); 801 I = new Ideal<BigRational>(fac, L, true); 802 //System.out.println("I = " + I); 803 dim = I.dimension(); 804 //System.out.println("dim(I) = " + dim); 805 assertTrue("dimension( I )", dim.d > 0); 806 } 807 } 808 809 810 /** 811 * Test Ideal term order optimization. 812 */ 813 public void testIdealTopt() { 814 Ideal<BigRational> I, J, K; 815 816 L = new ArrayList<GenPolynomial<BigRational>>(); 817 818 a = fac.random(kl, ll, el, q); 819 b = fac.random(kl, ll, el, q); 820 c = fac.random(kl, ll, el, q); 821 d = fac.random(kl, ll, el, q); 822 e = d; //fac.random(kl, ll, el, q ); 823 824 if (a.isZERO() || b.isZERO() || c.isZERO() || d.isZERO()) { 825 return; 826 } 827 828 assertTrue("not isZERO( a )", !a.isZERO()); 829 L.add(a); 830 831 I = new Ideal<BigRational>(fac, L); 832 I.doGB(); 833 assertTrue("not isZERO( I )", !I.isZERO()); 834 assertTrue("isGB( I )", I.isGB()); 835 //System.out.println("I = " + I); 836 837 J = I.copy(); //new Ideal<BigRational>(fac,L); 838 J.doToptimize(); 839 assertTrue("not isZERO( J )", !J.isZERO()); 840 assertTrue("isGB( J )", J.isGB()); 841 //System.out.println("J = " + J); 842 843 if (I.isONE()) { 844 return; 845 } 846 847 assertTrue("not isZERO( b )", !b.isZERO()); 848 L.add(b); 849 850 I = new Ideal<BigRational>(fac, L); 851 K = I.copy(); 852 I.doGB(); 853 assertTrue("not isZERO( I )", !I.isZERO()); 854 assertTrue("isGB( I )", I.isGB()); 855 //System.out.println("GB(I) = " + I); 856 857 K.doToptimize(); 858 K.doGB(); 859 assertTrue("not isZERO( K )", !K.isZERO()); 860 assertTrue("isGB( K )", K.isGB()); 861 //System.out.println("GB(opt(K)) = " + K); 862 863 J = I.copy(); 864 J.doToptimize(); 865 assertTrue("not isZERO( J )", !J.isZERO()); 866 assertTrue("isGB( J )", J.isGB()); 867 //System.out.println("opt(GB(J)) = " + J); 868 869 if (I.isONE()) { 870 return; 871 } 872 873 assertTrue("not isZERO( c )", !c.isZERO()); 874 L.add(c); 875 876 I = new Ideal<BigRational>(fac, L); 877 K = I.copy(); 878 I.doGB(); 879 assertTrue("not isZERO( I )", !I.isZERO()); 880 assertTrue("isGB( I )", I.isGB()); 881 //System.out.println("GB(I) = " + I); 882 883 K.doToptimize(); 884 K.doGB(); 885 assertTrue("not isZERO( K )", !K.isZERO()); 886 assertTrue("isGB( K )", K.isGB()); 887 //System.out.println("GB(opt(K)) = " + K); 888 889 J = I.copy(); 890 J.doToptimize(); 891 assertTrue("not isZERO( J )", !J.isZERO()); 892 assertTrue("isGB( J )", J.isGB()); 893 //System.out.println("opt(GB(J)) = " + J); 894 } 895 896 897 /** 898 * Test elimination Ideals. 899 */ 900 public void testElimIdeal() { 901 String[] vars = fac.getVars(); 902 //System.out.println("vars = " + Arrays.toString(vars)); 903 //System.out.println("fac = " + fac); 904 905 Ideal<BigRational> I, J; 906 907 L = new ArrayList<GenPolynomial<BigRational>>(); 908 909 a = fac.univariate(2, 3L); //fac.random(kl, ll, el, q ); 910 b = fac.univariate(1, 2L); //fac.random(kl, ll, el, q ); 911 c = fac.univariate(0, 1L); //fac.random(kl, ll, el, q ); 912 913 if (a.isZERO() || b.isZERO() || c.isZERO()) { 914 return; 915 } 916 917 L.add(a); 918 L.add(b); 919 L.add(c); 920 921 I = new Ideal<BigRational>(fac, L); 922 //I.doGB(); 923 assertTrue("not isZERO( I )", !I.isZERO()); 924 assertTrue("isGB( I )", I.isGB()); 925 //System.out.println("I = " + I); 926 927 List<String> sv = new ArrayList<String>(vars.length); 928 for (int i = 0; i < vars.length; i++) { 929 sv.add(vars[i]); 930 } 931 //System.out.println("sv = " + sv); 932 933 for (int i = 0; i <= vars.length; i++) { 934 KsubSet<String> ps = new KsubSet<String>(sv, i); 935 //System.out.println("========================== ps : " + i); 936 for (List<String> ev : ps) { 937 //System.out.println("ev = " + ev); 938 939 String[] evars = new String[ev.size()]; 940 for (int j = 0; j < ev.size(); j++) { 941 evars[j] = ev.get(j); 942 } 943 GenPolynomialRing<BigRational> efac; 944 efac = new GenPolynomialRing<BigRational>(fac.coFac, evars.length, fac.tord, evars); 945 //System.out.println("efac = " + efac); 946 947 J = I.eliminate(efac); 948 assertTrue("isGB( J )", J.isGB()); 949 assertTrue("size( J ) <= |ev|", J.getList().size() <= ev.size()); 950 //System.out.println("J = " + J); 951 } 952 } 953 } 954 955 956 /** 957 * Test univariate polynomials in ideal. 958 */ 959 public void testUnivPoly() { 960 String[] vars; 961 962 BigRational coeff = new BigRational(17, 1); 963 to = new TermOrder(TermOrder.INVLEX); 964 vars = new String[] { "x", "y", "z" }; 965 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 966 967 vars = fac.getVars(); 968 //System.out.println("vars = " + Arrays.toString(vars)); 969 //System.out.println("fac = " + fac); 970 assertTrue("vars.length == 3 ", vars.length == 3); 971 972 Ideal<BigRational> I; 973 L = new ArrayList<GenPolynomial<BigRational>>(); 974 975 a = fac.parse("( x^3 + 34/55 x^2 + 1/9 x + 99 )"); 976 b = fac.parse("( y^4 - x )"); 977 c = fac.parse("( z^3 - x y )"); 978 979 if (a.isZERO() || b.isZERO() || c.isZERO()) { 980 return; 981 } 982 983 L.add(a); 984 L.add(b); 985 L.add(c); 986 I = new Ideal<BigRational>(fac, L); 987 //I.doGB(); 988 assertTrue("not isZERO( I )", !I.isZERO()); 989 assertTrue("isGB( I )", I.isGB()); 990 //System.out.println("I = " + I); 991 992 for (int i = 0; i < rl; i++) { // rl 993 GenPolynomial<BigRational> u = I.constructUnivariate(rl - 1 - i); 994 //System.out.println("u = " + u); 995 GenPolynomial<BigRational> U = fac.parse(u.toString()); 996 //System.out.println("U = " + U + "\n"); 997 assertTrue("I.contains(U) ", I.contains(U)); 998 } 999 1000 List<GenPolynomial<BigRational>> Us = I.constructUnivariate(); 1001 for (GenPolynomial<BigRational> u : Us) { 1002 //System.out.println("u = " + u); 1003 GenPolynomial<BigRational> U = fac.parse(u.toString()); 1004 //System.out.println("U = " + U + "\n"); 1005 assertTrue("I.contains(U) ", I.contains(U)); 1006 } 1007 } 1008 1009 1010 /** 1011 * Test complex roots univariate polynomials in zero dim ideal. 1012 */ 1013 public void testComplexRoot() { 1014 String[] vars; 1015 1016 BigRational coeff = new BigRational(17, 1); 1017 to = new TermOrder(TermOrder.INVLEX); 1018 vars = new String[] { "x", "y", "z" }; 1019 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1020 1021 vars = fac.getVars(); 1022 //System.out.println("vars = " + Arrays.toString(vars)); 1023 //System.out.println("fac = " + fac); 1024 assertTrue("vars.length == 3 ", vars.length == 3); 1025 1026 Ideal<BigRational> I; 1027 L = new ArrayList<GenPolynomial<BigRational>>(); 1028 1029 a = fac.parse("( x^3 - 27 )"); 1030 b = fac.parse("( y^2 - 9 )"); 1031 c = fac.parse("( z - 7 )"); 1032 1033 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1034 return; 1035 } 1036 1037 L.add(a); 1038 L.add(b); 1039 L.add(c); 1040 I = new Ideal<BigRational>(fac, L); 1041 //I.doGB(); 1042 assertTrue("not isZERO( I )", !I.isZERO()); 1043 assertTrue("isGB( I )", I.isGB()); 1044 //System.out.println("I = " + I); 1045 1046 BigRational eps = new BigRational(1, 1000000); 1047 eps = eps.multiply(eps); 1048 eps = eps.multiply(eps).multiply(eps); 1049 BigDecimal e = new BigDecimal(eps.getRational()); 1050 e = e.abs(); //.multiply(e); 1051 1052 BigDecimal dc = BigDecimal.ONE; 1053 GenPolynomialRing<BigDecimal> dfac = new GenPolynomialRing<BigDecimal>(dc, fac); 1054 //System.out.println("dfac = " + dfac); 1055 ComplexRing<BigDecimal> dcc = new ComplexRing<BigDecimal>(dc); 1056 GenPolynomialRing<Complex<BigDecimal>> dcfac = new GenPolynomialRing<Complex<BigDecimal>>(dcc, dfac); 1057 //System.out.println("dcfac = " + dcfac); 1058 1059 List<List<Complex<BigDecimal>>> roots = PolyUtilApp.<BigRational> complexRootTuples(I, eps); 1060 //System.out.println("roots = " + roots + "\n"); 1061 for (GenPolynomial<BigRational> p : I.getList()) { 1062 GenPolynomial<BigDecimal> dp = PolyUtil.<BigRational> decimalFromRational(dfac, p); 1063 GenPolynomial<Complex<BigDecimal>> dpc = PolyUtil.<BigDecimal> toComplex(dcfac, dp); 1064 //System.out.println("dpc = " + dpc); 1065 for (List<Complex<BigDecimal>> r : roots) { 1066 //System.out.println("r = " + r); 1067 Complex<BigDecimal> ev = PolyUtil.<Complex<BigDecimal>> evaluateAll(dcc, dpc, r); 1068 if (ev.norm().getRe().compareTo(e) > 0) { 1069 //System.out.println("ev = " + ev); 1070 fail("ev > eps : " + ev + " > " + e); 1071 } 1072 } 1073 } 1074 //System.out.println(); 1075 } 1076 1077 1078 /** 1079 * Test real roots univariate polynomials in zero dim ideal. 1080 */ 1081 public void testRealRoot() { 1082 String[] vars; 1083 1084 BigRational coeff = new BigRational(17, 1); 1085 to = new TermOrder(TermOrder.INVLEX); 1086 vars = new String[] { "x", "y", "z" }; 1087 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1088 1089 vars = fac.getVars(); 1090 //System.out.println("vars = " + Arrays.toString(vars)); 1091 //System.out.println("fac = " + fac); 1092 assertTrue("vars.length == 3 ", vars.length == 3); 1093 1094 Ideal<BigRational> I; 1095 L = new ArrayList<GenPolynomial<BigRational>>(); 1096 1097 a = fac.parse("( x^3 - 27 )"); 1098 b = fac.parse("( y^4 - x )"); 1099 c = fac.parse("( z^2 - x^2 )"); 1100 1101 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1102 return; 1103 } 1104 1105 L.add(a); 1106 L.add(b); 1107 L.add(c); 1108 I = new Ideal<BigRational>(fac, L); 1109 //I.doGB(); 1110 assertTrue("not isZERO( I )", !I.isZERO()); 1111 assertTrue("isGB( I )", I.isGB()); 1112 //System.out.println("I = " + I); 1113 1114 BigRational eps = new BigRational(1, 10); 1115 eps = eps.power(BigDecimal.DEFAULT_PRECISION / 2); 1116 BigDecimal e = new BigDecimal(eps.getRational()); 1117 e = e.abs(); //.multiply(e); 1118 eps = eps.multiply(new BigRational(1, 100)); 1119 1120 List<List<BigDecimal>> roots = PolyUtilApp.<BigRational> realRootTuples(I, eps); 1121 //System.out.println("roots = " + roots + "\n"); 1122 // polynomials with decimal coefficients 1123 BigDecimal dc = BigDecimal.ONE; 1124 GenPolynomialRing<BigDecimal> dfac = new GenPolynomialRing<BigDecimal>(dc, fac); 1125 //System.out.println("dfac = " + dfac); 1126 for (GenPolynomial<BigRational> p : I.getList()) { 1127 GenPolynomial<BigDecimal> dp = PolyUtil.<BigRational> decimalFromRational(dfac, p); 1128 //System.out.println("dp = " + dp); 1129 for (List<BigDecimal> r : roots) { 1130 //System.out.println("r = " + r); 1131 BigDecimal ev = PolyUtil.<BigDecimal> evaluateAll(dc, dp, r); 1132 if (ev.abs().compareTo(e) > 0) { 1133 //System.out.println("ev = " + ev); 1134 fail("ev > e : " + ev + " > " + e + ", eps = " + new BigDecimal(eps)); 1135 } 1136 } 1137 } 1138 //System.out.println(); 1139 } 1140 1141 1142 /** 1143 * Test zero dimensional decomposition. 1144 */ 1145 public void testZeroDimDecomp() { 1146 String[] vars; 1147 1148 BigRational coeff = new BigRational(17, 1); 1149 to = new TermOrder(TermOrder.INVLEX); 1150 vars = new String[] { "x", "y", "z" }; 1151 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1152 1153 vars = fac.getVars(); 1154 //System.out.println("vars = " + Arrays.toString(vars)); 1155 //System.out.println("fac = " + fac); 1156 assertTrue("vars.length == 3 ", vars.length == 3); 1157 1158 Ideal<BigRational> I; 1159 L = new ArrayList<GenPolynomial<BigRational>>(); 1160 1161 a = fac.parse("( x^3 - 27 )"); 1162 b = fac.parse("( y^4 - x )"); 1163 c = fac.parse("( z^2 - x^2 )"); 1164 1165 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1166 return; 1167 } 1168 1169 L.add(a); 1170 L.add(b); 1171 L.add(c); 1172 I = new Ideal<BigRational>(fac, L); 1173 //I.doGB(); 1174 assertTrue("not isZERO( I )", !I.isZERO()); 1175 assertTrue("isGB( I )", I.isGB()); 1176 //System.out.println("I = " + I); 1177 1178 List<IdealWithUniv<BigRational>> zd = I.zeroDimDecomposition(); 1179 //System.out.println("I = " + I); 1180 //System.out.println("zd = " + zd); 1181 1182 boolean t = I.isZeroDimDecomposition(zd); 1183 //System.out.println("t = " + t); 1184 assertTrue("is decomposition ", t); 1185 1186 List<IdealWithUniv<BigRational>> zde = I.zeroDimElimination(zd); 1187 //System.out.println("I = " + I); 1188 //System.out.println("zde = " + zde); 1189 1190 t = I.isZeroDimDecomposition(zde); 1191 //System.out.println("t = " + t); 1192 assertTrue("is decomposition elimination", t); 1193 } 1194 1195 1196 /** 1197 * Test zero dimensional radical decomposition. 1198 */ 1199 public void testZeroDimRadicalDecomp() { 1200 String[] vars; 1201 1202 BigRational coeff = new BigRational(17, 1); 1203 to = new TermOrder(TermOrder.INVLEX); 1204 vars = new String[] { "x", "y", "z" }; 1205 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1206 1207 vars = fac.getVars(); 1208 //System.out.println("vars = " + Arrays.toString(vars)); 1209 //System.out.println("fac = " + fac); 1210 assertTrue("vars.length == 3 ", vars.length == 3); 1211 1212 Ideal<BigRational> I; 1213 L = new ArrayList<GenPolynomial<BigRational>>(); 1214 1215 a = fac.parse("( x^3 - 27 )**3 ( x**2 - 11 )**2 ( x + 1 ) "); 1216 b = fac.parse("( y^4 - x )"); 1217 c = fac.parse("( z^2 - x^2 )"); 1218 1219 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1220 return; 1221 } 1222 1223 L.add(a); 1224 L.add(b); 1225 L.add(c); 1226 I = new Ideal<BigRational>(fac, L); 1227 //I.doGB(); 1228 assertTrue("not isZERO( I )", !I.isZERO()); 1229 assertTrue("isGB( I )", I.isGB()); 1230 //System.out.println("I = " + I); 1231 1232 List<IdealWithUniv<BigRational>> zd = I.zeroDimRadicalDecomposition(); 1233 //System.out.println("I = " + I); 1234 //System.out.println("zd = " + zd); 1235 1236 boolean t = I.isZeroDimDecomposition(zd); 1237 //System.out.println("t = " + t); 1238 assertTrue("is decomposition ", t); 1239 1240 for (IdealWithUniv<BigRational> ru : zd) { 1241 t = I.isRadical(ru); // works also for ZeroDim 1242 //System.out.println("t = " + t); 1243 assertTrue("is radical decomposition: " + ru, t); 1244 1245 t = ru.ideal.isZeroDimRadical(); 1246 //System.out.println("t = " + t); 1247 assertTrue("is 0-dim radical decomposition: " + ru, t); 1248 } 1249 } 1250 1251 1252 /** 1253 * Test real roots univariate polynomials in zero dim ideal. 1254 */ 1255 public void testIdealRealRoot() { 1256 String[] vars; 1257 1258 BigRational coeff = new BigRational(17, 1); 1259 to = new TermOrder(TermOrder.INVLEX); 1260 vars = new String[] { "x", "y", "z" }; 1261 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1262 1263 vars = fac.getVars(); 1264 //System.out.println("vars = " + Arrays.toString(vars)); 1265 //System.out.println("fac = " + fac); 1266 assertTrue("vars.length == 3 ", vars.length == 3); 1267 1268 Ideal<BigRational> I; 1269 L = new ArrayList<GenPolynomial<BigRational>>(); 1270 1271 a = fac.parse("( x^3 - 27 )"); 1272 b = fac.parse("( y^4 - x )"); 1273 c = fac.parse("( z^2 - x^2 )"); 1274 1275 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1276 return; 1277 } 1278 1279 L.add(a); 1280 L.add(b); 1281 L.add(c); 1282 I = new Ideal<BigRational>(fac, L); 1283 //I.doGB(); 1284 assertTrue("not isZERO( I )", !I.isZERO()); 1285 assertTrue("isGB( I )", I.isGB()); 1286 //System.out.println("I = " + I); 1287 1288 List<IdealWithUniv<BigRational>> zd = I.zeroDimDecomposition(); 1289 //System.out.println("zd = " + zd); 1290 assertTrue("is decomposition ", I.isZeroDimDecomposition(zd)); 1291 1292 BigRational eps = new BigRational(1, 10); 1293 eps = eps.power(BigDecimal.DEFAULT_PRECISION / 2); 1294 BigDecimal e = new BigDecimal(eps.getRational()); 1295 e = e.abs(); //.multiply(e); 1296 eps = eps.multiply(new BigRational(1, 10)); 1297 BigDecimal dc = BigDecimal.ONE; 1298 1299 List<IdealWithRealRoots<BigRational>> roots = PolyUtilApp.<BigRational> realRoots(zd, eps); 1300 //System.out.println("roots = " + roots + "\n"); 1301 1302 for (IdealWithRealRoots<BigRational> Ir : roots) { 1303 List<GenPolynomial<BigRational>> L = Ir.ideal.getList(); 1304 List<GenPolynomial<BigDecimal>> Ld = new ArrayList<GenPolynomial<BigDecimal>>(L.size()); 1305 1306 GenPolynomialRing<BigDecimal> dfac = new GenPolynomialRing<BigDecimal>(dc, Ir.ideal.list.ring); 1307 //System.out.println("dfac = " + dfac); 1308 1309 for (GenPolynomial<BigRational> p : L) { 1310 GenPolynomial<BigDecimal> dp = PolyUtil.<BigRational> decimalFromRational(dfac, p); 1311 //System.out.println("dp = " + dp); 1312 Ld.add(dp); 1313 } 1314 boolean t = PolyUtilApp.isRealRoots(Ld, Ir.rroots, e); 1315 assertTrue("isRealRoots ", t); // this example only 1316 } 1317 } 1318 1319 1320 /** 1321 * Test complex roots univariate polynomials in zero dim ideal. 1322 */ 1323 public void testIdealComplexRoot() { 1324 String[] vars; 1325 BigRational coeff = new BigRational(1, 1); 1326 to = new TermOrder(TermOrder.INVLEX); 1327 //vars = new String[] { "x", "y" }; 1328 vars = new String[] { "x", "y", "z" }; 1329 fac = new GenPolynomialRing<BigRational>(coeff, vars.length, to, vars); 1330 1331 vars = fac.getVars(); 1332 //System.out.println("vars = " + Arrays.toString(vars)); 1333 //System.out.println("fac = " + fac); 1334 assertTrue("vars.length == 3 ", vars.length == 3); 1335 1336 Ideal<BigRational> I; 1337 L = new ArrayList<GenPolynomial<BigRational>>(); 1338 1339 a = fac.parse("( x^3 + 3 )"); 1340 //a = fac.parse("( x^3 - 3 )"); 1341 //a = fac.parse("( x^2 + 3 )"); 1342 b = fac.parse("( y^2 - x )"); 1343 //b = fac.parse("( y^2 + x )"); 1344 //b = fac.parse("( y^2 + 4 )"); 1345 c = fac.parse("( z^2 - x y )"); 1346 //c = fac.parse("( z^2 - 5 )"); 1347 1348 if (a.isZERO() || b.isZERO()) { 1349 return; 1350 } 1351 1352 L.add(a); 1353 L.add(b); 1354 L.add(c); 1355 I = new Ideal<BigRational>(fac, L); 1356 //I.doGB(); 1357 assertTrue("not isZERO( I )", !I.isZERO()); 1358 assertTrue("isGB( I )", I.isGB()); 1359 //System.out.println("I = " + I); 1360 1361 List<IdealWithUniv<BigRational>> zd = I.zeroDimRootDecomposition(); 1362 //System.out.println("zd = " + zd); 1363 assertTrue("is decomposition ", I.isZeroDimDecomposition(zd)); 1364 1365 BigRational eps = new BigRational(1, 1000000); 1366 //eps = eps.multiply(eps); 1367 eps = eps.multiply(eps).multiply(eps); 1368 BigDecimal e = new BigDecimal(eps.getRational()); 1369 e = e.abs(); //.multiply(e); 1370 1371 List<IdealWithComplexAlgebraicRoots<BigRational>> roots = PolyUtilApp 1372 .<BigRational> complexAlgebraicRoots(zd); //, eps); 1373 //System.out.println("roots = " + roots + "\n"); 1374 1375 ComplexRing<BigDecimal> dcc = new ComplexRing<BigDecimal>(e); 1376 1377 int d = 0; 1378 int s = 0; 1379 for (IdealWithComplexAlgebraicRoots<BigRational> Ic : roots) { 1380 List<GenPolynomial<BigRational>> L = Ic.ideal.getList(); 1381 List<GenPolynomial<Complex<BigDecimal>>> Ld = new ArrayList<GenPolynomial<Complex<BigDecimal>>>( 1382 L.size()); 1383 s += Ic.can.size(); 1384 1385 GenPolynomialRing<BigDecimal> dfac = new GenPolynomialRing<BigDecimal>(e, Ic.ideal.list.ring); 1386 //System.out.println("dfac = " + dfac); 1387 GenPolynomialRing<Complex<BigDecimal>> dcfac; 1388 dcfac = new GenPolynomialRing<Complex<BigDecimal>>(dcc, dfac); 1389 //System.out.println("dcfac = " + dcfac); 1390 int ds = 1; 1391 for (GenPolynomial<BigRational> p : L) { 1392 long dl = p.leadingExpVector().totalDeg(); 1393 ds *= dl; 1394 GenPolynomial<BigDecimal> dp = PolyUtil.<BigRational> decimalFromRational(dfac, p); 1395 GenPolynomial<Complex<BigDecimal>> dpc = PolyUtil.<BigDecimal> toComplex(dcfac, dp); 1396 //System.out.println("p = " + p); 1397 //System.out.println("dpc = " + dpc); 1398 Ld.add(dpc); 1399 } 1400 d += ds; 1401 assertTrue("#L == #Ld: ", L.size() == Ld.size()); 1402 //List<List<Complex<BigDecimal>>> droot = Ic.decimalApproximation(); 1403 Ic.doDecimalApproximation(); 1404 //System.out.println("Ic = " + Ic.isDecimalApproximation()); 1405 assertTrue("is decimal approximation ", Ic.isDecimalApproximation()); 1406 assertTrue("#droot == ds: ", Ic.decimalApproximation().size() == ds); 1407 } 1408 logger.info("#roots = " + s + ", #vr-dim = " + d); 1409 assertTrue("#roots(" + s + ") == degree(" + d + "): ", s == d); 1410 } 1411 1412 1413 /** 1414 * Test normal position. 1415 */ 1416 public void testNormalPosition() { 1417 String[] vars; 1418 1419 BigRational coeff = new BigRational(17, 1); 1420 to = new TermOrder(TermOrder.INVLEX); 1421 vars = new String[] { "x", "y", "z" }; 1422 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1423 1424 vars = fac.getVars(); 1425 //System.out.println("vars = " + Arrays.toString(vars)); 1426 //System.out.println("fac = " + fac); 1427 assertTrue("vars.length == 3 ", vars.length == 3); 1428 1429 Ideal<BigRational> I; 1430 L = new ArrayList<GenPolynomial<BigRational>>(); 1431 1432 a = fac.parse("( x^3 - 27 )"); 1433 b = fac.parse("( y^3 - x )"); 1434 c = fac.parse("( z^2 - x^2 )"); 1435 1436 L.add(a); 1437 L.add(b); 1438 L.add(c); 1439 I = new Ideal<BigRational>(fac, L); 1440 I.doGB(); 1441 assertTrue("not isZERO( I )", !I.isZERO()); 1442 assertTrue("isGB( I )", I.isGB()); 1443 //System.out.println("I = " + I); 1444 1445 int[] np = I.normalPositionIndex2Vars(); 1446 //System.out.println("np = " + Arrays.toString(np)); 1447 if (np == null) { 1448 np = I.normalPositionIndexUnivars(); 1449 //System.out.println("np = " + Arrays.toString(np)); 1450 } 1451 if (np == null) { 1452 return; 1453 } 1454 int i = np[0]; 1455 int j = np[1]; 1456 IdealWithUniv<BigRational> Ip = I.normalPositionFor(i, j, null); 1457 //System.out.println("Ip = " + Ip); 1458 1459 boolean t = Ip.ideal.isNormalPositionFor(i + 1, j + 1); // sic 1460 //System.out.println("t = " + t); 1461 assertTrue("is normal position ", t); 1462 1463 np = Ip.ideal.normalPositionIndex2Vars(); 1464 //System.out.println("np = " + Arrays.toString(np)); 1465 if (np == null) { 1466 np = Ip.ideal.normalPositionIndexUnivars(); 1467 //System.out.println("np = " + Arrays.toString(np)); 1468 } 1469 if (np == null) { 1470 return; 1471 } 1472 i = np[0]; 1473 j = np[1]; 1474 assertTrue("i == 0: " + Arrays.toString(np), i == 0); 1475 assertTrue("j == 2: " + Arrays.toString(np), j == 3); // fixed, was 3, again to 3 1476 } 1477 1478 1479 /** 1480 * Test 0-dim root decomposition char 0. 1481 */ 1482 public void testRootDecompositionChar0() { 1483 String[] vars; 1484 BigRational coeff = new BigRational(17, 1); 1485 to = new TermOrder(TermOrder.INVLEX); 1486 vars = new String[] { "x", "y", "z" }; 1487 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1488 vars = fac.getVars(); 1489 //System.out.println("vars = " + Arrays.toString(vars)); 1490 //System.out.println("fac = " + fac); 1491 assertTrue("vars.length == 3 ", vars.length == 3); 1492 1493 Ideal<BigRational> I; 1494 L = new ArrayList<GenPolynomial<BigRational>>(); 1495 1496 a = fac.parse("( x^2 - 7 )"); 1497 b = fac.parse("( y^2 - 5 )"); 1498 c = fac.parse("( z^3 - x * y )"); 1499 1500 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1501 return; 1502 } 1503 1504 L.add(a); 1505 L.add(b); 1506 L.add(c); 1507 I = new Ideal<BigRational>(fac, L); 1508 I.doGB(); 1509 assertTrue("not isZERO( I )", !I.isZERO()); 1510 assertTrue("isGB( I )", I.isGB()); 1511 //System.out.println("I = " + I); 1512 1513 List<IdealWithUniv<BigRational>> rzd = I.zeroDimRootDecomposition(); 1514 //System.out.println("rzd = " + rzd); 1515 1516 assertTrue("is contained in intersection ", I.isZeroDimDecomposition(rzd)); 1517 } 1518 1519 1520 /** 1521 * Test 0-dim root decomposition char p = 13. 1522 */ 1523 public void testRootDecompositionCharP() { 1524 String[] vars; 1525 ModIntegerRing coeff = new ModIntegerRing(13, true); // 13 important for field extension 1526 to = new TermOrder(TermOrder.INVLEX); 1527 vars = new String[] { "x", "y", "z" }; 1528 GenPolynomialRing<ModInteger> fac; 1529 fac = new GenPolynomialRing<ModInteger>(coeff, rl, to, vars); 1530 vars = fac.getVars(); 1531 //System.out.println("vars = " + Arrays.toString(vars)); 1532 //System.out.println("fac = " + fac.toScript()); 1533 assertTrue("vars.length == 3 ", vars.length == 3); 1534 1535 Ideal<ModInteger> I; 1536 List<GenPolynomial<ModInteger>> L; 1537 L = new ArrayList<GenPolynomial<ModInteger>>(); 1538 GenPolynomial<ModInteger> a, b, c; 1539 1540 // need field extension for this test: 1541 a = fac.parse("( x^2 - 7 )"); 1542 b = fac.parse("( y^3 + 3 )"); 1543 c = fac.parse("( z^5 + x * y )"); 1544 1545 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1546 return; 1547 } 1548 1549 L.add(a); 1550 L.add(b); 1551 L.add(c); 1552 I = new Ideal<ModInteger>(fac, L); 1553 //System.out.println("I = " + I); 1554 I.doGB(); 1555 assertTrue("not isZERO( I )", !I.isZERO()); 1556 assertTrue("isGB( I )", I.isGB()); 1557 //System.out.println("I = " + I); 1558 1559 List<IdealWithUniv<ModInteger>> rzd = I.zeroDimRootDecomposition(); 1560 //System.out.println("rzd = " + rzd); 1561 //System.out.println("#rzd = " + rzd.size()); 1562 assertTrue("is zero dim decomposition ", I.isZeroDimDecomposition(rzd)); 1563 1564 /* not ok when field extensions are used: 1565 List<Ideal<ModInteger>> izd = IdealWithUniv.asListOfIdeals(rzd); 1566 System.out.println("izd = " + izd); 1567 Ideal<ModInteger> J = I.intersect(izd); 1568 System.out.println("I = " + I.toScript()); 1569 System.out.println("J = " + J.toScript()); 1570 assertEquals("I == J ", I, J); 1571 */ 1572 } 1573 1574 1575 /** 1576 * Test 0-dim prime decomposition. 1577 */ 1578 public void testPrimeDecomposition() { 1579 String[] vars; 1580 1581 BigRational coeff = new BigRational(17, 1); 1582 to = new TermOrder(TermOrder.INVLEX); 1583 vars = new String[] { "x", "y", "z" }; 1584 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1585 1586 vars = fac.getVars(); 1587 //System.out.println("vars = " + Arrays.toString(vars)); 1588 //System.out.println("fac = " + fac); 1589 assertTrue("vars.length == 3 ", vars.length == 3); 1590 1591 Ideal<BigRational> I; 1592 L = new ArrayList<GenPolynomial<BigRational>>(); 1593 1594 a = fac.parse("( x^2 - 5 )^2 "); 1595 b = fac.parse("( y^2 - 5 )"); 1596 c = fac.parse("( z^3 - x )"); 1597 1598 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1599 return; 1600 } 1601 1602 L.add(a); 1603 L.add(b); 1604 L.add(c); 1605 I = new Ideal<BigRational>(fac, L); 1606 I.doGB(); 1607 assertTrue("not isZERO( I )", !I.isZERO()); 1608 assertTrue("isGB( I )", I.isGB()); 1609 //System.out.println("I = " + I); 1610 1611 List<IdealWithUniv<BigRational>> pzd = I.zeroDimPrimeDecomposition(); 1612 //System.out.println("pzd = " + pzd); 1613 //System.out.println("I = " + I); 1614 1615 assertTrue("is contained in intersection ", I.isZeroDimDecomposition(pzd)); 1616 } 1617 1618 1619 /** 1620 * Test 0-dim primary decomposition. 1621 */ 1622 public void testPrimaryDecomposition() { 1623 String[] vars; 1624 1625 BigRational coeff = new BigRational(17, 1); 1626 to = new TermOrder(TermOrder.INVLEX); 1627 vars = new String[] { "x", "y", "z" }; 1628 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1629 1630 vars = fac.getVars(); 1631 //System.out.println("vars = " + Arrays.toString(vars)); 1632 //System.out.println("fac = " + fac); 1633 assertTrue("vars.length == 3 ", vars.length == 3); 1634 1635 Ideal<BigRational> I; 1636 L = new ArrayList<GenPolynomial<BigRational>>(); 1637 1638 a = fac.parse("( x^2 - 5 )^2 "); 1639 b = fac.parse("( y^2 - 5 )"); 1640 c = fac.parse("( z^3 - x )"); 1641 1642 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1643 return; 1644 } 1645 1646 L.add(a); 1647 L.add(b); 1648 L.add(c); 1649 I = new Ideal<BigRational>(fac, L); 1650 I.doGB(); 1651 assertTrue("not isZERO( I )", !I.isZERO()); 1652 assertTrue("isGB( I )", I.isGB()); 1653 //System.out.println("I = " + I); 1654 1655 List<PrimaryComponent<BigRational>> qzd = I.zeroDimPrimaryDecomposition(); 1656 //System.out.println("qzd = " + qzd); 1657 //System.out.println("I = " + I); 1658 1659 assertTrue("is intersection ", I.isPrimaryDecomposition(qzd)); 1660 } 1661 1662 1663 /** 1664 * Test 0-dim root decomposition and real roots. 1665 */ 1666 public void testRootDecompositionReal() { 1667 String[] vars; 1668 1669 BigRational coeff = new BigRational(17, 1); 1670 to = new TermOrder(TermOrder.INVLEX); 1671 vars = new String[] { "x", "y", "z" }; 1672 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1673 1674 vars = fac.getVars(); 1675 //System.out.println("vars = " + Arrays.toString(vars)); 1676 //System.out.println("fac = " + fac); 1677 assertTrue("vars.length == 3 ", vars.length == 3); 1678 1679 Ideal<BigRational> I; 1680 L = new ArrayList<GenPolynomial<BigRational>>(); 1681 1682 a = fac.parse("( x^2 - 5 )"); 1683 b = fac.parse("( y^2 - 7 )"); 1684 c = fac.parse("( z^3 - x * y )"); 1685 1686 if (a.isZERO() || b.isZERO() || c.isZERO()) { 1687 return; 1688 } 1689 1690 L.add(a); 1691 L.add(b); 1692 L.add(c); 1693 I = new Ideal<BigRational>(fac, L); 1694 I.doGB(); 1695 assertTrue("not isZERO( I )", !I.isZERO()); 1696 assertTrue("isGB( I )", I.isGB()); 1697 //System.out.println("I = " + I); 1698 1699 List<IdealWithRealAlgebraicRoots<BigRational>> iur; 1700 iur = PolyUtilApp.<BigRational> realAlgebraicRoots(I); 1701 1702 List<IdealWithUniv<BigRational>> iul = new ArrayList<IdealWithUniv<BigRational>>(); 1703 for (IdealWithRealAlgebraicRoots<BigRational> iu : iur) { 1704 iul.add(iu); 1705 } 1706 assertTrue("is contained in intersection ", I.isZeroDimDecomposition(iul)); 1707 1708 for (IdealWithRealAlgebraicRoots<BigRational> iu : iur) { 1709 //@SuppressWarnings("unused") 1710 //List<List<BigDecimal>> rd = iu.decimalApproximation(); 1711 iu.doDecimalApproximation(); // side effect compute decimal approx 1712 //System.out.println("iu = " + iu); 1713 //System.out.println("isDecimalApproximation: = " + iu.isDecimalApproximation()); 1714 assertTrue("is decimal approximation ", iu.isDecimalApproximation()); 1715 } 1716 } 1717 1718 1719 /** 1720 * Test extension-contraction. 1721 */ 1722 public void testExtCont() { 1723 String[] vars; 1724 1725 BigRational coeff = new BigRational(17, 1); 1726 to = new TermOrder(); //TermOrder.INVLEX); 1727 vars = new String[] { "x", "y", "z" }; 1728 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1729 1730 vars = fac.getVars(); 1731 //System.out.println("vars = " + Arrays.toString(vars)); 1732 //System.out.println("fac = " + fac); 1733 assertTrue("vars.length == 3 ", vars.length == 3); 1734 1735 Ideal<BigRational> I; 1736 L = new ArrayList<GenPolynomial<BigRational>>(); 1737 1738 //a = fac.parse("( y^2 - 5 ) x "); 1739 //b = fac.parse("( y^2 - 5 ) x "); 1740 //c = fac.parse("( x z^3 - 3 )"); 1741 1742 //a = fac.parse("( x^2 + 2 x y z + z^4 ) "); 1743 //b = fac.parse("( y z - z^2 ) "); 1744 //c = fac.parse("0"); 1745 1746 a = fac.parse("( y + x y^2 ) "); 1747 b = fac.parse("( x z + x^2 y ) "); 1748 //c = fac.parse("0"); 1749 1750 if (a.isZERO() || b.isZERO()) { 1751 return; 1752 } 1753 1754 L.add(a); 1755 L.add(b); 1756 //L.add(c); 1757 I = new Ideal<BigRational>(fac, L); 1758 I.doGB(); 1759 assertTrue("not isZERO( I )", !I.isZERO()); 1760 assertTrue("isGB( I )", I.isGB()); 1761 //System.out.println("I = " + I); 1762 1763 IdealWithUniv<Quotient<BigRational>> Ext = I.extension(new String[] { "x" }); 1764 //Ideal<Quotient<BigRational>> Ext = I.extension( new String[] { "y", "z" } ); 1765 //System.out.println("Ext = " + Ext); 1766 //System.out.println("I = " + I); 1767 1768 IdealWithUniv<BigRational> Con = I.permContraction(Ext); 1769 //System.out.println("Con = " + Con); 1770 //System.out.println("I = " + I); 1771 1772 assertTrue("I subseteq Con(Ext(I)) ", Con.ideal.contains(I)); 1773 } 1774 1775 1776 /** 1777 * Test prime ideal decomposition. 1778 */ 1779 public void testPrimeDecomp() { 1780 String[] vars; 1781 1782 BigRational coeff = new BigRational(17, 1); 1783 to = new TermOrder(TermOrder.INVLEX); 1784 vars = new String[] { "x", "y", "z" }; 1785 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1786 1787 vars = fac.getVars(); 1788 //System.out.println("vars = " + Arrays.toString(vars)); 1789 //System.out.println("fac = " + fac); 1790 assertTrue("vars.length == 3 ", vars.length == 3); 1791 1792 Ideal<BigRational> I; 1793 L = new ArrayList<GenPolynomial<BigRational>>(); 1794 1795 //a = fac.parse("( y^2 - 5 ) x "); 1796 //b = fac.parse("( y^2 - 5 ) x "); 1797 //c = fac.parse("( x z^3 - 3 )"); 1798 1799 //a = fac.parse("( x^2 + 2 x y z + z^4 ) "); 1800 //b = fac.parse("( y z - z^2 ) "); 1801 1802 //a = fac.parse("( y + x y^2 ) "); 1803 //b = fac.parse("( x z + x^2 y ) "); 1804 1805 a = fac.parse("( z^2 - x ) "); 1806 b = fac.parse("( y^2 - x ) "); 1807 1808 //a = fac.parse("( x y ) "); 1809 //b = fac.parse("( x z ) "); 1810 1811 if (a.isZERO() || b.isZERO()) { 1812 return; 1813 } 1814 1815 L.add(a); 1816 L.add(b); 1817 //L.add(c); 1818 I = new Ideal<BigRational>(fac, L); 1819 I.doGB(); 1820 assertTrue("not isZERO( I )", !I.isZERO()); 1821 assertTrue("isGB( I )", I.isGB()); 1822 //System.out.println("I = " + I); 1823 1824 List<IdealWithUniv<BigRational>> pdec = I.primeDecomposition(); 1825 //System.out.println("pdec = " + pdec); 1826 //System.out.println("I = " + I); 1827 1828 assertTrue("I subseteq cup G_i ", I.isDecomposition(pdec)); 1829 1830 List<Ideal<BigRational>> dec = new ArrayList<Ideal<BigRational>>(pdec.size()); 1831 for (IdealWithUniv<BigRational> pu : pdec) { 1832 dec.add(pu.ideal); 1833 } 1834 Ideal<BigRational> Ii = I.intersect(dec); 1835 //System.out.println("Ii = " + Ii); 1836 //System.out.println("I = " + I); 1837 1838 // not always: 1839 assertTrue("I == Ii ", I.equals(Ii)); 1840 } 1841 1842 1843 /** 1844 * Test radical ideal decomposition. 1845 */ 1846 public void testRadicalDecomp() { 1847 String[] vars; 1848 1849 BigRational coeff = new BigRational(17, 1); 1850 to = new TermOrder(TermOrder.INVLEX); 1851 vars = new String[] { "x", "y", "z" }; 1852 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1853 1854 vars = fac.getVars(); 1855 //System.out.println("vars = " + Arrays.toString(vars)); 1856 //System.out.println("fac = " + fac); 1857 assertTrue("vars.length == 3 ", vars.length == 3); 1858 1859 Ideal<BigRational> I; 1860 L = new ArrayList<GenPolynomial<BigRational>>(); 1861 1862 //a = fac.parse("( y^2 - 5 ) x "); 1863 //b = fac.parse("( y^2 - 5 ) x "); 1864 //c = fac.parse("( x z^3 - 3 )"); 1865 1866 a = fac.parse("( x^2 + 2 x y z + z^4 ) "); 1867 b = fac.parse("( y z - z^2 ) "); 1868 1869 //a = fac.parse("( y + x y^2 ) "); 1870 //b = fac.parse("( x z + x^2 y ) "); 1871 1872 //a = fac.parse("( z^2 - x )^2 "); 1873 //b = fac.parse("( y^2 - x ) "); 1874 1875 //a = fac.parse("( x^2 y^3 ) "); 1876 //b = fac.parse("( x^2 z^5 ) "); 1877 1878 if (a.isZERO() || b.isZERO()) { 1879 return; 1880 } 1881 1882 L.add(a); 1883 L.add(b); 1884 //L.add(c); 1885 I = new Ideal<BigRational>(fac, L); 1886 I.doGB(); 1887 assertTrue("not isZERO( I )", !I.isZERO()); 1888 assertTrue("isGB( I )", I.isGB()); 1889 //System.out.println("I = " + I); 1890 1891 List<IdealWithUniv<BigRational>> rdec = I.radicalDecomposition(); 1892 //System.out.println("rdec = " + rdec); 1893 //System.out.println("I = " + I); 1894 1895 assertTrue("I subseteq cup G_i ", I.isDecomposition(rdec)); 1896 1897 List<Ideal<BigRational>> dec = new ArrayList<Ideal<BigRational>>(rdec.size()); 1898 for (IdealWithUniv<BigRational> ru : rdec) { 1899 dec.add(ru.ideal); 1900 } 1901 Ideal<BigRational> Ii = I.intersect(dec); 1902 //System.out.println("Ii = " + Ii); 1903 //System.out.println("I = " + I); 1904 assertTrue("Ii.contains(I) ", Ii.contains(I)); 1905 1906 for (IdealWithUniv<BigRational> ru : rdec) { 1907 //System.out.println("ru = " + ru); 1908 boolean t = I.isRadical(ru); 1909 assertTrue("isRadical: " + ru, t); 1910 } 1911 1912 //Ii = I.radical(); 1913 //System.out.println("Ii = " + Ii); 1914 //System.out.println("I = " + I); 1915 //assertTrue("Ii.contains(I) ", Ii.contains(I)); 1916 } 1917 1918 1919 /** 1920 * Test ideal decomposition. 1921 */ 1922 public void testIrredDecomp() { 1923 String[] vars; 1924 1925 BigRational coeff = new BigRational(17, 1); 1926 to = new TermOrder(TermOrder.INVLEX); 1927 vars = new String[] { "x", "y", "z" }; 1928 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 1929 1930 vars = fac.getVars(); 1931 //System.out.println("vars = " + Arrays.toString(vars)); 1932 //System.out.println("fac = " + fac); 1933 assertTrue("vars.length == 3 ", vars.length == 3); 1934 1935 Ideal<BigRational> I; 1936 L = new ArrayList<GenPolynomial<BigRational>>(); 1937 1938 //a = fac.parse("( y^2 - 5 ) x "); 1939 //b = fac.parse("( y^2 - 5 ) x "); 1940 //c = fac.parse("( x z^3 - 3 )"); 1941 1942 a = fac.parse("( x^2 + 2 x y z + z^4 ) "); 1943 b = fac.parse("( y z - z^2 ) "); 1944 1945 //a = fac.parse("( y + x y^2 ) "); 1946 //b = fac.parse("( x z + x^2 y ) "); 1947 1948 //a = fac.parse("( z^2 - x )^2 "); 1949 //b = fac.parse("( y^2 - x ) "); 1950 1951 //a = fac.parse("( x^2 y^3 ) "); 1952 //b = fac.parse("( x^2 z^5 ) "); 1953 1954 if (a.isZERO() || b.isZERO()) { 1955 return; 1956 } 1957 1958 L.add(a); 1959 L.add(b); 1960 //L.add(c); 1961 I = new Ideal<BigRational>(fac, L); 1962 I.doGB(); 1963 assertTrue("not isZERO( I )", !I.isZERO()); 1964 assertTrue("isGB( I )", I.isGB()); 1965 //System.out.println("I = " + I); 1966 1967 List<IdealWithUniv<BigRational>> rdec = I.decomposition(); 1968 //System.out.println("rdec = " + rdec); 1969 //System.out.println("I = " + I); 1970 1971 assertTrue("I subseteq cup G_i ", I.isDecomposition(rdec)); 1972 1973 List<Ideal<BigRational>> dec = new ArrayList<Ideal<BigRational>>(rdec.size()); 1974 for (IdealWithUniv<BigRational> ru : rdec) { 1975 dec.add(ru.ideal); 1976 } 1977 Ideal<BigRational> Ii = I.intersect(dec); 1978 //System.out.println("Ii = " + Ii); 1979 //System.out.println("I = " + I); 1980 1981 assertTrue("Ii.contains(I) ", Ii.contains(I)); 1982 1983 //Ii = I.radical(); 1984 //System.out.println("Ii = " + Ii); 1985 //System.out.println("I = " + I); 1986 //assertTrue("Ii.contains(I) ", Ii.contains(I)); 1987 } 1988 1989 1990 /** 1991 * Test primary ideal decomposition. 1992 */ 1993 public void testPrimaryDecomp() { 1994 String[] vars; 1995 1996 BigRational coeff = new BigRational(17, 1); 1997 to = new TermOrder(TermOrder.INVLEX); 1998 vars = new String[] { "x", "y", "z" }; 1999 fac = new GenPolynomialRing<BigRational>(coeff, rl, to, vars); 2000 2001 vars = fac.getVars(); 2002 //System.out.println("vars = " + Arrays.toString(vars)); 2003 //System.out.println("fac = " + fac); 2004 assertTrue("vars.length == 3 ", vars.length == 3); 2005 2006 Ideal<BigRational> I; 2007 L = new ArrayList<GenPolynomial<BigRational>>(); 2008 2009 //a = fac.parse("( y^2 - 5 ) x "); 2010 //b = fac.parse("( y^2 - 5 ) x "); 2011 //c = fac.parse("( x z^3 - 3 )"); 2012 2013 //a = fac.parse("( x^2 + 2 x y z + z^4 ) "); 2014 //b = fac.parse("( y z - z^2 ) "); 2015 2016 //a = fac.parse("( y + x y^2 ) "); 2017 //b = fac.parse("( x z + x^2 y ) "); 2018 2019 a = fac.parse("( x z^2 - 1 )^2 "); 2020 b = fac.parse("( y^2 - x ) "); 2021 2022 //a = fac.parse("( x^2 y ) "); 2023 //b = fac.parse("( x z^3 ) "); 2024 2025 if (a.isZERO() || b.isZERO()) { 2026 return; 2027 } 2028 2029 L.add(a); 2030 L.add(b); 2031 //L.add(c); 2032 I = new Ideal<BigRational>(fac, L); 2033 I.doGB(); 2034 assertTrue("not isZERO( I )", !I.isZERO()); 2035 assertTrue("isGB( I )", I.isGB()); 2036 //System.out.println("I = " + I); 2037 2038 List<PrimaryComponent<BigRational>> qdec = I.primaryDecomposition(); 2039 //System.out.println("qdec = " + qdec); 2040 //System.out.println("I = " + I); 2041 2042 List<Ideal<BigRational>> dec = new ArrayList<Ideal<BigRational>>(qdec.size()); 2043 for (PrimaryComponent<BigRational> ru : qdec) { 2044 dec.add(ru.primary); 2045 } 2046 assertTrue("#qdec == #dec: ", qdec.size() == dec.size()); 2047 assertTrue("I eq cup G_i ", I.isPrimaryDecomposition(qdec)); 2048 } 2049 2050 2051 /** 2052 * Test Ideal annihilator. 2053 */ 2054 public void testAnnihilator() { 2055 Ideal<BigRational> I, J, K; 2056 do { 2057 a = fac.random(kl, ll, el, q); 2058 } while (a.isZERO() || a.isConstant()); 2059 b = fac.univariate(1); 2060 c = fac.univariate(rl - 1); 2061 //b = fac.random(kl - 1, ll, el, q); 2062 //c = fac.random(kl - 1, ll - 1, el, q / 2); 2063 2064 L = new ArrayList<GenPolynomial<BigRational>>(); 2065 L.add(a); 2066 L.add(b); 2067 //System.out.println("L = " + L); 2068 L = bb.GB(L); 2069 I = new Ideal<BigRational>(fac, L, true); 2070 assertTrue("isGB( I )", I.isGB()); 2071 //System.out.println("I = " + I + "\n"); 2072 2073 J = I.annihilator(c); 2074 //System.out.println("J = " + J + "\n"); 2075 J.doGB(); 2076 //System.out.println("c = " + c); 2077 //System.out.println("J = " + J + "\n"); 2078 assertTrue("isAnnihilator(c,J)", I.isAnnihilator(c, J)); 2079 2080 d = fac.univariate(rl - 2); 2081 //d = fac.random(kl - 1, ll, el, q); 2082 M = new ArrayList<GenPolynomial<BigRational>>(); 2083 M.add(c); 2084 M.add(d); 2085 //System.out.println("M = " + M); 2086 K = new Ideal<BigRational>(fac, M); 2087 //System.out.println("K = " + K + "\n"); 2088 2089 J = I.annihilator(K); 2090 //System.out.println("J = " + J + "\n"); 2091 J.doGB(); 2092 //System.out.println("K = " + K); 2093 //System.out.println("J = " + J + "\n"); 2094 assertTrue("isAnnihilator(M,J)", I.isAnnihilator(K, J)); 2095 } 2096 2097}