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