Source code

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