Source code

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