Source code

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