Source code

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