Source code

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