Source code

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