Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.poly;
006
007import java.util.List;
008import java.util.Set;
009import java.util.HashSet;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015
016import edu.jas.arith.BigRational;
017
018
019/**
020 * BigRational coefficients GenSolvablePolynomial tests with JUnit.
021 * @author Heinz Kredel
022 */
023
024public class RatGenSolvablePolynomialTest extends TestCase {
025
026
027    /**
028     * main.
029     */
030    public static void main(String[] args) {
031        junit.textui.TestRunner.run(suite());
032    }
033
034
035    /**
036     * Constructs a <CODE>RatGenSolvablePolynomialTest</CODE> object.
037     * @param name String.
038     */
039    public RatGenSolvablePolynomialTest(String name) {
040        super(name);
041    }
042
043
044    /**
045     */
046    public static Test suite() {
047        TestSuite suite = new TestSuite(RatGenSolvablePolynomialTest.class);
048        return suite;
049    }
050
051
052    GenSolvablePolynomial<BigRational> a, b, c, d, e, f, x1, x2;
053
054
055    int rl = 6;
056
057
058    int kl = 10;
059
060
061    int ll = 5;
062
063
064    int el = 3;
065
066
067    float q = 0.5f;
068
069
070    RelationTable<BigRational> table;
071
072
073    GenSolvablePolynomialRing<BigRational> ring, fac;
074
075
076    BigRational cfac;
077
078
079    @Override
080    protected void setUp() {
081        cfac = new BigRational(1);
082        ring = new GenSolvablePolynomialRing<BigRational>(cfac, rl);
083        fac = ring;
084        table = ring.table;
085        a = b = c = d = e = null;
086    }
087
088
089    @Override
090    protected void tearDown() {
091        table = null;
092        ring = null;
093        a = b = c = d = e = null;
094    }
095
096
097    /**
098     * Test generate.
099     */
100    public void testGenerate() {
101        String s = fac.toScript();
102        //System.out.println("fac.toScript: " + s + ", " + s.length());
103        assertTrue("#s == 51: " + s, s.length() == 51);
104
105        List<GenPolynomial<BigRational>> gens = fac.generators();
106        assertFalse("#gens != () ", gens.isEmpty());
107        //System.out.println("generators: " + gens);
108
109        // test equals
110        Set<GenPolynomial<BigRational>> set = new HashSet<GenPolynomial<BigRational>>(gens);
111        //System.out.println("gen set: " + set);
112        assertEquals("#gens == #set: ", gens.size(), set.size());
113
114        // test for elements 0, 1
115        a = fac.getZERO();
116        b = fac.getONE();
117        assertFalse("0 not in #set: ", set.contains(a));
118        assertTrue("1 in #set: ", set.contains(b));
119
120        // specific tests
121        assertEquals("#gens == rl+1 ", rl + 1, gens.size());
122        Set<Integer> iset = new HashSet<Integer>(set.size());
123        for (GenPolynomial<BigRational> p : gens) {
124            //System.out.println("p = " + p.toScript() + ", # = " + p.hashCode() + ", red = " + p.reductum());
125            assertTrue("red(p) == 0 ", p.reductum().isZERO());
126            iset.add(p.hashCode());
127        }
128        assertEquals("#gens == #iset: ", gens.size(), iset.size());
129    }
130
131
132    /**
133     * Test constructor and toString.
134     */
135    public void testConstructor() {
136        a = new GenSolvablePolynomial<BigRational>(ring);
137        assertTrue("length( a ) = 0", a.length() == 0);
138        assertTrue("isZERO( a )", a.isZERO());
139        assertTrue("isONE( a )", !a.isONE());
140
141        c = ring.getONE();
142        assertTrue("length( c ) = 1", c.length() == 1);
143        assertTrue("isZERO( c )", !c.isZERO());
144        assertTrue("isONE( c )", c.isONE());
145
146        d = ring.getZERO();
147        assertTrue("length( d ) = 0", d.length() == 0);
148        assertTrue("isZERO( d )", d.isZERO());
149        assertTrue("isONE( d )", !d.isONE());
150    }
151
152
153    /**
154     * Test random polynomial.
155     */
156    public void testRandom() {
157        assertTrue("isCommutative()", ring.isCommutative());
158
159        for (int i = 0; i < 2; i++) {
160            // a = ring.random(ll+2*i);
161            a = ring.random(kl * (i + 1), ll + 2 * i, el + i, q);
162            assertTrue("length( a" + i + " ) <> 0", a.length() >= 0);
163            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
164            assertTrue(" not isONE( a" + i + " )", !a.isONE());
165        }
166    }
167
168
169    /**
170     * Test addition.
171     */
172    public void testAddition() {
173        a = ring.random(kl, ll, el, q);
174
175        c = (GenSolvablePolynomial<BigRational>) a.subtract(a);
176        assertTrue("a-a = 0", c.isZERO());
177
178        b = (GenSolvablePolynomial<BigRational>) a.sum(a);
179        c = (GenSolvablePolynomial<BigRational>) b.subtract(a);
180
181        assertEquals("a+a-a = a", c, a);
182        assertTrue("a+a-a = a", c.equals(a));
183
184        b = ring.random(kl, ll, el, q);
185        c = (GenSolvablePolynomial<BigRational>) b.sum(a);
186        d = (GenSolvablePolynomial<BigRational>) a.sum(b);
187
188        assertEquals("a+b = b+a", c, d);
189        assertTrue("a+b = b+a", c.equals(d));
190
191        c = ring.random(kl, ll, el, q);
192        d = (GenSolvablePolynomial<BigRational>) a.sum(b.sum(c));
193        e = (GenSolvablePolynomial<BigRational>) a.sum(b).sum(c);
194
195        assertEquals("a+(b+c) = (a+b)+c", d, e);
196        assertTrue("a+(b+c) = (a+b)+c", d.equals(e));
197
198        ExpVector u = ExpVector.random(rl, el, q);
199        BigRational x = cfac.random(kl);
200
201        b = ring.getONE().multiply(x, u);
202        c = (GenSolvablePolynomial<BigRational>) a.sum(b);
203        d = (GenSolvablePolynomial<BigRational>) a.sum(x, u);
204        assertEquals("a+p(x,u) = a+(x,u)", c, d);
205
206        c = (GenSolvablePolynomial<BigRational>) a.subtract(b);
207        d = (GenSolvablePolynomial<BigRational>) a.subtract(x, u);
208        assertEquals("a-p(x,u) = a-(x,u)", c, d);
209
210        a = ring.getZERO();
211        b = ring.getONE().multiply(x, u);
212        c = (GenSolvablePolynomial<BigRational>) b.sum(a);
213        d = (GenSolvablePolynomial<BigRational>) a.sum(x, u);
214        assertEquals("a+p(x,u) = a+(x,u)", c, d);
215
216        c = (GenSolvablePolynomial<BigRational>) a.subtract(b);
217        d = (GenSolvablePolynomial<BigRational>) a.subtract(x, u);
218        assertEquals("a-p(x,u) = a-(x,u)", c, d);
219    }
220
221
222    /**
223     * Test object multiplication.
224     */
225    @SuppressWarnings("cast")
226    public void testMultiplication() {
227        a = ring.random(kl, ll, el, q);
228        assertTrue("not isZERO( a )", !a.isZERO());
229        //a = RatGenSolvablePolynomial.DIRRAS(1, kl, 4, el, q );
230
231        b = ring.random(kl, ll, el, q);
232        assertTrue("not isZERO( b )", !b.isZERO());
233
234        c = b.multiply(a);
235        d = a.multiply(b);
236        assertTrue("not isZERO( c )", !c.isZERO());
237        assertTrue("not isZERO( d )", !d.isZERO());
238
239        e = (GenSolvablePolynomial<BigRational>) d.subtract(c);
240        assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO());
241
242        assertEquals("a*b = b*a", c, d);
243        assertTrue("a*b = b*a", c.equals(d));
244
245        c = ring.random(kl, ll, el, q);
246        d = a.multiply(b.multiply(c));
247        e = (a.multiply(b)).multiply(c);
248
249        assertEquals("a(bc) = (ab)c", d, e);
250        assertTrue("a(bc) = (ab)c", d.equals(e));
251
252        BigRational x = a.leadingBaseCoefficient().inverse();
253        c = (GenSolvablePolynomial<BigRational>) a.monic();
254        d = a.multiply(x);
255        assertEquals("a.monic() = a(1/ldcf(a))", c, d);
256
257        ExpVector u = ring.evzero;
258        BigRational y = b.leadingBaseCoefficient().inverse();
259        c = (GenSolvablePolynomial<BigRational>) b.monic();
260        d = b.multiply(y, u);
261        assertEquals("b.monic() = b(1/ldcf(b))", c, d);
262
263        e = ring.getONE().multiply(y, u);
264        d = b.multiply(e);
265        assertEquals("b.monic() = b(1/ldcf(b))", c, d);
266
267        d = e.multiply(b);
268        assertEquals("b.monic() = (1/ldcf(b) (0))*b", c, d);
269
270        d = a.monic();
271        assertTrue("a.monic(): ", d.leadingBaseCoefficient().isONE());
272    }
273
274
275    /**
276     * Test Weyl polynomials.
277     */
278    public void testWeyl() {
279        int rloc = 4;
280        ring = new GenSolvablePolynomialRing<BigRational>(cfac, rloc);
281
282        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
283        wl.generate(ring);
284        table = ring.table;
285        //System.out.println("table = " + table);
286        //System.out.println("ring = " + ring);
287
288        assertFalse("isCommutative()", ring.isCommutative());
289        assertTrue("isAssociative()", ring.isAssociative());
290
291        a = ring.random(kl, ll, el, q);
292        assertTrue("not isZERO( a )", !a.isZERO());
293        //System.out.println("a = " + a);
294
295        b = ring.random(kl, ll, el, q);
296        assertTrue("not isZERO( b )", !b.isZERO());
297        //System.out.println("b = " + b);
298
299
300        // non commutative
301        c = b.multiply(a);
302        d = a.multiply(b);
303        //System.out.println("c = " + c);
304        //System.out.println("d = " + d);
305        assertTrue("not isZERO( c )", !c.isZERO());
306        assertTrue("not isZERO( d )", !d.isZERO());
307
308        e = (GenSolvablePolynomial<BigRational>) d.subtract(c);
309        assertTrue("!isZERO( a*b-b*a ) " + e, !e.isZERO());
310        assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
311
312        c = ring.random(kl, ll, el, q);
313        //System.out.println("\na = " + a);
314        //System.out.println("\nb = " + b);
315        //System.out.println("\nc = " + c);
316
317        // associative
318        //x1 = b.multiply(c);
319        //System.out.println("\nx1 = " + x1);
320        d = a.multiply(b.multiply(c));
321
322        //x2 = a.multiply(b);
323        //System.out.println("\nx2 = " + x2);
324        e = a.multiply(b).multiply(c);
325
326        //System.out.println("\nd = " + d);
327        //System.out.println("\ne = " + e);
328
329        //f = (GenSolvablePolynomial<BigRational>)d.subtract(e);
330        //System.out.println("\nf = " + f);
331
332        assertEquals("a(bc) = (ab)c", d, e);
333        assertTrue("a(bc) = (ab)c", d.equals(e));
334    }
335
336
337    /**
338     * Test division of polynomials.
339     */
340    public void testDivide() {
341        int rloc = 4;
342        ring = new GenSolvablePolynomialRing<BigRational>(cfac, rloc);
343
344        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
345        wl.generate(ring);
346        //System.out.println("ring = " + ring.toScript());
347
348        assertFalse("isCommutative()", ring.isCommutative());
349        assertTrue("isAssociative()", ring.isAssociative());
350
351        do {
352            a = ring.random(kl, ll, el, q);
353        } while(a.isZERO());
354        //System.out.println("a = " + a);
355
356        do {
357            b = ring.random(kl, ll, el, q);
358        } while(b.isZERO());
359        //System.out.println("b = " + b);
360
361        // non commutative
362        c = b.multiply(a);
363        d = a.multiply(b);
364        //System.out.println("c = " + c);
365        //System.out.println("d = " + d);
366        assertTrue("not isZERO( c )", !c.isZERO());
367        assertTrue("not isZERO( d )", !d.isZERO());
368
369        e = (GenSolvablePolynomial<BigRational>) d.subtract(c);
370        assertTrue("a*b != b*a", !c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()));
371
372        // divide 
373        e = c.divide(a);
374        //System.out.println("e = " + e);
375        f = c.rightDivide(b);
376        //System.out.println("f = " + f);
377        assertEquals("b == b*a/a: " + e, e, b);
378        assertEquals("a == b*a/b: " + e, f, a);
379
380        e = d.rightDivide(a);
381        //System.out.println("e = " + e);
382        f = d.divide(b);
383        //System.out.println("f = " + f);
384        assertEquals("b == a*b/a: " + e, e, b);
385        assertEquals("a == a*b/b: " + e, f, a);
386    }
387
388
389    /**
390     * Test BLAS level 1.
391     */
392    public void testBLAS1() {
393        int rloc = 4;
394        ring = new GenSolvablePolynomialRing<BigRational>(cfac, rloc);
395        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
396        wl.generate(ring);
397        table = ring.table;
398        //System.out.println("table = " + table);
399        //System.out.println("ring = " + ring);
400
401        a = ring.random(kl,ll,el,q);
402        b = ring.random(kl,ll,el,q);
403        ExpVector ev = ExpVector.random(rloc,el,q);
404        BigRational lc = BigRational.ONE.random(kl);
405
406        d = a.subtractMultiple(lc,b);
407        e = (GenSolvablePolynomial<BigRational>) a.subtract( b.multiplyLeft(lc) );
408        assertEquals("a - (lc) b == a - ((lc) b)",d,e);
409
410        d = a.subtractMultiple(lc,ev,b);
411        e = (GenSolvablePolynomial<BigRational>) a.subtract( b.multiplyLeft(lc,ev) );
412        assertEquals("a - (lc ev) b == a - ((lc ev) b)",d,e);
413
414        ExpVector fv = ExpVector.random(rloc,el,q);
415        BigRational tc = BigRational.ONE.random(kl);
416
417        d = a.scaleSubtractMultiple(tc,lc,ev,b);
418        e = (GenSolvablePolynomial<BigRational>) a.multiplyLeft(tc).subtract( b.multiplyLeft(lc,ev) );
419        assertEquals("(tc) a - (lc ev) b == ((tc) a - ((lc ev) b))",d,e);
420
421        d = a.scaleSubtractMultiple(tc,fv,lc,ev,b);
422        e = (GenSolvablePolynomial<BigRational>) a.multiplyLeft(tc,fv).subtract( b.multiplyLeft(lc,ev) );
423        assertEquals("(tc fv) a - (lc ev) b == ((tc fv) a - ((lc ev) b))",d,e);
424
425        d = a.scaleSubtractMultiple(tc,lc,b);
426        e = (GenSolvablePolynomial<BigRational>) a.multiplyLeft(tc).subtract( b.multiplyLeft(lc) );
427        assertEquals("tc a - lc b == (tc a) - (lc b)",d,e);
428    }
429
430
431    /**
432     * Test distributive law.
433     */
434    public void testDistributive() {
435        int rloc = 4;
436        ring = new GenSolvablePolynomialRing<BigRational>(cfac, rloc);
437
438        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
439        wl.generate(ring);
440        //table = ring.table;
441        //System.out.println("table = " + table);
442        //System.out.println("ring = " + ring);
443
444        a = ring.random(kl, ll, el, q);
445        b = ring.random(kl, ll, el, q);
446        c = ring.random(kl, ll, el, q);
447
448        d = a.multiply((GenSolvablePolynomial<BigRational>) b.sum(c));
449        e = (GenSolvablePolynomial<BigRational>) a.multiply(b).sum(a.multiply(c));
450
451        assertEquals("a(b+c) = ab+ac", d, e);
452    }
453
454}