001/*
002 * $Id: ResidueSolvablePolynomialQLRTest.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.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        
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    @SuppressWarnings("unchecked")
205    public void testAddition() {
206        a = ring.random(kl, ll, el, q);
207        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(a);
208        assertTrue("a-a = 0", c.isZERO());
209
210        b = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(a);
211        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.subtract(a);
212        assertEquals("a+a-a = a", c, a);
213
214        b = ring.random(kl, ll, el, q);
215        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
216        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
217        assertEquals("a+b = b+a", c, d);
218
219        c = ring.random(kl, ll, el, q);
220        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b.sum(c));
221        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b).sum(c);
222        assertEquals("a+(b+c) = (a+b)+c", d, e);
223        //System.out.println("a = " + a);
224        //System.out.println("b = " + b);
225        //System.out.println("c = " + c);
226        //System.out.println("d = " + d);
227        //System.out.println("e = " + e);
228
229        ExpVector u = ExpVector.random(rl, el, q);
230        SolvableResidue<BigRational> x = rring.random(kl);
231        //System.out.println("x = " + x);
232        //System.out.println("u = " + u);
233
234        b = ring.getONE().multiply(x, u);
235        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(b);
236        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
237        //System.out.println("a = " + a);
238        //System.out.println("b = " + b);
239        //System.out.println("c = " + c);
240        //System.out.println("d = " + d);
241        assertEquals("a+p(x,u) = a+(x,u)", c, d);
242
243        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
244        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
245        assertEquals("a-p(x,u) = a-(x,u)", c, d);
246
247        a = ring.getZERO();
248        b = ring.getONE().multiply(x, u);
249        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(a);
250        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.sum(x, u);
251        assertEquals("a+p(x,u) = a+(x,u)", c, d);
252
253        c = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(b);
254        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.subtract(x, u);
255        assertEquals("a-p(x,u) = a-(x,u)", c, d);
256    }
257
258
259    /**
260     * Test multiplication.
261     */
262    @SuppressWarnings("unchecked")
263    public void testMultiplication() {
264        //System.out.println("ring = " + ring);
265        a = ring.random(kl, ll, el, q);
266        //a = ring.parse(" b y z + a w z ");  
267        b = ring.random(kl, ll, el, q);
268        //b = ring.parse(" w x - b x "); 
269
270        c = b.multiply(a);
271        d = a.multiply(b);
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        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
277
278        c = ring.random(kl, ll, el, q);
279        d = a.multiply(b.multiply(c));
280        e = a.multiply(b).multiply(c);
281        assertEquals("a(bc) = (ab)c", d, e);
282        //System.out.println("a = " + a);
283        //System.out.println("b = " + b);
284        //System.out.println("c = " + c);
285        //System.out.println("d = " + d);
286        //System.out.println("e = " + e);
287
288        d = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.monic();
289        //System.out.println("d = " + d);
290        assertTrue("a.monic(): " + d, d.leadingBaseCoefficient().isONE()
291                        || d.leadingBaseCoefficient().equals(a.leadingBaseCoefficient()));
292    }
293
294
295    /**
296     * Test partially commutative ring.
297     */
298    @SuppressWarnings("unchecked")
299    public void testPartCommutative() {
300        //System.out.println("table = " + table.toString(vars));
301        //System.out.println("table = " + table.toScript());
302        //System.out.println("ring = " + ring);
303        //System.out.println("ring.table = " + ring.table.toScript());
304        //assertEquals("table == ring.table: ", table, ring.table); // ?
305        assertTrue("# relations == 2", ring.table.size() == 2);
306
307        ring = new QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational>(rring, ring);
308        //System.out.println("ring = " + ring);
309
310        assertTrue("isCommutative()", ring.isCommutative() || !rring.isCommutative());
311        assertTrue("isAssociative()", ring.isAssociative());
312
313        a = ring.random(kl, ll, el, q);
314        //a = ring.parse(" b x y z + a w z ");
315        //System.out.println("a = " + a);
316        b = ring.random(kl, ll, el, q);
317        //b = ring.parse(" w y z - b x ");
318        //System.out.println("b = " + b);
319
320        // commutative
321        c = b.multiply(a);
322        //System.out.println("c = " + c);
323        d = a.multiply(b);
324        //d = ring.getONE(); 
325        //System.out.println("d = " + d);
326        assertEquals("ba == ab: ", c, d);
327    }
328
329
330    /**
331     * Test distributive law.
332     */
333    @SuppressWarnings("unchecked")
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((QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) b.sum(c));
340        e = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a.multiply(b).sum(
341                        a.multiply(c));
342        assertEquals("a(b+c) = ab+ac", d, e);
343    }
344
345
346    /**
347     * Test solvable coefficient ring.
348     */
349    @SuppressWarnings("unchecked")
350    public void testSolvableCoeffsRelations() {
351        assertTrue("# relations == 2", ring.table.size() == 2);
352        assertFalse("isCommutative()", ring.isCommutative());
353        assertTrue("isAssociative()", ring.isAssociative());
354        //System.out.println("ring = " + ring.toScript());
355
356        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("z");
357        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
358        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a z + b");
359        GenSolvablePolynomial<GenPolynomial<BigRational>> pp = ring.toPolyCoefficients(rp);
360        //System.out.println("r1 = " + r1);
361        //System.out.println("r2 = " + r2);
362        //System.out.println("rp = " + rp);
363        //System.out.println("pp = " + pp);
364        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
365        //ring.polCoeff.table.update(r1.leadingExpVector(), r2.leadingExpVector(), pp);
366        //ring.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(), rp);
367
368        //System.out.println("ring = " + ring.toScript());
369
370        assertFalse("isCommutative()", ring.isCommutative());
371        assertTrue("isAssociative()", ring.isAssociative());
372
373        List<GenPolynomial<SolvableResidue<BigRational>>> gens = ring.generators();
374        for (GenPolynomial<SolvableResidue<BigRational>> x : gens) {
375            GenSolvablePolynomial<SolvableResidue<BigRational>> xx = (GenSolvablePolynomial<SolvableResidue<BigRational>>) x;
376            a = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, xx);
377            for (GenPolynomial<SolvableResidue<BigRational>> y : gens) {
378                GenSolvablePolynomial<SolvableResidue<BigRational>> yy = (GenSolvablePolynomial<SolvableResidue<BigRational>>) y;
379                b = new QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>(ring, yy);
380                c = a.multiply(b);
381                //System.out.println("gens:" + a + " * " + b + " = " + c);
382                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
383                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
384                ev = a.leadingBaseCoefficient().val.leadingExpVector().sum(
385                                b.leadingBaseCoefficient().val.leadingExpVector());
386                assertTrue("LT(lc(a))*LT(lc(b)) == LT(lc(c))", c.leadingBaseCoefficient().val
387                                .leadingExpVector().equals(ev));
388            }
389        }
390        //System.out.println("ring = " + ring.toScript());
391
392        a = ring.random(kl, ll, el, q);
393        //a = ring.getONE();
394        //System.out.println("a = " + a);
395        b = ring.random(kl, ll, el, q);
396        //b = ring.getONE();
397        //System.out.println("b = " + b);
398
399        // non-commutative
400        c = b.multiply(a);
401        d = a.multiply(b);
402        //System.out.println("c = " + c);
403        //System.out.println("d = " + d);
404        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
405    }
406
407
408    /**
409     * Test extension and contraction for Weyl relations.
410     */
411    @SuppressWarnings("unchecked")
412    public void testExtendContractWeyl() {
413        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
414        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
415        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
416        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
417                        ring.toPolyCoefficients(rp));
418
419        int k = rl;
420        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfe = ring.extend(k);
421        //System.out.println("pfe = " + pfe);
422        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfec = pfe.contract(k);
423        //System.out.println("pfec = " + pfec);
424        assertEquals("ring == pfec", ring, pfec);
425
426        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
427        //System.out.println("a = " + a);
428
429        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ae = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
430                        .extend(pfe, 0, 0);
431        //System.out.println("ae = " + ae);
432
433        Map<ExpVector, GenPolynomial<SolvableResidue<BigRational>>> m = ae.contract(pfec);
434        List<GenPolynomial<SolvableResidue<BigRational>>> ml = new ArrayList<GenPolynomial<SolvableResidue<BigRational>>>(
435                        m.values());
436        GenPolynomial<SolvableResidue<BigRational>> aec = ml.get(0);
437        //System.out.println("ae  = " + ae);
438        //System.out.println("aec = " + aec);
439        assertEquals("a == aec", a, aec);
440    }
441
442
443    /**
444     * Test reversion for Weyl relations.
445     */
446    @SuppressWarnings("unchecked")
447    public void testReverseWeyl() {
448        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> r1 = ring.parse("x");
449        GenSolvablePolynomial<BigRational> r2 = sring.parse("a");
450        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> rp = ring.parse("a x + b");
451        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingExpVector(),
452                        ring.toPolyCoefficients(rp));
453
454        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfr = ring.reverse();
455        QLRSolvablePolynomialRing<SolvableResidue<BigRational>, BigRational> pfrr = pfr.reverse();
456        assertEquals("pf == pfrr", ring, pfrr);
457        //System.out.println("ring = " + ring);
458        //System.out.println("pfr = " + pfr);
459
460        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> a = ring.random(kl, ll, el, q);
461        //System.out.println("a = " + a);
462
463        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> ar = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) a
464                        .reverse(pfr);
465        QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational> arr = (QLRSolvablePolynomial<SolvableResidue<BigRational>, BigRational>) ar
466                        .reverse(pfrr);
467        assertEquals("a == arr", a, arr);
468        //System.out.println("ar = " + ar);
469        //System.out.println("arr = " + arr);
470    }
471
472
473    /**
474     * Test recursive for Weyl relations.
475     */
476    @SuppressWarnings("unchecked")
477    public void testRecursiveWeyl() {
478        GenSolvablePolynomialRing<GenPolynomial<SolvableResidue<BigRational>>> rsring = ring.recursive(2); // 1,2,3
479        //System.out.println("rsring = " + rsring.toScript());
480
481        GenSolvablePolynomial<SolvableResidue<BigRational>> ad, bd, cd, dd;
482        RecSolvablePolynomial<SolvableResidue<BigRational>> ar, br, cr, dr;
483        ad = ring.random(kl, ll, el, q);
484        bd = ring.random(kl, ll, el, q);
485        //ad = sring.parse("7/2 y^2 * z"); // - 15/2 w^2 + 262/225");
486        //bd = sring.parse("-10/13 x "); //+ 413/150");
487        //ad = (GenSolvablePolynomial<BigRational>) ad.monic();
488        //bd = (GenSolvablePolynomial<BigRational>) bd.monic();
489
490        //System.out.println("ad = " + ad);
491        //System.out.println("bd = " + bd);
492
493        cd = ad.multiply(bd);
494        //System.out.println("cd = " + cd);
495
496        ar = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
497                        .<SolvableResidue<BigRational>> recursive(rsring, ad);
498        br = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
499                        .<SolvableResidue<BigRational>> recursive(rsring, bd);
500        //System.out.println("ar = " + ar);
501        //System.out.println("br = " + br);
502
503        cr = ar.multiply(br);
504        //System.out.println("cr = " + cr);
505        //System.out.println("cr.ring = " + cr.ring.toScript());
506
507        dr = (RecSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
508                        .<SolvableResidue<BigRational>> recursive(rsring, cd);
509        //System.out.println("dr = " + dr);
510
511        assertEquals("dr.ring == cr.ring", dr.ring, cr.ring);
512        assertEquals("dr == cr", dr, cr);
513
514        dd = (GenSolvablePolynomial<SolvableResidue<BigRational>>) PolyUtil
515                        .<SolvableResidue<BigRational>> distribute(ring, cr);
516        // //System.out.println("dd = " + dd);
517        assertEquals("dd == cd", dd, cd);
518    }
519
520}