Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.fd;
006
007
008import java.util.List;
009import java.util.ArrayList;
010import java.util.Collection;
011
012import edu.jas.arith.BigInteger;
013import edu.jas.arith.BigRational;
014import edu.jas.kern.ComputerThreads;
015import edu.jas.poly.GenPolynomial;
016import edu.jas.poly.GenSolvablePolynomial;
017import edu.jas.poly.GenSolvablePolynomialRing;
018import edu.jas.poly.PolyUtil;
019import edu.jas.poly.RecSolvablePolynomial;
020import edu.jas.poly.RecSolvablePolynomialRing;
021import edu.jas.poly.RelationGenerator;
022import edu.jas.poly.TermOrder;
023import edu.jas.poly.WeylRelationsIterated;
024
025import junit.framework.Test;
026import junit.framework.TestCase;
027import junit.framework.TestSuite;
028
029
030/**
031 * FDUtil tests with JUnit.
032 * @author Heinz Kredel
033 */
034
035public class FDUtilTest extends TestCase {
036
037
038    /**
039     * main.
040     */
041    public static void main(String[] args) {
042        junit.textui.TestRunner.run(suite());
043        ComputerThreads.terminate();
044    }
045
046
047    /**
048     * Constructs a <CODE>FDUtilTest</CODE> object.
049     * @param name String.
050     */
051    public FDUtilTest(String name) {
052        super(name);
053    }
054
055
056    /**
057     */
058    public static Test suite() {
059        TestSuite suite = new TestSuite(FDUtilTest.class);
060        return suite;
061    }
062
063
064    TermOrder to = new TermOrder(TermOrder.INVLEX);
065
066
067    GenSolvablePolynomialRing<BigInteger> dfac;
068
069
070    GenSolvablePolynomialRing<BigRational> rdfac;
071
072
073    GenSolvablePolynomialRing<GenPolynomial<BigInteger>> rfac;
074
075
076    GenSolvablePolynomialRing<GenPolynomial<BigRational>> rrfac;
077
078
079    RecSolvablePolynomialRing<BigRational> rsfac;
080
081
082    GenSolvablePolynomial<BigInteger> a, b, c, d, e, f;
083
084
085    GenSolvablePolynomial<GenPolynomial<BigInteger>> ar, br, cr, dr, er, fr;
086
087
088    GenSolvablePolynomial<GenPolynomial<BigRational>> arr, brr, abrr, barr, crr, drr, err, frr, x1;
089
090
091    RecSolvablePolynomial<BigRational> as, bs, cs, ds, es, fs;
092
093
094    int rl = 4;
095
096
097    int kl = 2;
098
099
100    int ll = 4;
101
102
103    int el = 3;
104
105
106    float q = 0.35f;
107
108
109    @Override
110    protected void setUp() {
111        a = b = c = d = e = null;
112        ar = br = cr = dr = er = null;
113        String[] vars = new String[] { "a", "b", "c", "d" };
114        rl = vars.length;
115        dfac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(1), to, vars);
116        RelationGenerator<BigInteger> wl = new WeylRelationsIterated<BigInteger>();
117        dfac.addRelations(wl);
118        rfac = dfac.recursive(1);
119        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, vars);
120        RelationGenerator<BigRational> wlr = new WeylRelationsIterated<BigRational>();
121        rdfac.addRelations(wlr);
122        rrfac = rdfac.recursive(1);
123    }
124
125
126    @Override
127    protected void tearDown() {
128        a = b = c = d = e = null;
129        ar = br = cr = dr = er = null;
130        dfac = null;
131        rfac = null;
132    }
133
134
135    /**
136     * Test base pseudo division.
137     */
138    public void testBasePseudoDivisionExact() {
139        //System.out.println("dfac  = " + dfac.toScript());
140        do {
141            a = dfac.random(kl, ll + 1, el, q);
142        } while (a.isZERO());
143        //a = dfac.parse(" 3 x^5 + 44 ");
144        //System.out.println("a = " + a);
145
146        do {
147            b = dfac.random(kl, ll + 1, el, q);
148        } while (b.isZERO());
149        //a = a.sum(b);
150        //b = dfac.parse(" 2 x^2 + 40 ");
151        //System.out.println("b = " + b);
152
153        // non commutative
154        c = b.multiply(a);
155        d = a.multiply(b);
156        //System.out.println("c = " + c);
157        //System.out.println("d = " + d);
158        assertTrue("c != 0: ", !c.isZERO());
159        assertTrue("d != 0: ", !d.isZERO());
160
161        assertTrue("a*b != b*a", !c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
162
163        // divide 
164        e = FDUtil.<BigInteger> leftBasePseudoQuotient(c, a);
165        //System.out.println("e = " + e);
166        assertEquals("b == b*a/a: ", b, e);
167
168        f = FDUtil.<BigInteger> rightBasePseudoQuotient(c, b);
169        //System.out.println("f = " + f);
170        assertEquals("a == b*a/b: ", a, f);
171
172        e = FDUtil.<BigInteger> rightBasePseudoQuotient(d, a);
173        //System.out.println("e = " + e);
174        assertEquals("b == a*b/a: ", b, e);
175
176        f = FDUtil.<BigInteger> leftBasePseudoQuotient(d, b);
177        //System.out.println("f = " + f);
178        assertEquals("a == a*b/b: ", a, f);
179    }
180
181
182    /**
183     * Test base pseudo division.
184     */
185    //@SuppressWarnings({ "cast" })
186    public void testBasePseudoDivision() {
187        String[] names = new String[] { "x" };
188        GenSolvablePolynomialRing<BigInteger> dfac;
189        dfac = new GenSolvablePolynomialRing<BigInteger>(new BigInteger(1), to, names);
190        GenSolvablePolynomialRing<BigRational> rdfac;
191        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), dfac);
192        //System.out.println("dfac  = " + dfac.toScript());
193
194        do {
195            a = dfac.random(kl, ll * 1, el + 0, q);
196        } while (a.isZERO());
197        a = dfac.parse("3 x**5 + 44");
198        //System.out.println("a = " + a);
199
200        do {
201            b = dfac.random(kl, ll * 2, el + 1, q);
202        } while (b.isZERO());
203        //a = a.sum(b);
204        b = dfac.parse("2 x**2 + 40");
205        //System.out.println("b = " + b);
206        //System.out.println("a = " + a);
207
208        GenPolynomial<BigInteger>[] QR = PolyUtil.<BigInteger> basePseudoQuotientRemainder(a, b);
209        c = (GenSolvablePolynomial<BigInteger>) QR[0];
210        d = (GenSolvablePolynomial<BigInteger>) QR[1];
211        //System.out.println("c   = " + c);
212        //System.out.println("d   = " + d);
213
214        boolean t = PolyUtil.<BigInteger> isBasePseudoQuotientRemainder(a, b, c, d);
215        assertTrue("lc^n c = e b + f: " + f, t);
216
217        GenSolvablePolynomial<BigInteger>[] QRs = FDUtil.<BigInteger> leftBasePseudoQuotientRemainder(a, b);
218        e = QRs[0];
219        f = QRs[1];
220        //System.out.println("e   = " + e);
221        //System.out.println("f   = " + f);
222
223        t = PolyUtil.<BigInteger> isBasePseudoQuotientRemainder(a, b, e, f);
224        assertTrue("ore(lc^n) c = e b + f: " + f, t);
225
226        // compare with field coefficients:
227        GenSolvablePolynomial<BigRational> ap, bp, cp, dp, ep, fp, qp, rp, rhs;
228        ap = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, a);
229        bp = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, b);
230        cp = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, c);
231        dp = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, d);
232        ep = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, e);
233        fp = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> fromIntegerCoefficients(rdfac, f);
234        //System.out.println("ap  = " + ap);
235        //System.out.println("bp  = " + bp);
236        //System.out.println("cp  = " + cp);
237        //System.out.println("dp  = " + dp);
238        //System.out.println("ep  = " + ep);
239        //System.out.println("fp  = " + fp);
240
241        qp = (GenSolvablePolynomial<BigRational>) ap.divide(bp);
242        rp = (GenSolvablePolynomial<BigRational>) ap.remainder(bp);
243        //System.out.println("qp  = " + qp);
244        //System.out.println("rp  = " + rp);
245        GenSolvablePolynomial<BigRational>[] QRr = ap.quotientRemainder(bp);
246        assertEquals("qp == QRr[0]: ", qp, QRr[0]);
247        assertEquals("rp == QRr[1]: ", rp, QRr[1]);
248
249        rhs = (GenSolvablePolynomial<BigRational>) qp.multiply(bp).sum(rp);
250        //System.out.println("qp bp + rp  = " + rhs);
251        assertEquals("ap == qp bp + rp: ", ap, rhs);
252
253        assertEquals("cp == qp: ", qp.monic(), cp.monic());
254        assertEquals("dp == rp: ", rp.monic(), dp.monic());
255        //System.out.println("dp = qp: " + qp.monic().equals(dp.monic()) );
256        assertEquals("ep == qp: ", ep.monic(), cp.monic());
257        assertEquals("fp == rp: ", fp.monic(), dp.monic());
258    }
259
260
261    /**
262     * Test recursive pseudo division.
263     * @see edu.jas.ufd.PolyUfdUtilTest#testRecursivePseudoDivisionSparse
264     */
265    public void testRecursivePseudoDivision() {
266        //String[] cnames = new String[] { "x" };
267        //String[] mnames = new String[] { "t" };
268        String[] names = new String[] { "t", "x", "y", "z" };
269        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, names);
270        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
271        rdfac.addRelations(wl);
272        rsfac = (RecSolvablePolynomialRing<BigRational>) rdfac.recursive(1);
273
274        q = 0.27f;
275        kl = 1;
276        ll = 3;
277
278        arr = rrfac.random(kl, ll, el, q);
279        //arr = rrfac.parse(" ( t + x + y ) z^2 + ( 2 x - 8 ) y^2 - ( 13 t^4 - 13 t^3 + t^2 + 2 t - 13 ) ");
280        brr = rrfac.random(kl, ll, el, q);
281        if (brr.isZERO()) {
282            brr = rrfac.parse(" ( x - 2 ) z - ( t - y^2 + y ) ");
283        }
284        //System.out.println("FDQR: arr  = " + arr);
285        //System.out.println("FDQR: brr  = " + brr);
286
287        drr = FDUtil.<BigRational> recursivePseudoQuotient(arr, brr);
288        crr = FDUtil.<BigRational> recursiveSparsePseudoRemainder(arr, brr);
289        //System.out.println("FDQR: qr  = " + drr);
290        //System.out.println("FDQR: rr  = " + crr);
291
292        GenSolvablePolynomial<GenPolynomial<BigRational>>[] QR;
293        QR = FDUtil.<BigRational> recursivePseudoQuotientRemainder(arr, brr);
294        assertEquals("drr == QR[0]: ", drr, QR[0]);
295        assertEquals("crr == QR[1]: ", crr, QR[1]);
296
297        boolean t = FDUtil.<BigRational> isRecursivePseudoQuotientRemainder(arr, brr, drr, crr);
298        //System.out.println("FDQR: ore(lc^n) a == q b + r: " + t);
299        assertTrue("ore(lc^n) a = q b + r: " + crr, t); // ?? 
300    }
301
302
303    /**
304     * Test recursive division coefficient polynomial.
305     */
306    public void testLeftAndRightRecursiveDivision() {
307        //String[] names = new String[] { "t", "x", "y", "z" };
308        String[] names = new String[] { "y", "z" };
309        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, names);
310        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
311        rdfac.addRelations(wl);
312        rrfac = rdfac.recursive(1);
313        //System.out.println("\nrdfac  = " + rdfac.toScript());
314        //System.out.println("rrfac  = " + rrfac.toScript());
315        GenSolvablePolynomial<GenPolynomial<BigRational>>[] QR;
316        boolean t;
317
318        // q = q;
319        kl = 2;
320        ll = 4;
321        el = 5;
322
323        arr = rrfac.random(kl, ll, el + 1, q);
324        //arr = rrfac.parse("z^5 - ( 1260/551 y^2 - 143/35 y - 33/100  ) z - ( 1/3 y^2 + 419/299 y - 19/56  )");
325        // b * q + r:
326        //arr = rrfac.parse("z^5 + z^2 - 1");
327        //System.out.println("arr  = " + arr);
328
329        brr = rrfac.random(kl, ll, el, q);
330        //brr = rrfac.parse("z^3 - ( 377/140 y^2 + 211/232 y + 1213967/85560  )");
331        //brr = rrfac.parse("( y ) z^3 - ( 1 ) z + ( 2 )");
332        //System.out.println("brr  = " + brr);
333
334        abrr = arr.multiply(brr);
335        //System.out.println("abrr  = " + abrr);
336
337        // exact left division
338        drr = FDUtil.<BigRational> recursivePseudoQuotient(abrr, brr);
339        crr = FDUtil.<BigRational> recursiveSparsePseudoRemainder(abrr, brr);
340        //System.out.println("drr  = " + drr);
341        //System.out.println("crr  = " + crr);
342
343        QR = FDUtil.<BigRational> recursivePseudoQuotientRemainder(abrr, brr);
344        assertEquals("drr == QR[0]: ", drr, QR[0]);
345        assertEquals("crr == QR[1]: ", crr, QR[1]);
346
347        //t = PolyUtil.<BigRational> isRecursivePseudoQuotientRemainder(arr, brr, drr, crr);
348        t = FDUtil.<BigRational> isRecursivePseudoQuotientRemainder(abrr, brr, drr, crr);
349        //System.out.println("FDQR: ore(lc^n) a == q b + r: " + t);
350        assertTrue("ore(lc^n) a = q b + r: " + crr, t); // ?? 
351
352        barr = brr.multiply(arr);
353        //System.out.println("barr  = " + barr);
354
355        // exact right division
356        QR = FDUtil.<BigRational> recursiveRightPseudoQuotientRemainder(barr, brr);
357        drr = QR[0];
358        crr = QR[1];
359        //System.out.println("drr  = " + drr);
360        //System.out.println("crr  = " + crr);
361        //assertEquals("drr == QR[0]: ", drr, QR[0]);
362        //assertEquals("crr == QR[1]: ", crr, QR[1]);
363
364        t = FDUtil.<BigRational> isRecursiveRightPseudoQuotientRemainder(barr, brr, drr, crr);
365        //System.out.println("FDQR: a ore(lc^n) == q b + r: " + t);
366        assertTrue("a ore(lc^n) = q b + r: " + crr, t); // ?? 
367
368        // left division
369        QR = FDUtil.<BigRational> recursivePseudoQuotientRemainder(arr, brr);
370        drr = QR[0];
371        crr = QR[1];
372        t = FDUtil.<BigRational> isRecursivePseudoQuotientRemainder(arr, brr, drr, crr);
373        //System.out.println("drr  = " + drr);
374        //System.out.println("crr  = " + crr);
375        assertTrue("ore(lc^n) a = b q + r: " + crr, t); // ?? 
376
377        // right division
378        QR = FDUtil.<BigRational> recursiveRightPseudoQuotientRemainder(arr, brr);
379        drr = QR[0];
380        crr = QR[1];
381        t = FDUtil.<BigRational> isRecursiveRightPseudoQuotientRemainder(arr, brr, drr, crr);
382        //System.out.println("drr  = " + drr);
383        //System.out.println("crr  = " + crr);
384        assertTrue("ore(lc^n) a = q p + r: " + crr, t); // ?? 
385    }
386
387
388    /**
389     * Test recursive right coefficient polynomial.
390     */
391    //@SuppressWarnings("unchecked")
392    public void testRightRecursivePolynomial() {
393        //String[] names = new String[] { "t", "x", "y", "z" };
394        String[] names = new String[] { "y", "z" };
395        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), to, names);
396        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
397        rdfac.addRelations(wl);
398        rrfac = rdfac.recursive(1);
399        //System.out.println("\nrdfac  = " + rdfac.toScript());
400        //System.out.println("rrfac  = " + rrfac.toScript());
401        //GenSolvablePolynomialRing<BigRational> cfac = (GenSolvablePolynomialRing) rrfac.coFac;
402        //System.out.println("cfac  = " + cfac.toScript());
403
404        // q = q;
405        kl = 3;
406        ll = 5;
407        el = 5;
408
409        arr = rrfac.random(kl, ll, el, q);
410        //arr = rrfac.parse(" z { y } ");
411        //System.out.println("FDQR: arr  = " + arr);
412
413        brr = arr.rightRecursivePolynomial();
414        //System.out.println("FDQR: brr  = " + brr);
415
416        boolean t = arr.isRightRecursivePolynomial(brr);
417        assertTrue("arr == eval(brr): ", t);
418
419        GenSolvablePolynomial<BigRational> c = (GenSolvablePolynomial<BigRational>) rrfac
420                        .random(kl, ll, el, q).leadingBaseCoefficient();
421        //c = cfac.parse("y**2");
422        //System.out.println("FDQR: c  = " + c);
423
424        drr = arr.multiply(c); // arr * c = drr
425        //System.out.println("FDQR: drr  = " + drr);
426
427        //err = FDUtil.<BigRational> recursiveLeftDivide(drr, c); // err * c = drr
428        //System.out.println("FDQR: err  = " + err);
429        //assertEquals("arr == err: ", arr, err);
430
431
432        //System.out.println("\nFDQR: arr  = " + arr);
433        drr = arr.multiplyLeft(c); // c * arr = drr
434        //System.out.println("FDQR: drr  = " + drr);
435
436        //err = FDUtil.<BigRational> recursiveRightDivide(drr, c); // c * err = drr
437        //todo: System.out.println("FDQR: err  = " + err);
438        //assertEquals("arr == err: ", arr, err);
439    }
440
441
442    /**
443     * Test exact division of recursive polynomials.
444     */
445    //@SuppressWarnings({ "cast" })
446    public void testRecursiveDivide() {
447        rdfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), dfac);
448        RelationGenerator<BigRational> wl = new WeylRelationsIterated<BigRational>();
449        rdfac.addRelations(wl);
450        //System.out.println("rdfac  = " + rdfac.toScript());
451        rsfac = (RecSolvablePolynomialRing<BigRational>) rdfac.recursive(1);
452        //System.out.println("rsfac  = " + rsfac.toScript());
453
454        assertFalse("isCommutative()", rsfac.isCommutative());
455        assertTrue("isAssociative()", rsfac.isAssociative());
456
457        do {
458            as = rsfac.random(kl, ll, el, q);
459        } while (as.isZERO());
460        //System.out.println("as = " + as);
461
462        do {
463            bs = rsfac.random(kl, ll, el, q);
464        } while (bs.isZERO());
465        //System.out.println("bs = " + bs);
466
467        // non commutative
468        cs = bs.multiply(as);
469        ds = as.multiply(bs);
470        //System.out.println("cs = " + cs);
471        //System.out.println("ds = " + ds);
472        assertTrue("cs != 0: ", !cs.isZERO());
473        assertTrue("ds != 0: ", !ds.isZERO());
474
475        //es = (RecSolvablePolynomial<BigRational>) ds.subtract(cs);
476        assertTrue("as*bs != bs*as", !cs.equals(ds) || cs.leadingExpVector().equals(ds.leadingExpVector()));
477
478        // divide 
479        es = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursivePseudoQuotient(cs, as);
480        //System.out.println("es = " + es);
481        final int max = 4;
482        int i = 0;
483        do {
484            x1 = (RecSolvablePolynomial<BigRational>) bs.multiplyLeft(as.leadingBaseCoefficient().power(i));
485            //System.out.println("lc(a)^"+i+"*b = " + x1);
486            if (es.equals(x1)) {
487                assertEquals("b == b*a/a: ", es, x1);
488                break;
489            }
490            if (es.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
491                // assertEquals("b == b*a/a: ", e, x1);
492                System.out.println("fail: b == b*a/a: lc(e)==lc(x1)");
493                if (es.abs().equals(bs.abs())) {
494                    System.out.println("success via pseudo: b == b*a/a: ");
495                }
496                break;
497            }
498        } while (i++ < max);
499
500        fs = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightPseudoQuotient(cs, bs);
501        //System.out.println("fs = " + fs);
502        i = 0;
503        do {
504            x1 = (RecSolvablePolynomial<BigRational>) as.multiply(bs.leadingBaseCoefficient().power(i));
505            //System.out.println("a*lc(b)^"+i+" = " + x1);
506            if (fs.equals(x1)) {
507                assertEquals("a == b*a/b: ", fs, x1);
508                break;
509            }
510            if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
511                System.out.println("fail: a == b*a/b: lc(f)==lc(x1)");
512                if (fs.abs().equals(as.abs())) {
513                    System.out.println("success via pseudo: a == b*a/b: ");
514                }
515                break;
516            }
517        } while (i++ < max);
518
519        es = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveRightPseudoQuotient(ds, as);
520        //System.out.println("es = " + es);
521        i = 0;
522        do {
523            x1 = (RecSolvablePolynomial<BigRational>) bs.multiply(as.leadingBaseCoefficient().power(i));
524            //System.out.println("b*lc(a)^"+i+" = " + x1);
525            if (es.equals(x1)) {
526                assertEquals("b == a*b/a: ", es, x1);
527                break;
528            }
529            if (es.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
530                System.out.println("fail: b == a*b/a: lc(e) == lc(x1)");
531                if (es.abs().equals(bs.abs())) {
532                    //System.out.println("success via pseudo: b == a*b/a: ");
533                }
534                break;
535            }
536        } while (i++ < max);
537
538        fs = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursivePseudoQuotient(ds, bs);
539        //System.out.println("fs = " + fs);
540        i = 0;
541        do {
542            x1 = (RecSolvablePolynomial<BigRational>) as.multiplyLeft(bs.leadingBaseCoefficient().power(i));
543            //System.out.println("lc(b)^"+i+"*a = " + x1);
544            if (fs.equals(x1)) {
545                assertEquals("a == a*b/b: ", fs, x1);
546                break;
547            }
548            if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
549                System.out.println("fail: a == a*b/b: lc(f)==lc(x1)");
550                if (fs.abs().equals(as.abs())) {
551                    System.out.println("success via pseudo: a == a*b/b: ");
552                }
553                break;
554            }
555        } while (i++ < max);
556
557        GenSolvablePolynomial<BigRational> bc = (GenSolvablePolynomial<BigRational>) bs.leadingBaseCoefficient();
558        ds = (RecSolvablePolynomial<BigRational>) as.multiply(bc);
559        fs = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveDivide(ds, bc);
560        //System.out.println("bc = " + bc);
561        //System.out.println("ds = " + ds);
562        //System.out.println("fs = " + fs);
563        i = 0;
564        do {
565            x1 = (RecSolvablePolynomial<BigRational>) as.multiply(bc.power(i));
566            //System.out.println("lc(b)^"+i+"*a = " + x1);
567            if (fs.equals(x1)) {
568                assertEquals("a == a*b/b: ", fs, x1);
569                break;
570            }
571            if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
572                System.out.println("fail: a == a*b/b: lc(f)==lc(x1)");
573                if (fs.abs().equals(as.abs())) {
574                    System.out.println("success via pseudo: a == a*b/b: ");
575                }
576                break;
577            }
578        } while (i++ < max);
579
580        bc = (GenSolvablePolynomial<BigRational>) bs.leadingBaseCoefficient();
581        ds = (RecSolvablePolynomial<BigRational>) as.multiply(bc);
582        fs = (RecSolvablePolynomial<BigRational>) FDUtil.<BigRational> recursiveLeftDivide(ds, bc);
583        //System.out.println("bc = " + bc);
584        //System.out.println("ds = " + ds);
585        //System.out.println("fs = " + fs);
586        i = 0;
587        do {
588            x1 = (RecSolvablePolynomial<BigRational>) as.multiply(bc.power(i));
589            //System.out.println("lc(b)^"+i+"*a = " + x1);
590            if (fs.equals(x1)) {
591                assertEquals("a == a*b/b: ", fs, x1);
592                break;
593            }
594            if (fs.leadingBaseCoefficient().equals(x1.leadingBaseCoefficient())) {
595                System.out.println("fail: a == a*b/b: lc(f)==lc(x1)");
596                if (fs.abs().equals(as.abs())) {
597                    System.out.println("success via pseudo: a == a*b/b: ");
598                }
599                break;
600            }
601        } while (i++ < max);
602    }
603
604
605    /**
606     * Test integer polynomial conversions.
607     */
608    public void testIntConversion() {
609        //System.out.println("dfac = " + dfac.toScript());
610        //System.out.println("rdfac = " + rdfac.toScript());
611        //System.out.println("rrfac = " + rrfac.toScript());
612
613        rfac = dfac.recursive(2); // avoid polCoeff
614        //System.out.println("rfac = " + rfac.toScript());
615        assertFalse("isCommutative()", rfac.isCommutative());
616        assertTrue("isAssociative()", rfac.isAssociative());
617
618        GenSolvablePolynomialRing<BigInteger> ifac = (GenSolvablePolynomialRing<BigInteger>) rfac.coFac;
619        //System.out.println("ifac = " + ifac.toScript());
620
621        SolvableQuotientRing <BigInteger> qfac = new SolvableQuotientRing<BigInteger>(ifac);
622        //System.out.println("qfac = " + qfac.toScript());
623        GenSolvablePolynomialRing<SolvableQuotient<BigInteger>> iqfac = new GenSolvablePolynomialRing<SolvableQuotient<BigInteger>>(qfac, rfac);
624        //System.out.println("iqfac = " + iqfac.toScript());
625
626        List<GenSolvablePolynomial<GenPolynomial<BigInteger>>> irel = rfac.table.relationList();
627        //System.out.println("irel = " + irel);
628
629        List<GenSolvablePolynomial<SolvableQuotient<BigInteger>>> qrel;
630        qrel = FDUtil.<BigInteger> quotientFromIntegralCoefficients(iqfac, irel);
631        //System.out.println("qrel = " + qrel);
632        assertEquals("#irel == #qrel: ", irel.size(), qrel.size());
633        iqfac.table.addSolvRelations(qrel);
634        //System.out.println("iqfac = " + iqfac.toScript());
635        assertFalse("isCommutative()", iqfac.isCommutative());
636        //assertTrue("isAssociative()", iqfac.isAssociative()); //extLeftGB is missing
637
638        List<GenSolvablePolynomial<GenPolynomial<BigInteger>>> iqrel;
639        iqrel = FDUtil.<BigInteger> integralFromQuotientCoefficients(rfac, qrel);
640        //System.out.println("iqrel = " + iqrel);
641        assertEquals("#qrel == #iqrel: ", qrel.size(), iqrel.size());
642        assertEquals("irel == iqrel: ", irel, iqrel);
643
644        // not possible because of missing extLeftGB for pseudo GB:
645        // iqfac.random(kl, ll, el, q);
646    }
647
648
649    /**
650     * Test rational polynomial conversions.
651     */
652    public void testRatConversion() {
653        ////System.out.println("dfac = " + dfac.toScript());
654        //System.out.println("rdfac = " + rdfac.toScript());
655        //System.out.println("rrfac = " + rrfac.toScript());
656
657        rrfac = rdfac.recursive(2); // avoid polCoeff
658        //System.out.println("rrfac = " + rrfac.toScript());
659        assertFalse("isCommutative()", rrfac.isCommutative());
660        assertTrue("isAssociative()", rrfac.isAssociative());
661
662        GenSolvablePolynomialRing<BigRational> irfac = (GenSolvablePolynomialRing<BigRational>) rrfac.coFac;
663        //System.out.println("irfac = " + irfac.toScript());
664
665        SolvableQuotientRing <BigRational> qfac = new SolvableQuotientRing<BigRational>(irfac);
666        //System.out.println("qfac = " + qfac.toScript());
667        GenSolvablePolynomialRing<SolvableQuotient<BigRational>> rqfac = new GenSolvablePolynomialRing<SolvableQuotient<BigRational>>(qfac, rrfac);
668        //System.out.println("rqfac = " + rqfac.toScript());
669
670        List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rrel = rrfac.table.relationList();
671        //System.out.println("rrel = " + rrel);
672
673        List<GenSolvablePolynomial<SolvableQuotient<BigRational>>> qrel;
674        qrel = FDUtil.<BigRational> quotientFromIntegralCoefficients(rqfac, rrel);
675        //System.out.println("qrel = " + qrel);
676        assertEquals("#rrel == #qrel: ", rrel.size(), qrel.size());
677        rqfac.table.addSolvRelations(qrel);
678        //System.out.println("rqfac = " + rqfac.toScript());
679        assertFalse("isCommutative()", rqfac.isCommutative());
680        assertTrue("isAssociative()", rqfac.isAssociative());
681
682        List<GenSolvablePolynomial<GenPolynomial<BigRational>>> rqrel;
683        rqrel = FDUtil.<BigRational> integralFromQuotientCoefficients(rrfac, qrel);
684        //System.out.println("rqrel = " + rqrel);
685        assertEquals("#rrel == #rqrel: ", rrel.size(), rqrel.size());
686        assertEquals("rrel == rqrel: ", rrel, rqrel);
687
688        kl = 1;
689        q = 0.3f;
690        //System.out.println("kl = " + kl + ", ll = " + ll + ", el = " + el + ", q = " + q);
691        GenSolvablePolynomial<SolvableQuotient<BigRational>> aq, bq, cq, dq;
692        do {
693            aq = rqfac.random(kl, ll, el, q);
694        } while (aq.isZERO());
695
696        do {
697            bq = rqfac.random(kl, ll, el, q/2f);
698        } while (bq.isZERO());
699        //System.out.println("aq = " + aq);
700        //System.out.println("bq = " + bq);
701
702        // non commutative
703        cq = bq.multiply(aq);
704        dq = aq.multiply(bq);
705        //System.out.println("cq = " + cq);
706        //System.out.println("dq = " + dq);
707        assertTrue("cq != 0: ", !cq.isZERO());
708        assertTrue("dq != 0: ", !dq.isZERO());
709
710        assertTrue("aq*bq != bq*aq", !cq.equals(dq) || cq.leadingExpVector().equals(dq.leadingExpVector()));
711    }
712
713}