Source code

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