001 /*
002 * $Id: PolyUtilTest.java 3641 2011-05-22 12:23:54Z kredel $
003 */
004
005 package edu.jas.poly;
006
007
008 import java.util.ArrayList;
009 import java.util.List;
010
011 import junit.framework.Test;
012 import junit.framework.TestCase;
013 import junit.framework.TestSuite;
014
015 import edu.jas.arith.BigComplex;
016 import edu.jas.arith.BigInteger;
017 import edu.jas.arith.BigRational;
018 import edu.jas.arith.ModInteger;
019 import edu.jas.arith.ModIntegerRing;
020 import edu.jas.arith.Product;
021 import edu.jas.arith.ProductRing;
022
023
024 /**
025 * PolyUtil tests with JUnit.
026 * @author Heinz Kredel.
027 */
028
029 public class PolyUtilTest extends TestCase {
030
031
032 /**
033 * main.
034 */
035 public static void main(String[] args) {
036 junit.textui.TestRunner.run(suite());
037 }
038
039
040 /**
041 * Constructs a <CODE>PolyUtilTest</CODE> object.
042 * @param name String.
043 */
044 public PolyUtilTest(String name) {
045 super(name);
046 }
047
048
049 /**
050 */
051 public static Test suite() {
052 TestSuite suite = new TestSuite(PolyUtilTest.class);
053 return suite;
054 }
055
056
057 //private final static int bitlen = 100;
058
059 TermOrder to = new TermOrder(TermOrder.INVLEX);
060
061
062 GenPolynomialRing<BigInteger> dfac;
063
064
065 GenPolynomialRing<BigInteger> cfac;
066
067
068 GenPolynomialRing<GenPolynomial<BigInteger>> rfac;
069
070
071 BigInteger ai;
072
073
074 BigInteger bi;
075
076
077 BigInteger ci;
078
079
080 BigInteger di;
081
082
083 BigInteger ei;
084
085
086 GenPolynomial<BigInteger> a;
087
088
089 GenPolynomial<BigInteger> b;
090
091
092 GenPolynomial<BigInteger> c;
093
094
095 GenPolynomial<BigInteger> d;
096
097
098 GenPolynomial<BigInteger> e;
099
100
101 GenPolynomial<GenPolynomial<BigInteger>> ar;
102
103
104 GenPolynomial<GenPolynomial<BigInteger>> br;
105
106
107 GenPolynomial<GenPolynomial<BigInteger>> cr;
108
109
110 GenPolynomial<GenPolynomial<BigInteger>> dr;
111
112
113 GenPolynomial<GenPolynomial<BigInteger>> er;
114
115
116 int rl = 5;
117
118
119 int kl = 5;
120
121
122 int ll = 5;
123
124
125 int el = 3;
126
127
128 float q = 0.3f;
129
130
131 @Override
132 protected void setUp() {
133 a = b = c = d = e = null;
134 ai = bi = ci = di = ei = null;
135 ar = br = cr = dr = er = null;
136 dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl, to);
137 cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl - 1, to);
138 rfac = new GenPolynomialRing<GenPolynomial<BigInteger>>(cfac, 1, to);
139 }
140
141
142 @Override
143 protected void tearDown() {
144 a = b = c = d = e = null;
145 ai = bi = ci = di = ei = null;
146 ar = br = cr = dr = er = null;
147 dfac = null;
148 cfac = null;
149 rfac = null;
150 }
151
152
153 protected static java.math.BigInteger getPrime1() {
154 long prime = 2; //2^60-93; // 2^30-35; //19; knuth (2,390)
155 for (int i = 1; i < 60; i++) {
156 prime *= 2;
157 }
158 prime -= 93;
159 //prime = 37;
160 //System.out.println("p1 = " + prime);
161 return new java.math.BigInteger("" + prime);
162 }
163
164
165 protected static java.math.BigInteger getPrime2() {
166 long prime = 2; //2^60-93; // 2^30-35; //19; knuth (2,390)
167 for (int i = 1; i < 30; i++) {
168 prime *= 2;
169 }
170 prime -= 35;
171 //prime = 19;
172 //System.out.println("p1 = " + prime);
173 return new java.math.BigInteger("" + prime);
174 }
175
176
177 /**
178 * Test recursive <--> distributive conversion.
179 *
180 */
181 public void testConversion() {
182 c = dfac.getONE();
183 assertTrue("length( c ) = 1", c.length() == 1);
184 assertTrue("isZERO( c )", !c.isZERO());
185 assertTrue("isONE( c )", c.isONE());
186
187 cr = PolyUtil.recursive(rfac, c);
188 a = PolyUtil.distribute(dfac, cr);
189 assertEquals("c == dist(rec(c))", c, a);
190
191 d = dfac.getZERO();
192 assertTrue("length( d ) = 0", d.length() == 0);
193 assertTrue("isZERO( d )", d.isZERO());
194 assertTrue("isONE( d )", !d.isONE());
195
196 dr = PolyUtil.recursive(rfac, d);
197 b = PolyUtil.distribute(dfac, dr);
198 assertEquals("d == dist(rec(d))", d, b);
199 }
200
201
202 /**
203 * Test recursive <--> distributive ring conversion.
204 *
205 */
206 public void testConversionRing() {
207 GenPolynomialRing<GenPolynomial<BigInteger>> rf = dfac.recursive(1);
208 GenPolynomialRing<BigInteger> cf = (GenPolynomialRing<BigInteger>)rf.coFac;
209 assertEquals("rfac#var == rf#var ", rfac.nvar, rf.nvar);
210 assertEquals("rfac.coFac#var == rf.coFac#var ", cfac.nvar, cf.nvar);
211 assertEquals("rfac.coFac.coFac == rf.coFac.coFac ", cfac.coFac, cf.coFac);
212 // variable names not same in this test
213 }
214
215
216 /**
217 * Test random recursive <--> distributive conversion.
218 *
219 */
220 public void testRandomConversion() {
221 for (int i = 0; i < 7; i++) {
222 c = dfac.random(kl * (i + 2), ll + 2 * i, el + i, q);
223
224 assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
225 assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
226 assertTrue(" not isONE( c" + i + " )", !c.isONE());
227
228 cr = PolyUtil.recursive(rfac, c);
229 a = PolyUtil.distribute(dfac, cr);
230 //System.out.println("c = " + c);
231 //System.out.println("cr = " + cr);
232 //System.out.println("crd = " + a);
233
234 assertEquals("c == dist(rec(c))", c, a);
235 }
236 }
237
238
239 /**
240 * Test random rational <--> integer conversion.
241 *
242 */
243 public void testRationalConversion() {
244 GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(new BigRational(1), rl, to);
245
246 GenPolynomial<BigRational> ar;
247 GenPolynomial<BigRational> br;
248
249 for (int i = 0; i < 3; i++) {
250 c = dfac.random(kl * (i + 9), ll * (i + 3), el + i, q).abs();
251 //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
252 //c = GreatestCommonDivisor.primitivePart(c);
253
254 assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
255 assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
256 assertTrue(" not isONE( c" + i + " )", !c.isONE());
257
258 ar = PolyUtil.<BigRational> fromIntegerCoefficients(rfac, c);
259 br = ar.monic();
260 a = PolyUtil.integerFromRationalCoefficients(dfac, br);
261 //System.out.println("c = " + c);
262 //System.out.println("ar = " + ar);
263 //System.out.println("br = " + br);
264 //System.out.println("crd = " + a);
265
266 assertEquals("c == integer(rational(c))", c, a);
267 }
268 }
269
270
271 /**
272 * Test random modular <--> integer conversion.
273 *
274 */
275 public void testModularConversion() {
276 ModIntegerRing pm = new ModIntegerRing(getPrime1());
277 GenPolynomialRing<ModInteger> mfac = new GenPolynomialRing<ModInteger>(pm, rl, to);
278
279 GenPolynomial<ModInteger> ar;
280
281 for (int i = 0; i < 3; i++) {
282 c = dfac.random(kl * (i + 2), ll * (i + 1), el + i, q).abs();
283 //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
284 //c = GreatestCommonDivisor.primitivePart(c);
285
286 assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
287 assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
288 assertTrue(" not isONE( c" + i + " )", !c.isONE());
289
290 ar = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac, c);
291 a = PolyUtil.integerFromModularCoefficients(dfac, ar);
292 //System.out.println("c = " + c);
293 //System.out.println("ar = " + ar);
294 //System.out.println("crd = " + a);
295
296 assertEquals("c == integer(modular(c))", c, a);
297 }
298 }
299
300
301 /**
302 * Test chinese remainder.
303 *
304 */
305 public void testChineseRemainder() {
306 java.math.BigInteger p1 = getPrime1();
307 java.math.BigInteger p2 = getPrime2();
308 java.math.BigInteger p12 = p1.multiply(p2);
309
310 ModIntegerRing pm1 = new ModIntegerRing(p1);
311 GenPolynomialRing<ModInteger> mfac1 = new GenPolynomialRing<ModInteger>(pm1, rl, to);
312
313 ModIntegerRing pm2 = new ModIntegerRing(p2);
314 GenPolynomialRing<ModInteger> mfac2 = new GenPolynomialRing<ModInteger>(pm2, rl, to);
315
316 ModIntegerRing pm12 = new ModIntegerRing(p12);
317 GenPolynomialRing<ModInteger> mfac = new GenPolynomialRing<ModInteger>(pm12, rl, to);
318
319 ModInteger di = pm2.create(p1);
320 di = di.inverse();
321 //System.out.println("di = " + di);
322
323 GenPolynomial<ModInteger> am;
324 GenPolynomial<ModInteger> bm;
325 GenPolynomial<ModInteger> cm;
326
327 ExpVector degv, qdegv;
328
329 for (int i = 0; i < 3; i++) {
330 c = dfac.random((59 + 29) / 2, ll * (i + 1), el + i, q);
331 //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
332 //c = GreatestCommonDivisor.primitivePart(c);
333 degv = c.degreeVector();
334 //System.out.println("degv = " + degv);
335
336 assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
337 assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
338 assertTrue(" not isONE( c" + i + " )", !c.isONE());
339
340 am = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac1, c);
341 qdegv = am.degreeVector();
342 //System.out.println("qdegv = " + qdegv);
343 if (!degv.equals(qdegv)) {
344 continue;
345 }
346 bm = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac2, c);
347 qdegv = bm.degreeVector();
348 //System.out.println("qdegv = " + qdegv);
349 if (!degv.equals(qdegv)) {
350 continue;
351 }
352
353 cm = PolyUtil.chineseRemainder(mfac, am, di, bm);
354 a = PolyUtil.integerFromModularCoefficients(dfac, cm);
355
356 //System.out.println("c = " + c);
357 //System.out.println("am = " + am);
358 //System.out.println("bm = " + bm);
359 //System.out.println("cm = " + cm);
360 //System.out.println("a = " + a);
361
362 assertEquals("cra(c mod p1,c mod p2) = c", c, a);
363 }
364 }
365
366
367 /**
368 * Test complex conversion.
369 *
370 */
371 public void testComplexConversion() {
372 BigRational rf = new BigRational(1);
373 GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(rf, rl, to);
374
375 BigComplex cf = new BigComplex(1);
376 GenPolynomialRing<BigComplex> cfac = new GenPolynomialRing<BigComplex>(cf, rl, to);
377
378 BigComplex imag = BigComplex.I;
379
380 GenPolynomial<BigRational> rp;
381 GenPolynomial<BigRational> ip;
382 GenPolynomial<BigComplex> crp;
383 GenPolynomial<BigComplex> cip;
384 GenPolynomial<BigComplex> cp;
385 GenPolynomial<BigComplex> ap;
386
387 for (int i = 0; i < 3; i++) {
388 cp = cfac.random(kl + 2 * i, ll * (i + 1), el + i, q);
389
390 assertTrue("length( c" + i + " ) <> 0", cp.length() >= 0);
391 assertTrue(" not isZERO( c" + i + " )", !cp.isZERO());
392 assertTrue(" not isONE( c" + i + " )", !cp.isONE());
393
394 rp = PolyUtil.realPart(rfac, cp);
395 ip = PolyUtil.imaginaryPart(rfac, cp);
396
397 crp = PolyUtil.complexFromRational(cfac, rp);
398 cip = PolyUtil.complexFromRational(cfac, ip);
399
400 ap = crp.sum(cip.multiply(imag));
401
402 //System.out.println("cp = " + cp);
403 //System.out.println("rp = " + rp);
404 //System.out.println("ip = " + ip);
405 //System.out.println("crp = " + crp);
406 //System.out.println("cip = " + cip);
407 //System.out.println("ap = " + ap);
408
409 assertEquals("re(c)+i*im(c) = c", cp, ap);
410 }
411 }
412
413
414 /**
415 * Test evaluate main recursive.
416 *
417 */
418 public void testEvalMainRecursive() {
419 ai = (new BigInteger()).random(kl);
420 //System.out.println("ai = " + ai);
421
422 ar = rfac.getZERO();
423 //System.out.println("ar = " + ar);
424
425 a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
426 //System.out.println("a = " + a);
427
428 assertTrue("isZERO( a )", a.isZERO());
429
430 ar = rfac.getONE();
431 //System.out.println("ar = " + ar);
432
433 a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
434 //System.out.println("a = " + a);
435
436 assertTrue("isONE( a )", a.isONE());
437
438
439 //ar = rfac.getONE();
440 ar = rfac.random(kl, ll, el, q);
441 //System.out.println("ar = " + ar);
442 //br = rfac.getONE();
443 br = rfac.random(kl, ll, el, q);
444 //System.out.println("br = " + br);
445
446 cr = br.sum(ar);
447 //System.out.println("cr = " + cr);
448
449 a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
450 b = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, br, ai);
451 c = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, cr, ai);
452 //System.out.println("a = " + a);
453 //System.out.println("b = " + b);
454 //System.out.println("c = " + c);
455
456 d = a.sum(b);
457 //System.out.println("d = " + d);
458
459 assertEquals("eval(a+b) == eval(a) + eval(b)", c, d);
460
461
462 cr = br.multiply(ar);
463 //System.out.println("cr = " + cr);
464
465 a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
466 b = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, br, ai);
467 c = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, cr, ai);
468 //System.out.println("a = " + a);
469 //System.out.println("b = " + b);
470 //System.out.println("c = " + c);
471
472 d = a.multiply(b);
473 //System.out.println("d = " + d);
474
475 assertEquals("eval(a*b) == eval(a) * eval(b)", c, d);
476 }
477
478
479 /**
480 * Test evaluate main.
481 *
482 */
483 public void testEvalMain() {
484 ei = (new BigInteger()).random(kl);
485 //System.out.println("ei = " + ei);
486
487 cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
488 //System.out.println("cfac = " + cfac);
489
490 a = cfac.getZERO();
491 //System.out.println("a = " + a);
492
493 ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
494 //System.out.println("ai = " + ai);
495
496 assertTrue("isZERO( ai )", ai.isZERO());
497
498 a = cfac.getONE();
499 //System.out.println("a = " + a);
500
501 ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
502 //System.out.println("ai = " + ai);
503
504 assertTrue("isONE( ai )", ai.isONE());
505
506 //a = cfac.getONE();
507 a = cfac.random(kl, ll, el, q);
508 //System.out.println("a = " + a);
509 //b = cfac.getONE();
510 b = cfac.random(kl, ll, el, q);
511 //System.out.println("b = " + b);
512
513 c = b.sum(a);
514 //System.out.println("c = " + c);
515
516 ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
517 bi = PolyUtil.<BigInteger> evaluateMain(ei, b, ei);
518 ci = PolyUtil.<BigInteger> evaluateMain(ei, c, ei);
519 //System.out.println("ai = " + ai);
520 //System.out.println("bi = " + bi);
521 //System.out.println("ci = " + ci);
522
523 di = bi.sum(ai);
524 //System.out.println("di = " + di);
525
526 assertEquals("eval(a+b) == eval(a) + eval(b)", ci, di);
527
528
529 c = b.multiply(a);
530 //System.out.println("c = " + c);
531
532 ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
533 bi = PolyUtil.<BigInteger> evaluateMain(ei, b, ei);
534 ci = PolyUtil.<BigInteger> evaluateMain(ei, c, ei);
535 //System.out.println("ai = " + ai);
536 //System.out.println("bi = " + bi);
537 //System.out.println("ci = " + ci);
538
539 di = bi.multiply(ai);
540 //System.out.println("di = " + di);
541
542 assertEquals("eval(a*b) == eval(a) * eval(b)", ci, di);
543 }
544
545
546 /**
547 * Test evaluate first.
548 *
549 */
550 public void testEvalFirst() {
551 ei = (new BigInteger()).random(kl);
552 //System.out.println("ei = " + ei);
553
554 GenPolynomial<BigInteger> ae, be, ce, de;
555
556 GenPolynomialRing<BigInteger> fac;
557 fac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl, to);
558 //System.out.println("fac = " + fac);
559
560 cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
561 //System.out.println("cfac = " + cfac);
562
563 dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl - 1, to);
564 //System.out.println("dfac = " + dfac);
565
566 a = fac.getZERO();
567 //System.out.println("a = " + a);
568
569 ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
570 //System.out.println("ae = " + ae);
571
572 assertTrue("isZERO( ae )", ae.isZERO());
573
574 a = fac.getONE();
575 //System.out.println("a = " + a);
576
577 ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
578 //System.out.println("ae = " + ae);
579
580 assertTrue("isONE( ae )", ae.isONE());
581
582 //a = fac.getONE();
583 a = fac.random(kl, ll, el, q);
584 //System.out.println("a = " + a);
585 //b = fac.getONE();
586 b = fac.random(kl, ll, el, q);
587 //System.out.println("b = " + b);
588
589 c = b.sum(a);
590 //System.out.println("c = " + c);
591
592 ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
593 be = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, b, ei);
594 ce = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, c, ei);
595 //System.out.println("ae = " + ae);
596 //System.out.println("be = " + be);
597 //System.out.println("ce = " + ce);
598
599 de = be.sum(ae);
600 //System.out.println("de = " + de);
601
602 assertEquals("eval(a+b) == eval(a) + eval(b)", ce, de);
603
604
605 c = b.multiply(a);
606 //System.out.println("c = " + c);
607
608 ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
609 be = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, b, ei);
610 ce = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, c, ei);
611 //System.out.println("ae = " + ae);
612 //System.out.println("be = " + be);
613 //System.out.println("ce = " + ce);
614
615 de = be.multiply(ae);
616 //System.out.println("de = " + de);
617
618 assertEquals("eval(a*b) == eval(a) * eval(b)", ce, de);
619 }
620
621
622 /**
623 * Test evaluate all.
624 *
625 */
626 public void testEvalAll() {
627 BigInteger cfac = new BigInteger();
628
629 List<BigInteger> Ev = new ArrayList<BigInteger>();
630 for (int i = 0; i < rl; i++) {
631 ei = cfac.random(kl);
632 Ev.add(ei);
633 }
634 //System.out.println("Ev = " + Ev);
635
636 BigInteger ae, be, ce, de;
637
638 GenPolynomialRing<BigInteger> fac;
639 fac = new GenPolynomialRing<BigInteger>(cfac, rl, to);
640 //System.out.println("fac = " + fac);
641
642 a = fac.getZERO();
643 //System.out.println("a = " + a);
644
645 ae = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, a, Ev);
646 //System.out.println("ae = " + ae);
647
648 assertTrue("isZERO( ae )", ae.isZERO());
649
650 a = fac.getONE();
651 //System.out.println("a = " + a);
652
653 ae = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, a, Ev);
654 //System.out.println("ae = " + ae);
655
656 assertTrue("isONE( ae )", ae.isONE());
657
658 //a = fac.getONE();
659 a = fac.random(kl, ll, el, q);
660 //System.out.println("a = " + a);
661 //b = fac.getONE();
662 b = fac.random(kl, ll, el, q);
663 //System.out.println("b = " + b);
664
665 c = b.sum(a);
666 //System.out.println("c = " + c);
667
668 ae = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, a, Ev);
669 be = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, b, Ev);
670 ce = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, c, Ev);
671 //System.out.println("ae = " + ae);
672 //System.out.println("be = " + be);
673 //System.out.println("ce = " + ce);
674
675 de = be.sum(ae);
676 //System.out.println("de = " + de);
677
678 assertEquals("eval(a+b) == eval(a) + eval(b)", ce, de);
679
680 c = b.multiply(a);
681 //System.out.println("c = " + c);
682
683 ce = PolyUtil.<BigInteger> evaluateAll(cfac, dfac, c, Ev);
684 //System.out.println("ae = " + ae);
685 //System.out.println("be = " + be);
686 //System.out.println("ce = " + ce);
687
688 de = be.multiply(ae);
689 //System.out.println("de = " + de);
690
691 assertEquals("eval(a*b) == eval(a) * eval(b)", ce, de);
692 }
693
694
695 /**
696 * Test interpolate univariate 1 polynomial.
697 *
698 */
699 public void testInterpolateUnivariateOne() {
700 ModInteger ai, bi, ci, di, ei, fi, gi, hi;
701 GenPolynomial<ModInteger> a;
702 GenPolynomialRing<ModInteger> cfac;
703 ModIntegerRing fac;
704 GenPolynomial<ModInteger> r;
705 GenPolynomial<ModInteger> Q;
706 GenPolynomial<ModInteger> Qp;
707
708 fac = new ModIntegerRing(19);
709 //System.out.println("fac.modul = " + fac.getModul());
710 cfac = new GenPolynomialRing<ModInteger>(fac, 1, to);
711 //System.out.println("cfac = " + cfac);
712
713
714 a = cfac.getONE();
715 //System.out.println("a = " + a);
716
717
718 ei = fac.fromInteger(11);
719 //System.out.println("ei = " + ei);
720 // a(ei)
721 ai = PolyUtil.<ModInteger> evaluateMain(fac, a, ei);
722 //System.out.println("ai = " + ai);
723 assertTrue("isONE( ai )", ai.isONE());
724
725 di = fac.fromInteger(13);
726 //System.out.println("di = " + di);
727 // a(di)
728 bi = PolyUtil.<ModInteger> evaluateMain(fac, a, di);
729 //System.out.println("bi = " + bi);
730 assertTrue("isONE( bi )", bi.isONE());
731
732
733 // interpolation result
734 r = cfac.getZERO();
735 //System.out.println("r = " + r);
736
737 // interpolation polynomials product
738 Q = cfac.getONE();
739 //System.out.println("Q = " + Q);
740
741
742 ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
743 //System.out.println("ci = " + ci);
744 // Q(ei)^-1
745 fi = ci.inverse();
746 //System.out.println("fi = " + fi);
747 r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ai, ei);
748 //System.out.println("r = " + r);
749
750
751 // next evaluation polynomial
752 Qp = cfac.univariate(0);
753 Qp = Qp.subtract(cfac.getONE().multiply(ei));
754 //System.out.println("Qp = " + Qp);
755 Q = Q.multiply(Qp);
756 //System.out.println("Q = " + Q);
757
758 ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, di);
759 //System.out.println("ci = " + ci);
760 // Q(di)^-1
761 fi = ci.inverse();
762 //System.out.println("fi = " + fi);
763 r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, bi, di);
764 //System.out.println("r = " + r);
765
766 // check evaluation
767 gi = PolyUtil.<ModInteger> evaluateMain(fac, r, ei);
768 //System.out.println("gi = " + gi);
769 hi = PolyUtil.<ModInteger> evaluateMain(fac, r, di);
770 //System.out.println("hi = " + hi);
771
772 // interpolate( a(ei), a(di) ) = a (mod 19)
773 assertEquals("interpolate(a mod (x-ei),a mod (x-di)) = a (mod 19)", a, r);
774 }
775
776
777 /**
778 * Test interpolate univariate deg > 0 polynomial.
779 *
780 */
781 public void testInterpolateUnivariate() {
782 ModInteger ai, ci, ei, fi;
783 GenPolynomial<ModInteger> a;
784 GenPolynomialRing<ModInteger> cfac;
785 ModIntegerRing fac;
786 GenPolynomial<ModInteger> r;
787 GenPolynomial<ModInteger> Q;
788 GenPolynomial<ModInteger> Qp;
789
790 //long prime = 19;
791 long prime = getPrime1().longValue();
792 fac = new ModIntegerRing(prime);
793 //System.out.println("fac.modul = " + fac.getModul());
794 cfac = new GenPolynomialRing<ModInteger>(fac, 1, to);
795 //System.out.println("cfac = " + cfac);
796 int maxdeg = 19;
797
798 // polynomial to interpolate
799 long deg = 0;
800 do {
801 a = cfac.random(kl, ll, maxdeg, q);
802 if (!a.isZERO()) {
803 deg = a.degree(0);
804 }
805 } while (deg <= 0);
806 //System.out.println("a = " + a);
807 //System.out.println("deg = " + deg);
808
809 // interpolation result
810 r = cfac.getZERO();
811 //System.out.println("r = " + r);
812
813 // interpolation polynomials product
814 Q = cfac.getONE();
815 //System.out.println("Q = " + Q);
816
817 long i = -1;
818 long qdeg;
819 do {
820 i++;
821 if (i >= prime) {
822 assertTrue("elements of Z_prime exhausted", i < prime);
823 }
824 qdeg = Q.degree(0);
825 ei = fac.fromInteger(i);
826 //System.out.println("ei = " + ei);
827 // a(ei)
828 ai = PolyUtil.<ModInteger> evaluateMain(fac, a, ei);
829 //System.out.println("ai = " + ai);
830
831 ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
832 //System.out.println("ci = " + ci);
833 // Q(ei)^-1
834 fi = ci.inverse();
835 //System.out.println("fi = " + fi);
836 r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ai, ei);
837 //System.out.println("r = " + r);
838
839 // next evaluation polynomial
840 Qp = cfac.univariate(0);
841 Qp = Qp.subtract(cfac.getONE().multiply(ei));
842 //System.out.println("Qp = " + Qp);
843 Q = Q.multiply(Qp);
844 //System.out.println("Q = " + Q);
845 } while (qdeg < deg);
846
847 //System.out.println("a = " + a);
848 //System.out.println("r = " + r);
849
850 // interpolate( a(e1), ..., a(ei) ) = a (mod 19)
851 assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
852 }
853
854
855 /**
856 * Test interpolate multivariate deg > 0 polynomial.
857 *
858 */
859 public void testInterpolateMultivariate() {
860 ModInteger ci, ei, fi;
861 GenPolynomial<ModInteger> ap, bp;
862 GenPolynomial<GenPolynomial<ModInteger>> a;
863 GenPolynomialRing<GenPolynomial<ModInteger>> cfac;
864 GenPolynomialRing<ModInteger> ufac;
865 GenPolynomialRing<ModInteger> dfac;
866 ModIntegerRing fac;
867 GenPolynomial<GenPolynomial<ModInteger>> r;
868 GenPolynomial<ModInteger> Q;
869 GenPolynomial<ModInteger> Qp;
870
871 //long prime = 19;
872 long prime = getPrime1().longValue();
873 fac = new ModIntegerRing(prime);
874 //System.out.println("fac.modul = " + fac.getModul());
875 ufac = new GenPolynomialRing<ModInteger>(fac, 1, to);
876 //System.out.println("ufac = " + ufac);
877 cfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(ufac, rl, to);
878 //System.out.println("cfac = " + cfac);
879 dfac = new GenPolynomialRing<ModInteger>(fac, rl, to);
880 //System.out.println("dfac = " + dfac);
881 int maxdeg = 19;
882
883 // polynomial to interpolate
884 long deg = 0;
885 do {
886 a = cfac.random(kl, ll + 9, maxdeg, q);
887 if (!a.isZERO()) {
888 deg = PolyUtil.<ModInteger> coeffMaxDegree(a);
889 }
890 } while (deg <= 0);
891 //System.out.println("a = " + a);
892 //System.out.println("deg = " + deg);
893 ExpVector degv = a.degreeVector();
894 //System.out.println("degv = " + degv);
895
896 // interpolation result
897 r = cfac.getZERO();
898 //System.out.println("r = " + r);
899
900 // interpolation polynomials product
901 Q = ufac.getONE();
902 //System.out.println("Q = " + Q);
903
904 long i = -1;
905 long qdeg;
906 ExpVector qdegv;
907 do {
908 i++;
909 if (i >= prime) {
910 assertTrue("elements of Z_prime exhausted", i < prime);
911 }
912 qdeg = Q.degree(0);
913 ei = fac.fromInteger(i);
914 //System.out.println("ei = " + ei);
915 // a(ei)
916 ap = PolyUtil.<ModInteger> evaluateFirstRec(ufac, dfac, a, ei);
917 //System.out.println("ap = " + ap);
918 qdegv = ap.degreeVector();
919 //System.out.println("qdegv = " + qdegv);
920 if (!degv.equals(qdegv)) {
921 continue;
922 }
923 ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
924 //System.out.println("ci = " + ci);
925 // Q(ei)^-1
926 fi = ci.inverse();
927 //System.out.println("fi = " + fi);
928 r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ap, ei);
929 //System.out.println("r = " + r);
930
931 // check
932 bp = PolyUtil.<ModInteger> evaluateFirstRec(ufac, dfac, r, ei);
933 //System.out.println("bp = " + bp);
934 assertEquals("interpolate(a)(ei) == a ", bp, ap);
935
936
937 // next evaluation polynomial
938 Qp = ufac.univariate(0);
939 Qp = Qp.subtract(ufac.getONE().multiply(ei));
940 //System.out.println("Qp = " + Qp);
941 Q = Q.multiply(Qp);
942 //System.out.println("Q = " + Q);
943 } while (qdeg <= deg);
944
945 //System.out.println("a = " + a);
946 //System.out.println("r = " + r);
947
948 // interpolate( a(e1), ..., a(ei) ) = a (mod 19)
949 assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
950 }
951
952
953 /**
954 * Test interpolate rational multivariate deg > 0 polynomial.
955 *
956 */
957 public void testInterpolateRationalMultivariate() {
958 BigRational ci, ei, fi;
959 GenPolynomial<BigRational> ap, bp;
960 GenPolynomial<GenPolynomial<BigRational>> a;
961 GenPolynomialRing<GenPolynomial<BigRational>> cfac;
962 GenPolynomialRing<BigRational> ufac;
963 GenPolynomialRing<BigRational> dfac;
964 BigRational fac;
965 GenPolynomial<GenPolynomial<BigRational>> r;
966 GenPolynomial<BigRational> Q;
967 GenPolynomial<BigRational> Qp;
968
969 fac = new BigRational();
970 //System.out.println("fac.modul = " + fac.getModul());
971 ufac = new GenPolynomialRing<BigRational>(fac, 1, to);
972 //System.out.println("ufac = " + ufac);
973 cfac = new GenPolynomialRing<GenPolynomial<BigRational>>(ufac, rl, to);
974 //System.out.println("cfac = " + cfac);
975 dfac = new GenPolynomialRing<BigRational>(fac, rl, to);
976 //System.out.println("dfac = " + dfac);
977 int maxdeg = 19;
978
979 // polynomial to interpolate
980 long deg = 0;
981 do {
982 a = cfac.random(kl, ll + 9, maxdeg, q);
983 if (!a.isZERO()) {
984 deg = PolyUtil.<BigRational> coeffMaxDegree(a);
985 }
986 } while (deg <= 0);
987 //System.out.println("a = " + a);
988 //System.out.println("deg = " + deg);
989 ExpVector degv = a.degreeVector();
990 //System.out.println("degv = " + degv);
991
992 // interpolation result
993 r = cfac.getZERO();
994 //System.out.println("r = " + r);
995
996 // interpolation polynomials product
997 Q = ufac.getONE();
998 //System.out.println("Q = " + Q);
999
1000 long i = -1;
1001 long qdeg;
1002 ExpVector qdegv;
1003 do {
1004 i++;
1005 qdeg = Q.degree(0);
1006 ei = fac.fromInteger(i);
1007 //System.out.println("ei = " + ei);
1008 // a(ei)
1009 ap = PolyUtil.<BigRational> evaluateFirstRec(ufac, dfac, a, ei);
1010 //System.out.println("ap = " + ap);
1011 qdegv = ap.degreeVector();
1012 //System.out.println("qdegv = " + qdegv);
1013 if (!degv.equals(qdegv)) {
1014 continue;
1015 }
1016 ci = PolyUtil.<BigRational> evaluateMain(fac, Q, ei);
1017 //System.out.println("ci = " + ci);
1018 // Q(ei)^-1
1019 fi = ci.inverse();
1020 //System.out.println("fi = " + fi);
1021 r = PolyUtil.<BigRational> interpolate(cfac, r, Q, fi, ap, ei);
1022 //System.out.println("r = " + r);
1023
1024 // check
1025 bp = PolyUtil.<BigRational> evaluateFirstRec(ufac, dfac, r, ei);
1026 //System.out.println("bp = " + bp);
1027 assertEquals("interpolate(a)(ei) == a ", bp, ap);
1028
1029
1030 // next evaluation polynomial
1031 Qp = ufac.univariate(0);
1032 Qp = Qp.subtract(ufac.getONE().multiply(ei));
1033 //System.out.println("Qp = " + Qp);
1034 Q = Q.multiply(Qp);
1035 //System.out.println("Q = " + Q);
1036 } while (qdeg <= deg);
1037
1038 //System.out.println("a = " + a);
1039 //System.out.println("r = " + r);
1040
1041 // interpolate( a(e1), ..., a(ei) ) = a (mod 19)
1042 assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
1043 }
1044
1045
1046 /**
1047 * Test coefficient map function.
1048 *
1049 */
1050 public void testMap() {
1051 // integers
1052 BigInteger fi = new BigInteger();
1053 //System.out.println("fi = " + fi);
1054
1055 // rational numbers
1056 BigRational fr = new BigRational();
1057 //System.out.println("fr = " + fr);
1058
1059 // modular integers
1060 ModIntegerRing fm = new ModIntegerRing(17);
1061 //System.out.println("fm = " + fm);
1062
1063 // polynomials over integral numbers
1064 GenPolynomialRing<BigInteger> pfi = new GenPolynomialRing<BigInteger>(fi, rl);
1065 //System.out.println("pfi = " + pfi);
1066
1067 // polynomials over rational numbers
1068 GenPolynomialRing<BigRational> pfr = new GenPolynomialRing<BigRational>(fr, rl);
1069 //System.out.println("pfr = " + pfr);
1070
1071 // polynomials over modular integers
1072 GenPolynomialRing<ModInteger> pfm = new GenPolynomialRing<ModInteger>(fm, rl);
1073 //System.out.println("pfm = " + pfm);
1074
1075
1076 // random polynomial
1077 GenPolynomial<BigInteger> pi = pfi.random(kl, 2 * ll, el, q);
1078 //System.out.println("pi = " + pi);
1079
1080 // random polynomial
1081 GenPolynomial<BigRational> pr = pfr.random(kl, 2 * ll, el, q);
1082 //System.out.println("pr = " + pr);
1083
1084 // random polynomial
1085 GenPolynomial<ModInteger> pm = pfm.random(kl, 2 * ll, el, q);
1086 //System.out.println("pm = " + pm);
1087
1088 // test integer to rational and back
1089 GenPolynomial<BigRational> qr;
1090 GenPolynomial<BigInteger> qi;
1091 qr = PolyUtil.<BigInteger, BigRational> map(pfr, pi, new FromInteger<BigRational>(fr));
1092 qi = PolyUtil.<BigRational, BigInteger> map(pfi, qr, new RatNumer());
1093 //System.out.println("qr = " + qr);
1094 //System.out.println("qi = " + qi);
1095 assertEquals("pi == qi ", pi, qi);
1096
1097 // test symmetric modular integer to integer and back
1098 GenPolynomial<ModInteger> qm;
1099 qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModSymToInt<ModInteger>());
1100 qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1101 //System.out.println("qi = " + qi);
1102 //System.out.println("qm = " + qm);
1103 assertEquals("pm == qm ", pm, qm);
1104
1105 // test modular integer to integer and back
1106 qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModToInt<ModInteger>());
1107 qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1108 //System.out.println("qi = " + qi);
1109 //System.out.println("qm = " + qm);
1110 assertEquals("pm == qm ", pm, qm);
1111
1112 // test symmetric modular integer to integer to rational and back
1113 qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModSymToInt<ModInteger>());
1114 qr = PolyUtil.<BigInteger, BigRational> map(pfr, qi, new FromInteger<BigRational>(fr));
1115 qi = PolyUtil.<BigRational, BigInteger> map(pfi, qr, new RatNumer());
1116 qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1117 //System.out.println("qi = " + qi);
1118 //System.out.println("qm = " + qm);
1119 assertEquals("pm == qm ", pm, qm);
1120 }
1121
1122
1123 /**
1124 * Test substitution.
1125 *
1126 */
1127 public void testSubstitution() {
1128 dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
1129
1130 // subs = x - 7
1131 GenPolynomial<BigInteger> s = dfac.univariate(0).subtract(dfac.fromInteger(7));
1132 GenPolynomial<BigInteger> s1 = dfac.univariate(0).sum(dfac.fromInteger(7));
1133 //System.out.println("s = " + s);
1134 //System.out.println("s1 = " + s1);
1135
1136 for (int i = 0; i < 5; i++) {
1137 a = dfac.random(kl, ll, el, q);
1138 //System.out.println("a = " + a);
1139 b = PolyUtil.<BigInteger> substituteMain(a, s);
1140 c = PolyUtil.<BigInteger> substituteMain(b, s1);
1141 //System.out.println("b = " + b);
1142 //System.out.println("c = " + c);
1143 //System.out.println("a == c " + a.equals(c));
1144 assertEquals("a == c ", a, c);
1145 }
1146 }
1147
1148
1149 /**
1150 * Test algebraic substitution.
1151 *
1152 */
1153 public void testAlgebraicSubstitution() {
1154
1155 BigRational cfac = new BigRational(1);
1156 String[] alpha = new String[] { "alpha" };
1157 String[] vars = new String[] { "z" };
1158 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
1159 GenPolynomial<BigRational> agen = pfac.univariate(0, 2);
1160 agen = agen.sum(pfac.getONE()); // x^2 + 1
1161 AlgebraicNumberRing<BigRational> afac = new AlgebraicNumberRing<BigRational>(agen, true);
1162 GenPolynomialRing<AlgebraicNumber<BigRational>> apfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(
1163 afac, 1, to, vars); // univariate
1164
1165 //System.out.println("agen = " + agen);
1166 //System.out.println("afac = " + afac);
1167 //System.out.println("apfac = " + apfac);
1168
1169 // subs = x - 7
1170 GenPolynomial<AlgebraicNumber<BigRational>> s = apfac.univariate(0).subtract(
1171 apfac.fromInteger(7).multiply(afac.getGenerator()));
1172 GenPolynomial<AlgebraicNumber<BigRational>> s1 = apfac.univariate(0).sum(
1173 apfac.fromInteger(7).multiply(afac.getGenerator()));
1174 //System.out.println("s = " + s);
1175 //System.out.println("s1 = " + s1);
1176
1177 GenPolynomial<AlgebraicNumber<BigRational>> a, b, c;
1178 for (int i = 0; i < 5; i++) {
1179 a = apfac.random(kl, ll, el, q);
1180 //System.out.println("a = " + a);
1181 b = PolyUtil.<AlgebraicNumber<BigRational>> substituteMain(a, s);
1182 c = PolyUtil.<AlgebraicNumber<BigRational>> substituteMain(b, s1);
1183 //System.out.println("b = " + b);
1184 //System.out.println("c = " + c);
1185 //System.out.println("a == c " + a.equals(c));
1186 assertEquals("a == c ", a, c);
1187 }
1188 }
1189
1190
1191 /**
1192 * Test switch variables.
1193 *
1194 */
1195 public void testSwitchVariables() {
1196
1197 BigRational cfac = new BigRational(1);
1198 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, rl, to);
1199 GenPolynomialRing<GenPolynomial<BigRational>> rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(
1200 pfac, rl, to);
1201
1202 //System.out.println("pfac = " + pfac);
1203 //System.out.println("rfac = " + rfac);
1204
1205 GenPolynomial<GenPolynomial<BigRational>> a, c;
1206 GenPolynomial<GenPolynomial<BigRational>> b;
1207 for (int i = 0; i < 5; i++) {
1208 a = rfac.random(kl, ll, el, q);
1209 //System.out.println("a = " + a);
1210 b = PolyUtil.<BigRational> switchVariables(a);
1211 c = PolyUtil.<BigRational> switchVariables(b);
1212 //System.out.println("b = " + b);
1213 //System.out.println("c = " + c);
1214 //System.out.println("a == c " + a.equals(c));
1215 assertEquals("a == c ", a, c);
1216 }
1217 }
1218
1219
1220 /**
1221 * Test algebraic conversions.
1222 *
1223 */
1224 public void testAlgebraicConversions() {
1225
1226 BigRational cfac = new BigRational(1);
1227 String[] alpha = new String[] { "alpha" };
1228 String[] vars = new String[] { "z" };
1229 GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
1230 GenPolynomial<BigRational> agen = pfac.univariate(0, 2);
1231 agen = agen.sum(pfac.getONE()); // x^2 + 1
1232 AlgebraicNumberRing<BigRational> afac = new AlgebraicNumberRing<BigRational>(agen, true);
1233 GenPolynomialRing<AlgebraicNumber<BigRational>> apfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(
1234 afac, rl, to);
1235 GenPolynomialRing<GenPolynomial<BigRational>> rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(
1236 pfac, rl, to);
1237
1238 //System.out.println("agen = " + agen);
1239 //System.out.println("afac = " + afac);
1240 //System.out.println("apfac = " + apfac);
1241 //System.out.println("pfac = " + pfac);
1242 //System.out.println("rfac = " + rfac);
1243
1244 GenPolynomial<AlgebraicNumber<BigRational>> a, c;
1245 GenPolynomial<GenPolynomial<BigRational>> b;
1246 for (int i = 0; i < 5; i++) {
1247 a = apfac.random(kl, ll, el, q);
1248 //System.out.println("a = " + a);
1249 b = PolyUtil.<BigRational> fromAlgebraicCoefficients(rfac, a);
1250 c = PolyUtil.<BigRational> convertRecursiveToAlgebraicCoefficients(apfac, b);
1251 //System.out.println("b = " + b);
1252 //System.out.println("c = " + c);
1253 //System.out.println("a == c " + a.equals(c));
1254 assertEquals("a == c ", a, c);
1255 }
1256 }
1257
1258
1259 /**
1260 * Test Taylor series.
1261 *
1262 */
1263 public void testTaylorSeries() {
1264 GenPolynomial<BigRational> a;
1265 GenPolynomial<BigRational> b;
1266 GenPolynomial<BigRational> c;
1267 GenPolynomialRing<BigRational> dfac;
1268 BigRational cfac;
1269
1270 cfac = new BigRational(1);
1271 String[] vars = new String[] { "x" };
1272 dfac = new GenPolynomialRing<BigRational>(cfac, 1, to, vars);
1273
1274 a = dfac.random(kl, ll, el, q);
1275 //System.out.println("a = " + a);
1276
1277 BigRational v = cfac.getZERO();
1278 //System.out.println("v = " + v);
1279
1280 b = PolyUtil.<BigRational> seriesOfTaylor(a, v);
1281 //System.out.println("taylor(a,0) = " + b);
1282 assertTrue("taylor(a,0) == a ", a.equals(b));
1283
1284 v = cfac.random(kl);
1285 //System.out.println("v = " + v);
1286
1287 b = PolyUtil.<BigRational> seriesOfTaylor(a, v);
1288 //System.out.println("taylor(a,v) = " + b);
1289
1290 c = PolyUtil.<BigRational> seriesOfTaylor(b, v.negate());
1291 //System.out.println("tailor(taylor(a,v),-v) = " + c);
1292 assertTrue("tailor(taylor(a,v),-v) == a ", a.equals(c));
1293 }
1294
1295
1296 /**
1297 * Test Complex real and imaginary part.
1298 *
1299 */
1300 public void testComplexParts() {
1301 BigRational rf = new BigRational(1);
1302 GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(rf, rl, to);
1303
1304 ComplexRing<BigRational> cf = new ComplexRing<BigRational>(new BigRational(1));
1305 GenPolynomialRing<Complex<BigRational>> cfac = new GenPolynomialRing<Complex<BigRational>>(cf, rl, to);
1306
1307 Complex<BigRational> imag = cf.getIMAG();
1308
1309 GenPolynomial<BigRational> rp;
1310 GenPolynomial<BigRational> ip;
1311 GenPolynomial<Complex<BigRational>> crp;
1312 GenPolynomial<Complex<BigRational>> cip;
1313 GenPolynomial<Complex<BigRational>> cp;
1314 GenPolynomial<Complex<BigRational>> ap;
1315
1316 for (int i = 0; i < 3; i++) {
1317 cp = cfac.random(kl + 2 * i, ll * (i + 1), el + i, q);
1318
1319 assertTrue("length( c" + i + " ) <> 0", cp.length() >= 0);
1320 assertTrue(" not isZERO( c" + i + " )", !cp.isZERO());
1321 assertTrue(" not isONE( c" + i + " )", !cp.isONE());
1322
1323 rp = PolyUtil.<BigRational> realPartFromComplex(rfac, cp);
1324 ip = PolyUtil.<BigRational> imaginaryPartFromComplex(rfac, cp);
1325
1326 crp = PolyUtil.<BigRational> toComplex(cfac, rp);
1327 cip = PolyUtil.<BigRational> toComplex(cfac, ip);
1328
1329 ap = crp.sum(cip.multiply(imag));
1330
1331 //System.out.println("cp = " + cp);
1332 //System.out.println("rp = " + rp);
1333 //System.out.println("ip = " + ip);
1334 //System.out.println("crp = " + crp);
1335 //System.out.println("cip = " + cip);
1336 //System.out.println("ap = " + ap);
1337
1338 assertEquals("re(c)+i*im(c) = c", cp, ap);
1339 }
1340 }
1341
1342
1343 /**
1344 * Test product represenation conversion, rational numbers.
1345 *
1346 */
1347 public void testProductConversionRN() {
1348 GenPolynomialRing<BigRational> ufac;
1349 ufac = new GenPolynomialRing<BigRational>(new BigRational(1), 1);
1350
1351 ProductRing<GenPolynomial<BigRational>> pfac;
1352 pfac = new ProductRing<GenPolynomial<BigRational>>(ufac, rl);
1353
1354 GenPolynomialRing<BigRational> dfac = new GenPolynomialRing<BigRational>(new BigRational(1), rl, to);
1355
1356 GenPolynomial<BigRational> c;
1357 Product<GenPolynomial<BigRational>> cp;
1358
1359 c = dfac.getONE();
1360 //System.out.println("c = " + c);
1361
1362 cp = PolyUtil.<BigRational> toProduct(pfac, c);
1363 //System.out.println("cp = " + cp);
1364 assertTrue("isONE( cp )", cp.isONE());
1365
1366 c = dfac.random(kl, ll, el, q);
1367 //System.out.println("c = " + c);
1368
1369 cp = PolyUtil.<BigRational> toProduct(pfac, c);
1370 //System.out.println("cp = " + cp);
1371 assertTrue("!isONE( cp )", !cp.isONE());
1372 }
1373
1374
1375 /**
1376 * Test polynomal over product represenation conversion, algebraic numbers.
1377 *
1378 */
1379 public void testPolyProductConversionAN() {
1380 GenPolynomialRing<BigRational> ufac;
1381 ufac = new GenPolynomialRing<BigRational>(new BigRational(1), 1);
1382
1383 GenPolynomial<BigRational> m;
1384 m = ufac.univariate(0, 2);
1385 m = m.subtract(ufac.univariate(0, 1));
1386 //System.out.println("m = " + m);
1387
1388 AlgebraicNumberRing<BigRational> afac;
1389 afac = new AlgebraicNumberRing<BigRational>(m);
1390 //System.out.println("afac = " + afac);
1391
1392 ProductRing<AlgebraicNumber<BigRational>> pfac;
1393 pfac = new ProductRing<AlgebraicNumber<BigRational>>(afac, rl);
1394
1395 GenPolynomialRing<Product<AlgebraicNumber<BigRational>>> dpfac;
1396 dpfac = new GenPolynomialRing<Product<AlgebraicNumber<BigRational>>>(pfac, 2);
1397
1398 GenPolynomialRing<AlgebraicNumber<BigRational>> dfac;
1399 dfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(afac, 2, to);
1400
1401
1402 GenPolynomial<AlgebraicNumber<BigRational>> c;
1403 GenPolynomial<Product<AlgebraicNumber<BigRational>>> cp;
1404
1405 c = dfac.getONE();
1406 //System.out.println("c = " + c);
1407
1408 cp = PolyUtil.<AlgebraicNumber<BigRational>> toProductGen(dpfac, c);
1409 //System.out.println("cp = " + cp);
1410 assertTrue("isZERO( cp )", cp.isONE());
1411
1412 c = dfac.random(kl, ll, el, q);
1413 //System.out.println("c = " + c);
1414
1415 cp = PolyUtil.<AlgebraicNumber<BigRational>> toProductGen(dpfac, c);
1416 //System.out.println("cp = " + cp);
1417 assertTrue("!isONE( cp )", !cp.isONE());
1418 }
1419
1420 }