Source code

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