Source code

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