Source code

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