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