001/*
002 * $Id: LocalSolvablePolynomialQLRTest.java 5137 2015-02-28 19:03:26Z kredel $
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015import org.apache.log4j.BasicConfigurator;
016
017import edu.jas.arith.BigRational;
018import edu.jas.poly.ExpVector;
019import edu.jas.poly.GenPolynomial;
020import edu.jas.poly.GenSolvablePolynomial;
021import edu.jas.poly.GenSolvablePolynomialRing;
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;
028
029
030/**
031 * BigRational coefficients LocalSolvablePolynomial QLR representation tests
032 * with JUnit.
033 * @author Heinz Kredel.
034 */
035
036public class LocalSolvablePolynomialQLRTest extends TestCase {
037
038
039    /**
040     * main.
041     */
042    public static void main(String[] args) {
043        BasicConfigurator.configure();
044        junit.textui.TestRunner.run(suite());
045    }
046
047
048    /**
049     * Constructs a <CODE>LocalSolvablePolynomialQLRTest</CODE> object.
050     * @param name String.
051     */
052    public LocalSolvablePolynomialQLRTest(String name) {
053        super(name);
054    }
055
056
057    /**
058     */
059    public static Test suite() {
060        TestSuite suite = new TestSuite(LocalSolvablePolynomialQLRTest.class);
061        return suite;
062    }
063
064
065    QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational> a, b, c, d, e, f, x1, x2;
066
067
068    int rl = 4;
069
070
071    int kl = 1;
072
073
074    int ll = 4;
075
076
077    int el = 3;
078
079
080    float q = 0.2f;
081
082
083    String[] cvars = new String[] { "a", "b" };
084
085
086    String[] vars = new String[] { "w", "x", "y", "z" };
087
088
089    QLRSolvablePolynomialRing<SolvableLocal<BigRational>, BigRational> ring;
090
091
092    BigRational cfac;
093
094
095    GenSolvablePolynomialRing<SolvableLocal<BigRational>> sring;
096
097
098    GenSolvablePolynomialRing<BigRational> cring;
099
100
101    SolvableLocalRing<BigRational> qcring;
102
103
104    SolvableIdeal<BigRational> sideal;
105
106
107    TermOrder tord = new TermOrder(TermOrder.INVLEX);
108
109
110    @Override
111    protected void setUp() {
112        cfac = new BigRational(1);
113        cring = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
114        RelationGenerator<BigRational> wc = new WeylRelations<BigRational>();
115        cring.addRelations(wc); //wc.generate(cring);
116        List<GenSolvablePolynomial<BigRational>> il = new ArrayList<GenSolvablePolynomial<BigRational>>();
117        GenSolvablePolynomial<BigRational> p1 = cring.parse("b - a^2");
118        il.add(p1);
119        //p1 = cring.parse("a - b^5"); 
120        //il.add(p1);
121        sideal = new SolvableIdeal<BigRational>(cring, il);
122        qcring = new SolvableLocalRing<BigRational>(sideal);
123        ring = new QLRSolvablePolynomialRing<SolvableLocal<BigRational>, BigRational>(qcring, tord, vars);
124        RelationGenerator<SolvableLocal<BigRational>> wl = new WeylRelations<SolvableLocal<BigRational>>();
125        ring.addRelations(wl); //wl.generate(ring);
126        a = b = c = d = e = null;
127    }
128
129
130    @Override
131    protected void tearDown() {
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<SolvableLocal<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<SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) a.subtract(a);
192        assertTrue("a-a = 0", c.isZERO());
193
194        b = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.sum(a);
195        c = (QLRSolvablePolynomial<SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) b.sum(a);
200        d = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.sum(b);
201        assertEquals("a+b = b+a", c, d);
202
203        c = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.sum(b);
204        d = (QLRSolvablePolynomial<SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) a.sum(b.sum(c));
211        e = (QLRSolvablePolynomial<SolvableLocal<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.EVRAND(rl, el, q);
220        SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) a.sum(b);
226        d = (QLRSolvablePolynomial<SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) a.subtract(b);
234        d = (QLRSolvablePolynomial<SolvableLocal<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<SolvableLocal<BigRational>, BigRational>) b.sum(a);
240        d = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.sum(x, u);
241        assertEquals("a+p(x,u) = a+(x,u)", c, d);
242
243        c = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.subtract(b);
244        d = (QLRSolvablePolynomial<SolvableLocal<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        SolvableLocal<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<SolvableLocal<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        List<GenSolvablePolynomial<BigRational>> il = new ArrayList<GenSolvablePolynomial<BigRational>>();
303        GenSolvablePolynomial<BigRational> p1 = cring.parse("b - a^2");
304        il.add(p1);
305        sideal = new SolvableIdeal<BigRational>(cring, il);
306        qcring = new SolvableLocalRing<BigRational>(sideal);
307        ring = new QLRSolvablePolynomialRing<SolvableLocal<BigRational>, BigRational>(qcring, ring);
308        //table = ring.table;
309        //System.out.println("table = " + table.toString(vars));
310        //System.out.println("ring = " + ring);
311
312        assertTrue("isCommutative()", ring.isCommutative());
313        assertTrue("isAssociative()", ring.isAssociative());
314
315        a = ring.random(kl, ll, el, q);
316        //a = ring.parse(" b x y z + a w z ");
317        //System.out.println("a = " + a);
318        b = ring.random(kl, ll, el, q);
319        //b = ring.parse(" w y z - b x ");
320        //System.out.println("b = " + b);
321
322        // commutative
323        c = b.multiply(a);
324        //System.out.println("c = " + c);
325        d = a.multiply(b);
326        //d = ring.getONE(); 
327        //System.out.println("d = " + d);
328        assertEquals("b*a == a*b: ", c, d);
329    }
330
331
332    /**
333     * Test distributive law.
334     */
335    @SuppressWarnings("unchecked")
336    public void testDistributive() {
337        a = ring.random(kl, ll, el, q);
338        b = ring.random(kl, ll, el, q);
339        c = ring.random(kl, ll, el, q);
340
341        d = a.multiply((QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) b.sum(c));
342        e = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) a.multiply(b).sum(a.multiply(c));
343        assertEquals("a*(b+c) = a*b+a*c", d, e);
344    }
345
346
347    /**
348     * Test solvable coefficient ring.
349     */
350    @SuppressWarnings("unchecked")
351    public void testSolvableCoeffs() {
352        GenSolvablePolynomialRing<BigRational> csring = new GenSolvablePolynomialRing<BigRational>(cfac,
353                        tord, cvars);
354        //RelationGenerator<BigRational> wc = new WeylRelations<BigRational>();
355        //no: csring.addRelations(wc); //wc.generate(csring);
356        //assertTrue("# relations == 1", csring.table.size() == 1);
357        assertTrue("isCommutative()", csring.isCommutative());
358        assertTrue("isAssociative()", csring.isAssociative());
359
360        List<GenSolvablePolynomial<BigRational>> il = new ArrayList<GenSolvablePolynomial<BigRational>>();
361        GenSolvablePolynomial<BigRational> p1 = csring.parse("b - a^2");
362        il.add(p1);
363        //p1 = csring.parse("a - b^5");
364        //il.add(p1);
365        sideal = new SolvableIdeal<BigRational>(csring, il);
366        SolvableLocalRing<BigRational> qcsring = new SolvableLocalRing<BigRational>(sideal);
367        assertTrue("isCommutative()", qcsring.isCommutative());
368        assertTrue("isAssociative()", qcsring.isAssociative());
369
370        ring = new QLRSolvablePolynomialRing<SolvableLocal<BigRational>, BigRational>(qcsring, ring);
371        RelationGenerator<SolvableLocal<BigRational>> wl = new WeylRelations<SolvableLocal<BigRational>>();
372        ring.addRelations(wl); //wl.generate(ring);
373        assertTrue("# relations == 2", ring.table.size() == 2);
374        assertFalse("isCommutative()", ring.isCommutative());
375        assertTrue("isAssociative()", ring.isAssociative());
376        //System.out.println("ring = " + ring);
377
378        RecSolvablePolynomial<BigRational> r1 = ring.polCoeff.parse("x");
379        GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
380        RecSolvablePolynomial<BigRational> rp = ring.polCoeff.parse("b x + a"); // + a
381        //System.out.println("r1 = " + r1);
382        //System.out.println("r2 = " + r2);
383        //System.out.println("rp = " + rp);
384        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
385        //System.out.println("ring = " + ring.toScript());
386        //System.out.println("ring.polCoeff = " + ring.polCoeff);
387        assertFalse("isCommutative()", ring.isCommutative());
388        assertTrue("isAssociative()", ring.isAssociative());
389
390        List<GenPolynomial<SolvableLocal<BigRational>>> gens = ring.generators();
391        for (GenPolynomial<SolvableLocal<BigRational>> x : gens) {
392            GenSolvablePolynomial<SolvableLocal<BigRational>> xx = (GenSolvablePolynomial<SolvableLocal<BigRational>>) x;
393            a = new QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>(ring, xx);
394            //System.out.println("a = " + a);
395            for (GenPolynomial<SolvableLocal<BigRational>> y : gens) {
396                GenSolvablePolynomial<SolvableLocal<BigRational>> yy = (GenSolvablePolynomial<SolvableLocal<BigRational>>) y;
397                b = new QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>(ring, yy);
398                //System.out.println("b = " + b);
399                c = a.multiply(b);
400                //System.out.println("gens: " + a + " * " + b + " = " + c);
401                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
402                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
403            }
404        }
405        //System.out.println("=============");
406        //a = ring.random(kl, ll, el, q);
407        //a = ring.getONE();
408        a = ring.parse("x^2 + a b");
409        //System.out.println("a = " + a.toScript());
410        //b = ring.random(kl, ll, el, q);
411        //b = ring.getONE();
412        b = ring.parse("a b + a"); // a b^2 + a 
413        b = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) b.inverse();
414        //System.out.println("b = " + b.toScript());
415
416        // non-commutative
417        c = b.multiply(a);
418        d = a.multiply(b);
419        //System.out.println("a = " + a.toScript());
420        //System.out.println("b = " + b.toScript());
421        //System.out.println("c = " + c.toScript());
422        //System.out.println("d = " + d.toScript());
423        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
424
425        e = (QLRSolvablePolynomial<SolvableLocal<BigRational>, BigRational>) b.inverse();
426        //System.out.println("e = " + e.toScript());
427        assertTrue("b*b^-1 == 1", e.multiply(b).isONE());
428
429        c = e.multiply(c);
430        d = d.multiply(e);
431        //System.out.println("a = " + a.toScript());
432        //System.out.println("b = " + b.toScript());
433        //System.out.println("c = " + c.toScript());
434        //System.out.println("d = " + d.toScript());
435        assertTrue("a == b * 1/b * a", a.equals(c));
436        assertTrue("a == a * 1/b * b", a.equals(d));
437    }
438
439
440    /*
441     * Test extension and contraction for Weyl relations. public void
442     * testExtendContractWeyl() { GenSolvablePolynomialRing<BigRational> csring
443     * = new GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
444     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
445     * wlc.generate(csring); assertFalse("isCommutative()", csring.isCommutative());
446     * assertTrue("isAssociative()", csring.isAssociative());
447     * 
448     * QLRSolvablePolynomial<BigRational> r1 = ring.parse("x");
449     * GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
450     * QLRSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
451     * ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
452     * 
453     * int k = rl; QLRSolvablePolynomialRing<BigRational> pfe = ring.extend(k);
454     * //System.out.println("pfe = " + pfe);
455     * QLRSolvablePolynomialRing<BigRational> pfec = pfe.contract(k);
456     * //System.out.println("pfec = " + pfec); assertEquals("ring == pfec",
457     * ring, pfec);
458     * 
459     * QLRSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q);
460     * //System.out.println("a = " + a);
461     * 
462     * QLRSolvablePolynomial<BigRational> ae =
463     * (QLRSolvablePolynomial<BigRational>) a.extend(pfe, 0, 0);
464     * //System.out.println("ae = " + ae);
465     * 
466     * Map<ExpVector, GenPolynomial<GenPolynomial<BigRational>>> m =
467     * ae.contract(pfec); List<GenPolynomial<GenPolynomial<BigRational>>> ml =
468     * new ArrayList<GenPolynomial<GenPolynomial<BigRational>>>( m.values());
469     * GenPolynomial<GenPolynomial<BigRational>> aec = ml.get(0);
470     * //System.out.println("ae  = " + ae); //System.out.println("aec = " +
471     * aec); assertEquals("a == aec", a, aec); }
472     */
473
474
475    /*
476     * Test reversion for Weyl relations. public void testReverseWeyl() {
477     * GenSolvablePolynomialRing<BigRational> csring = new
478     * GenSolvablePolynomialRing<BigRational>(cfac, tord, cvars);
479     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
480     * wlc.generate(csring); assertFalse("isCommutative()", csring.isCommutative());
481     * assertTrue("isAssociative()", csring.isAssociative());
482     * 
483     * QLRSolvablePolynomial<BigRational> r1 = ring.parse("x");
484     * GenSolvablePolynomial<BigRational> r2 = csring.parse("b");
485     * QLRSolvablePolynomial<BigRational> rp = ring.parse("b x + a");
486     * ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
487     * 
488     * QLRSolvablePolynomialRing<BigRational> pfr = ring.reverse();
489     * QLRSolvablePolynomialRing<BigRational> pfrr = pfr.reverse();
490     * assertEquals("pf == pfrr", ring, pfrr); //System.out.println("ring = " +
491     * ring); //System.out.println("pfr = " + pfr);
492     * 
493     * QLRSolvablePolynomial<BigRational> a = ring.random(kl, ll, el, q);
494     * //System.out.println("a = " + a);
495     * 
496     * QLRSolvablePolynomial<BigRational> ar =
497     * (QLRSolvablePolynomial<BigRational>) a.reverse(pfr);
498     * QLRSolvablePolynomial<BigRational> arr =
499     * (QLRSolvablePolynomial<BigRational>) ar.reverse(pfrr);
500     * assertEquals("a == arr", a, arr); //System.out.println("ar = " + ar);
501     * //System.out.println("arr = " + arr); }
502     */
503
504
505    /*
506     * Test recursive for Weyl relations. public void testRecursiveWeyl() {
507     * String[] svars = new String[] { "w", "x", "y", "z" };
508     * GenSolvablePolynomialRing<BigRational> sring = new
509     * GenSolvablePolynomialRing<BigRational>(cfac, tord, svars);
510     * RelationGenerator<BigRational> wlc = new WeylRelations<BigRational>();
511     * wlc.generate(sring); assertFalse("isCommutative()", sring.isCommutative());
512     * assertTrue("isAssociative()", sring.isAssociative());
513     * //System.out.println("sring = " + sring.toScript());
514     * 
515     * GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring =
516     * sring.recursive(2); // 1,2,3 //System.out.println("rsring = " + rsring);
517     * //.toScript()); System.out.println("rsring = " + rsring.toScript());
518     * 
519     * GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
520     * QLRSolvablePolynomial<BigRational> ar, br, cr, dr; ad = sring.random(kl,
521     * ll, el, q); bd = sring.random(kl, ll, el, q); //ad =
522     * sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225"); //bd =
523     * sring.parse("-10/13 x "); //+ 413/150"); //ad =
524     * (GenSolvablePolynomial<BigRational>) ad.monic(); //bd =
525     * (GenSolvablePolynomial<BigRational>) bd.monic();
526     * 
527     * //System.out.println("ad = " + ad); //System.out.println("bd = " + bd);
528     * 
529     * cd = ad.multiply(bd); //System.out.println("cd = " + cd);
530     * 
531     * ar = (QLRSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
532     * recursive(rsring, ad); br = (QLRSolvablePolynomial<BigRational>)
533     * PolyUtil.<BigRational> recursive(rsring, bd);
534     * //System.out.println("ar = " + ar); //System.out.println("br = " + br);
535     * 
536     * cr = ar.multiply(br); //System.out.println("cr = " + cr);
537     * //System.out.println("cr.ring = " + cr.ring.toScript());
538     * 
539     * dr = (QLRSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
540     * recursive(rsring, cd); //System.out.println("dr = " + dr);
541     * 
542     * assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
543     * assertEquals("dr == cr", dr, cr);
544     * 
545     * dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
546     * distribute(sring, cr); //System.out.println("dd = " + dd);
547     * assertEquals("dd == cd", dd, cd); }
548     */
549
550
551    /*
552     * Test recursive for iterated Weyl relations. public void
553     * testRecursiveIteratedWeyl() { String[] svars = new String[] { "w", "x",
554     * "y", "z" }; GenSolvablePolynomialRing<BigRational> sring = new
555     * GenSolvablePolynomialRing<BigRational>(cfac, tord, svars);
556     * RelationGenerator<BigRational> wlc = new WeylRelationsIterated<BigRational>();
557     * wlc.generate(sring); assertFalse("isCommutative()",
558     * sring.isCommutative()); assertTrue("isAssociative()",
559     * sring.isAssociative()); //System.out.println("sring = " +
560     * sring.toScript());
561     * 
562     * GenSolvablePolynomialRing<GenPolynomial<BigRational>> rsring =
563     * sring.recursive(2); // 1,2,3 //System.out.println("rsring = " + rsring);
564     * //.toScript()); System.out.println("rsring = " + rsring.toScript());
565     * 
566     * GenSolvablePolynomial<BigRational> ad, bd, cd, dd;
567     * QLRSolvablePolynomial<BigRational> ar, br, cr, dr; ad = sring.random(kl,
568     * ll, el, q); bd = sring.random(kl, ll, el, q); //ad =
569     * (GenSolvablePolynomial<BigRational>) ad.monic(); //bd =
570     * (GenSolvablePolynomial<BigRational>) bd.monic();
571     * 
572     * //System.out.println("ad = " + ad); //System.out.println("bd = " + bd);
573     * 
574     * cd = ad.multiply(bd); //System.out.println("cd = " + cd);
575     * 
576     * ar = (QLRSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
577     * recursive(rsring, ad); br = (QLRSolvablePolynomial<BigRational>)
578     * PolyUtil.<BigRational> recursive(rsring, bd);
579     * //System.out.println("ar = " + ar); //System.out.println("br = " + br);
580     * 
581     * cr = ar.multiply(br); //System.out.println("cr = " + cr);
582     * 
583     * dr = (QLRSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
584     * recursive(rsring, cd); //System.out.println("dr = " + dr);
585     * 
586     * assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
587     * assertEquals("dr == cr", dr, cr);
588     * 
589     * dd = (GenSolvablePolynomial<BigRational>) PolyUtil.<BigRational>
590     * distribute(sring, cr); //System.out.println("dd = " + dd);
591     * assertEquals("dd == cd", dd, cd); }
592     */
593
594}