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        String s = ring.toScript();
184        //System.out.println("ring.toScript: " + s + ", " + s.length());
185        assertEquals("#s == 291: " + s, s.length(), 291);
186    }
187
188
189    /**
190     * Test random polynomial.
191     */
192    public void testRandom() {
193        for (int i = 0; i < 3; i++) {
194            // a = ring.random(ll+2*i);
195            a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q);
196            //System.out.println("a = " + a);
197            assertTrue("length( a" + i + " ) <> 0", a.length() >= 0);
198            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
199            assertTrue(" not isONE( a" + i + " )", !a.isONE());
200        }
201    }
202
203
204    /**
205     * Test addition.
206     */
207    @SuppressWarnings("unchecked")
208    public void testAddition() {
209        a = ring.random(kl, ll, el, q);
210        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(a);
211        assertTrue("a-a = 0", c.isZERO());
212
213        b = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(a);
214        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.subtract(a);
215        assertEquals("a+a-a = a", c, a);
216
217        b = ring.random(kl, ll, el, q);
218        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
219        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
220        assertEquals("a+b = b+a", c, d);
221
222        c = ring.random(kl, ll, el, q);
223        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b.sum(c));
224        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b).sum(c);
225        assertEquals("a+(b+c) = (a+b)+c", d, e);
226        //System.out.println("a = " + a);
227        //System.out.println("b = " + b);
228        //System.out.println("c = " + c);
229        //System.out.println("d = " + d);
230        //System.out.println("e = " + e);
231
232        ExpVector u = ExpVector.random(rl, el, q);
233        SolvableResidue<BigRational> x = rring.random(kl);
234        //System.out.println("x = " + x);
235        //System.out.println("u = " + u);
236
237        b = ring.getONE().multiply(x, u);
238        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
239        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
240        //System.out.println("a = " + a);
241        //System.out.println("b = " + b);
242        //System.out.println("c = " + c);
243        //System.out.println("d = " + d);
244        assertEquals("a+p(x,u) = a+(x,u)", c, d);
245
246        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
247        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
248        assertEquals("a-p(x,u) = a-(x,u)", c, d);
249
250        a = ring.getZERO();
251        b = ring.getONE().multiply(x, u);
252        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
253        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
254        assertEquals("a+p(x,u) = a+(x,u)", c, d);
255
256        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
257        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
258        assertEquals("a-p(x,u) = a-(x,u)", c, d);
259    }
260
261
262    /**
263     * Test multiplication.
264     */
265    @SuppressWarnings("unchecked")
266    public void testMultiplication() {
267        //System.out.println("ring = " + ring);
268        a = ring.random(kl, ll, el, q);
269        //a = ring.parse(" b y z + a w z ");  
270        b = ring.random(kl, ll, el, q);
271        //b = ring.parse(" w x - b x "); 
272
273        c = b.multiply(a);
274        d = a.multiply(b);
275        //System.out.println("a = " + a);
276        //System.out.println("b = " + b);
277        //System.out.println("c = " + c);
278        //System.out.println("d = " + d);
279        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
280
281        c = ring.random(kl, ll, el, q);
282        d = a.multiply(b.multiply(c));
283        e = a.multiply(b).multiply(c);
284        assertEquals("a(bc) = (ab)c", d, e);
285        //System.out.println("a = " + a);
286        //System.out.println("b = " + b);
287        //System.out.println("c = " + c);
288        //System.out.println("d = " + d);
289        //System.out.println("e = " + e);
290
291        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.monic();
292        //System.out.println("d = " + d);
293        assertTrue("a.monic(): " + d, d.leadingBaseCoefficient().isONE()
294                        || d.leadingBaseCoefficient().equals(a.leadingBaseCoefficient()));
295    }
296
297
298    /**
299     * Test partially commutative ring.
300     */
301    @SuppressWarnings("unchecked")
302    public void testPartCommutative() {
303        //System.out.println("table = " + table.toString(vars));
304        //System.out.println("table = " + table.toScript());
305        //System.out.println("ring = " + ring);
306        //System.out.println("ring.table = " + ring.table.toScript());
307        //assertEquals("table == ring.table: ", table, ring.table); // ?
308        assertTrue("# relations == 2", ring.table.size() == 2);
309
310        ring = new QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational>(rring, ring);
311        //System.out.println("ring = " + ring);
312
313        assertTrue("isCommutative()", ring.isCommutative() || !rring.isCommutative());
314        assertTrue("isAssociative()", ring.isAssociative());
315
316        a = ring.random(kl, ll, el, q);
317        //a = ring.parse(" b x y z + a w z ");
318        //System.out.println("a = " + a);
319        b = ring.random(kl, ll, el, q);
320        //b = ring.parse(" w y z - b x ");
321        //System.out.println("b = " + b);
322
323        // commutative
324        c = b.multiply(a);
325        //System.out.println("c = " + c);
326        d = a.multiply(b);
327        //d = ring.getONE(); 
328        //System.out.println("d = " + d);
329        assertEquals("ba == ab: ", c, d);
330    }
331
332
333    /**
334     * Test distributive law.
335     */
336    @SuppressWarnings("unchecked")
337    public void testDistributive() {
338        a = ring.random(kl, ll, el, q);
339        b = ring.random(kl, ll, el, q);
340        c = ring.random(kl, ll, el, q);
341
342        d = a.multiply((QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(c));
343        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.multiply(b)
344                        .sum(a.multiply(c));
345        assertEquals("a(b+c) = ab+ac", d, e);
346    }
347
348
349    /**
350     * Test solvable coefficient ring.
351     */
352    @SuppressWarnings("unchecked")
353    public void testSolvableCoeffsRelations() {
354        assertTrue("# relations == 2", ring.table.size() == 2);
355        assertFalse("isCommutative()", ring.isCommutative());
356        assertTrue("isAssociative()", ring.isAssociative());
357        //System.out.println("ring = " + ring.toScript());
358
359        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("z");
360        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
361        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a z + b");
362        GenSolvablePolynomial<GenPolynomial<BigRational>> pp = ring.toPolyCoefficients(rp);
363        //System.out.println("r1 = " + r1);
364        //System.out.println("r2 = " + r2);
365        //System.out.println("rp = " + rp);
366        //System.out.println("pp = " + pp);
367        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
368        //ring.polCoeff.table.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
369        //ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
370
371        //System.out.println("ring = " + ring.toScript());
372
373        assertFalse("isCommutative()", ring.isCommutative());
374        assertTrue("isAssociative()", ring.isAssociative());
375
376        List<GenPolynomial<SolvableResidue<BigRational>>> gens = ring.generators();
377        for (GenPolynomial<SolvableResidue<BigRational>> x : gens) {
378            GenSolvablePolynomial<SolvableResidue<BigRational>> xx = (GenSolvablePolynomial<SolvableResidue<BigRational>>) x;
379            a = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, xx);
380            for (GenPolynomial<SolvableResidue<BigRational>> y : gens) {
381                GenSolvablePolynomial<SolvableResidue<BigRational>> yy = (GenSolvablePolynomial<SolvableResidue<BigRational>>) y;
382                b = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, yy);
383                c = a.multiply(b);
384                //System.out.println("gens:" + a + " * " + b + " = " + c);
385                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
386                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
387                ev = a.leadingBaseCoefficient().val.leadingExpVector()
388                                .sum(b.leadingBaseCoefficient().val.leadingExpVector());
389                assertTrue("LT(lc(a))*LT(lc(b)) == LT(lc(c))",
390                                c.leadingBaseCoefficient().val.leadingExpVector().equals(ev));
391            }
392        }
393        //System.out.println("ring = " + ring.toScript());
394
395        a = ring.random(kl, ll, el, q);
396        //a = ring.getONE();
397        //System.out.println("a = " + a);
398        b = ring.random(kl, ll, el, q);
399        //b = ring.getONE();
400        //System.out.println("b = " + b);
401
402        // non-commutative
403        c = b.multiply(a);
404        d = a.multiply(b);
405        //System.out.println("c = " + c);
406        //System.out.println("d = " + d);
407        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
408    }
409
410
411    /**
412     * Test extension and contraction for Weyl relations.
413     */
414    @SuppressWarnings("unchecked")
415    public void testExtendContractWeyl() {
416        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
417        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
418        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
419        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
420                        ring.toPolyCoefficients(rp));
421
422        int k = rl;
423        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfe = ring.extend(k);
424        //System.out.println("pfe = " + pfe);
425        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfec = pfe.contract(k);
426        //System.out.println("pfec = " + pfec);
427        assertEquals("ring == pfec", ring, pfec);
428
429        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
430        //System.out.println("a = " + a);
431
432        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ae = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
433                        .extend(pfe, 0, 0);
434        //System.out.println("ae = " + ae);
435
436        Map<ExpVector, GenPolynomial<SolvableResidue<BigRational>>> m = ae.contract(pfec);
437        List<GenPolynomial<SolvableResidue<BigRational>>> ml = new ArrayList<GenPolynomial<SolvableResidue<BigRational>>>(
438                        m.values());
439        GenPolynomial<SolvableResidue<BigRational>> aec = ml.get(0);
440        //System.out.println("ae  = " + ae);
441        //System.out.println("aec = " + aec);
442        assertEquals("a == aec", a, aec);
443    }
444
445
446    /**
447     * Test reversion for Weyl relations.
448     */
449    @SuppressWarnings("unchecked")
450    public void testReverseWeyl() {
451        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
452        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
453        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
454        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
455                        ring.toPolyCoefficients(rp));
456
457        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfr = ring.reverse();
458        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfrr = pfr.reverse();
459        assertEquals("pf == pfrr", ring, pfrr);
460        //System.out.println("ring = " + ring);
461        //System.out.println("pfr = " + pfr);
462
463        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
464        //System.out.println("a = " + a);
465
466        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ar = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
467                        .reverse(pfr);
468        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> arr = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) ar
469                        .reverse(pfrr);
470        assertEquals("a == arr", a, arr);
471        //System.out.println("ar = " + ar);
472        //System.out.println("arr = " + arr);
473    }
474
475
476    /**
477     * Test recursive for Weyl relations.
478     */
479    @SuppressWarnings("unchecked")
480    public void testRecursiveWeyl() {
481        GenSolvablePolynomialRing<GenPolynomial<SolvableResidue<BigRational>>> rsring = ring.recursive(2); // 1,2,3
482        //System.out.println("rsring = " + rsring.toScript());
483
484        GenSolvablePolynomial<SolvableResidue<BigRational>> ad, bd, cd, dd;
485        RecSolvablePolynomial<SolvableResidue<BigRational>> ar, br, cr, dr;
486        ad = ring.random(kl, ll, el, q);
487        bd = ring.random(kl, ll, el, q);
488        //ad = sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225");
489        //bd = sring.parse("-10/13 x "); //+ 413/150");
490        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
491        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
492
493        //System.out.println("ad = " + ad);
494        //System.out.println("bd = " + bd);
495
496        cd = ad.multiply(bd);
497        //System.out.println("cd = " + cd);
498
499        ar = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
500                        .<SolvableResidue<BigRational>> recursive(rsring, ad);
501        br = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
502                        .<SolvableResidue<BigRational>> recursive(rsring, bd);
503        //System.out.println("ar = " + ar);
504        //System.out.println("br = " + br);
505
506        cr = ar.multiply(br);
507        //System.out.println("cr = " + cr);
508        //System.out.println("cr.ring = " + cr.ring.toScript());
509
510        dr = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
511                        .<SolvableResidue<BigRational>> recursive(rsring, cd);
512        //System.out.println("dr = " + dr);
513
514        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
515        assertEquals("dr == cr", dr, cr);
516
517        dd = (GenSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
518                        .<SolvableResidue<BigRational>> distribute(ring, cr);
519        // //System.out.println("dd = " + dd);
520        assertEquals("dd == cd", dd, cd);
521    }
522
523
524    /*
525     * Test recursive for iterated Weyl relations.
526     */
527    public void testRecursiveIteratedWeyl() {
528        String[] svars = new String[] { "w", "x", "y", "z" };
529        GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord,
530                        svars);
531        RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>();
532        wlc.generate(sring);
533        assertFalse("isCommutative()", sring.isCommutative());
534        assertTrue("isAssociative()", sring.isAssociative());
535        //System.out.println("sring = " + sring.toScript());
536
537        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3
538        //System.out.println("rsring = " + rsring); //.toScript());
539        //System.out.println("rsring = " + rsring.toScript());
540
541        GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
542        RecSolvablePolynomial<BigRational> ar, br, cr, dr;
543        ad = sring.random(kl, ll, el, q);
544        bd = sring.random(kl, ll, el, q);
545        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
546        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
547
548        //System.out.println("ad = " + ad);
549        //System.out.println("bd = " + bd);
550
551        cd = ad.multiply(bd);
552        //System.out.println("cd = " + cd);
553
554        ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad);
555        br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd);
556        //System.out.println("ar = " + ar);
557        //System.out.println("br = " + br);
558
559        cr = ar.multiply(br);
560        //System.out.println("cr = " + cr);
561
562        dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd);
563        //System.out.println("dr = " + dr);
564
565        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
566        assertEquals("dr == cr", dr, cr);
567
568        dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr);
569        //System.out.println("dd = " + dd);
570        assertEquals("dd == cd", dd, cd);
571    }
572
573}