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