Source code

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