Source code

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