Source code

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