Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.poly;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import edu.jas.arith.BigComplex;
012import edu.jas.arith.BigInteger;
013import edu.jas.arith.BigRational;
014import edu.jas.arith.ModInteger;
015import edu.jas.arith.ModIntegerRing;
016import edu.jas.arith.Product;
017import edu.jas.arith.ProductRing;
018
019import junit.framework.Test;
020import junit.framework.TestCase;
021import junit.framework.TestSuite;
022
023
024/**
025 * PolyUtil tests with JUnit.
026 * @author Heinz Kredel
027 */
028
029public 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    public void testConversion() {
181        c = dfac.getONE();
182        assertTrue("length( c ) = 1", c.length() == 1);
183        assertTrue("isZERO( c )", !c.isZERO());
184        assertTrue("isONE( c )", c.isONE());
185
186        cr = PolyUtil.recursive(rfac, c);
187        a = PolyUtil.distribute(dfac, cr);
188        assertEquals("c == dist(rec(c))", c, a);
189
190        d = dfac.getZERO();
191        assertTrue("length( d ) = 0", d.length() == 0);
192        assertTrue("isZERO( d )", d.isZERO());
193        assertTrue("isONE( d )", !d.isONE());
194
195        dr = PolyUtil.recursive(rfac, d);
196        b = PolyUtil.distribute(dfac, dr);
197        assertEquals("d == dist(rec(d))", d, b);
198    }
199
200
201    /**
202     * Test recursive -- distributive ring conversion.
203     */
204    public void testConversionRing() {
205        GenPolynomialRing<GenPolynomial<BigInteger>> rf = dfac.recursive(1);
206        GenPolynomialRing<BigInteger> cf = (GenPolynomialRing<BigInteger>) rf.coFac;
207        assertEquals("rfac#var == rf#var ", rfac.nvar, rf.nvar);
208        assertEquals("rfac.coFac#var == rf.coFac#var ", cfac.nvar, cf.nvar);
209        assertEquals("rfac.coFac.coFac == rf.coFac.coFac ", cfac.coFac, cf.coFac);
210        // variable names not same in this test
211    }
212
213
214    /**
215     * Test random recursive -- distributive conversion.
216     */
217    public void testRandomConversion() {
218        for (int i = 0; i < 7; i++) {
219            c = dfac.random(kl * (i + 2), ll + 2 * i, el + i, q);
220
221            assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
222            assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
223            assertTrue(" not isONE( c" + i + " )", !c.isONE());
224
225            cr = PolyUtil.recursive(rfac, c);
226            a = PolyUtil.distribute(dfac, cr);
227            //System.out.println("c   = " + c);
228            //System.out.println("cr  = " + cr);
229            //System.out.println("crd = " + a);
230
231            assertEquals("c == dist(rec(c))", c, a);
232        }
233    }
234
235
236    /**
237     * Test random rational -- integer conversion.
238     */
239    public void testRationalConversion() {
240        GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(new BigRational(1), rl, to);
241
242        GenPolynomial<BigRational> ar;
243        GenPolynomial<BigRational> br;
244
245        for (int i = 0; i < 3; i++) {
246            c = dfac.random(kl * (i + 9), ll * (i + 3), el + i, q).abs();
247            //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
248            //c = GreatestCommonDivisor.primitivePart(c);
249
250            assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
251            assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
252            assertTrue(" not isONE( c" + i + " )", !c.isONE());
253
254            ar = PolyUtil.<BigRational> fromIntegerCoefficients(rfac, c);
255            br = ar.monic();
256            a = PolyUtil.integerFromRationalCoefficients(dfac, br);
257            //System.out.println("c   = " + c);
258            //System.out.println("ar  = " + ar);
259            //System.out.println("br  = " + br);
260            //System.out.println("crd = " + a);
261
262            assertEquals("c == integer(rational(c))", c, a);
263        }
264    }
265
266
267    /**
268     * Test random modular -- integer conversion.
269     */
270    public void testModularConversion() {
271        ModIntegerRing pm = new ModIntegerRing(getPrime1());
272        GenPolynomialRing<ModInteger> mfac = new GenPolynomialRing<ModInteger>(pm, rl, to);
273
274        GenPolynomial<ModInteger> ar;
275
276        for (int i = 0; i < 3; i++) {
277            c = dfac.random(kl * (i + 2), ll * (i + 1), el + i, q).abs();
278            //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
279            //c = GreatestCommonDivisor.primitivePart(c);
280
281            assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
282            assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
283            assertTrue(" not isONE( c" + i + " )", !c.isONE());
284
285            ar = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac, c);
286            a = PolyUtil.integerFromModularCoefficients(dfac, ar);
287            //System.out.println("c   = " + c);
288            //System.out.println("ar  = " + ar);
289            //System.out.println("crd = " + a);
290
291            assertEquals("c == integer(modular(c))", c, a);
292        }
293    }
294
295
296    /**
297     * Test chinese remainder.
298     */
299    public void testChineseRemainder() {
300        java.math.BigInteger p1 = getPrime1();
301        java.math.BigInteger p2 = getPrime2();
302        java.math.BigInteger p12 = p1.multiply(p2);
303
304        ModIntegerRing pm1 = new ModIntegerRing(p1);
305        GenPolynomialRing<ModInteger> mfac1 = new GenPolynomialRing<ModInteger>(pm1, rl, to);
306
307        ModIntegerRing pm2 = new ModIntegerRing(p2);
308        GenPolynomialRing<ModInteger> mfac2 = new GenPolynomialRing<ModInteger>(pm2, rl, to);
309
310        ModIntegerRing pm12 = new ModIntegerRing(p12);
311        GenPolynomialRing<ModInteger> mfac = new GenPolynomialRing<ModInteger>(pm12, rl, to);
312
313        ModInteger di = pm2.create(p1);
314        di = di.inverse();
315        //System.out.println("di = " + di);
316
317        GenPolynomial<ModInteger> am;
318        GenPolynomial<ModInteger> bm;
319        GenPolynomial<ModInteger> cm;
320
321        ExpVector degv, qdegv;
322
323        for (int i = 0; i < 3; i++) {
324            c = dfac.random((59 + 29) / 2, ll * (i + 1), el + i, q);
325            //c = c.multiply( new BigInteger(99) ); // fails, since not primitive
326            //c = GreatestCommonDivisor.primitivePart(c);
327            degv = c.degreeVector();
328            //System.out.println("degv  = " + degv);
329
330            assertTrue("length( c" + i + " ) <> 0", c.length() >= 0);
331            assertTrue(" not isZERO( c" + i + " )", !c.isZERO());
332            assertTrue(" not isONE( c" + i + " )", !c.isONE());
333
334            am = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac1, c);
335            qdegv = am.degreeVector();
336            //System.out.println("qdegv  = " + qdegv);
337            if (!degv.equals(qdegv)) {
338                continue;
339            }
340            bm = PolyUtil.<ModInteger> fromIntegerCoefficients(mfac2, c);
341            qdegv = bm.degreeVector();
342            //System.out.println("qdegv  = " + qdegv);
343            if (!degv.equals(qdegv)) {
344                continue;
345            }
346
347            cm = PolyUtil.chineseRemainder(mfac, am, di, bm);
348            a = PolyUtil.integerFromModularCoefficients(dfac, cm);
349
350            //System.out.println("c  = " + c);
351            //System.out.println("am = " + am);
352            //System.out.println("bm = " + bm);
353            //System.out.println("cm = " + cm);
354            //System.out.println("a  = " + a);
355
356            assertEquals("cra(c mod p1,c mod p2) = c", c, a);
357        }
358    }
359
360
361    /**
362     * Test complex conversion.
363     */
364    public void testComplexConversion() {
365        BigRational rf = new BigRational(1);
366        GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(rf, rl, to);
367
368        BigComplex cf = new BigComplex(1);
369        GenPolynomialRing<BigComplex> cfac = new GenPolynomialRing<BigComplex>(cf, rl, to);
370
371        BigComplex imag = BigComplex.I;
372
373        GenPolynomial<BigRational> rp;
374        GenPolynomial<BigRational> ip;
375        GenPolynomial<BigComplex> crp;
376        GenPolynomial<BigComplex> cip;
377        GenPolynomial<BigComplex> cp;
378        GenPolynomial<BigComplex> ap;
379
380        for (int i = 0; i < 3; i++) {
381            cp = cfac.random(kl + 2 * i, ll * (i + 1), el + i, q);
382
383            assertTrue("length( c" + i + " ) <> 0", cp.length() >= 0);
384            assertTrue(" not isZERO( c" + i + " )", !cp.isZERO());
385            assertTrue(" not isONE( c" + i + " )", !cp.isONE());
386
387            rp = PolyUtil.realPart(rfac, cp);
388            ip = PolyUtil.imaginaryPart(rfac, cp);
389
390            crp = PolyUtil.complexFromRational(cfac, rp);
391            cip = PolyUtil.complexFromRational(cfac, ip);
392
393            ap = crp.sum(cip.multiply(imag));
394
395            //System.out.println("cp = " + cp);
396            //System.out.println("rp = " + rp);
397            //System.out.println("ip = " + ip);
398            //System.out.println("crp = " + crp);
399            //System.out.println("cip = " + cip);
400            //System.out.println("ap  = " + ap);
401
402            assertEquals("re(c)+i*im(c) = c", cp, ap);
403        }
404    }
405
406
407    /**
408     * Test base pseudo division.
409     */
410    public void testBasePseudoDivision() {
411        String[] names = new String[] { "x" };
412        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), to, names);
413        GenPolynomialRing<BigRational> rdfac = new GenPolynomialRing<BigRational>(new BigRational(1), dfac);
414        //System.out.println("\ndfac  = " + dfac);
415        //System.out.println("rdfac = " + rdfac);
416
417        a = dfac.random(kl, 2 * ll, el + 17, q);
418        //a = dfac.parse(" 3 x^5 + 44 ");
419        //b = a;
420        b = dfac.random(kl, 2 * ll, el + 3, q);
421        //a = a.multiply(b);
422        //a = a.sum(b);
423        //b = dfac.parse(" 2 x^2 + 40 ");
424        //System.out.println("a   = " + a);
425        //System.out.println("b   = " + b);
426
427        GenPolynomial<BigInteger>[] QR = PolyUtil.<BigInteger> basePseudoQuotientRemainder(a, b);
428        c = QR[1];
429        d = QR[0];
430        //System.out.println("q   = " + d);
431        //System.out.println("r   = " + c);
432
433        boolean t = PolyUtil.<BigInteger> isBasePseudoQuotientRemainder(a, b, d, c);
434        assertTrue("lc^n a = q b + r: " + c, t);
435
436        GenPolynomial<BigRational> ap = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, a);
437        GenPolynomial<BigRational> bp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, b);
438        GenPolynomial<BigRational> cp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, c);
439        GenPolynomial<BigRational> dp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, d);
440        //System.out.println("ap  = " + ap);
441        //System.out.println("bp  = " + bp);
442        //System.out.println("cp  = " + cp);
443        ////System.out.println("dp  = " + dp);
444        //System.out.println("dp  = " + dp.monic());
445
446        GenPolynomial<BigRational> qp = ap.divide(bp);
447        GenPolynomial<BigRational> rp = ap.remainder(bp);
448        //System.out.println("qp  = " + qp);
449        //System.out.println("qp  = " + qp.monic());
450        //System.out.println("rp  = " + rp);
451        GenPolynomial<BigRational> rhs = qp.multiply(bp).sum(rp);
452        //System.out.println("qp bp + rp  = " + rhs);
453
454        assertEquals("ap = qp bp + rp: ", ap, rhs);
455
456        assertEquals("cp = rp: ", rp.monic(), cp.monic());
457        assertEquals("dp = qp: ", qp.monic(), dp.monic()); // ??
458        //System.out.println("dp = qp: " + qp.monic().equals(dp.monic()) );
459    }
460
461
462    /**
463     * Test base sparse pseudo division.
464     */
465    public void testBasePseudoDivisionSparse() {
466        String[] names = new String[] { "x" };
467        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), to, names);
468        GenPolynomialRing<BigRational> rdfac = new GenPolynomialRing<BigRational>(new BigRational(1), dfac);
469        //System.out.println("\ndfac  = " + dfac);
470        //System.out.println("rdfac = " + rdfac);
471
472        a = dfac.random(kl, 2 * ll, el + 17, q);
473        //a = dfac.parse(" 3 x^5 + 44 ");
474        //b = a;
475        b = dfac.random(kl, 2 * ll, el + 3, q);
476        //a = a.multiply(b);
477        //a = a.sum(b);
478        //b = dfac.parse(" 2 x^2 + 40 ");
479        //System.out.println("a   = " + a);
480        //System.out.println("b   = " + b);
481
482        d = PolyUtil.<BigInteger> basePseudoDivide(a, b);
483        //System.out.println("q   = " + d);
484        c = PolyUtil.<BigInteger> baseSparsePseudoRemainder(a, b);
485        //System.out.println("r   = " + c);
486
487        boolean t = PolyUtil.<BigInteger> isBasePseudoQuotientRemainder(a, b, d, c);
488        assertTrue("lc^n a = q b + r: " + c, t);
489
490        GenPolynomial<BigRational> ap = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, a);
491        GenPolynomial<BigRational> bp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, b);
492        GenPolynomial<BigRational> cp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, c);
493        GenPolynomial<BigRational> dp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, d);
494        //System.out.println("ap  = " + ap);
495        //System.out.println("bp  = " + bp);
496        //System.out.println("cp  = " + cp);
497        ////System.out.println("dp  = " + dp);
498        //System.out.println("dp  = " + dp.monic());
499
500        GenPolynomial<BigRational> qp = ap.divide(bp);
501        GenPolynomial<BigRational> rp = ap.remainder(bp);
502        //System.out.println("qp  = " + qp);
503        //System.out.println("qp  = " + qp.monic());
504        //System.out.println("rp  = " + rp);
505        GenPolynomial<BigRational> rhs = qp.multiply(bp).sum(rp);
506        //System.out.println("qp bp + rp  = " + rhs);
507
508        assertEquals("ap = qp bp + rp: ", ap, rhs);
509
510        assertEquals("cp = rp: ", rp.monic(), cp.monic());
511        assertEquals("dp = qp: ", qp.monic(), dp.monic()); // ??
512        //System.out.println("dp = qp: " + qp.monic().equals(dp.monic()) );
513    }
514
515
516    /**
517     * Test base dense pseudo division.
518     */
519    public void testBasePseudoDivisionDense() {
520        String[] names = new String[] { "x" };
521        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), to, names);
522        GenPolynomialRing<BigRational> rdfac = new GenPolynomialRing<BigRational>(new BigRational(1), dfac);
523        //System.out.println("\ndfac  = " + dfac);
524        //System.out.println("rdfac = " + rdfac);
525
526        a = dfac.random(kl, 2 * ll, el + 17, q);
527        //a = dfac.parse(" 3 x^5 + 44 ");
528        //b = a;
529        b = dfac.random(kl, 2 * ll, el + 3, q);
530        //a = a.multiply(b);
531        //a = a.sum(b);
532        //b = dfac.parse(" 2 x^2 + 40 ");
533        //System.out.println("a   = " + a);
534        //System.out.println("b   = " + b);
535
536        d = PolyUtil.<BigInteger> baseDensePseudoQuotient(a, b);
537        //System.out.println("q   = " + d);
538        c = PolyUtil.<BigInteger> baseDensePseudoRemainder(a, b);
539        //System.out.println("r   = " + c);
540
541        boolean t = PolyUtil.<BigInteger> isBasePseudoQuotientRemainder(a, b, d, c);
542        assertTrue("lc^n a = q b + r: " + c, t);
543
544        GenPolynomial<BigRational> ap = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, a);
545        GenPolynomial<BigRational> bp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, b);
546        GenPolynomial<BigRational> cp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, c);
547        GenPolynomial<BigRational> dp = PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, d);
548        //System.out.println("ap  = " + ap);
549        //System.out.println("bp  = " + bp);
550        //System.out.println("cp  = " + cp);
551        ////System.out.println("dp  = " + dp);
552        //System.out.println("dp  = " + dp.monic());
553
554        GenPolynomial<BigRational> qp = ap.divide(bp);
555        GenPolynomial<BigRational> rp = ap.remainder(bp);
556        //System.out.println("qp  = " + qp);
557        //System.out.println("qp  = " + qp.monic());
558        //System.out.println("rp  = " + rp);
559        GenPolynomial<BigRational> rhs = qp.multiply(bp).sum(rp);
560        //System.out.println("qp bp + rp  = " + rhs);
561
562        assertEquals("ap = qp bp + rp: ", ap, rhs);
563
564        assertEquals("cp = rp: ", rp.monic(), cp.monic());
565        assertEquals("dp = qp: ", qp.monic(), dp.monic()); // ??
566        //System.out.println("dp = qp: " + qp.monic().equals(dp.monic()) );
567    }
568
569
570    /**
571     * Test recursive pseudo division.
572     * @see edu.jas.ufd.PolyUfdUtilTest#testRecursivePseudoDivisionSparse
573     */
574    public void testRecursivePseudoDivision() {
575    }
576
577
578    /**
579     * Test evaluate main recursive.
580     */
581    public void testEvalMainRecursive() {
582        ai = (new BigInteger()).random(kl);
583        //System.out.println("ai  = " + ai);
584
585        ar = rfac.getZERO();
586        //System.out.println("ar  = " + ar);
587
588        a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
589        //System.out.println("a   = " + a);
590
591        assertTrue("isZERO( a )", a.isZERO());
592
593        ar = rfac.getONE();
594        //System.out.println("ar  = " + ar);
595
596        a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
597        //System.out.println("a   = " + a);
598
599        assertTrue("isONE( a )", a.isONE());
600
601
602        //ar = rfac.getONE();
603        ar = rfac.random(kl, ll, el, q);
604        //System.out.println("ar  = " + ar);
605        //br = rfac.getONE();
606        br = rfac.random(kl, ll, el, q);
607        //System.out.println("br  = " + br);
608
609        cr = br.sum(ar);
610        //System.out.println("cr  = " + cr);
611
612        a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
613        b = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, br, ai);
614        c = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, cr, ai);
615        //System.out.println("a   = " + a);
616        //System.out.println("b   = " + b);
617        //System.out.println("c   = " + c);
618
619        d = a.sum(b);
620        //System.out.println("d   = " + d);
621
622        assertEquals("eval(a+b) == eval(a) + eval(b)", c, d);
623
624
625        cr = br.multiply(ar);
626        //System.out.println("cr  = " + cr);
627
628        a = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, ar, ai);
629        b = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, br, ai);
630        c = PolyUtil.<BigInteger> evaluateMainRecursive(cfac, cr, ai);
631        //System.out.println("a   = " + a);
632        //System.out.println("b   = " + b);
633        //System.out.println("c   = " + c);
634
635        d = a.multiply(b);
636        //System.out.println("d   = " + d);
637
638        assertEquals("eval(a*b) == eval(a) * eval(b)", c, d);
639    }
640
641
642    /**
643     * Test evaluate main.
644     */
645    public void testEvalMain() {
646        ei = (new BigInteger()).random(kl);
647        //System.out.println("ei  = " + ei);
648
649        cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
650        //System.out.println("cfac  = " + cfac);
651
652        a = cfac.getZERO();
653        //System.out.println("a  = " + a);
654
655        ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
656        //System.out.println("ai   = " + ai);
657
658        assertTrue("isZERO( ai )", ai.isZERO());
659
660        a = cfac.getONE();
661        //System.out.println("a  = " + a);
662
663        ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
664        //System.out.println("ai   = " + ai);
665
666        assertTrue("isONE( ai )", ai.isONE());
667
668        //a = cfac.getONE();
669        a = cfac.random(kl, ll, el, q);
670        //System.out.println("a  = " + a);
671        //b = cfac.getONE();
672        b = cfac.random(kl, ll, el, q);
673        //System.out.println("b  = " + b);
674
675        c = b.sum(a);
676        //System.out.println("c  = " + c);
677
678        ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
679        bi = PolyUtil.<BigInteger> evaluateMain(ei, b, ei);
680        ci = PolyUtil.<BigInteger> evaluateMain(ei, c, ei);
681        //System.out.println("ai   = " + ai);
682        //System.out.println("bi   = " + bi);
683        //System.out.println("ci   = " + ci);
684
685        di = bi.sum(ai);
686        //System.out.println("di   = " + di);
687
688        assertEquals("eval(a+b) == eval(a) + eval(b)", ci, di);
689
690        c = b.multiply(a);
691        //System.out.println("c  = " + c);
692
693        ai = PolyUtil.<BigInteger> evaluateMain(ei, a, ei);
694        bi = PolyUtil.<BigInteger> evaluateMain(ei, b, ei);
695        ci = PolyUtil.<BigInteger> evaluateMain(ei, c, ei);
696        //System.out.println("ai   = " + ai);
697        //System.out.println("bi   = " + bi);
698        //System.out.println("ci   = " + ci);
699
700        di = bi.multiply(ai);
701        //System.out.println("di   = " + di);
702
703        assertEquals("eval(a*b) == eval(a) * eval(b)", ci, di);
704    }
705
706
707    /**
708     * Test evaluate first.
709     */
710    public void testEvalFirst() {
711        ei = (new BigInteger()).random(kl);
712        //System.out.println("ei  = " + ei);
713
714        GenPolynomial<BigInteger> ae, be, ce, de;
715
716        GenPolynomialRing<BigInteger> fac;
717        fac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl, to);
718        //System.out.println("fac  = " + fac);
719
720        cfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
721        //System.out.println("cfac  = " + cfac);
722
723        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), rl - 1, to);
724        //System.out.println("dfac  = " + dfac);
725
726        a = fac.getZERO();
727        //System.out.println("a  = " + a);
728
729        ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
730        //System.out.println("ae   = " + ae);
731
732        assertTrue("isZERO( ae )", ae.isZERO());
733
734        a = fac.getONE();
735        //System.out.println("a  = " + a);
736
737        ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
738        //System.out.println("ae   = " + ae);
739
740        assertTrue("isONE( ae )", ae.isONE());
741
742        //a = fac.getONE();
743        a = fac.random(kl, ll, el, q);
744        //System.out.println("a  = " + a);
745        //b = fac.getONE();
746        b = fac.random(kl, ll, el, q);
747        //System.out.println("b  = " + b);
748
749        c = b.sum(a);
750        //System.out.println("c  = " + c);
751
752        ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
753        be = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, b, ei);
754        ce = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, c, ei);
755        //System.out.println("ae   = " + ae);
756        //System.out.println("be   = " + be);
757        //System.out.println("ce   = " + ce);
758
759        de = be.sum(ae);
760        //System.out.println("de   = " + de);
761
762        assertEquals("eval(a+b) == eval(a) + eval(b)", ce, de);
763
764        c = b.multiply(a);
765        //System.out.println("c  = " + c);
766
767        ae = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, a, ei);
768        be = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, b, ei);
769        ce = PolyUtil.<BigInteger> evaluateFirst(cfac, dfac, c, ei);
770        //System.out.println("ae   = " + ae);
771        //System.out.println("be   = " + be);
772        //System.out.println("ce   = " + ce);
773
774        de = be.multiply(ae);
775        //System.out.println("de   = " + de);
776
777        assertEquals("eval(a*b) == eval(a) * eval(b)", ce, de);
778    }
779
780
781    /**
782     * Test evaluate all.
783     */
784    public void testEvalAll() {
785        BigInteger cfac = new BigInteger();
786
787        List<BigInteger> Ev = new ArrayList<BigInteger>();
788        for (int i = 0; i < rl; i++) {
789            ei = cfac.random(kl);
790            Ev.add(ei);
791        }
792        //System.out.println("Ev  = " + Ev);
793
794        BigInteger ae, be, ce, de;
795
796        GenPolynomialRing<BigInteger> fac;
797        fac = new GenPolynomialRing<BigInteger>(cfac, rl, to);
798        //System.out.println("fac  = " + fac);
799
800        a = fac.getZERO();
801        //System.out.println("a  = " + a);
802
803        ae = PolyUtil.<BigInteger> evaluateAll(cfac, a, Ev);
804        //System.out.println("ae   = " + ae);
805
806        assertTrue("isZERO( ae )", ae.isZERO());
807
808        a = fac.getONE();
809        //System.out.println("a  = " + a);
810
811        ae = PolyUtil.<BigInteger> evaluateAll(cfac, a, Ev);
812        //System.out.println("ae   = " + ae);
813
814        assertTrue("isONE( ae )", ae.isONE());
815
816        //a = fac.getONE();
817        a = fac.random(kl, ll, el, q);
818        //System.out.println("a  = " + a);
819        //b = fac.getONE();
820        b = fac.random(kl, ll, el, q);
821        //System.out.println("b  = " + b);
822
823        c = b.sum(a);
824        //System.out.println("c  = " + c);
825
826        ae = PolyUtil.<BigInteger> evaluateAll(cfac, a, Ev);
827        be = PolyUtil.<BigInteger> evaluateAll(cfac, b, Ev);
828        ce = PolyUtil.<BigInteger> evaluateAll(cfac, c, Ev);
829        //System.out.println("ae   = " + ae);
830        //System.out.println("be   = " + be);
831        //System.out.println("ce   = " + ce);
832
833        de = be.sum(ae);
834        //System.out.println("de   = " + de);
835
836        assertEquals("eval(a+b) == eval(a) + eval(b)", ce, de);
837
838        c = b.multiply(a);
839        //System.out.println("c  = " + c);
840
841        ce = PolyUtil.<BigInteger> evaluateAll(cfac, c, Ev);
842        //System.out.println("ae   = " + ae);
843        //System.out.println("be   = " + be);
844        //System.out.println("ce   = " + ce);
845
846        de = be.multiply(ae);
847        //System.out.println("de   = " + de);
848
849        assertEquals("eval(a*b) == eval(a) * eval(b)", ce, de);
850    }
851
852
853    /**
854     * Test interpolate univariate 1 polynomial.
855     */
856    public void testInterpolateUnivariateOne() {
857        ModInteger ai, bi, ci, di, ei, fi, gi, hi;
858        GenPolynomial<ModInteger> a;
859        GenPolynomialRing<ModInteger> cfac;
860        ModIntegerRing fac;
861        GenPolynomial<ModInteger> r;
862        GenPolynomial<ModInteger> Q;
863        GenPolynomial<ModInteger> Qp;
864
865        fac = new ModIntegerRing(19);
866        //System.out.println("fac.modul  = " + fac.getModul());
867        cfac = new GenPolynomialRing<ModInteger>(fac, 1, to);
868        //System.out.println("cfac  = " + cfac);
869
870        a = cfac.getONE();
871        //System.out.println("a  = " + a);
872
873        ei = fac.fromInteger(11);
874        //System.out.println("ei  = " + ei);
875        // a(ei)
876        ai = PolyUtil.<ModInteger> evaluateMain(fac, a, ei);
877        //System.out.println("ai   = " + ai);
878        assertTrue("isONE( ai )", ai.isONE());
879
880        di = fac.fromInteger(13);
881        //System.out.println("di  = " + di);
882        // a(di)
883        bi = PolyUtil.<ModInteger> evaluateMain(fac, a, di);
884        //System.out.println("bi   = " + bi);
885        assertTrue("isONE( bi )", bi.isONE());
886
887        // interpolation result
888        r = cfac.getZERO();
889        //System.out.println("r   = " + r);
890
891        // interpolation polynomials product
892        Q = cfac.getONE();
893        //System.out.println("Q   = " + Q);
894
895        ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
896        //System.out.println("ci   = " + ci);
897        // Q(ei)^-1
898        fi = ci.inverse();
899        //System.out.println("fi   = " + fi);
900        r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ai, ei);
901        //System.out.println("r   = " + r);
902
903        // next evaluation polynomial
904        Qp = cfac.univariate(0);
905        Qp = Qp.subtract(cfac.getONE().multiply(ei));
906        //System.out.println("Qp   = " + Qp);
907        Q = Q.multiply(Qp);
908        //System.out.println("Q   = " + Q);
909
910        ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, di);
911        //System.out.println("ci   = " + ci);
912        // Q(di)^-1
913        fi = ci.inverse();
914        //System.out.println("fi   = " + fi);
915        r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, bi, di);
916        //System.out.println("r   = " + r);
917
918        // check evaluation
919        gi = PolyUtil.<ModInteger> evaluateMain(fac, r, ei);
920        //System.out.println("gi   = " + gi);
921        hi = PolyUtil.<ModInteger> evaluateMain(fac, r, di);
922        //System.out.println("hi   = " + hi);
923        assertTrue("gi == 1 ", gi.isONE());
924        assertTrue("hi == 1 ", hi.isONE());
925
926        //            interpolate( a(ei), a(di) )            = a (mod 19)
927        assertEquals("interpolate(a mod (x-ei),a mod (x-di)) = a (mod 19)", a, r);
928    }
929
930
931    /**
932     * Test interpolate univariate deg &gt; 0 polynomial.
933     */
934    public void testInterpolateUnivariate() {
935        ModInteger ai, ci, ei, fi;
936        GenPolynomial<ModInteger> a;
937        GenPolynomialRing<ModInteger> cfac;
938        ModIntegerRing fac;
939        GenPolynomial<ModInteger> r;
940        GenPolynomial<ModInteger> Q;
941        GenPolynomial<ModInteger> Qp;
942
943        //long prime = 19;
944        long prime = getPrime1().longValue();
945        fac = new ModIntegerRing(prime);
946        //System.out.println("fac.modul  = " + fac.getModul());
947        cfac = new GenPolynomialRing<ModInteger>(fac, 1, to);
948        //System.out.println("cfac  = " + cfac);
949        int maxdeg = 19;
950
951        // polynomial to interpolate
952        long deg = 0;
953        do {
954            a = cfac.random(kl, ll, maxdeg, q);
955            if (!a.isZERO()) {
956                deg = a.degree(0);
957            }
958        } while (deg <= 0);
959        //System.out.println("a  = " + a);
960        //System.out.println("deg  = " + deg);
961
962        // interpolation result
963        r = cfac.getZERO();
964        //System.out.println("r   = " + r);
965
966        // interpolation polynomials product
967        Q = cfac.getONE();
968        //System.out.println("Q   = " + Q);
969
970        long i = -1;
971        long qdeg;
972        do {
973            i++;
974            if (i >= prime) {
975                assertTrue("elements of Z_prime exhausted", i < prime);
976            }
977            qdeg = Q.degree(0);
978            ei = fac.fromInteger(i);
979            //System.out.println("ei  = " + ei);
980            // a(ei)
981            ai = PolyUtil.<ModInteger> evaluateMain(fac, a, ei);
982            //System.out.println("ai   = " + ai);
983
984            ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
985            //System.out.println("ci   = " + ci);
986            // Q(ei)^-1
987            fi = ci.inverse();
988            //System.out.println("fi   = " + fi);
989            r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ai, ei);
990            //System.out.println("r   = " + r);
991
992            // next evaluation polynomial
993            Qp = cfac.univariate(0);
994            Qp = Qp.subtract(cfac.getONE().multiply(ei));
995            //System.out.println("Qp   = " + Qp);
996            Q = Q.multiply(Qp);
997            //System.out.println("Q   = " + Q);
998        } while (qdeg < deg);
999
1000        //System.out.println("a   = " + a);
1001        //System.out.println("r   = " + r);
1002
1003        //            interpolate( a(e1), ..., a(ei) )           = a (mod 19)
1004        assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
1005    }
1006
1007
1008    /**
1009     * Test interpolate multivariate deg &gt; 0 polynomial.
1010     */
1011    public void testInterpolateMultivariate() {
1012        ModInteger ci, ei, fi;
1013        GenPolynomial<ModInteger> ap, bp;
1014        GenPolynomial<GenPolynomial<ModInteger>> a;
1015        GenPolynomialRing<GenPolynomial<ModInteger>> cfac;
1016        GenPolynomialRing<ModInteger> ufac;
1017        GenPolynomialRing<ModInteger> dfac;
1018        ModIntegerRing fac;
1019        GenPolynomial<GenPolynomial<ModInteger>> r;
1020        GenPolynomial<ModInteger> Q;
1021        GenPolynomial<ModInteger> Qp;
1022
1023        //long prime = 19;
1024        long prime = getPrime1().longValue();
1025        fac = new ModIntegerRing(prime);
1026        //System.out.println("fac.modul  = " + fac.getModul());
1027        ufac = new GenPolynomialRing<ModInteger>(fac, 1, to);
1028        //System.out.println("ufac  = " + ufac);
1029        cfac = new GenPolynomialRing<GenPolynomial<ModInteger>>(ufac, rl, to);
1030        //System.out.println("cfac  = " + cfac);
1031        dfac = new GenPolynomialRing<ModInteger>(fac, rl, to);
1032        //System.out.println("dfac  = " + dfac);
1033        int maxdeg = 19;
1034
1035        // polynomial to interpolate
1036        long deg = 0;
1037        do {
1038            a = cfac.random(kl, ll + 9, maxdeg, q);
1039            if (!a.isZERO()) {
1040                deg = PolyUtil.<ModInteger> coeffMaxDegree(a);
1041            }
1042        } while (deg <= 0);
1043        //System.out.println("a  = " + a);
1044        //System.out.println("deg  = " + deg);
1045        ExpVector degv = a.degreeVector();
1046        //System.out.println("degv  = " + degv);
1047
1048        // interpolation result
1049        r = cfac.getZERO();
1050        //System.out.println("r   = " + r);
1051
1052        // interpolation polynomials product
1053        Q = ufac.getONE();
1054        //System.out.println("Q   = " + Q);
1055
1056        long i = -1;
1057        long qdeg;
1058        ExpVector qdegv;
1059        do {
1060            i++;
1061            if (i >= prime) {
1062                assertTrue("elements of Z_prime exhausted", i < prime);
1063            }
1064            qdeg = Q.degree(0);
1065            ei = fac.fromInteger(i);
1066            //System.out.println("ei  = " + ei);
1067            // a(ei)
1068            ap = PolyUtil.<ModInteger> evaluateFirstRec(ufac, dfac, a, ei);
1069            //System.out.println("ap   = " + ap);
1070            qdegv = ap.degreeVector();
1071            //System.out.println("qdegv = " + qdegv);
1072            if (!degv.equals(qdegv)) {
1073                continue;
1074            }
1075            ci = PolyUtil.<ModInteger> evaluateMain(fac, Q, ei);
1076            //System.out.println("ci   = " + ci);
1077            // Q(ei)^-1
1078            fi = ci.inverse();
1079            //System.out.println("fi   = " + fi);
1080            r = PolyUtil.<ModInteger> interpolate(cfac, r, Q, fi, ap, ei);
1081            //System.out.println("r   = " + r);
1082
1083            // check
1084            bp = PolyUtil.<ModInteger> evaluateFirstRec(ufac, dfac, r, ei);
1085            //System.out.println("bp   = " + bp);
1086            assertEquals("interpolate(a)(ei) == a ", bp, ap);
1087
1088
1089            // next evaluation polynomial
1090            Qp = ufac.univariate(0);
1091            Qp = Qp.subtract(ufac.getONE().multiply(ei));
1092            //System.out.println("Qp   = " + Qp);
1093            Q = Q.multiply(Qp);
1094            //System.out.println("Q   = " + Q);
1095        } while (qdeg <= deg);
1096
1097        //System.out.println("a   = " + a);
1098        //System.out.println("r   = " + r);
1099
1100        //            interpolate( a(e1), ..., a(ei) )           = a (mod 19)
1101        assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
1102    }
1103
1104
1105    /**
1106     * Test interpolate rational multivariate deg &gt; 0 polynomial.
1107     */
1108    public void testInterpolateRationalMultivariate() {
1109        BigRational ci, ei, fi;
1110        GenPolynomial<BigRational> ap, bp;
1111        GenPolynomial<GenPolynomial<BigRational>> a;
1112        GenPolynomialRing<GenPolynomial<BigRational>> cfac;
1113        GenPolynomialRing<BigRational> ufac;
1114        GenPolynomialRing<BigRational> dfac;
1115        BigRational fac;
1116        GenPolynomial<GenPolynomial<BigRational>> r;
1117        GenPolynomial<BigRational> Q;
1118        GenPolynomial<BigRational> Qp;
1119
1120        fac = new BigRational();
1121        //System.out.println("fac.modul  = " + fac.getModul());
1122        ufac = new GenPolynomialRing<BigRational>(fac, 1, to);
1123        //System.out.println("ufac  = " + ufac);
1124        cfac = new GenPolynomialRing<GenPolynomial<BigRational>>(ufac, rl, to);
1125        //System.out.println("cfac  = " + cfac);
1126        dfac = new GenPolynomialRing<BigRational>(fac, rl, to);
1127        //System.out.println("dfac  = " + dfac);
1128        int maxdeg = 19;
1129
1130        // polynomial to interpolate
1131        long deg = 0;
1132        do {
1133            a = cfac.random(kl, ll + 9, maxdeg, q);
1134            if (!a.isZERO()) {
1135                deg = PolyUtil.<BigRational> coeffMaxDegree(a);
1136            }
1137        } while (deg <= 0);
1138        //System.out.println("a  = " + a);
1139        //System.out.println("deg  = " + deg);
1140        ExpVector degv = a.degreeVector();
1141        //System.out.println("degv  = " + degv);
1142
1143        // interpolation result
1144        r = cfac.getZERO();
1145        //System.out.println("r   = " + r);
1146
1147        // interpolation polynomials product
1148        Q = ufac.getONE();
1149        //System.out.println("Q   = " + Q);
1150
1151        long i = -1;
1152        long qdeg;
1153        ExpVector qdegv;
1154        do {
1155            i++;
1156            qdeg = Q.degree(0);
1157            ei = fac.fromInteger(i);
1158            //System.out.println("ei  = " + ei);
1159            // a(ei)
1160            ap = PolyUtil.<BigRational> evaluateFirstRec(ufac, dfac, a, ei);
1161            //System.out.println("ap   = " + ap);
1162            qdegv = ap.degreeVector();
1163            //System.out.println("qdegv = " + qdegv);
1164            if (!degv.equals(qdegv)) {
1165                continue;
1166            }
1167            ci = PolyUtil.<BigRational> evaluateMain(fac, Q, ei);
1168            //System.out.println("ci   = " + ci);
1169            // Q(ei)^-1
1170            fi = ci.inverse();
1171            //System.out.println("fi   = " + fi);
1172            r = PolyUtil.<BigRational> interpolate(cfac, r, Q, fi, ap, ei);
1173            //System.out.println("r   = " + r);
1174
1175            // check
1176            bp = PolyUtil.<BigRational> evaluateFirstRec(ufac, dfac, r, ei);
1177            //System.out.println("bp   = " + bp);
1178            assertEquals("interpolate(a)(ei) == a ", bp, ap);
1179
1180
1181            // next evaluation polynomial
1182            Qp = ufac.univariate(0);
1183            Qp = Qp.subtract(ufac.getONE().multiply(ei));
1184            //System.out.println("Qp   = " + Qp);
1185            Q = Q.multiply(Qp);
1186            //System.out.println("Q   = " + Q);
1187        } while (qdeg <= deg);
1188
1189        //System.out.println("a   = " + a);
1190        //System.out.println("r   = " + r);
1191
1192        //            interpolate( a(e1), ..., a(ei) )           = a (mod 19)
1193        assertEquals("interpolate(a mod (x-e1),...,a mod (x-ei)) = a (mod 19)", a, r);
1194    }
1195
1196
1197    /**
1198     * Test coefficient map function.
1199     */
1200    public void testMap() {
1201        // integers
1202        BigInteger fi = new BigInteger();
1203        //System.out.println("fi = " + fi);
1204
1205        // rational numbers
1206        BigRational fr = new BigRational();
1207        //System.out.println("fr = " + fr);
1208
1209        // modular integers
1210        ModIntegerRing fm = new ModIntegerRing(17);
1211        //System.out.println("fm = " + fm);
1212
1213        // polynomials over integral numbers
1214        GenPolynomialRing<BigInteger> pfi = new GenPolynomialRing<BigInteger>(fi, rl);
1215        //System.out.println("pfi = " + pfi);
1216
1217        // polynomials over rational numbers
1218        GenPolynomialRing<BigRational> pfr = new GenPolynomialRing<BigRational>(fr, rl);
1219        //System.out.println("pfr = " + pfr);
1220
1221        // polynomials over modular integers
1222        GenPolynomialRing<ModInteger> pfm = new GenPolynomialRing<ModInteger>(fm, rl);
1223        //System.out.println("pfm = " + pfm);
1224
1225
1226        // random polynomial
1227        GenPolynomial<BigInteger> pi = pfi.random(kl, 2 * ll, el, q);
1228        //System.out.println("pi = " + pi);
1229
1230        // random polynomial
1231        GenPolynomial<BigRational> pr = pfr.random(kl, 2 * ll, el, q).monic();
1232        //System.out.println("pr = " + pr);
1233
1234        // random polynomial
1235        GenPolynomial<ModInteger> pm = pfm.random(kl, 2 * ll, el, q);
1236        //System.out.println("pm = " + pm);
1237
1238        // test integer to rational and back
1239        GenPolynomial<BigRational> qr;
1240        GenPolynomial<BigInteger> qi;
1241        qr = PolyUtil.<BigInteger, BigRational> map(pfr, pi, new FromInteger<BigRational>(fr));
1242        qi = PolyUtil.<BigRational, BigInteger> map(pfi, qr, new RatNumer());
1243        //System.out.println("qr = " + qr);
1244        //System.out.println("qi = " + qi);
1245        assertEquals("pi == qi ", pi, qi);
1246
1247        // test rational to integer and back
1248        qi = PolyUtil.integerFromRationalCoefficients(pfi, pr);
1249        qr = PolyUtil.<BigInteger, BigRational> map(pfr, qi, new FromInteger<BigRational>(fr));
1250        qr = qr.monic();
1251        //System.out.println("pr = " + pr);
1252        //System.out.println("qr = " + qr);
1253        //System.out.println("qi = " + qi);
1254        assertEquals("pr == qr ", pr, qr);
1255
1256        // test symmetric modular integer to integer and back
1257        GenPolynomial<ModInteger> qm;
1258        qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModSymToInt<ModInteger>());
1259        qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1260        //System.out.println("qi = " + qi);
1261        //System.out.println("qm = " + qm);
1262        assertEquals("pm == qm ", pm, qm);
1263
1264        // test modular integer to integer and back
1265        qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModToInt<ModInteger>());
1266        qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1267        //System.out.println("qi = " + qi);
1268        //System.out.println("qm = " + qm);
1269        assertEquals("pm == qm ", pm, qm);
1270
1271        // test symmetric modular integer to integer to rational and back
1272        qi = PolyUtil.<ModInteger, BigInteger> map(pfi, pm, new ModSymToInt<ModInteger>());
1273        qr = PolyUtil.<BigInteger, BigRational> map(pfr, qi, new FromInteger<BigRational>(fr));
1274        qi = PolyUtil.<BigRational, BigInteger> map(pfi, qr, new RatNumer());
1275        qm = PolyUtil.<BigInteger, ModInteger> map(pfm, qi, new FromInteger<ModInteger>(fm));
1276        //System.out.println("qi = " + qi);
1277        //System.out.println("qm = " + qm);
1278        assertEquals("pm == qm ", pm, qm);
1279    }
1280
1281
1282    /**
1283     * Test substitution.
1284     */
1285    public void testSubstitution() {
1286        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 1, to);
1287
1288        // subs = x - 7
1289        GenPolynomial<BigInteger> s = dfac.univariate(0).subtract(dfac.fromInteger(7));
1290        GenPolynomial<BigInteger> s1 = dfac.univariate(0).sum(dfac.fromInteger(7));
1291        //System.out.println("s = " + s);
1292        //System.out.println("s1 = " + s1);
1293
1294        for (int i = 0; i < 5; i++) {
1295            a = dfac.random(kl, ll, el, q);
1296            //System.out.println("a = " + a);
1297            b = PolyUtil.<BigInteger> substituteMain(a, s);
1298            c = PolyUtil.<BigInteger> substituteMain(b, s1);
1299            //System.out.println("b = " + b);
1300            //System.out.println("c = " + c);
1301            //System.out.println("a == c " + a.equals(c));
1302            assertEquals("a == c ", a, c);
1303        }
1304    }
1305
1306
1307    /**
1308     * Test algebraic substitution.
1309     */
1310    public void testAlgebraicSubstitution() {
1311
1312        BigRational cfac = new BigRational(1);
1313        String[] alpha = new String[] { "alpha" };
1314        String[] vars = new String[] { "z" };
1315        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
1316        GenPolynomial<BigRational> agen = pfac.univariate(0, 2);
1317        agen = agen.sum(pfac.getONE()); // x^2 + 1
1318        AlgebraicNumberRing<BigRational> afac = new AlgebraicNumberRing<BigRational>(agen, true);
1319        GenPolynomialRing<AlgebraicNumber<BigRational>> apfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(
1320                        afac, 1, to, vars); // univariate
1321
1322        //System.out.println("agen  = " + agen);
1323        //System.out.println("afac  = " + afac);
1324        //System.out.println("apfac = " + apfac);
1325
1326        // subs = x - 7
1327        GenPolynomial<AlgebraicNumber<BigRational>> s = apfac.univariate(0)
1328                        .subtract(apfac.fromInteger(7).multiply(afac.getGenerator()));
1329        GenPolynomial<AlgebraicNumber<BigRational>> s1 = apfac.univariate(0)
1330                        .sum(apfac.fromInteger(7).multiply(afac.getGenerator()));
1331        //System.out.println("s = " + s);
1332        //System.out.println("s1 = " + s1);
1333
1334        GenPolynomial<AlgebraicNumber<BigRational>> a, b, c;
1335        for (int i = 0; i < 5; i++) {
1336            a = apfac.random(kl, ll, el, q);
1337            //System.out.println("a = " + a);
1338            b = PolyUtil.<AlgebraicNumber<BigRational>> substituteMain(a, s);
1339            c = PolyUtil.<AlgebraicNumber<BigRational>> substituteMain(b, s1);
1340            //System.out.println("b = " + b);
1341            //System.out.println("c = " + c);
1342            //System.out.println("a == c " + a.equals(c));
1343            assertEquals("a == c ", a, c);
1344        }
1345    }
1346
1347
1348    /**
1349     * Test multivariate substitution.
1350     */
1351    public void testMultivarSubstitution() {
1352        dfac = new GenPolynomialRing<BigInteger>(new BigInteger(1), 2, to);
1353        // subs = x - 7
1354        GenPolynomial<BigInteger> s = dfac.univariate(0).subtract(dfac.fromInteger(7));
1355        GenPolynomial<BigInteger> s1 = dfac.univariate(0).sum(dfac.fromInteger(7));
1356        //System.out.println("s = " + s);
1357        //System.out.println("s1 = " + s1);
1358
1359        for (int i = 0; i < 5; i++) {
1360            a = dfac.random(kl, ll, el, q);
1361            //System.out.println("a = " + a);
1362            b = PolyUtil.<BigInteger> substituteUnivariateMult(a, s);
1363            c = PolyUtil.<BigInteger> substituteUnivariateMult(b, s1);
1364            //System.out.println("b = " + b);
1365            //System.out.println("c = " + c);
1366            //System.out.println("a == c " + a.equals(c));
1367            assertEquals("a == c ", a, c);
1368        }
1369    }
1370
1371
1372    /**
1373     * Test switch variables.
1374     */
1375    public void testSwitchVariables() {
1376        BigRational cfac = new BigRational(1);
1377        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, rl, to);
1378        GenPolynomialRing<GenPolynomial<BigRational>> rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(
1379                        pfac, rl, to);
1380
1381        //System.out.println("pfac  = " + pfac);
1382        //System.out.println("rfac  = " + rfac);
1383
1384        GenPolynomial<GenPolynomial<BigRational>> a, c;
1385        GenPolynomial<GenPolynomial<BigRational>> b;
1386        for (int i = 0; i < 5; i++) {
1387            a = rfac.random(kl, ll, el, q);
1388            //System.out.println("a = " + a);
1389            b = PolyUtil.<BigRational> switchVariables(a);
1390            c = PolyUtil.<BigRational> switchVariables(b);
1391            //System.out.println("b = " + b);
1392            //System.out.println("c = " + c);
1393            //System.out.println("a == c " + a.equals(c));
1394            assertEquals("a == c ", a, c);
1395        }
1396    }
1397
1398
1399    /**
1400     * Test algebraic conversions.
1401     */
1402    public void testAlgebraicConversions() {
1403
1404        BigRational cfac = new BigRational(1);
1405        String[] alpha = new String[] { "alpha" };
1406        //String[] vars = new String[] { "z" };
1407        GenPolynomialRing<BigRational> pfac = new GenPolynomialRing<BigRational>(cfac, 1, to, alpha);
1408        GenPolynomial<BigRational> agen = pfac.univariate(0, 2);
1409        agen = agen.sum(pfac.getONE()); // x^2 + 1
1410        AlgebraicNumberRing<BigRational> afac = new AlgebraicNumberRing<BigRational>(agen, true);
1411        GenPolynomialRing<AlgebraicNumber<BigRational>> apfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(
1412                        afac, rl, to);
1413        GenPolynomialRing<GenPolynomial<BigRational>> rfac = new GenPolynomialRing<GenPolynomial<BigRational>>(
1414                        pfac, rl, to);
1415
1416        //System.out.println("agen  = " + agen);
1417        //System.out.println("afac  = " + afac);
1418        //System.out.println("apfac = " + apfac);
1419        //System.out.println("pfac  = " + pfac);
1420        //System.out.println("rfac  = " + rfac);
1421
1422        GenPolynomial<AlgebraicNumber<BigRational>> a, c;
1423        GenPolynomial<GenPolynomial<BigRational>> b;
1424        for (int i = 0; i < 5; i++) {
1425            a = apfac.random(kl, ll, el, q);
1426            //System.out.println("a = " + a);
1427            b = PolyUtil.<BigRational> fromAlgebraicCoefficients(rfac, a);
1428            c = PolyUtil.<BigRational> convertRecursiveToAlgebraicCoefficients(apfac, b);
1429            //System.out.println("b = " + b);
1430            //System.out.println("c = " + c);
1431            //System.out.println("a == c " + a.equals(c));
1432            assertEquals("a == c ", a, c);
1433        }
1434    }
1435
1436
1437    /**
1438     * Test Taylor series.
1439     */
1440    public void testTaylorSeries() {
1441        GenPolynomial<BigRational> a;
1442        GenPolynomial<BigRational> b;
1443        GenPolynomial<BigRational> c;
1444        GenPolynomialRing<BigRational> dfac;
1445        BigRational cfac;
1446
1447        cfac = new BigRational(1);
1448        String[] vars = new String[] { "x" };
1449        dfac = new GenPolynomialRing<BigRational>(cfac, 1, to, vars);
1450
1451        a = dfac.random(kl, ll, el, q);
1452        //System.out.println("a = " + a);
1453
1454        BigRational v = cfac.getZERO();
1455        //System.out.println("v = " + v);
1456
1457        b = PolyUtil.<BigRational> seriesOfTaylor(a, v);
1458        //System.out.println("taylor(a,0) = " + b);
1459        assertTrue("taylor(a,0) == a ", a.equals(b));
1460
1461        v = cfac.random(kl);
1462        //System.out.println("v = " + v);
1463
1464        b = PolyUtil.<BigRational> seriesOfTaylor(a, v);
1465        //System.out.println("taylor(a,v) = " + b);
1466
1467        c = PolyUtil.<BigRational> seriesOfTaylor(b, v.negate());
1468        //System.out.println("tailor(taylor(a,v),-v) = " + c);
1469        assertTrue("tailor(taylor(a,v),-v) == a ", a.equals(c));
1470    }
1471
1472
1473    /**
1474     * Test Complex real and imaginary part.
1475     */
1476    public void testComplexParts() {
1477        BigRational rf = new BigRational(1);
1478        GenPolynomialRing<BigRational> rfac = new GenPolynomialRing<BigRational>(rf, rl, to);
1479
1480        ComplexRing<BigRational> cf = new ComplexRing<BigRational>(new BigRational(1));
1481        GenPolynomialRing<Complex<BigRational>> cfac = new GenPolynomialRing<Complex<BigRational>>(cf, rl,
1482                        to);
1483
1484        Complex<BigRational> imag = cf.getIMAG();
1485
1486        GenPolynomial<BigRational> rp;
1487        GenPolynomial<BigRational> ip;
1488        GenPolynomial<Complex<BigRational>> crp;
1489        GenPolynomial<Complex<BigRational>> cip;
1490        GenPolynomial<Complex<BigRational>> cp;
1491        GenPolynomial<Complex<BigRational>> ap;
1492
1493        for (int i = 0; i < 3; i++) {
1494            cp = cfac.random(kl + 2 * i, ll * (i + 1), el + i, q);
1495
1496            assertTrue("length( c" + i + " ) <> 0", cp.length() >= 0);
1497            assertTrue(" not isZERO( c" + i + " )", !cp.isZERO());
1498            assertTrue(" not isONE( c" + i + " )", !cp.isONE());
1499
1500            rp = PolyUtil.<BigRational> realPartFromComplex(rfac, cp);
1501            ip = PolyUtil.<BigRational> imaginaryPartFromComplex(rfac, cp);
1502
1503            crp = PolyUtil.<BigRational> toComplex(cfac, rp);
1504            cip = PolyUtil.<BigRational> toComplex(cfac, ip);
1505
1506            ap = crp.sum(cip.multiply(imag));
1507
1508            //System.out.println("cp = " + cp);
1509            //System.out.println("rp = " + rp);
1510            //System.out.println("ip = " + ip);
1511            //System.out.println("crp = " + crp);
1512            //System.out.println("cip = " + cip);
1513            //System.out.println("ap  = " + ap);
1514
1515            assertEquals("re(c)+i*im(c) = c", cp, ap);
1516        }
1517    }
1518
1519
1520    /**
1521     * Test product represenation conversion, rational numbers.
1522     */
1523    public void testProductConversionRN() {
1524        GenPolynomialRing<BigRational> ufac;
1525        ufac = new GenPolynomialRing<BigRational>(new BigRational(1), 1);
1526
1527        ProductRing<GenPolynomial<BigRational>> pfac;
1528        pfac = new ProductRing<GenPolynomial<BigRational>>(ufac, rl);
1529
1530        GenPolynomialRing<BigRational> dfac = new GenPolynomialRing<BigRational>(new BigRational(1), rl, to);
1531
1532        GenPolynomial<BigRational> c;
1533        Product<GenPolynomial<BigRational>> cp;
1534
1535        c = dfac.getONE();
1536        //System.out.println("c = " + c);
1537
1538        cp = PolyUtil.<BigRational> toProduct(pfac, c);
1539        //System.out.println("cp = " + cp);
1540        assertTrue("isONE( cp )", cp.isONE());
1541
1542        c = dfac.random(kl, ll, el, q);
1543        //System.out.println("c = " + c);
1544
1545        cp = PolyUtil.<BigRational> toProduct(pfac, c);
1546        //System.out.println("cp = " + cp);
1547        assertTrue("!isONE( cp )", !cp.isONE());
1548    }
1549
1550
1551    /**
1552     * Test polynomal over product represenation conversion, algebraic numbers.
1553     */
1554    public void testPolyProductConversionAN() {
1555        GenPolynomialRing<BigRational> ufac;
1556        ufac = new GenPolynomialRing<BigRational>(new BigRational(1), 1);
1557
1558        GenPolynomial<BigRational> m;
1559        m = ufac.univariate(0, 2);
1560        m = m.subtract(ufac.univariate(0, 1));
1561        //System.out.println("m = " + m);
1562
1563        AlgebraicNumberRing<BigRational> afac;
1564        afac = new AlgebraicNumberRing<BigRational>(m);
1565        //System.out.println("afac = " + afac);
1566
1567        ProductRing<AlgebraicNumber<BigRational>> pfac;
1568        pfac = new ProductRing<AlgebraicNumber<BigRational>>(afac, rl);
1569
1570        GenPolynomialRing<Product<AlgebraicNumber<BigRational>>> dpfac;
1571        dpfac = new GenPolynomialRing<Product<AlgebraicNumber<BigRational>>>(pfac, 2);
1572
1573        GenPolynomialRing<AlgebraicNumber<BigRational>> dfac;
1574        dfac = new GenPolynomialRing<AlgebraicNumber<BigRational>>(afac, 2, to);
1575
1576
1577        GenPolynomial<AlgebraicNumber<BigRational>> c;
1578        GenPolynomial<Product<AlgebraicNumber<BigRational>>> cp;
1579
1580        c = dfac.getONE();
1581        //System.out.println("c = " + c);
1582
1583        cp = PolyUtil.<AlgebraicNumber<BigRational>> toProductGen(dpfac, c);
1584        //System.out.println("cp = " + cp);
1585        assertTrue("isZERO( cp )", cp.isONE());
1586
1587        c = dfac.random(kl, ll, el, q);
1588        //System.out.println("c = " + c);
1589
1590        cp = PolyUtil.<AlgebraicNumber<BigRational>> toProductGen(dpfac, c);
1591        //System.out.println("cp = " + cp);
1592        assertTrue("!isONE( cp )", !cp.isONE());
1593    }
1594
1595
1596    /**
1597     * Test remove unused upper varaibles.
1598     */
1599    public void testRemoveUnusedUpper() {
1600        //System.out.println("dfac = " + dfac);
1601        a = dfac.univariate(3, 2);
1602        b = a.subtract(dfac.univariate(1, 1));
1603        //System.out.println("a = " + a);
1604        //System.out.println("b = " + b);
1605
1606        c = PolyUtil.<BigInteger> removeUnusedUpperVariables(b);
1607        //System.out.println("c = " + c + ", fac = " + c.ring);
1608        assertTrue("#var == 4: " + c.ring.nvar, c.ring.nvar == 4);
1609
1610        a = dfac.univariate(3, 2);
1611        //System.out.println("a = " + a);
1612
1613        c = PolyUtil.<BigInteger> removeUnusedUpperVariables(a);
1614        //System.out.println("c = " + c + ", fac = " + c.ring);
1615        assertTrue("#var == 2: " + c.ring.nvar, c.ring.nvar == 2);
1616
1617        a = dfac.univariate(1, 2);
1618        //System.out.println("a = " + a);
1619
1620        c = PolyUtil.<BigInteger> removeUnusedUpperVariables(a);
1621        //System.out.println("c = " + c + ", fac = " + c.ring);
1622        assertTrue("#var == 4: " + c.ring.nvar, c.ring.nvar == 4);
1623    }
1624
1625
1626    /**
1627     * Test remove unused lower varaibles.
1628     */
1629    public void testRemoveUnusedLower() {
1630        //System.out.println("dfac = " + dfac);
1631        a = dfac.univariate(3, 2);
1632        b = a.subtract(dfac.univariate(1, 1));
1633        //System.out.println("a = " + a);
1634        //System.out.println("b = " + b);
1635
1636        c = PolyUtil.<BigInteger> removeUnusedLowerVariables(b);
1637        //System.out.println("c = " + c + ", fac = " + c.ring);
1638        assertTrue("#var == 4: " + c.ring.nvar, c.ring.nvar == 4);
1639
1640        a = dfac.univariate(3, 2);
1641        //System.out.println("a = " + a);
1642
1643        c = PolyUtil.<BigInteger> removeUnusedLowerVariables(a);
1644        //System.out.println("c = " + c + ", fac = " + c.ring);
1645        assertTrue("#var == 4: " + c.ring.nvar, c.ring.nvar == 4);
1646
1647        a = dfac.univariate(1, 2);
1648        //System.out.println("a = " + a);
1649
1650        c = PolyUtil.<BigInteger> removeUnusedLowerVariables(a);
1651        //System.out.println("c = " + c + ", fac = " + c.ring);
1652        assertTrue("#var == 2: " + c.ring.nvar, c.ring.nvar == 2);
1653    }
1654
1655
1656    /**
1657     * Test remove unused middle varaibles.
1658     */
1659    public void testRemoveUnusedMiddle() {
1660        //System.out.println("dfac = " + dfac);
1661        a = dfac.univariate(4, 2);
1662        b = a.subtract(dfac.univariate(0, 1));
1663        //System.out.println("a = " + a);
1664        //System.out.println("b = " + b);
1665
1666        c = PolyUtil.<BigInteger> removeUnusedLowerVariables(b);
1667        //System.out.println("c = " + c + ", fac = " + c.ring);
1668        assertTrue("#var == 5: " + c.ring.nvar, c.ring.nvar == 5);
1669        c = PolyUtil.<BigInteger> removeUnusedUpperVariables(c);
1670        //System.out.println("c = " + c + ", fac = " + c.ring);
1671        assertTrue("#var == 5: " + c.ring.nvar, c.ring.nvar == 5);
1672
1673        c = PolyUtil.<BigInteger> removeUnusedMiddleVariables(c);
1674        //System.out.println("c = " + c + ", fac = " + c.ring);
1675        assertTrue("#var == 2: " + c.ring.nvar, c.ring.nvar == 2);
1676
1677        a = dfac.univariate(3, 2);
1678        b = a.subtract(dfac.univariate(1, 1));
1679        //System.out.println("a = " + a);
1680        //System.out.println("b = " + b);
1681
1682        try {
1683            c = PolyUtil.<BigInteger> removeUnusedMiddleVariables(b);
1684            fail("c = " + c + ", fac = " + c.ring);
1685        } catch (RuntimeException e) {
1686            // success
1687        }
1688
1689        c = PolyUtil.<BigInteger> removeUnusedLowerVariables(b);
1690        //System.out.println("c = " + c + ", fac = " + c.ring);
1691        assertTrue("#var == 4: " + c.ring.nvar, c.ring.nvar == 4);
1692        c = PolyUtil.<BigInteger> removeUnusedUpperVariables(c);
1693        //System.out.println("c = " + c + ", fac = " + c.ring);
1694        assertTrue("#var == 3: " + c.ring.nvar, c.ring.nvar == 3);
1695
1696        c = PolyUtil.<BigInteger> removeUnusedMiddleVariables(c);
1697        //System.out.println("c = " + c + ", fac = " + c.ring);
1698        assertTrue("#var == 2: " + c.ring.nvar, c.ring.nvar == 2);
1699    }
1700
1701}