Source code

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