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