Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.poly;
006
007import java.util.Map;
008import java.util.SortedMap;
009
010import junit.framework.Test;
011import junit.framework.TestCase;
012import junit.framework.TestSuite;
013
014import edu.jas.arith.BigRational;
015import edu.jas.arith.BigDecimal;
016import edu.jas.arith.Roots;
017
018
019/**
020 * BigDecimal coefficients GenPolynomial tests with JUnit.
021 * @author Heinz Kredel
022 */
023
024public class DecGenPolynomialTest extends TestCase {
025
026    /**
027     * main.
028     */
029    public static void main (String[] args) {
030        junit.textui.TestRunner.run( suite() );
031    }
032
033    /**
034     * Constructs a <CODE>RatGenPolynomialTest</CODE> object.
035     * @param name String.
036     */
037    public DecGenPolynomialTest(String name) {
038        super(name);
039    }
040
041    /**
042     */ 
043    public static Test suite() {
044        TestSuite suite= new TestSuite(DecGenPolynomialTest.class);
045        return suite;
046    }
047
048    GenPolynomialRing<BigDecimal> fac;
049
050    GenPolynomial<BigDecimal> a, b, c, d, e;
051
052    int rl = 7; 
053    int kl = 10;
054    int ll = 10;
055    int el = 5;
056    float q = 0.5f;
057
058    protected void setUp() {
059        a = b = c = d = e = null;
060        fac = new GenPolynomialRing<BigDecimal>(new BigDecimal(1),rl);
061    }
062
063    protected void tearDown() {
064        a = b = c = d = e = null;
065        fac = null;
066    }
067
068    
069    /**
070     * Test constructor and toString.
071     */
072    public void testConstruction() {
073        c = fac.getONE();
074        assertTrue("length( c ) = 1", c.length() == 1);
075        assertTrue("isZERO( c )", !c.isZERO() );
076        assertTrue("isONE( c )", c.isONE() );
077
078        d = fac.getZERO();
079        assertTrue("length( d ) = 0", d.length() == 0);
080        assertTrue("isZERO( d )", d.isZERO() );
081        assertTrue("isONE( d )", !d.isONE() );
082    }
083
084
085    /**
086     * Test random polynomial.
087     */
088    public void testRandom() {
089        for (int i = 0; i < 7; i++) {
090            //a = fac.random(ll);
091            a = fac.random(kl*(i+1), ll+2*i, el+i, q );
092            //System.out.println("a = " + a);
093
094            assertTrue("length( a"+i+" ) <> 0", a.length() >= 0);
095            assertTrue(" not isZERO( a"+i+" )", !a.isZERO() );
096            assertTrue(" not isONE( a"+i+" )", !a.isONE() );
097        }
098    }
099
100
101    /**
102     * Test addition.
103     */
104    public void testAddition() {
105        a = fac.random(ll);
106        b = fac.random(ll);
107
108        c = a.sum(b);
109        d = c.subtract(b);
110        assertEquals("a+b-b = a",a,d);
111
112        c = fac.random(ll);
113
114        ExpVector u = ExpVector.random(rl,el,q);
115        BigDecimal x = fac.coFac.random(kl);
116
117        b = new GenPolynomial<BigDecimal>(fac,x, u);
118        c = a.sum(b);
119        d = a.sum(x,u);
120        assertEquals("a+p(x,u) = a+(x,u)",c,d);
121
122        c = a.subtract(b);
123        d = a.subtract(x,u);
124        assertEquals("a-p(x,u) = a-(x,u)",c,d);
125
126        a = new GenPolynomial<BigDecimal>(fac);
127        b = new GenPolynomial<BigDecimal>(fac,x, u);
128        c = b.sum(a);
129        d = a.sum(x,u);
130        assertEquals("a+p(x,u) = a+(x,u)",c,d);
131
132        c = a.subtract(b);
133        d = a.subtract(x,u);
134        assertEquals("a-p(x,u) = a-(x,u)",c,d);
135    }
136
137
138    /**
139     * Test object multiplication.
140     */
141    public void testMultiplication() {
142        a = fac.random(ll);
143        assertTrue("not isZERO( a )", !a.isZERO() );
144
145        b = fac.random(ll);
146        assertTrue("not isZERO( b )", !b.isZERO() );
147
148        c = b.multiply(a);
149        d = a.multiply(b);
150        assertTrue("not isZERO( c )", !c.isZERO() );
151        assertTrue("not isZERO( d )", !d.isZERO() );
152
153        //System.out.println("a = " + a);
154        //System.out.println("b = " + b);
155        e = d.subtract(c);
156        assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO() );
157
158        assertTrue("a*b = b*a", c.equals(d) );
159        assertEquals("a*b = b*a",c,d);
160
161        c = fac.random(ll);
162        //System.out.println("c = " + c);
163        d = a.multiply( b.multiply(c) );
164        e = (a.multiply(b)).multiply(c);
165
166        //System.out.println("d = " + d);
167        //System.out.println("e = " + e);
168
169        //System.out.println("d-e = " + d.subtract(c) );
170
171        assertEquals("a(bc) = (ab)c",d,e);
172        assertTrue("a(bc) = (ab)c", d.equals(e) );
173
174        BigDecimal x = a.leadingBaseCoefficient().inverse();
175        c = a.monic();
176        d = a.multiply(x);
177        assertEquals("a.monic() = a(1/ldcf(a))",c,d);
178
179        BigDecimal y = b.leadingBaseCoefficient().inverse();
180        c = b.monic();
181        d = b.multiply(y);
182        assertEquals("b.monic() = b(1/ldcf(b))",c,d);
183
184        e = new GenPolynomial<BigDecimal>(fac,y);
185        d = b.multiply(e);
186        assertEquals("b.monic() = b(1/ldcf(b))",c,d);
187
188        d = e.multiply(b);
189        assertEquals("b.monic() = (1/ldcf(b) (0))*b",c,d);
190    }
191
192
193    /**
194     * Test BLAS level 1.
195     */
196    public void testBLAS1() {
197        a = fac.random(kl,ll,el,q);
198        b = fac.random(kl,ll,el,q);
199        c = fac.random(kl,3,el*el,q);
200        ExpVector ev = ExpVector.random(rl,el,q);
201        BigDecimal lc = fac.coFac.random(kl);
202
203        d = a.subtractMultiple(lc,b);
204        e = a.subtract( b.multiply(lc) );
205        assertEquals("a - (lc) b == a - ((lc) b)",d,e);
206
207        d = a.subtractMultiple(lc,ev,b);
208        e = a.subtract( b.multiply(lc,ev) );
209        assertEquals("a - (lc ev) b == a - ((lc ev) b)",d,e);
210
211        ExpVector fv = ExpVector.random(rl,el,q);
212        BigDecimal tc = fac.coFac.random(kl);
213
214        d = a.scaleSubtractMultiple(tc,lc,ev,b);
215        e = a.multiply(tc).subtract( b.multiply(lc,ev) );
216        assertEquals("(tc) a - (lc ev) b == ((tc) a - ((lc ev) b))",d,e);
217
218        d = a.scaleSubtractMultiple(tc,fv,lc,ev,b);
219        e = a.multiply(tc,fv).subtract( b.multiply(lc,ev) );
220        assertEquals("(tc fv) a - (lc ev) b == ((tc fv) a - ((lc ev) b))",d,e);
221    }
222
223
224    /**
225     * Test distributive law.
226     */
227    public void testDistributive() {
228        a = fac.random(kl,ll,el,q);
229        b = fac.random(kl,ll,el,q);
230        c = fac.random(kl,ll,el,q);
231
232        d = a.multiply( b.sum(c) );
233        e = a.multiply( b ).sum( a.multiply(c) );
234
235        assertEquals("a(b+c) == ab+ac",d,e);
236    }
237
238
239    /*
240     * Test object quotient and remainder.
241     * Not meaningful.
242     */
243
244    /**
245     * Test addition speed.
246     */
247    public void testAdditionSpeed() {
248        int ll = 100;
249        long t = 1000;
250        boolean print = false;
251        int jit = 1;
252        for (int j = 1; j < 5; j++) {
253            for (int i = 1; i < 5; i++) {
254                a = fac.random(kl, i*ll, el, q);
255                b = fac.random(kl, ll,   el, q);
256                for (int k = 0; k < jit; k++) {
257                    long t1 = System.nanoTime();
258                    c = a.sum(b);
259                    t1 = System.nanoTime() - t1;
260                    assertTrue("c != 0", !c.isZERO() );
261
262                    long t2 = System.nanoTime();
263                    d = b.sum(a);
264                    t2 = System.nanoTime() - t2;
265                    assertTrue("d != 0", !d.isZERO() );
266                    if (print) {
267                        System.out.print("#a = " + a.length() + ", #b = " + b.length() );
268                        System.out.println(",\t t1 = " + (t1/t) + ", t2 = " + (t2/t) );
269                    }
270                    //assertTrue("t2 <= t1", ((t1/t) >= (t2/t)) );
271                }
272                if (print) System.out.println();
273                assertEquals("c == d", c, d );
274            }
275            ll = 3 * ll;
276        }
277    }
278
279    
280    /**
281     * Test absolute norm.
282     */
283    public void testAbsNorm() {
284        BigDecimal r;
285        a = fac.getONE().negate();
286        //System.out.println("a = " + a);
287
288        r = PolyUtil.<BigDecimal> absNorm(a);
289        //System.out.println("r = " + r);
290        assertTrue("isONE( absNorm(-1) )", r.isONE() );
291
292        a = fac.random(kl*2, ll+2, el, q );
293        //System.out.println("a = " + a);
294
295        r = PolyUtil.<BigDecimal> absNorm(a);
296        //System.out.println("r = " + r);
297        assertTrue(" not isZERO( absNorm(a) )", !r.isZERO() || a.isZERO() );
298    }
299
300}