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