Source code

001/*
002 * $Id: WordResidueTest.java 5303 2015-08-16 17:11:07Z kredel $
003 */
004
005package edu.jas.application;
006
007
008import java.util.ArrayList;
009import java.util.List;
010
011import junit.framework.Test;
012import junit.framework.TestCase;
013import junit.framework.TestSuite;
014
015import org.apache.log4j.BasicConfigurator;
016// import org.apache.log4j.Logger;
017
018import edu.jas.arith.BigRational;
019import edu.jas.poly.GenWordPolynomial;
020import edu.jas.poly.GenWordPolynomialRing;
021import edu.jas.structure.NotDivisibleException;
022import edu.jas.structure.NotInvertibleException;
023
024
025/**
026 * WordResidue tests with JUnit.
027 * @author Heinz Kredel.
028 */
029
030public class WordResidueTest extends TestCase {
031
032
033    /**
034     * main.
035     */
036    public static void main(String[] args) {
037        BasicConfigurator.configure();
038        junit.textui.TestRunner.run(suite());
039    }
040
041
042    /**
043     * Constructs a <CODE>WordResidueTest</CODE> object.
044     * @param name String.
045     */
046    public WordResidueTest(String name) {
047        super(name);
048    }
049
050
051    /**
052     * suite.
053     */
054    public static Test suite() {
055        TestSuite suite = new TestSuite(WordResidueTest.class);
056        return suite;
057    }
058
059
060    WordIdeal<BigRational> id;
061
062
063    WordResidueRing<BigRational> fac;
064
065
066    GenWordPolynomialRing<BigRational> mfac;
067
068
069    List<GenWordPolynomial<BigRational>> F;
070
071
072    WordResidue<BigRational> a, b, c, d, e, f;
073
074
075    int rl = 4;
076
077
078    int kl = 3;
079
080
081    int ll = 4;
082
083
084    int el = 2;
085
086
087    int il = (rl == 1 ? 1 : 2);
088
089
090    @Override
091    protected void setUp() {
092        a = b = c = d = e = null;
093        String[] vars = new String[] { "w", "x", "y", "z" };
094        mfac = new GenWordPolynomialRing<BigRational>(new BigRational(1), vars);
095        //System.out.println("mfac = " + mfac.toScript());
096        //GenWordPolynomial<BigRational> p1 = mfac.parse("w - x^2");
097        //GenWordPolynomial<BigRational> p1 = mfac.parse("x + 49/12");
098        //GenWordPolynomial<BigRational> p2 = mfac.parse("y - 5 * w - 65/28");
099        do {
100            F = new ArrayList<GenWordPolynomial<BigRational>>(il);
101            for (int i = 0; i < il; i++) {
102                GenWordPolynomial<BigRational> mo = mfac.random(kl, ll, el);
103                while (mo.isConstant()) {
104                    mo = mfac.random(kl, ll, el);
105                }
106                F.add(mo);
107            }
108            //F.add(p1); F.add(p2);
109            id = new WordIdeal<BigRational>(mfac, F);
110            id.doGB();
111        } while (id.isONE());
112        //System.out.println("id = " + id);
113        assert !id.isONE() : "id = " + id;
114        fac = new WordResidueRing<BigRational>(id);
115        //System.out.println("fac = " + fac.toScript());
116        F = null;
117    }
118
119
120    @Override
121    protected void tearDown() {
122        a = b = c = d = e = null;
123        fac = null;
124        id = null;
125        mfac = null;
126    }
127
128
129    /**
130     * Test constructor and toString.
131     */
132    public void testConstruction() {
133        c = fac.getONE();
134        //System.out.println("c = " + c);
135        //System.out.println("c.val = " + c.val);
136        assertTrue("length( c ) = 1 ", c.val.length() == 1 || id.isONE());
137        assertTrue("isZERO( c )", !c.isZERO() || id.isONE());
138        assertTrue("isONE( c )", c.isONE() || id.isONE());
139
140        d = fac.getZERO();
141        //System.out.println("d = " + d);
142        //System.out.println("d.val = " + d.val);
143        assertTrue("length( d ) = 0", d.val.length() == 0);
144        assertTrue("isZERO( d )", d.isZERO());
145        assertTrue("isONE( d )", !d.isONE());
146
147        for (WordResidue<BigRational> g : fac.generators()) {
148            //System.out.println("g = " + g);
149            assertFalse("not isZERO( g )", g.isZERO());
150        }
151    }
152
153
154    /**
155     * Test random polynomial.
156     */
157    public void testRandom() {
158        for (int i = 1; i < 7; i++) {
159            //a = fac.random(ll+i);
160            a = fac.random(kl * i / 2, ll + i, el + i / 2);
161            //System.out.println("a = " + a);
162            if (a.isZERO() || a.isONE()) {
163                continue;
164            }
165            assertTrue("length( a" + i + " ) <> 0", a.val.length() >= 0);
166            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
167            assertTrue(" not isONE( a" + i + " )", !a.isONE());
168        }
169    }
170
171
172    /**
173     * Test addition.
174     */
175    public void testAddition() {
176        a = fac.random(kl, ll, el + 1);
177        b = fac.random(kl, ll, el + 1);
178        //System.out.println("a = " + a);
179        //System.out.println("b = " + b);
180
181        c = a.sum(b);
182        d = c.subtract(b);
183        assertEquals("a+b-b = a", a, d);
184
185        c = a.sum(b);
186        d = b.sum(a);
187        assertEquals("a+b = b+a", c, d);
188
189        c = fac.random(kl, ll, el);
190        //System.out.println("c = " + c);
191        d = c.sum(a.sum(b));
192        e = c.sum(a).sum(b);
193        assertEquals("c+(a+b) = (c+a)+b", d, e);
194
195        c = a.sum(fac.getZERO());
196        d = a.subtract(fac.getZERO());
197        assertEquals("a+0 = a-0", c, d);
198
199        c = fac.getZERO().sum(a);
200        d = fac.getZERO().subtract(a.negate());
201        assertEquals("0+a = 0+(-a)", c, d);
202    }
203
204
205    /**
206     * Test multiplication.
207     */
208    public void testMultiplication() {
209        List<WordResidue<BigRational>> g = fac.generators();
210        //System.out.println("g = " + g);
211        //a = fac.random(kl,ll,el,q);
212        a = g.get(1);
213        if (a.isZERO()) {
214            a = fac.getONE(); //return;
215        }
216        assertTrue("not isZERO( a )", !a.isZERO());
217
218        b = fac.random(kl, ll, el);
219        //b = g.get(g.size()-1);
220        if (b.isZERO()) {
221            b = fac.getONE(); //return;
222        }
223        assertTrue("not isZERO( b )", !b.isZERO());
224        //System.out.println("a = " + a);
225        //System.out.println("b = " + b);
226
227        c = a.multiply(fac.getONE());
228        d = fac.getONE().multiply(a);
229        assertEquals("a*1 = 1*a", c, d);
230        assertEquals("a*1 = 1*a", c, a);
231
232        c = b.multiply(a);
233        d = a.multiply(b);
234        assertTrue("not isZERO( c )", !c.isZERO());
235        assertTrue("not isZERO( d )", !d.isZERO());
236
237        //System.out.println("a = " + a);
238        //System.out.println("b = " + b);
239        //System.out.println("c = " + c);
240        //System.out.println("d = " + d);
241        //e = d.subtract(c);
242        //non-com: assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO() );
243        //non-com: assertEquals("a*b = b*a",c,d);
244
245        c = fac.random(kl, ll + 1, el);
246        //System.out.println("c = " + c);
247        d = a.multiply(b.multiply(c));
248        e = a.multiply(b).multiply(c);
249        //System.out.println("d = " + d);
250        //System.out.println("e = " + e);
251        //System.out.println("d-e = " + d.subtract(e) );
252        assertEquals("a(bc) = (ab)c", d, e);
253        //assertTrue("a(bc) = (ab)c", d.equals(e) );
254
255        if (a.isUnit()) { // !a.isZERO() isUnit()
256            try {
257                c = a.inverse();
258                //System.out.println("a = " + a);
259                //System.out.println("c = " + c);
260                d = c.multiply(a);
261                //System.out.println("d = " + d);
262                assertTrue("a*1/a = 1: " + fac, d.isONE()); // || true 
263            } catch (NotInvertibleException e) {
264                // can happen
265            } catch (UnsupportedOperationException e) {
266            }
267        }
268    }
269
270
271    /**
272     * Test division.
273     */
274    public void testDivision() {
275        List<WordResidue<BigRational>> g = fac.generators();
276        //System.out.println("g = " + g);
277        //a = fac.random(kl,ll,el,q);
278        a = g.get(1);
279        if (a.isZERO()) {
280            a = fac.getONE();
281        }
282        assertTrue("not isZERO( a )", !a.isZERO());
283
284        b = fac.random(kl, ll, el + 2).monic();
285        if (b.isZERO() || b.isONE()) {
286            b = g.get(g.size() - 1);
287            //b = fac.getONE();
288        }
289        assertTrue("not isZERO( b )", !b.isZERO());
290        //a = fac.parse("w");
291        //b = fac.parse("w w + 79/360 z + 13/28 w");
292
293        //System.out.println("a = " + a);
294        //System.out.println("b = " + b);
295
296        // left division
297        c = a.multiply(b);
298        //System.out.println("c = " + c);
299        try {
300            d = c.divide(b);
301            //System.out.println("d = " + d);
302            e = c.remainder(b);
303            //System.out.println("e = " + e);
304
305            f = d.multiply(b).sum(e);
306            //System.out.println("f = " + f);
307            assertEquals("c == f: ", c, f);
308        } catch (NotDivisibleException ex) {
309            // pass
310            System.out.println("ex = " + ex);
311        }
312
313        // right division
314        c = b.multiply(a);
315        //System.out.println("c = " + c);
316        try {
317            d = c.rightDivide(b);
318            //System.out.println("d = " + d);
319            e = c.rightRemainder(b);
320            //System.out.println("e = " + e);
321
322            f = b.multiply(d).sum(e);
323            //System.out.println("f = " + f);
324            assertEquals("c == f: ", c, f);
325        } catch (NotDivisibleException ex) {
326            // pass
327            System.out.println("ex = " + ex);
328        }
329
330        // two-sided division
331        c = a.multiply(b.multiply(a));
332        //System.out.println("c = " + c);
333        try {
334            WordResidue<BigRational>[] dd = c.twosidedDivide(b);
335            //System.out.println("dd = " + dd[0] + " // " + dd[1]);
336            e = c.twosidedRemainder(b);
337            //System.out.println("e = " + e);
338
339            f = dd[0].multiply(b).multiply(dd[1]).sum(e);
340            //System.out.println("f = " + f);
341            //System.out.println("c-f = " + c.subtract(f));
342            assertEquals("c == f: ", c, f);
343        } catch (NotDivisibleException ex) {
344            // pass
345            System.out.println("ex = " + ex);
346        }
347    }
348}