Source code

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