Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.poly;
006
007
008import java.util.List;
009import java.util.ArrayList;
010import java.io.StringReader;
011import java.io.IOException;
012
013import junit.framework.Test;
014import junit.framework.TestCase;
015import junit.framework.TestSuite;
016
017
018import edu.jas.arith.BigInteger;
019import edu.jas.arith.BigRational;
020import edu.jas.arith.BigComplex;
021import edu.jas.structure.RingElem;
022
023
024/**
025 * GenWordPolynomial tests with JUnit.
026 * @author Heinz Kredel
027 */
028
029public class GenWordPolynomialTest extends TestCase {
030
031
032    /**
033     * main
034     */
035    public static void main(String[] args) {
036        junit.textui.TestRunner.run(suite());
037    }
038
039
040    /**
041     * Constructs a <CODE>GenWordPolynomialTest</CODE> object.
042     * @param name String.
043     */
044    public GenWordPolynomialTest(String name) {
045        super(name);
046    }
047
048
049    /**
050     * suite.
051     */
052    public static Test suite() {
053        TestSuite suite = new TestSuite(GenWordPolynomialTest.class);
054        return suite;
055    }
056
057
058    int rl = 6;
059
060
061    int kl = 10;
062
063
064    int ll = 7;
065
066
067    int el = 5;
068
069
070    @Override
071    protected void setUp() {
072    }
073
074
075    @Override
076    protected void tearDown() {
077    }
078
079
080    /**
081     * Test constructors and factory.
082     */
083    public void testConstructors() {
084        // integers
085        BigInteger rf = new BigInteger();
086        //System.out.println("rf = " + rf);
087
088        // non-commuting vars: abcdef
089        WordFactory wf = new WordFactory("abcdef");
090        //System.out.println("wf = " + wf);
091
092        // polynomials over integers
093        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
094        //System.out.println("pf = " + pf);
095        assertFalse("not commutative",pf.isCommutative());
096        assertTrue("associative",pf.isAssociative());
097        assertFalse("not field",pf.isField());
098
099        GenWordPolynomial<BigInteger> p = pf.getONE();
100        //System.out.println("p = " + p);
101        assertTrue("p == 1", p.isONE());
102        p = pf.getZERO();
103        assertTrue("p == 0", p.isZERO());
104        //System.out.println("p = " + p);
105        //p = pf.random(9);
106        //System.out.println("p = " + p);
107
108        List<GenWordPolynomial<BigInteger>> gens = pf.generators();
109        //System.out.println("gens = " + gens);
110        assertTrue("#gens == 7", gens.size() == 7);
111
112        RingElem<GenWordPolynomial<BigInteger>> pe = new GenWordPolynomial<BigInteger>(pf);
113        //System.out.println("pe = " + pe);
114        //System.out.println("p.equals(pe) = " + p.equals(pe) );
115        //System.out.println("p.equals(p) = " + p.equals(p) );
116        assertTrue("p.equals(pe) = ", p.equals(pe));
117        assertTrue("p.equals(p) = ", p.equals(p));
118
119        pe = pe.sum(p);
120        //System.out.println("pe = " + pe);
121        assertTrue("pe.isZERO() = ", pe.isZERO());
122        p = pf.random(9);
123        p = p.subtract(p);
124        //System.out.println("p = " + p);
125        //System.out.println("p.isZERO() = " + p.isZERO());
126        assertTrue("p.isZERO() = ", p.isZERO());
127
128        // polynomials over (polynomials over integers)
129        // non-commuting vars: xyz
130        WordFactory wf2 = new WordFactory("xyz");
131        //System.out.println("wf2 = " + wf2);
132
133        GenWordPolynomialRing<GenWordPolynomial<BigInteger>> 
134            ppf = new GenWordPolynomialRing<GenWordPolynomial<BigInteger>>(pf, wf2);
135        //System.out.println("ppf = " + ppf);
136
137        GenWordPolynomial<GenWordPolynomial<BigInteger>> pp = ppf.getONE();
138        //System.out.println("pp = " + pp);
139        assertTrue("pp == 1", pp.isONE());
140        //pp = ppf.random(2);
141        //System.out.println("pp = " + pp);
142        pp = ppf.getZERO();
143        //System.out.println("pp = " + pp);
144        assertTrue("pp == 0", pp.isZERO());
145
146        List<GenWordPolynomial<GenWordPolynomial<BigInteger>>> pgens = ppf.generators();
147        //System.out.println("pgens = " + pgens);
148        assertTrue("#pgens == 7+3", pgens.size() == 10);
149
150        RingElem<GenWordPolynomial<GenWordPolynomial<BigInteger>>> 
151            ppe = new GenWordPolynomial<GenWordPolynomial<BigInteger>>(ppf);
152        //System.out.println("ppe = " + ppe);
153        //System.out.println("pp.equals(ppe) = " + pp.equals(ppe) );
154        //System.out.println("pp.equals(pp) = " + pp.equals(pp) );
155        assertTrue("pp.equals(ppe) = ", pp.equals(ppe));
156        assertTrue("pp.equals(pp) = ", pp.equals(pp));
157
158        ppe = ppe.sum(pp); // why not pp = pp.add(ppe) ?
159        //System.out.println("ppe = " + ppe);
160        assertTrue("ppe.isZERO() = ", ppe.isZERO());
161        pp = ppf.random(2);
162        pp = pp.subtract(pp);
163        //System.out.println("pp = " + pp);
164        //System.out.println("pp.isZERO() = " + pp.isZERO());
165        assertTrue("pp.isZERO() = ", pp.isZERO());
166
167        // polynomials over (polynomials over (polynomials over integers))
168        // non-commuting vars: uvw
169        WordFactory wf3 = new WordFactory("uvw");
170        //System.out.println("wf3 = " + wf3);
171        GenWordPolynomialRing<GenWordPolynomial<GenWordPolynomial<BigInteger>>> 
172            pppf = new GenWordPolynomialRing<GenWordPolynomial<GenWordPolynomial<BigInteger>>>(ppf, wf3);
173        //System.out.println("pppf = " + pppf);
174
175        GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>> ppp = pppf.getONE();
176        //System.out.println("ppp = " + ppp);
177        assertTrue("ppp == 1", ppp.isONE());
178        //ppp = pppf.random(2);
179        //System.out.println("ppp = " + ppp);
180        ppp = pppf.getZERO();
181        //System.out.println("ppp = " + ppp);
182        assertTrue("ppp == 0", ppp.isZERO());
183
184        List<GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>> ppgens = pppf.generators();
185        //System.out.println("ppgens = " + ppgens);
186        assertTrue("#ppgens == 7+3+3", ppgens.size() == 13);
187
188        RingElem<GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>> 
189            pppe = new GenWordPolynomial<GenWordPolynomial<GenWordPolynomial<BigInteger>>>(pppf);
190        //System.out.println("pppe = " + pppe);
191        // System.out.println("ppp.equals(pppe) = " + ppp.equals(pppe) );
192        // System.out.println("ppp.equals(ppp) = " + ppp.equals(ppp) );
193        assertTrue("ppp.equals(pppe) = ", ppp.equals(pppe));
194        assertTrue("ppp.equals(ppp) = ", ppp.equals(ppp));
195
196        pppe = pppe.sum(ppp);
197        //System.out.println("pppe = " + pppe);
198        assertTrue("pppe.isZERO() = ", pppe.isZERO());
199        //ppp = pppf.random(2);
200        ppp = ppp.subtract(ppp);
201        //System.out.println("ppp = " + ppp);
202        //System.out.println("ppp.isZERO() = " + ppp.isZERO());
203        assertTrue("ppp.isZERO() = ", ppp.isZERO());
204    }
205
206
207    /**
208     * Test accessors.
209     */
210    public void testAccessors() {
211        // integers
212        BigInteger rf = new BigInteger();
213        // System.out.println("rf = " + rf);
214
215        // non-commuting vars: abcdef
216        WordFactory wf = new WordFactory("abcdef");
217        //System.out.println("wf = " + wf);
218
219        // polynomials over integers
220        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
221        //System.out.println("pf = " + pf);
222
223        // test 1
224        GenWordPolynomial<BigInteger> p = pf.getONE();
225        //System.out.println("p = " + p);
226
227        Word e = p.leadingWord();
228        BigInteger c = p.leadingBaseCoefficient();
229
230        GenWordPolynomial<BigInteger> f = new GenWordPolynomial<BigInteger>(pf, c, e);
231        assertEquals("1 == 1 ", p, f);
232
233        GenWordPolynomial<BigInteger> r = p.reductum();
234        assertTrue("red(1) == 0 ", r.isZERO());
235
236        // test 0
237        p = pf.getZERO();
238        // System.out.println("p = " + p);
239        e = p.leadingWord();
240        c = p.leadingBaseCoefficient();
241
242        f = new GenWordPolynomial<BigInteger>(pf, c, e);
243        assertEquals("0 == 0 ", p, f);
244
245        r = p.reductum();
246        assertTrue("red(0) == 0 ", r.isZERO());
247
248        // test random
249        p = pf.random(kl, ll, el);
250        // System.out.println("p = " + p);
251        e = p.leadingWord();
252        c = p.leadingBaseCoefficient();
253        r = p.reductum();
254
255        f = new GenWordPolynomial<BigInteger>(pf, c, e);
256        f = r.sum(f);
257        assertEquals("p == lm(f)+red(f) ", p, f);
258
259        // test iteration over random
260        GenWordPolynomial<BigInteger> g;
261        g = p;
262        f = pf.getZERO();
263        while (!g.isZERO()) {
264            e = g.leadingWord();
265            c = g.leadingBaseCoefficient();
266            //System.out.println("c e = " + c + " " + e);
267            r = g.reductum();
268            f = f.sum(c, e);
269            g = r;
270        }
271        assertEquals("p == lm(f)+lm(red(f))+... ", p, f);
272    }
273
274
275    /**
276     * Test addition.
277     */
278    public void testAddition() {
279        // integers
280        BigInteger rf = new BigInteger();
281        // System.out.println("rf = " + rf);
282
283        // non-commuting vars: abcdef
284        WordFactory wf = new WordFactory("abcdef");
285        //System.out.println("wf = " + wf);
286
287        // polynomials over integers
288        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
289        //System.out.println("fac = " + fac);
290
291        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
292        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
293
294        GenWordPolynomial<BigInteger> c = a.sum(b);
295        GenWordPolynomial<BigInteger> d = c.subtract(b);
296        GenWordPolynomial<BigInteger> e;
297        assertEquals("a+b-b = a", a, d);
298        //System.out.println("a = " + a);
299        //System.out.println("b = " + b);
300        //System.out.println("c = " + c);
301        //System.out.println("d = " + d);
302
303        c = fac.random(kl, ll, el);
304        //System.out.println("\nc = " + c);
305        d = a.sum(b.sum(c));
306        e = (a.sum(b)).sum(c);
307
308        //System.out.println("d = " + d);
309        //System.out.println("e = " + e);
310        //System.out.println("d-e = " + d.subtract(e) );
311        assertEquals("a+(b+c) = (a+b)+c", d, e);
312
313        Word u = wf.random(rl);
314        BigInteger x = rf.random(kl);
315
316        b = new GenWordPolynomial<BigInteger>(fac, x, u);
317        c = a.sum(b);
318        d = a.sum(x, u);
319        assertEquals("a+p(x,u) = a+(x,u)", c, d);
320        //System.out.println("\nc = " + c);
321        //System.out.println("d = " + d);
322
323        c = a.subtract(b);
324        d = a.subtract(x, u);
325        assertEquals("a-p(x,u) = a-(x,u)", c, d);
326        //System.out.println("c = " + c);
327        //System.out.println("d = " + d);
328
329        //a = new GenWordPolynomial<BigInteger>(fac);
330        b = new GenWordPolynomial<BigInteger>(fac, x, u);
331        c = b.sum(a);
332        d = a.sum(x, u);
333        assertEquals("a+p(x,u) = a+(x,u)", c, d);
334        //System.out.println("a = " + a);
335        //System.out.println("b = " + b);
336        //System.out.println("c = " + c);
337        //System.out.println("d = " + d);
338
339        c = a.subtract(b);
340        d = a.subtract(x, u);
341        assertEquals("a-p(x,u) = a-(x,u)", c, d);
342        //System.out.println("c = " + c);
343        //System.out.println("d = " + d);
344    }
345
346
347    /**
348     * Test multiplication.
349     */
350    public void testMultiplication() {
351        // integers
352        BigInteger rf = new BigInteger();
353        // System.out.println("rf = " + rf);
354
355        // non-commuting vars: abcdef
356        WordFactory wf = new WordFactory("abcdef");
357        //System.out.println("wf = " + wf);
358
359        // polynomials over integers
360        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
361        //System.out.println("fac = " + fac);
362
363        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
364        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
365
366        GenWordPolynomial<BigInteger> c = a.multiply(b);
367        GenWordPolynomial<BigInteger> d = b.multiply(a);
368        GenWordPolynomial<BigInteger> e;
369        assertFalse("a*b != b*a", c.equals(d));
370        //System.out.println("a = " + a);
371        //System.out.println("b = " + b);
372        //System.out.println("c = " + c);
373        //System.out.println("d = " + d);
374
375        c = fac.random(kl, ll, el);
376        //System.out.println("c = " + c);
377        d = a.multiply(b.multiply(c));
378        e = (a.multiply(b)).multiply(c);
379
380        //System.out.println("d = " + d);
381        //System.out.println("e = " + e);
382        //System.out.println("d-e = " + d.subtract(c) );
383        assertEquals("a*(b*c) = (a*b)*c", d, e);
384
385        Word u = wf.random(rl);
386        BigInteger x = rf.random(kl);
387
388        b = new GenWordPolynomial<BigInteger>(fac, x, u);
389        c = a.multiply(b);
390        d = a.multiply(x, u);
391        assertEquals("a+p(x,u) = a+(x,u)", c, d);
392        //System.out.println("c = " + c);
393        //System.out.println("d = " + d);
394
395        //a = new GenWordPolynomial<BigInteger>(fac);
396        b = new GenWordPolynomial<BigInteger>(fac, x, u);
397        c = a.multiply(b);
398        d = a.multiply(x, u);
399        assertEquals("a+p(x,u) = a+(x,u)", c, d);
400        //System.out.println("a = " + a);
401        //System.out.println("b = " + b);
402        //System.out.println("c = " + c);
403        //System.out.println("d = " + d);
404    }
405
406
407    /**
408     * Test distributive law.
409     */
410    public void testDistributive() {
411        // integers
412        BigInteger rf = new BigInteger();
413        // System.out.println("rf = " + rf);
414
415        // non-commuting vars: abcdef
416        WordFactory wf = new WordFactory("abcdef");
417        //System.out.println("wf = " + wf);
418
419        // polynomials over integers
420        GenWordPolynomialRing<BigInteger> fac = new GenWordPolynomialRing<BigInteger>(rf, wf);
421        //System.out.println("fac = " + fac);
422
423        GenWordPolynomial<BigInteger> a = fac.random(kl, ll, el);
424        GenWordPolynomial<BigInteger> b = fac.random(kl, ll, el);
425        GenWordPolynomial<BigInteger> c = fac.random(kl, ll, el);
426        GenWordPolynomial<BigInteger> d, e;
427
428        d = a.multiply(b.sum(c));
429        e = a.multiply(b).sum(a.multiply(c));
430
431        assertEquals("a(b+c) = ab+ac", d, e);
432    }
433
434
435    /**
436     * Test univariate division.
437     */
438    public void testUnivDivision() {
439        // rational numbers
440        BigRational rf = new BigRational();
441        //System.out.println("rf = " + rf);
442
443        // non-commuting vars: x
444        WordFactory wf = new WordFactory("x");
445        //System.out.println("wf = " + wf);
446
447        // polynomials over rational numbers
448        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
449        //System.out.println("fac = " + fac);
450
451        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
452        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
453
454        GenWordPolynomial<BigRational> c = a.multiply(b);
455        GenWordPolynomial<BigRational> d = b.multiply(a);
456        GenWordPolynomial<BigRational> e, f;
457        assertTrue("a*b == b*a", c.equals(d)); // since univariate
458        //System.out.println("a = " + a);
459        //System.out.println("b = " + b);
460        //System.out.println("c = " + c);
461        //System.out.println("d = " + d);
462
463        e = c.divide(a);
464        //System.out.println("e = " + e);
465        assertTrue("a*b/a == b", b.equals(e));
466        d = c.divide(b);
467        //System.out.println("d = " + d);
468        assertTrue("a*b/b == a", a.equals(d));
469
470        d = c.gcd(a);
471        //System.out.println("d = " + d);
472        assertTrue("gcd(a*b,a) == a", a.equals(d));
473
474        d = a.gcd(b);
475        //System.out.println("d = " + d);
476        if (d.isConstant()) {
477            assertTrue("gcd(b,a) == 1", d.isONE());
478        } else {
479            return;
480        }
481        d = a.modInverse(b);
482        //System.out.println("d = " + d);
483        e = d.multiply(a);
484        //System.out.println("e = " + e);
485        f = e.remainder(b);
486        //System.out.println("f = " + f);
487        assertTrue("d * a == 1 mod b ", f.isONE());
488    }
489
490
491    /**
492     * Test multivariate 2 division.
493     */
494    public void testMulti2Division() {
495        // rational numbers
496        BigRational rf = new BigRational();
497        // System.out.println("rf = " + rf);
498
499        // non-commuting vars: xy
500        WordFactory wf = new WordFactory("xy");
501        //System.out.println("wf = " + wf);
502
503        // polynomials over rational numbers
504        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
505        //System.out.println("fac = " + fac);
506
507        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
508        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
509
510        GenWordPolynomial<BigRational> c = a.multiply(b);
511        GenWordPolynomial<BigRational> d = b.multiply(a);
512        GenWordPolynomial<BigRational> e, f;
513        assertFalse("a*b == b*a", c.equals(d));
514        //System.out.println("a = " + a);
515        //System.out.println("b = " + b);
516        //System.out.println("c = " + c);
517        //System.out.println("d = " + d);
518
519        e = c.divide(a);
520        //System.out.println("e = " + e);
521        assertTrue("a*b/a == b", b.equals(e));
522        f = d.divide(b);
523        //System.out.println("f = " + f);
524        assertTrue("a*b/b == a", a.equals(f));
525
526        try {
527            f = a.divide(b);
528            //System.out.println("f = " + f);
529        } catch (RuntimeException re) {
530            System.out.println("a divide b fail: " + a + ", " + b);
531            return;
532        }
533        WordFactory.WordComparator cmp = fac.alphabet.getDescendComparator();
534        f = a.remainder(b);
535        //System.out.println("a = " + a);
536        //System.out.println("f = " + f);
537        assertTrue("a rem2 b <= a", cmp.compare(a.leadingWord(), f.leadingWord()) <= 0);
538    }
539
540
541    /**
542     * Test multivariate 3 division.
543     */
544    public void testMulti3Division() {
545        // rational numbers
546        BigRational rf = new BigRational();
547        // System.out.println("rf = " + rf);
548
549        // non-commuting vars: xyz
550        WordFactory wf = new WordFactory("xyz");
551        //System.out.println("wf = " + wf);
552
553        // polynomials over rational numbers
554        GenWordPolynomialRing<BigRational> fac = new GenWordPolynomialRing<BigRational>(rf, wf);
555        //System.out.println("fac = " + fac);
556
557        GenWordPolynomial<BigRational> a = fac.random(7, ll, el).monic();
558        GenWordPolynomial<BigRational> b = fac.random(7, ll, el).monic();
559
560        GenWordPolynomial<BigRational> c = a.multiply(b);
561        GenWordPolynomial<BigRational> d = b.multiply(a);
562        GenWordPolynomial<BigRational> e, f;
563        assertFalse("a*b == b*a", c.equals(d));
564        //System.out.println("a = " + a);
565        //System.out.println("b = " + b);
566        //System.out.println("c = " + c);
567        //System.out.println("d = " + d);
568
569        e = c.divide(a);
570        //System.out.println("e = " + e);
571        assertTrue("a*b/a == b", b.equals(e));
572        f = d.divide(b);
573        //System.out.println("f = " + f);
574        assertTrue("a*b/b == a", a.equals(f));
575
576        try {
577            f = a.divide(b);
578            //System.out.println("f = " + f);
579        } catch (RuntimeException re) {
580            System.out.println("a divide b fail: " + a + ", " + b);
581            return;
582        }
583        WordFactory.WordComparator cmp = fac.alphabet.getDescendComparator();
584        f = a.remainder(b);
585        //System.out.println("a = " + a);
586        //System.out.println("f = " + f);
587        assertTrue("a rem3 b <= a: " + a.leadingWord() + ", " + f.leadingWord(),
588                   cmp.compare(a.leadingWord(), f.leadingWord()) <= 0);
589    }
590
591
592    /**
593     * Test polynomial and solvable coefficients.
594     */
595    public void testCoefficients() {
596        // integers
597        BigComplex rf = new BigComplex();
598        //System.out.println("rf = " + rf);
599
600        // commuting vars: uvw
601        String[] cvar = new String[] { "u", "v", "w" };
602        GenPolynomialRing<BigComplex> cf = new GenPolynomialRing<BigComplex>(rf, cvar);
603        //System.out.println("cf = " + cf);
604
605        // solvable vars: x1 x2 y1 y2
606        String[] svar = new String[] { "x1", "x2", "y1", "y2" };
607        GenSolvablePolynomialRing<GenPolynomial<BigComplex>> sf;
608        sf = new GenSolvablePolynomialRing<GenPolynomial<BigComplex>>(cf, svar);
609        //System.out.println("sf = " + sf);
610        RelationGenerator<GenPolynomial<BigComplex>> wr = new WeylRelations<GenPolynomial<BigComplex>>();
611        wr.generate(sf);
612        //System.out.println("sf = " + sf);
613
614        // non-commuting vars: abcdef
615        WordFactory wf = new WordFactory("abcdef");
616        //System.out.println("wf = " + wf);
617        // non-commuting polynomials over commuting and solvable coefficients
618        GenWordPolynomialRing<GenPolynomial<GenPolynomial<BigComplex>>> nf;
619        nf = new GenWordPolynomialRing<GenPolynomial<GenPolynomial<BigComplex>>>(sf, wf);
620        //want: GenWordPolynomialRing<GenSolvablePolynomial<GenPolynomial<BigComplex>>> nf;
621        //System.out.println("nf = " + nf.toScript());
622
623        assertFalse("not commutative",nf.isCommutative());
624        assertTrue("associative",nf.isAssociative());
625        assertFalse("not field",nf.isField());
626
627        GenWordPolynomial<GenPolynomial<GenPolynomial<BigComplex>>> p = nf.getONE();
628        //System.out.println("p = " + p);
629        assertTrue("p == 1", p.isONE());
630        p = nf.getZERO();
631        //System.out.println("p = " + p);
632        assertTrue("p == 0", p.isZERO());
633        p = nf.random(3);
634        //System.out.println("p = " + p);
635        //p = p.sum(p);
636        p = p.multiply(p);
637        //System.out.println("p = " + p);
638        p = p.subtract(p);
639        //System.out.println("p = " + p);
640        assertTrue("p == 0", p.isZERO());
641
642        List<GenWordPolynomial<GenPolynomial<GenPolynomial<BigComplex>>>> gens = nf.generators();
643        //System.out.println("gens = " + gens);
644        assertTrue("#gens == 2+3+4+6", gens.size() == 15);
645    }
646
647    
648    /**
649     * Test contraction.
650     */
651    public void testContraction() {
652        // integers
653        BigInteger rf = new BigInteger();
654        //System.out.println("rf = " + rf);
655
656        // non-commuting vars: abcdef
657        WordFactory wf = new WordFactory("abcdef");
658        //System.out.println("wf = " + wf);
659        WordFactory wfs = new WordFactory("abc");
660        //System.out.println("wf = " + wf);
661
662        // polynomials over integers
663        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
664        //System.out.println("pf = " + pf);
665        GenWordPolynomialRing<BigInteger> pfs = new GenWordPolynomialRing<BigInteger>(rf, wfs);
666        //System.out.println("pfs = " + pfs);
667
668        List<GenWordPolynomial<BigInteger>> H = new ArrayList<GenWordPolynomial<BigInteger>>();
669
670        GenWordPolynomial<BigInteger> a = pf.random(5).abs();
671        //System.out.println("a = " + a);
672        GenWordPolynomial<BigInteger> as = pfs.random(5).abs();
673        //System.out.println("as = " + as);
674        GenWordPolynomial<BigInteger> asf = pf.valueOf(as);
675        H.add(asf);
676        H.add(asf.multiply(pf.valueOf(pfs.random(5).abs())));
677        H.add(pfs.random(5).abs());
678        //System.out.println("asf = " + asf);
679        GenWordPolynomial<BigInteger> asfc = asf.contract(pfs);
680        //System.out.println("asfc = " + asfc);
681        assertEquals("as == contract(extend(as)): ", as, asfc);
682
683        // mostly not contractable
684        GenWordPolynomial<BigInteger> ac = a.contract(pfs);
685        H.add(a);
686        //System.out.println("ac = " + ac);
687        assertTrue("contract(a) == 0: " + ac, ac.isZERO() || pf.valueOf(ac).equals(a)); 
688
689        // 1 always contractable
690        a = pf.getONE();
691        H.add(a);
692        ac = a.contract(pfs);
693        //System.out.println("ac = " + ac);
694        assertTrue("contract(1) == 1: ", ac.isONE());
695
696        // now contract lists of word polynomials
697        //System.out.println("H = " + H);
698        List<GenWordPolynomial<BigInteger>> M = PolyUtil.<BigInteger> intersect(pfs,H);
699        //System.out.println("M = " + M);
700        int i = 0;
701        for (GenWordPolynomial<BigInteger> h : H) {
702            if (!h.contract(pfs).isZERO()) {
703                assertEquals("extend(contract(h)) == h: " + h, h, pf.valueOf(M.get(i++)) ); 
704            }
705        }
706    }
707
708
709    /**
710     * Test constructors and factory.
711     */
712    @SuppressWarnings("unchecked")
713    public void testParser() {
714        BigInteger rf = new BigInteger();
715        //System.out.println("rf = " + rf.toScriptFactory());
716
717        // non-commuting vars: abcdef
718        String[] sa = new String[]{"a", "b", "c", "d", "e", "f"};
719        WordFactory wf = new WordFactory(sa);
720        //System.out.println("wf = " + wf.toScript());
721
722        // word polynomials over integers
723        GenWordPolynomialRing<BigInteger> pf = new GenWordPolynomialRing<BigInteger>(rf, wf);
724        //System.out.println("pf = " + pf.toScript());
725        assertFalse("not commutative",pf.isCommutative());
726        assertTrue("associative",pf.isAssociative());
727        assertFalse("not field",pf.isField());
728
729        List<GenWordPolynomial<BigInteger>> gens = pf.generators();
730        //System.out.println("pf = " + gens);
731        GenWordPolynomial<BigInteger> ga, gb, crel;
732        ga = gens.get(1);
733        gb = gens.get(2);
734        //System.out.println("ga = " + ga);
735        //System.out.println("gb = " + gb);
736        crel = ga.multiply(gb).subtract(gb.multiply(ga));
737        //System.out.println("crel = " + crel);
738
739        StringReader sr = new StringReader("a b - b a, b c - c b");
740        GenPolynomialTokenizer tok = new GenPolynomialTokenizer(sr);
741
742        GenWordPolynomial<BigInteger> a;
743        // parse of tokenizer
744        try {
745            a = (GenWordPolynomial) tok.nextWordPolynomial(pf);
746        } catch (IOException e) {
747            a = null;
748            e.printStackTrace();
749        }
750        //System.out.println("a = " + a);
751        assertEquals("parse() == ab - ba: ", a, crel);
752
753        // now parse of factory
754        a = pf.parse("a b - b a");
755        //System.out.println("a = " + a);
756        assertEquals("parse() == ab - ba: ", a, crel);
757
758        // polynomials over integers
759        GenPolynomialRing<BigInteger> fac = new GenPolynomialRing<BigInteger>(rf, sa);
760        //System.out.println("fac = " + fac.toScript());
761        assertTrue("commutative",fac.isCommutative());
762        assertTrue("associative",fac.isAssociative());
763        assertFalse("not field",fac.isField());
764
765        sr = new StringReader("a b - b a, b c - c b");
766        tok = new GenPolynomialTokenizer(fac,sr);
767        // parse of tokenizer
768        try {
769            a = (GenWordPolynomial) tok.nextWordPolynomial();
770        } catch (IOException e) {
771            a = null;
772            e.printStackTrace();
773        }
774        //System.out.println("a = " + a);
775        assertEquals("parse() == ab - ba: ", a, crel);
776    }
777
778}