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