Source code

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