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