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