Source code

001/*
002 * $Id: SolvableLocalResidueTest.java 4668 2013-10-19 17:41:05Z 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
017import edu.jas.arith.BigRational;
018import edu.jas.kern.ComputerThreads;
019import edu.jas.kern.PrettyPrint;
020import edu.jas.poly.GenSolvablePolynomial;
021import edu.jas.poly.GenSolvablePolynomialRing;
022import edu.jas.poly.RelationGenerator;
023import edu.jas.poly.TermOrder;
024import edu.jas.poly.WeylRelations;
025
026
027/**
028 * SolvableLocalResidue over BigRational GenSolvablePolynomial tests with JUnit.
029 * @author Heinz Kredel.
030 */
031public class SolvableLocalResidueTest extends TestCase {
032
033
034    /**
035     * main.
036     */
037    public static void main(String[] args) {
038        BasicConfigurator.configure();
039        junit.textui.TestRunner.run(suite());
040    }
041
042
043    /**
044     * Constructs a <CODE>SolvableLocalResidueTest</CODE> object.
045     * @param name String.
046     */
047    public SolvableLocalResidueTest(String name) {
048        super(name);
049    }
050
051
052    /**
053     * suite.
054     */
055    public static Test suite() {
056        TestSuite suite = new TestSuite(SolvableLocalResidueTest.class);
057        return suite;
058    }
059
060
061    SolvableLocalResidueRing<BigRational> efac;
062
063
064    GenSolvablePolynomialRing<BigRational> mfac;
065
066
067    SolvableIdeal<BigRational> id;
068
069
070    SolvableLocalResidue<BigRational> a, b, c, d, e;
071
072
073    SolvableLocalResidue<BigRational> az, bz, cz, dz, ez;
074
075
076    int rl = 4;
077
078
079    int kl = 2;
080
081
082    int ll = 3; //6;
083
084
085    int el = 2;
086
087
088    float q = 0.15f;
089
090
091    int il = (rl == 1 ? 1 : 2);
092
093
094    @Override
095    protected void setUp() {
096        a = b = c = d = e = null;
097        TermOrder to = new TermOrder(TermOrder.INVLEX);
098        String[] vars = new String[] { "w", "x", "y", "z" };
099        mfac = new GenSolvablePolynomialRing<BigRational>(new BigRational(1), rl, to, vars);
100        RelationGenerator<BigRational> wl = new WeylRelations<BigRational>();
101        wl.generate(mfac);
102        if (!mfac.isAssociative()) {
103            System.out.println("ring not associative: " + mfac);
104        }
105        //id = genRandomIdeal();
106        //id = genIdealA();
107        id = genPrimeIdealA();
108        //System.out.println("id = " + id);
109        assert !id.isONE() : "id = " + id;
110        efac = new SolvableLocalResidueRing<BigRational>(id);
111        //System.out.println("efac = " + efac.toScript());
112    }
113
114
115    protected SolvableIdeal<BigRational> genRandomIdeal() {
116        List<GenSolvablePolynomial<BigRational>> F;
117        do {
118            F = new ArrayList<GenSolvablePolynomial<BigRational>>(il);
119            for (int i = 0; i < il; i++) {
120                GenSolvablePolynomial<BigRational> mo = mfac.random(kl, ll, el + 1, q);
121                while (mo.isConstant()) {
122                    mo = mfac.random(kl, ll, el + 1, q);
123                }
124                F.add(mo);
125            }
126            SolvableIdeal<BigRational> id = new SolvableIdeal<BigRational>(mfac, F);
127            id.doGB();
128        } while (id.isONE());
129        return id;
130    }
131
132
133    protected SolvableIdeal<BigRational> genIdealA() {
134        GenSolvablePolynomial<BigRational> p;
135        List<GenSolvablePolynomial<BigRational>> F;
136        F = new ArrayList<GenSolvablePolynomial<BigRational>>(il);
137        p = mfac.parse("y^2 - 42/5");
138        F.add(p);
139        //p = mfac.parse("z^2");
140        p = mfac.parse("x^2");
141        F.add(p);
142        //p = mfac.parse("x^2 - w^2 ");
143        //F.add( p );
144        SolvableIdeal<BigRational> id = new SolvableIdeal<BigRational>(mfac, F);
145        id.doGB();
146        return id;
147    }
148
149
150    protected SolvableIdeal<BigRational> genPrimeIdealA() { // well, almost
151        GenSolvablePolynomial<BigRational> p;
152        List<GenSolvablePolynomial<BigRational>> F;
153        F = new ArrayList<GenSolvablePolynomial<BigRational>>(il);
154        p = mfac.parse("y^2 + 5");
155        F.add(p);
156        p = mfac.parse("x^2 + 3");
157        F.add(p);
158        SolvableIdeal<BigRational> id = new SolvableIdeal<BigRational>(mfac, F);
159        id.doGB();
160        return id;
161    }
162
163
164    @Override
165    protected void tearDown() {
166        a = b = c = d = e = null;
167        //efac.terminate();
168        efac = null;
169        ComputerThreads.terminate();
170    }
171
172
173    /**
174     * Test constructor and toString.
175     */
176    public void testConstruction() {
177        c = efac.getONE();
178        //System.out.println("c = " + c);
179        //System.out.println("c.val = " + c.val);
180        assertTrue("length( c ) = 1", c.num.length() == 1);
181        assertTrue("isZERO( c )", !c.isZERO());
182        assertTrue("isONE( c )", c.isONE());
183
184        d = efac.getZERO();
185        //System.out.println("d = " + d);
186        //System.out.println("d.val = " + d.val);
187        assertTrue("length( d ) = 0", d.num.length() == 0);
188        assertTrue("isZERO( d )", d.isZERO());
189        assertTrue("isONE( d )", !d.isONE());
190
191        for (SolvableLocalResidue<BigRational> g : efac.generators()) {
192            //System.out.println("g = " + g);
193            assertFalse("not isZERO( g )", g.isZERO());
194        }
195        //wrong, solved: 
196        assertTrue("isAssociative: ", efac.isAssociative());
197    }
198
199
200    /**
201     * Test random polynomial.
202     */
203    public void testRandom() {
204        for (int i = 0; i < 4; i++) {
205            //a = efac.random(ll+i);
206            a = efac.random(kl + i, ll + 1, el, q);
207            //System.out.println("a = " + a);
208            if (a.isZERO() || a.isONE()) {
209                continue;
210            }
211            assertTrue("length( a" + i + " ) <> 0", a.num.length() >= 0);
212            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
213            assertTrue(" not isONE( a" + i + " )", !a.isONE());
214            assertEquals("a == a: ", a, a);
215        }
216    }
217
218
219    /**
220     * Test addition.
221     */
222    public void testAddition() {
223        a = efac.random(kl, ll, el, q);
224        b = efac.random(kl, ll, el, q);
225        //a = efac.parse("{ 1  | w * x + 25/28  }");
226        //b = efac.parse("{ x - 35/18  | x + 2 w - 6  }");
227        //!a = efac.parse("{ x - 1/7  | y * z + 7/10  }");
228        //!b = efac.parse("{ 1  | w + 3  }");
229        //a = efac.parse("{ 1  | y * z + 7/10 }");
230        //b = efac.parse("{ x - 1/7 | w + 3  }");
231        //a = efac.parse("{ ( -21/10 ) z - 5/4 x | x * z - 1/2 x + 1/2 }");
232        //b = efac.parse("{ 1 | z^2 - 63/5 }");
233        //a = efac.parse("{ 1  | z - 92/105 }");
234        //b = efac.parse("{ 1  | x }"); // when not prime
235        //a = efac.parse("{ x - 3 | z + 5 }");
236        //b = efac.parse("{ w + 2 | z - x * y }");
237        //b = new SolvableLocalResidue<BigRational>(efac,efac.ideal.getList().get(0));
238        //b = a.negate();
239        //System.out.println("a = " + a);
240        //System.out.println("b = " + b);
241
242        c = a.sum(efac.getZERO());
243        d = a.subtract(efac.getZERO());
244        assertEquals("a+0 = a-0", c, d);
245
246        c = efac.getZERO().sum(a);
247        d = efac.getZERO().subtract(a.negate());
248        assertEquals("0+a = 0-(-a)", c, d);
249
250        c = a.sum(b);
251        d = b.sum(a);
252        //System.out.println("c = " + c);
253        //System.out.println("d = " + d);
254        assertEquals("a+b = b+a", c, d);
255
256        c = a.sum(b);
257        //System.out.println("c = " + c);
258        d = c.subtract(b);
259        //System.out.println("d = " + d);
260        //System.out.println("a = " + a);
261        assertEquals("(a+b)-b = a: b = " + b, a, d);
262
263        c = efac.random(kl, ll, el, q);
264        //c = new SolvableLocalResidue<BigRational>(efac, mfac.univariate(1, 2));
265        //c = efac.parse("{ 42/5 }");
266        //System.out.println("c = " + c);
267        d = c.sum(a.sum(b));
268        e = c.sum(a).sum(b);
269        //System.out.println("d = " + d);
270        //System.out.println("e = " + e);
271        //System.out.println("d-e = " + d.subtract(e));
272        assertEquals("c+(a+b) = (c+a)+b: a = " + a + ", b = " + b + ", c = " + c, d, e);
273    }
274
275
276    /**
277     * Test multiplication.
278     */
279    public void testMultiplication() {
280        a = efac.random(kl, ll, el, q);
281        b = efac.random(kl, ll, el, q);
282        //System.out.println("a = " + a);
283        //System.out.println("b = " + b);
284
285        c = a.multiply(efac.getONE());
286        d = efac.getONE().multiply(a);
287        //System.out.println("c = " + c);
288        //System.out.println("d = " + d);
289        assertEquals("a*1 = 1*a", c, a);
290        assertEquals("a*1 = 1*a", c, d);
291
292        c = b.multiply(a);
293        d = a.multiply(b);
294        //System.out.println("c = " + c);
295        //System.out.println("d = " + d);
296        //non-com TODO 
297        //assertTrue("a*b != b*a", c.equals(d) || c.leadingExpVector().equals(d.leadingExpVector()) );
298
299        //c = efac.random(kl,ll,el,q);
300        c = new SolvableLocalResidue<BigRational>(efac, mfac.univariate(1, 2));
301        //System.out.println("c = " + c);
302        d = a.multiply(b.multiply(c));
303        //System.out.println("d = " + d);
304        e = (a.multiply(b)).multiply(c);
305        //System.out.println("e = " + e);
306        assertEquals("a(bc) = (ab)c", d, e);
307    }
308
309
310    /**
311     * Test inverse.
312     */
313    public void testInverse() {
314        a = efac.random(kl, ll + 1, el + 1, q * 1.15f);
315        //System.out.println("a = " + a);
316        b = new SolvableLocalResidue<BigRational>(efac, mfac.getONE(), mfac.univariate(1, 2));
317        //System.out.println("b = " + b);
318        a = a.multiply(b);
319        //System.out.println("a = " + a);
320
321        if (a.isUnit()) { // true if != 0
322            c = a.inverse();
323            //System.out.println("c = " + c);
324            d = c.multiply(a);
325            //d = a.multiply(c);
326            //System.out.println("d = " + d);
327            assertTrue("1/a * a = 1", d.isONE());
328            d = c.inverse();
329            //System.out.println("d = " + d);
330            //System.out.println("a = " + a);
331            //System.out.println("c = " + c);
332            //System.out.println("a-d = " + a.subtract(d));
333            assertEquals("1/(1/a) = a", a, d);
334        }
335    }
336
337
338    /**
339     * Test roots (eval mod ideal). todo
340     */
341    public void testRoot() {
342        c = efac.parse("y");
343        //System.out.println("c = " + c);
344        d = efac.parse("5");
345        //System.out.println("d = " + d);
346        e = c.multiply(c).sum(d);
347        //System.out.println("e = " + e);
348        assertTrue("e == 0 mod ideal", e.isZERO());
349        for (GenSolvablePolynomial<BigRational> p : efac.ideal.getList()) {
350            String s = p.toString();
351            //System.out.println("s = " + s);
352            e = efac.parse(s); // eval mod ideal
353            //System.out.println("e = " + e);
354            assertTrue("e == 0 mod ideal", e.isZERO());
355        }
356    }
357
358
359    /**
360     * Test parse.
361     */
362    public void testParse() {
363        a = efac.random(kl, ll, el, q);
364        //PrettyPrint.setInternal();
365        //System.out.println("a = " + a);
366        PrettyPrint.setPretty();
367        //System.out.println("a = " + a);
368        String p = a.toString();
369        //System.out.println("p = " + p);
370        b = efac.parse(p);
371        //System.out.println("b = " + b);
372        assertEquals("parse(a.toSting()) = a", a, b);
373    }
374
375}