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