Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.Map;
011
012import edu.jas.arith.BigRational;
013import edu.jas.poly.ExpVector;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenPolynomialRing;
016import edu.jas.poly.GenSolvablePolynomial;
017import edu.jas.poly.GenSolvablePolynomialRing;
018import edu.jas.poly.PolyUtil;
019import edu.jas.poly.QLRSolvablePolynomial;
020import edu.jas.poly.QLRSolvablePolynomialRing;
021import edu.jas.poly.RecSolvablePolynomial;
022import edu.jas.poly.RelationGenerator;
023import edu.jas.poly.TermOrder;
024import edu.jas.poly.WeylRelations;
025import edu.jas.poly.WeylRelationsIterated;
026
027import junit.framework.Test;
028import junit.framework.TestCase;
029import junit.framework.TestSuite;
030
031
032/**
033 * BigRational coefficients ResidueSolvablePolynomial QLR representation tests
034 * with JUnit.
035 * @author Heinz Kredel
036 */
037
038public class ResidueSolvablePolynomialQLRTest extends TestCase {
039
040
041    /**
042     * main.
043     */
044    public static void main(String[] args) {
045
046        junit.textui.TestRunner.run(suite());
047    }
048
049
050    /**
051     * Constructs a <CODE>ResidueSolvablePolynomialQLRTest</CODE> object.
052     * @param name String.
053     */
054    public ResidueSolvablePolynomialQLRTest(String name) {
055        super(name);
056    }
057
058
059    /**
060     */
061    public static Test suite() {
062        TestSuite suite = new TestSuite(ResidueSolvablePolynomialQLRTest.class);
063        return suite;
064    }
065
066
067    QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a, b, c, d, e, f, x1, x2;
068
069
070    int rl = 4;
071
072
073    int kl = 3;
074
075
076    int ll = 4;
077
078
079    int el = 3;
080
081
082    float q = 0.3f;
083
084
085    String[] cvars = new String[] { "a", "b" };
086
087
088    String[] vars = new String[] { "w", "x", "y", "z" };
089
090
091    SolvableResidueRing<BigRational> rring;
092
093
094    SolvableIdeal<BigRational> sideal;
095
096
097    QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> ring;
098
099
100    BigRational cfac;
101
102
103    GenSolvablePolynomialRing<BigRational> sring;
104
105
106    GenPolynomialRing<BigRational> cring;
107
108
109    TermOrder tord = new TermOrder(TermOrder.INVLEX);
110
111
112    @Override
113    protected void setUp() {
114        cfac = new BigRational(1);
115        sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
116        //RelationGenerator<BigRational> wc = new WeylRelations<BigRational>();
117        //not possible: sring.addRelations(wc); //wc.generate(sring);
118        List<GenSolvablePolynomial<BigRational>> il = new ArrayList<GenSolvablePolynomial<BigRational>>();
119        GenSolvablePolynomial<BigRational> p1 = sring.parse("b - a^2");
120        il.add(p1);
121        //p1 = sring.parse("a - b^5");
122        //il.add(p1);
123        sideal = new SolvableIdeal<BigRational>(sring, il);
124        sideal = sideal.twosidedGB();
125        if (sideal.isONE()) {
126            System.out.println("twosided sideal = " + sideal.toScript());
127            throw new IllegalArgumentException("ideal is one");
128        }
129        rring = new SolvableResidueRing<BigRational>(sideal);
130        ring = new QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational>(rring, tord, vars);
131        RelationGenerator<SolvableResidue<BigRational>> wl = new WeylRelations<SolvableResidue<BigRational>>();
132        wl.generate(ring);
133        List<GenSolvablePolynomial<SolvableResidue<BigRational>>> qrel = ring.table.relationList();
134        //System.out.println("qrel = " + qrel);
135        List<GenSolvablePolynomial<GenPolynomial<BigRational>>> prel = new ArrayList<GenSolvablePolynomial<GenPolynomial<BigRational>>>();
136        for (GenSolvablePolynomial<SolvableResidue<BigRational>> q : qrel) {
137            GenSolvablePolynomial<GenPolynomial<BigRational>> p = ring.toPolyCoefficients(q);
138            prel.add(p);
139        }
140        //System.out.println("prel = " + prel);
141        ring.polCoeff.table.addSolvRelations(prel);
142        a = b = c = d = e = null;
143    }
144
145
146    @Override
147    protected void tearDown() {
148        ring = null;
149        a = b = c = d = e = null;
150    }
151
152
153    /**
154     * Test constructor, generators and properties.
155     */
156    public void testConstructor() {
157        assertFalse("not commutative", ring.isCommutative());
158        assertTrue("associative", ring.isAssociative());
159
160        a = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring);
161        assertTrue("length( a ) = 0", a.length() == 0);
162        assertTrue("isZERO( a )", a.isZERO());
163        assertTrue("isONE( a )", !a.isONE());
164
165        c = ring.getONE();
166        assertTrue("length( c ) = 1", c.length() == 1);
167        assertTrue("isZERO( c )", !c.isZERO());
168        assertTrue("isONE( c )", c.isONE());
169
170        d = ring.getZERO();
171        assertTrue("length( d ) = 0", d.length() == 0);
172        assertTrue("isZERO( d )", d.isZERO());
173        assertTrue("isONE( d )", !d.isONE());
174        //System.out.println("d = " + d);
175
176        //System.out.println("");
177        for (GenPolynomial<SolvableResidue<BigRational>> g : ring.generators()) {
178            //System.out.print("g = " + g + ", ");
179            assertFalse("not isZERO( g )", g.isZERO());
180        }
181        //System.out.println("");
182    }
183
184
185    /**
186     * Test random polynomial.
187     */
188    public void testRandom() {
189        for (int i = 0; i < 3; i++) {
190            // a = ring.random(ll+2*i);
191            a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q);
192            //System.out.println("a = " + a);
193            assertTrue("length( a" + i + " ) <> 0", a.length() >= 0);
194            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
195            assertTrue(" not isONE( a" + i + " )", !a.isONE());
196        }
197    }
198
199
200    /**
201     * Test addition.
202     */
203    @SuppressWarnings("unchecked")
204    public void testAddition() {
205        a = ring.random(kl, ll, el, q);
206        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(a);
207        assertTrue("a-a = 0", c.isZERO());
208
209        b = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(a);
210        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.subtract(a);
211        assertEquals("a+a-a = a", c, a);
212
213        b = ring.random(kl, ll, el, q);
214        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
215        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
216        assertEquals("a+b = b+a", c, d);
217
218        c = ring.random(kl, ll, el, q);
219        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b.sum(c));
220        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b).sum(c);
221        assertEquals("a+(b+c) = (a+b)+c", d, e);
222        //System.out.println("a = " + a);
223        //System.out.println("b = " + b);
224        //System.out.println("c = " + c);
225        //System.out.println("d = " + d);
226        //System.out.println("e = " + e);
227
228        ExpVector u = ExpVector.random(rl, el, q);
229        SolvableResidue<BigRational> x = rring.random(kl);
230        //System.out.println("x = " + x);
231        //System.out.println("u = " + u);
232
233        b = ring.getONE().multiply(x, u);
234        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
235        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
236        //System.out.println("a = " + a);
237        //System.out.println("b = " + b);
238        //System.out.println("c = " + c);
239        //System.out.println("d = " + d);
240        assertEquals("a+p(x,u) = a+(x,u)", c, d);
241
242        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
243        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
244        assertEquals("a-p(x,u) = a-(x,u)", c, d);
245
246        a = ring.getZERO();
247        b = ring.getONE().multiply(x, u);
248        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
249        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
250        assertEquals("a+p(x,u) = a+(x,u)", c, d);
251
252        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
253        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
254        assertEquals("a-p(x,u) = a-(x,u)", c, d);
255    }
256
257
258    /**
259     * Test multiplication.
260     */
261    @SuppressWarnings("unchecked")
262    public void testMultiplication() {
263        //System.out.println("ring = " + ring);
264        a = ring.random(kl, ll, el, q);
265        //a = ring.parse(" b y z + a w z ");  
266        b = ring.random(kl, ll, el, q);
267        //b = ring.parse(" w x - b x "); 
268
269        c = b.multiply(a);
270        d = a.multiply(b);
271        //System.out.println("a = " + a);
272        //System.out.println("b = " + b);
273        //System.out.println("c = " + c);
274        //System.out.println("d = " + d);
275        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
276
277        c = ring.random(kl, ll, el, q);
278        d = a.multiply(b.multiply(c));
279        e = a.multiply(b).multiply(c);
280        assertEquals("a(bc) = (ab)c", d, e);
281        //System.out.println("a = " + a);
282        //System.out.println("b = " + b);
283        //System.out.println("c = " + c);
284        //System.out.println("d = " + d);
285        //System.out.println("e = " + e);
286
287        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.monic();
288        //System.out.println("d = " + d);
289        assertTrue("a.monic(): " + d, d.leadingBaseCoefficient().isONE()
290                        || d.leadingBaseCoefficient().equals(a.leadingBaseCoefficient()));
291    }
292
293
294    /**
295     * Test partially commutative ring.
296     */
297    @SuppressWarnings("unchecked")
298    public void testPartCommutative() {
299        //System.out.println("table = " + table.toString(vars));
300        //System.out.println("table = " + table.toScript());
301        //System.out.println("ring = " + ring);
302        //System.out.println("ring.table = " + ring.table.toScript());
303        //assertEquals("table == ring.table: ", table, ring.table); // ?
304        assertTrue("# relations == 2", ring.table.size() == 2);
305
306        ring = new QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational>(rring, ring);
307        //System.out.println("ring = " + ring);
308
309        assertTrue("isCommutative()", ring.isCommutative() || !rring.isCommutative());
310        assertTrue("isAssociative()", ring.isAssociative());
311
312        a = ring.random(kl, ll, el, q);
313        //a = ring.parse(" b x y z + a w z ");
314        //System.out.println("a = " + a);
315        b = ring.random(kl, ll, el, q);
316        //b = ring.parse(" w y z - b x ");
317        //System.out.println("b = " + b);
318
319        // commutative
320        c = b.multiply(a);
321        //System.out.println("c = " + c);
322        d = a.multiply(b);
323        //d = ring.getONE(); 
324        //System.out.println("d = " + d);
325        assertEquals("ba == ab: ", c, d);
326    }
327
328
329    /**
330     * Test distributive law.
331     */
332    @SuppressWarnings("unchecked")
333    public void testDistributive() {
334        a = ring.random(kl, ll, el, q);
335        b = ring.random(kl, ll, el, q);
336        c = ring.random(kl, ll, el, q);
337
338        d = a.multiply((QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(c));
339        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.multiply(b)
340                        .sum(a.multiply(c));
341        assertEquals("a(b+c) = ab+ac", d, e);
342    }
343
344
345    /**
346     * Test solvable coefficient ring.
347     */
348    @SuppressWarnings("unchecked")
349    public void testSolvableCoeffsRelations() {
350        assertTrue("# relations == 2", ring.table.size() == 2);
351        assertFalse("isCommutative()", ring.isCommutative());
352        assertTrue("isAssociative()", ring.isAssociative());
353        //System.out.println("ring = " + ring.toScript());
354
355        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("z");
356        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
357        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a z + b");
358        GenSolvablePolynomial<GenPolynomial<BigRational>> pp = ring.toPolyCoefficients(rp);
359        //System.out.println("r1 = " + r1);
360        //System.out.println("r2 = " + r2);
361        //System.out.println("rp = " + rp);
362        //System.out.println("pp = " + pp);
363        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
364        //ring.polCoeff.table.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
365        //ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
366
367        //System.out.println("ring = " + ring.toScript());
368
369        assertFalse("isCommutative()", ring.isCommutative());
370        assertTrue("isAssociative()", ring.isAssociative());
371
372        List<GenPolynomial<SolvableResidue<BigRational>>> gens = ring.generators();
373        for (GenPolynomial<SolvableResidue<BigRational>> x : gens) {
374            GenSolvablePolynomial<SolvableResidue<BigRational>> xx = (GenSolvablePolynomial<SolvableResidue<BigRational>>) x;
375            a = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, xx);
376            for (GenPolynomial<SolvableResidue<BigRational>> y : gens) {
377                GenSolvablePolynomial<SolvableResidue<BigRational>> yy = (GenSolvablePolynomial<SolvableResidue<BigRational>>) y;
378                b = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, yy);
379                c = a.multiply(b);
380                //System.out.println("gens:" + a + " * " + b + " = " + c);
381                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
382                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
383                ev = a.leadingBaseCoefficient().val.leadingExpVector()
384                                .sum(b.leadingBaseCoefficient().val.leadingExpVector());
385                assertTrue("LT(lc(a))*LT(lc(b)) == LT(lc(c))",
386                                c.leadingBaseCoefficient().val.leadingExpVector().equals(ev));
387            }
388        }
389        //System.out.println("ring = " + ring.toScript());
390
391        a = ring.random(kl, ll, el, q);
392        //a = ring.getONE();
393        //System.out.println("a = " + a);
394        b = ring.random(kl, ll, el, q);
395        //b = ring.getONE();
396        //System.out.println("b = " + b);
397
398        // non-commutative
399        c = b.multiply(a);
400        d = a.multiply(b);
401        //System.out.println("c = " + c);
402        //System.out.println("d = " + d);
403        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
404    }
405
406
407    /**
408     * Test extension and contraction for Weyl relations.
409     */
410    @SuppressWarnings("unchecked")
411    public void testExtendContractWeyl() {
412        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
413        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
414        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
415        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
416                        ring.toPolyCoefficients(rp));
417
418        int k = rl;
419        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfe = ring.extend(k);
420        //System.out.println("pfe = " + pfe);
421        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfec = pfe.contract(k);
422        //System.out.println("pfec = " + pfec);
423        assertEquals("ring == pfec", ring, pfec);
424
425        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
426        //System.out.println("a = " + a);
427
428        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ae = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
429                        .extend(pfe, 0, 0);
430        //System.out.println("ae = " + ae);
431
432        Map<ExpVector, GenPolynomial<SolvableResidue<BigRational>>> m = ae.contract(pfec);
433        List<GenPolynomial<SolvableResidue<BigRational>>> ml = new ArrayList<GenPolynomial<SolvableResidue<BigRational>>>(
434                        m.values());
435        GenPolynomial<SolvableResidue<BigRational>> aec = ml.get(0);
436        //System.out.println("ae  = " + ae);
437        //System.out.println("aec = " + aec);
438        assertEquals("a == aec", a, aec);
439    }
440
441
442    /**
443     * Test reversion for Weyl relations.
444     */
445    @SuppressWarnings("unchecked")
446    public void testReverseWeyl() {
447        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
448        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
449        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
450        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
451                        ring.toPolyCoefficients(rp));
452
453        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfr = ring.reverse();
454        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfrr = pfr.reverse();
455        assertEquals("pf == pfrr", ring, pfrr);
456        //System.out.println("ring = " + ring);
457        //System.out.println("pfr = " + pfr);
458
459        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
460        //System.out.println("a = " + a);
461
462        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ar = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
463                        .reverse(pfr);
464        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> arr = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) ar
465                        .reverse(pfrr);
466        assertEquals("a == arr", a, arr);
467        //System.out.println("ar = " + ar);
468        //System.out.println("arr = " + arr);
469    }
470
471
472    /**
473     * Test recursive for Weyl relations.
474     */
475    @SuppressWarnings("unchecked")
476    public void testRecursiveWeyl() {
477        GenSolvablePolynomialRing<GenPolynomial<SolvableResidue<BigRational>>> rsring = ring.recursive(2); // 1,2,3
478        //System.out.println("rsring = " + rsring.toScript());
479
480        GenSolvablePolynomial<SolvableResidue<BigRational>> ad, bd, cd, dd;
481        RecSolvablePolynomial<SolvableResidue<BigRational>> ar, br, cr, dr;
482        ad = ring.random(kl, ll, el, q);
483        bd = ring.random(kl, ll, el, q);
484        //ad = sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225");
485        //bd = sring.parse("-10/13 x "); //+ 413/150");
486        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
487        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
488
489        //System.out.println("ad = " + ad);
490        //System.out.println("bd = " + bd);
491
492        cd = ad.multiply(bd);
493        //System.out.println("cd = " + cd);
494
495        ar = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
496                        .<SolvableResidue<BigRational>> recursive(rsring, ad);
497        br = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
498                        .<SolvableResidue<BigRational>> recursive(rsring, bd);
499        //System.out.println("ar = " + ar);
500        //System.out.println("br = " + br);
501
502        cr = ar.multiply(br);
503        //System.out.println("cr = " + cr);
504        //System.out.println("cr.ring = " + cr.ring.toScript());
505
506        dr = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
507                        .<SolvableResidue<BigRational>> recursive(rsring, cd);
508        //System.out.println("dr = " + dr);
509
510        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
511        assertEquals("dr == cr", dr, cr);
512
513        dd = (GenSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
514                        .<SolvableResidue<BigRational>> distribute(ring, cr);
515        // //System.out.println("dd = " + dd);
516        assertEquals("dd == cd", dd, cd);
517    }
518
519
520    /*
521     * Test recursive for iterated Weyl relations.
522     */
523    public void testRecursiveIteratedWeyl() {
524        String[] svars = new String[] { "w", "x", "y", "z" };
525        GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord,
526                        svars);
527        RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>();
528        wlc.generate(sring);
529        assertFalse("isCommutative()", sring.isCommutative());
530        assertTrue("isAssociative()", sring.isAssociative());
531        //System.out.println("sring = " + sring.toScript());
532
533        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3
534        //System.out.println("rsring = " + rsring); //.toScript());
535        //System.out.println("rsring = " + rsring.toScript());
536
537        GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
538        RecSolvablePolynomial<BigRational> ar, br, cr, dr;
539        ad = sring.random(kl, ll, el, q);
540        bd = sring.random(kl, ll, el, q);
541        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
542        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
543
544        //System.out.println("ad = " + ad);
545        //System.out.println("bd = " + bd);
546
547        cd = ad.multiply(bd);
548        //System.out.println("cd = " + cd);
549
550        ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad);
551        br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd);
552        //System.out.println("ar = " + ar);
553        //System.out.println("br = " + br);
554
555        cr = ar.multiply(br);
556        //System.out.println("cr = " + cr);
557
558        dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd);
559        //System.out.println("dr = " + dr);
560
561        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
562        assertEquals("dr == cr", dr, cr);
563
564        dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr);
565        //System.out.println("dd = " + dd);
566        assertEquals("dd == cd", dd, cd);
567    }
568
569}