Source code

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