Source code

001/*
002 * $Id: RecSolvablePolynomialTest.java 5315 2015-10-30 18:33:42Z 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 = 5;
062
063
064    int ll = 4;
065
066
067    int el = 3;
068
069
070    float q = 0.3f;
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    GenPolynomialRing<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 GenPolynomialRing<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    public void testDistRecWeyl() {
442        GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac,
443                        tord, cvars);
444        RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
445        csring.addRelations(wlc);
446        assertFalse("isCommutative()", csring.isCommutative());
447        assertTrue("isAssociative()", csring.isAssociative());
448
449        ring = new RecSolvablePolynomialRing<BigRational>(csring, tord, vars);
450        RelationGenerator<GenPolynomial<BigRational>> wl = new WeylRelations<GenPolynomial<BigRational>>();
451        ring.addRelations(wl);
452
453        // first distribute solvable polynomial only
454        GenSolvablePolynomialRing<BigRational> fring = (GenSolvablePolynomialRing) ring;
455        GenSolvablePolynomialRing<BigRational> pfd = fring.distribute();
456        //System.out.println("pfd = " + pfd.toScript());
457        RecSolvablePolynomialRing<BigRational> pfdr = (RecSolvablePolynomialRing<BigRational>) pfd
458                        .recursive(ring.nvar);
459        //System.out.println("pfdr = " + pfdr.toScript());
460        //System.out.println("ring = " + ring.toScript());
461        assertEquals("ring == pfdr", ring, pfdr);
462
463        RecSolvablePolynomial<BigRational> a = ring.random(kl, 2 * ll, el, 2.0f * q);
464        //System.out.println("a   = " + a);
465
466        GenSolvablePolynomial<BigRational> ad = (GenSolvablePolynomial<BigRational>) PolyUtil
467                        .<BigRational> distribute(pfd, a);
468        //System.out.println("ad  = " + ad);
469
470        GenSolvablePolynomial<GenPolynomial<BigRational>> adr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) PolyUtil
471                        .<BigRational> recursive(pfdr, ad);
472        //System.out.println("adr = " + adr);
473        assertEquals("a == adr", a, adr);
474
475        // now recursive solvable polynials with coefficient relations:
476        RecSolvablePolynomial<BigRational> r1 = ring.parse("x");
477        GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
478        RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
479        ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
480        //System.out.println("ring = " + ring.toScript());
481
482        GenSolvablePolynomialRing<BigRational> pfrd = RecSolvablePolynomialRing
483                        .<BigRational> distribute(ring);
484        //System.out.println("pfrd = " + pfrd.toScript());
485        RecSolvablePolynomialRing<BigRational> pfrdr = (RecSolvablePolynomialRing<BigRational>) pfrd
486                        .recursive(ring.nvar);
487        //System.out.println("pfrdr = " + pfrdr.toScript());
488        //System.out.println("ring = " + ring.toScript());
489        assertEquals("ring == pfrdr", ring, pfrdr);
490
491        //System.out.println("a   = " + a);
492        ad = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(pfrd, a);
493        //System.out.println("ad  = " + ad);
494        adr = (GenSolvablePolynomial<GenPolynomial<BigRational>>) PolyUtil.<BigRational> recursive(pfrdr, ad);
495        //System.out.println("adr = " + adr);
496        assertEquals("a == adr", a, adr);
497    }
498
499
500    /**
501     * Test reversion for Weyl relations.
502     */
503    public void testReverseWeyl() {
504        GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac,
505                        tord, cvars);
506        RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
507        //wlc.generate(csring);
508        csring.addRelations(wlc);
509        assertFalse("isCommutative()", csring.isCommutative());
510        assertTrue("isAssociative()", csring.isAssociative());
511
512        RecSolvablePolynomial<BigRational> r1 = ring.parse("x");
513        GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
514        RecSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
515        ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
516
517        RecSolvablePolynomialRing<BigRational> pfr = ring.reverse();
518        RecSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
519        assertEquals("pf == pfrr", ring, pfrr);
520        //System.out.println("ring = " + ring);
521        //System.out.println("pfr = " + pfr);
522
523        RecSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q);
524        //System.out.println("a = " + a);
525
526        RecSolvablePolynomial<BigRational> ar = (RecSolvablePolynomial<BigRational>) a.reverse(pfr);
527        RecSolvablePolynomial<BigRational> arr = (RecSolvablePolynomial<BigRational>) ar.reverse(pfrr);
528        assertEquals("a == arr", a, arr);
529        //System.out.println("ar = " + ar);
530        //System.out.println("arr = " + arr);
531    }
532
533
534    /**
535     * Test recursive for Weyl relations.
536     */
537    public void testRecursiveWeyl() {
538        String[] svars = new String[] { "w", "x", "y", "z" };
539        GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord,
540                        svars);
541        RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>(sring);
542        //wlc.generate(sring);
543        sring.addRelations(wlc);
544        assertFalse("isCommutative()", sring.isCommutative());
545        assertTrue("isAssociative()", sring.isAssociative());
546        //System.out.println("sring = " + sring.toScript());
547
548        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3
549        //System.out.println("rsring = " + rsring.toScript());
550
551        GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
552        RecSolvablePolynomial<BigRational> ar, br, cr, dr;
553        ad = sring.random(kl, ll, el, q);
554        bd = sring.random(kl, ll, el, q);
555        //ad = sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225");
556        //bd = sring.parse("-10/13 x "); //+ 413/150");
557        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
558        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
559
560        //System.out.println("ad = " + ad);
561        //System.out.println("bd = " + bd);
562
563        cd = ad.multiply(bd);
564        //System.out.println("cd = " + cd);
565
566        ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad);
567        br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd);
568        //System.out.println("ar = " + ar);
569        //System.out.println("br = " + br);
570
571        cr = ar.multiply(br);
572        //System.out.println("cr = " + cr);
573        //System.out.println("cr.ring = " + cr.ring.toScript());
574
575        dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd);
576        //System.out.println("dr = " + dr);
577
578        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
579        assertEquals("dr == cr", dr, cr);
580
581        dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr);
582        //System.out.println("dd = " + dd);
583        assertEquals("dd == cd", dd, cd);
584    }
585
586
587    /**
588     * Test recursive for iterated Weyl relations.
589     */
590    public void testRecursiveIteratedWeyl() {
591        String[] svars = new String[] { "w", "x", "y", "z" };
592        GenSolvablePolynomialRing<BigRational> sring = new GenSolvablePolynomialRing<BigRational>(cfac, tord,
593                        svars);
594        RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>();
595        //wlc.generate(sring);
596        sring.addRelations(wlc);
597        assertFalse("isCommutative()", sring.isCommutative());
598        assertTrue("isAssociative()", sring.isAssociative());
599        //System.out.println("sring = " + sring.toScript());
600
601        GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring = sring.recursive(2); // 1,2,3
602        //System.out.println("rsring = " + rsring); //.toScript());
603        //System.out.println("rsring = " + rsring.toScript());
604
605        GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
606        RecSolvablePolynomial<BigRational> ar, br, cr, dr;
607        ad = sring.random(kl, ll, el, q);
608        bd = sring.random(kl, ll, el, q);
609        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
610        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
611
612        //System.out.println("ad = " + ad);
613        //System.out.println("bd = " + bd);
614
615        cd = ad.multiply(bd);
616        //System.out.println("cd = " + cd);
617
618        ar = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, ad);
619        br = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, bd);
620        //System.out.println("ar = " + ar);
621        //System.out.println("br = " + br);
622
623        cr = ar.multiply(br);
624        //System.out.println("cr = " + cr);
625
626        dr = (RecSolvablePolynomial<BigRational>) PolyUtil.<BigRational> recursive(rsring, cd);
627        //System.out.println("dr = " + dr);
628
629        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
630        assertEquals("dr == cr", dr, cr);
631
632        dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational> distribute(sring, cr);
633        //System.out.println("dd = " + dd);
634        assertEquals("dd == cd", dd, cd);
635    }
636
637}