Source code

001/*
002 * $Id: ResidueSolvableWordPolynomialTest.java 5288 2015-08-01 17:22:12Z kredel
003 * $
004 */
005
006package edu.jas.application;
007
008
009import java.util.ArrayList;
010import java.util.List;
011import java.util.Map;
012
013import junit.framework.Test;
014import junit.framework.TestCase;
015import junit.framework.TestSuite;
016
017import org.apache.log4j.BasicConfigurator;
018
019import edu.jas.arith.BigRational;
020import edu.jas.poly.ExpVector;
021import edu.jas.poly.GenPolynomial;
022import edu.jas.poly.GenPolynomialRing;
023import edu.jas.poly.GenSolvablePolynomial;
024import edu.jas.poly.GenWordPolynomial;
025import edu.jas.poly.GenWordPolynomialRing;
026import edu.jas.poly.RecSolvableWordPolynomial;
027import edu.jas.poly.RelationGenerator;
028import edu.jas.poly.TermOrder;
029import edu.jas.poly.WeylRelations;
030
031
032/**
033 * BigRational coefficients ResidueSolvableWordPolynomial tests with JUnit.
034 * @author Heinz Kredel.
035 */
036
037public class ResidueSolvableWordPolynomialTest extends TestCase {
038
039
040    /**
041     * main.
042     */
043    public static void main(String[] args) {
044        BasicConfigurator.configure();
045        junit.textui.TestRunner.run(suite());
046    }
047
048
049    /**
050     * Constructs a <CODE>ResidueSolvableWordPolynomialTest</CODE> object.
051     * @param name String.
052     */
053    public ResidueSolvableWordPolynomialTest(String name) {
054        super(name);
055    }
056
057
058    /**
059     */
060    public static Test suite() {
061        TestSuite suite = new TestSuite(ResidueSolvableWordPolynomialTest.class);
062        return suite;
063    }
064
065
066    ResidueSolvableWordPolynomial<BigRational> a, b, c, d, e, f, x1, x2;
067
068
069    int rl = 4;
070
071
072    int kl = 2;
073
074
075    int ll = 3;
076
077
078    int el = 2;
079
080
081    float q = 0.3f;
082
083
084    String[] cvars = new String[] { "a", "b" };
085
086
087    String[] vars = new String[] { "w", "x", "y", "z" };
088
089
090    WordResidueRing<BigRational> rring;
091
092
093    WordIdeal<BigRational> wideal;
094
095
096    ResidueSolvableWordPolynomialRing<BigRational> ring;
097
098
099    BigRational cfac;
100
101
102    GenWordPolynomialRing<BigRational> wring;
103
104
105    GenPolynomialRing<BigRational> cring;
106
107
108    TermOrder tord = new TermOrder(TermOrder.INVLEX);
109
110
111    @Override
112    protected void setUp() {
113        cfac = new BigRational(1);
114        wring = new GenWordPolynomialRing<BigRational>(cfac, cvars);
115        //RelationGenerator<BigRational> wc = new WeylRelations<BigRational>();
116        //not possible: wring.addRelations(wc); 
117        List<GenWordPolynomial<BigRational>> il = new ArrayList<GenWordPolynomial<BigRational>>();
118        //GenWordPolynomial<BigRational> p1 = wring.parse("b - a^2"); // not associative
119        //GenWordPolynomial<BigRational> p1 = wring.parse("b - a^3"); // not associative
120        GenWordPolynomial<BigRational> p1 = wring.parse("b a - 1"); // Weyl relation
121        il.add(p1);
122        //p1 = wring.parse("a - b^5");
123        //il.add(p1);
124        wideal = new WordIdeal<BigRational>(wring, il);
125        wideal = wideal.GB();
126        if (wideal.isONE()) {
127            System.out.println("twosided wideal = " + wideal.toScript());
128            throw new IllegalArgumentException("ideal is one");
129        }
130        rring = new WordResidueRing<BigRational>(wideal);
131        //System.out.println("rring = " + rring.toScript());
132        ring = new ResidueSolvableWordPolynomialRing<BigRational>(rring, tord, vars);
133        RelationGenerator<WordResidue<BigRational>> wl = new WeylRelations<WordResidue<BigRational>>();
134        wl.generate(ring);
135        List<GenSolvablePolynomial<WordResidue<BigRational>>> qrel = ring.table.relationList();
136        //System.out.println("qrel = " + qrel);
137        List<GenSolvablePolynomial<GenWordPolynomial<BigRational>>> prel = new ArrayList<GenSolvablePolynomial<GenWordPolynomial<BigRational>>>();
138        for (GenSolvablePolynomial<WordResidue<BigRational>> q : qrel) {
139            GenSolvablePolynomial<GenWordPolynomial<BigRational>> p = ring.toPolyCoefficients(q);
140            prel.add(p);
141        }
142        //System.out.println("prel = " + prel);
143        ring.polCoeff.table.addSolvRelations(prel);
144        //System.out.println("ring = " + ring.toScript());
145        a = b = c = d = e = null;
146    }
147
148
149    @Override
150    protected void tearDown() {
151        ring = null;
152        a = b = c = d = e = null;
153    }
154
155
156    /**
157     * Test constructor, generators and properties.
158     */
159    public void testConstructor() {
160        assertFalse("not commutative", ring.isCommutative());
161        assertTrue("associative", ring.isAssociative());
162
163        a = new ResidueSolvableWordPolynomial<BigRational>(ring);
164        assertTrue("length( a ) = 0", a.length() == 0);
165        assertTrue("isZERO( a )", a.isZERO());
166        assertTrue("isONE( a )", !a.isONE());
167
168        c = ring.getONE();
169        assertTrue("length( c ) = 1", c.length() == 1);
170        assertTrue("isZERO( c )", !c.isZERO());
171        assertTrue("isONE( c )", c.isONE());
172
173        d = ring.getZERO();
174        assertTrue("length( d ) = 0", d.length() == 0);
175        assertTrue("isZERO( d )", d.isZERO());
176        assertTrue("isONE( d )", !d.isONE());
177        //System.out.println("d = " + d);
178
179        //System.out.println("");
180        for (GenPolynomial<WordResidue<BigRational>> g : ring.generators()) {
181            //System.out.print("g = " + g + ", ");
182            assertFalse("not isZERO( g )", g.isZERO());
183        }
184        //System.out.println("");
185    }
186
187
188    /**
189     * Test random polynomial and conversion.
190     */
191    public void testRandom() {
192        for (int i = 0; i < 3; i++) {
193            // a = ring.random(ll+2*i);
194            a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q);
195            //System.out.println("a = " + a);
196            assertTrue("length( a" + i + " ) <> 0", a.length() >= 0);
197            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
198            assertTrue(" not isONE( a" + i + " )", !a.isONE());
199
200            RecSolvableWordPolynomial<BigRational> b = ring.toPolyCoefficients(a);
201            c = ring.fromPolyCoefficients(b);
202            assertEquals("res(poly(a)) == a", a, c);
203        }
204    }
205
206
207    /**
208     * Test addition.
209     */
210    public void testAddition() {
211        a = ring.random(kl, ll, el, q);
212        c = (ResidueSolvableWordPolynomial<BigRational>) a.subtract(a);
213        assertTrue("a-a = 0", c.isZERO());
214
215        b = (ResidueSolvableWordPolynomial<BigRational>) a.sum(a);
216        c = (ResidueSolvableWordPolynomial<BigRational>) b.subtract(a);
217        assertEquals("a+a-a = a", c, a);
218
219        b = ring.random(kl, ll, el, q);
220        c = (ResidueSolvableWordPolynomial<BigRational>) b.sum(a);
221        d = (ResidueSolvableWordPolynomial<BigRational>) a.sum(b);
222        assertEquals("a+b = b+a", c, d);
223
224        c = ring.random(kl, ll, el, q);
225        d = (ResidueSolvableWordPolynomial<BigRational>) a.sum(b.sum(c));
226        e = (ResidueSolvableWordPolynomial<BigRational>) a.sum(b).sum(c);
227        assertEquals("a+(b+c) = (a+b)+c", d, e);
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        //System.out.println("e = " + e);
233
234        ExpVector u = ExpVector.EVRAND(rl, el, q);
235        WordResidue<BigRational> x = rring.random(kl);
236        //System.out.println("x = " + x);
237        //System.out.println("u = " + u);
238
239        b = ring.getONE().multiply(x, u);
240        c = (ResidueSolvableWordPolynomial<BigRational>) a.sum(b);
241        d = (ResidueSolvableWordPolynomial<BigRational>) a.sum(x, u);
242        //System.out.println("a = " + a);
243        //System.out.println("b = " + b);
244        //System.out.println("c = " + c);
245        //System.out.println("d = " + d);
246        assertEquals("a+p(x,u) = a+(x,u)", c, d);
247
248        c = (ResidueSolvableWordPolynomial<BigRational>) a.subtract(b);
249        d = (ResidueSolvableWordPolynomial<BigRational>) a.subtract(x, u);
250        assertEquals("a-p(x,u) = a-(x,u)", c, d);
251
252        a = ring.getZERO();
253        b = ring.getONE().multiply(x, u);
254        c = (ResidueSolvableWordPolynomial<BigRational>) b.sum(a);
255        d = (ResidueSolvableWordPolynomial<BigRational>) a.sum(x, u);
256        assertEquals("a+p(x,u) = a+(x,u)", c, d);
257
258        c = (ResidueSolvableWordPolynomial<BigRational>) a.subtract(b);
259        d = (ResidueSolvableWordPolynomial<BigRational>) a.subtract(x, u);
260        assertEquals("a-p(x,u) = a-(x,u)", c, d);
261    }
262
263
264    /**
265     * Test multiplication.
266     */
267    public void testMultiplication() {
268        //System.out.println("ring = " + ring);
269        a = ring.random(kl, ll, el, q);
270        //a = ring.parse(" b y z + a w z ");  
271        b = ring.random(kl, ll, el, q);
272        //b = ring.parse(" w x - b x "); 
273
274        c = b.multiply(a);
275        d = a.multiply(b);
276        //System.out.println("a = " + a);
277        //System.out.println("b = " + b);
278        //System.out.println("c = " + c);
279        //System.out.println("d = " + d);
280        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
281
282        c = ring.random(kl, ll, el, q);
283        //a = ring.parse("( ( a + 11/5 ) )");
284        //b = ring.parse("( ( a + 35/6 ) )");
285        //c = ring.parse("( ( b a + 11/24 a ) )");
286        //System.out.println("a = " + a);
287        //System.out.println("b = " + b);
288        //System.out.println("c = " + c);
289
290        d = a.multiply(b.multiply(c));
291        e = a.multiply(b).multiply(c);
292        //System.out.println("d = " + d);
293        //System.out.println("e = " + e);
294        //System.out.println("d-e = " + d.subtract(e));
295        assertEquals("a(bc) = (ab)c", d, e);
296
297        d = (ResidueSolvableWordPolynomial<BigRational>) a.monic();
298        //System.out.println("d = " + d);
299        assertTrue("a.monic(): " + d, d.leadingBaseCoefficient().isONE()
300                        || d.leadingBaseCoefficient().abs().equals(a.leadingBaseCoefficient().abs()));
301    }
302
303
304    /**
305     * Test distributive law.
306     */
307    public void testDistributive() {
308        a = ring.random(kl, ll, el, q);
309        b = ring.random(kl, ll, el, q);
310        c = ring.random(kl, ll, el, q);
311
312        d = a.multiply((ResidueSolvableWordPolynomial<BigRational>) b.sum(c));
313        e = (ResidueSolvableWordPolynomial<BigRational>) a.multiply(b).sum(a.multiply(c));
314        assertEquals("a(b+c) = ab+ac", d, e);
315    }
316
317
318    /**
319     * Test word coefficient ring.
320     */
321    public void testWordCoeffsRelations() {
322        assertTrue("# relations == 2", ring.table.size() == 2);
323        assertFalse("isCommutative()", ring.isCommutative());
324        assertTrue("isAssociative()", ring.isAssociative());
325        //System.out.println("ring = " + ring.toScript());
326
327        ResidueSolvableWordPolynomial<BigRational> r1 = ring.parse("x");
328        GenWordPolynomial<BigRational> r2 = wring.parse("a");
329        ResidueSolvableWordPolynomial<BigRational> rp = ring.parse("a x + b");
330        GenSolvablePolynomial<GenWordPolynomial<BigRational>> pp = ring.toPolyCoefficients(rp);
331        //System.out.println("r1 = " + r1);
332        //System.out.println("r2 = " + r2);
333        //System.out.println("rp = " + rp);
334        //System.out.println("pp = " + pp);
335        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingWord().leadingExpVector(), pp);
336
337        //System.out.println("ring = " + ring.toScript());
338
339        assertFalse("isCommutative()", ring.isCommutative());
340        assertTrue("isAssociative()", ring.isAssociative());
341
342        List<GenPolynomial<WordResidue<BigRational>>> gens = ring.generators();
343        for (GenPolynomial<WordResidue<BigRational>> x : gens) {
344            GenSolvablePolynomial<WordResidue<BigRational>> xx = (GenSolvablePolynomial<WordResidue<BigRational>>) x;
345            a = new ResidueSolvableWordPolynomial<BigRational>(ring, xx);
346            for (GenPolynomial<WordResidue<BigRational>> y : gens) {
347                GenSolvablePolynomial<WordResidue<BigRational>> yy = (GenSolvablePolynomial<WordResidue<BigRational>>) y;
348                b = new ResidueSolvableWordPolynomial<BigRational>(ring, yy);
349                c = a.multiply(b);
350                //System.out.println("gens:" + a + " * " + b + " = " + c);
351                ExpVector ev = a.leadingExpVector().sum(b.leadingExpVector());
352                // not always true
353                assertTrue("LT(a)*LT(b) == LT(c)", c.leadingExpVector().equals(ev));
354                // not true
355                //ev = a.leadingBaseCoefficient().val.leadingWord().leadingExpVector()
356                //                .sum(b.leadingBaseCoefficient().val.leadingWord().leadingExpVector());
357                //assertTrue("LT(lc(a))*LT(lc(b)) == LT(lc(c))", c.leadingBaseCoefficient().val.leadingWord()
358                //                .leadingExpVector().equals(ev));
359            }
360        }
361        //System.out.println("ring = " + ring.toScript());
362
363        a = ring.random(kl, ll, el, q);
364        //a = ring.getONE();
365        //System.out.println("a = " + a);
366        b = ring.random(kl, ll, el, q);
367        //b = ring.getONE();
368        //System.out.println("b = " + b);
369
370        // non-commutative
371        c = b.multiply(a);
372        d = a.multiply(b);
373        //System.out.println("c = " + c);
374        //System.out.println("d = " + d);
375        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
376    }
377
378
379    /**
380     * Test extension and contraction for Weyl relations.
381     */
382    public void testExtendContractWeyl() {
383        ResidueSolvableWordPolynomial<BigRational> r1 = ring.parse("x");
384        GenWordPolynomial<BigRational> r2 = wring.parse("a");
385        ResidueSolvableWordPolynomial<BigRational> rp = ring.parse("a x + b");
386        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingWord().leadingExpVector(),
387                        ring.toPolyCoefficients(rp));
388
389        int k = rl;
390        ResidueSolvableWordPolynomialRing<BigRational> pfe = ring.extend(k);
391        //System.out.println("pfe = " + pfe);
392        ResidueSolvableWordPolynomialRing<BigRational> pfec = pfe.contract(k);
393        //System.out.println("pfec = " + pfec);
394        assertEquals("ring == pfec", ring, pfec);
395
396        ResidueSolvableWordPolynomial<BigRational> a = ring.random(kl, ll, el, q);
397        //System.out.println("a = " + a);
398
399        ResidueSolvableWordPolynomial<BigRational> ae = (ResidueSolvableWordPolynomial<BigRational>) a
400                        .extend(pfe, 0, 0);
401        //System.out.println("ae = " + ae);
402
403        Map<ExpVector, GenPolynomial<WordResidue<BigRational>>> m = ae.contract(pfec);
404        List<GenPolynomial<WordResidue<BigRational>>> ml = new ArrayList<GenPolynomial<WordResidue<BigRational>>>(
405                        m.values());
406        GenPolynomial<WordResidue<BigRational>> aec = ml.get(0);
407        //System.out.println("ae  = " + ae);
408        //System.out.println("aec = " + aec);
409        assertEquals("a == aec", a, aec);
410    }
411
412
413    /**
414     * Test reversion for Weyl relations.
415     */
416    public void testReverseWeyl() {
417        ResidueSolvableWordPolynomial<BigRational> r1 = ring.parse("x");
418        GenWordPolynomial<BigRational> r2 = wring.parse("a");
419        ResidueSolvableWordPolynomial<BigRational> rp = ring.parse("a x + b");
420        ring.polCoeff.coeffTable.update(r1.leadingExpVector(), r2.leadingWord().leadingExpVector(),
421                        ring.toPolyCoefficients(rp));
422
423        ResidueSolvableWordPolynomialRing<BigRational> pfr = ring.reverse();
424        ResidueSolvableWordPolynomialRing<BigRational> pfrr = pfr.reverse();
425        assertEquals("pf == pfrr", ring, pfrr);
426        //System.out.println("ring = " + ring);
427        //System.out.println("pfr = " + pfr);
428
429        ResidueSolvableWordPolynomial<BigRational> a = ring.random(kl, ll, el, q);
430        //System.out.println("a = " + a);
431
432        ResidueSolvableWordPolynomial<BigRational> ar = (ResidueSolvableWordPolynomial<BigRational>) a
433                        .reverse(pfr);
434        ResidueSolvableWordPolynomial<BigRational> arr = (ResidueSolvableWordPolynomial<BigRational>) ar
435                        .reverse(pfrr);
436        assertEquals("a == arr", a, arr);
437        //System.out.println("ar = " + ar);
438        //System.out.println("arr = " + arr);
439    }
440
441}