Source code

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