Source code

001/*
002 * $Id$
003 */
004
005package edu.jas.ps;
006
007
008import java.util.HashSet;
009import java.util.List;
010import java.util.Set;
011
012import edu.jas.arith.BigRational;
013import edu.jas.kern.ComputerThreads;
014import edu.jas.poly.GenPolynomial;
015import edu.jas.poly.GenPolynomialRing;
016import edu.jas.vector.GenVector;
017import edu.jas.vector.GenVectorModul;
018
019import junit.framework.Test;
020import junit.framework.TestCase;
021import junit.framework.TestSuite;
022
023
024/**
025 * Univariate power series tests with JUnit.
026 * @author Heinz Kredel
027 */
028
029public class UnivPowerSeriesTest extends TestCase {
030
031
032    /**
033     * main.
034     */
035    public static void main(String[] args) {
036        junit.textui.TestRunner.run(suite());
037    }
038
039
040    /**
041     * Constructs a <CODE>UnivPowerSeriesTest</CODE> object.
042     * @param name String.
043     */
044    public UnivPowerSeriesTest(String name) {
045        super(name);
046    }
047
048
049    /**
050     */
051    public static Test suite() {
052        TestSuite suite = new TestSuite(UnivPowerSeriesTest.class);
053        return suite;
054    }
055
056
057    BigRational cfac;
058
059
060    UnivPowerSeriesRing<BigRational> fac;
061
062
063    UnivPowerSeries<BigRational> a, b, c, d, e;
064
065
066    int kl = 10;
067
068
069    float q = 0.5f;
070
071
072    @Override
073    protected void setUp() {
074        a = b = c = d = e = null;
075        cfac = new BigRational(1);
076        fac = new UnivPowerSeriesRing<BigRational>(cfac);
077    }
078
079
080    @Override
081    protected void tearDown() {
082        a = b = c = d = e = null;
083        fac = null;
084        cfac = null;
085        ComputerThreads.terminate();
086    }
087
088
089    /**
090     * Test generate.
091     */
092    public void testGenerate() {
093        String s = fac.toScript();
094        //System.out.println("fac.toScript: " + s + ", " + s.length());
095        assertTrue("#s == 15: " + s, s.length() == 15);
096
097        List<UnivPowerSeries<BigRational>> gens = fac.generators();
098        assertFalse("#gens != () ", gens.isEmpty());
099        //System.out.println("generators: " + gens);
100
101        // test equals
102        Set<UnivPowerSeries<BigRational>> set = new HashSet<UnivPowerSeries<BigRational>>(gens);
103        //System.out.println("gen set: " + set);
104        assertEquals("#gens == #set: ", gens.size(), set.size());
105
106        // test for elements 0, 1
107        a = fac.getZERO();
108        b = fac.getONE();
109        assertFalse("0 not in #set: ", set.contains(a));
110        assertTrue("1 in #set: ", set.contains(b));
111
112        // specific tests
113        assertEquals("#gens == 2 ", 2, gens.size());
114        Set<Integer> iset = new HashSet<Integer>(set.size());
115        for (UnivPowerSeries<BigRational> p : gens) {
116            //System.out.println("p = " + p.toScript() + ", # = " + p.hashCode() + ", red = " + p.reductum());
117            assertTrue("red(p) == 0 ", p.reductum().isZERO());
118            iset.add(p.hashCode());
119        }
120        assertEquals("#gens == #iset: ", gens.size(), iset.size());
121    }
122
123
124    /**
125     * Test constructor and toString.
126     */
127    public void testConstruction() {
128        c = fac.getONE();
129        assertTrue("isZERO( c )", !c.isZERO());
130        assertTrue("isONE( c )", c.isONE());
131        //System.out.println("c = " + c);
132
133        d = fac.getZERO();
134        assertTrue("isZERO( d )", d.isZERO());
135        assertTrue("isONE( d )", !d.isONE());
136
137        e = fac.generate((i) -> i == 0 ? cfac.getONE() : cfac.getZERO());
138        //System.out.println("e = " + e);
139        assertTrue("isZERO( e )", !e.isZERO());
140        assertTrue("isONE( e )", e.isONE());
141    }
142
143
144    /**
145     * Test random polynomial.
146     */
147    public void testRandom() {
148        for (int i = 0; i < 5; i++) {
149            a = fac.random(i + 2);
150            //System.out.println("a = " + a);
151            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
152            assertTrue(" not isONE( a" + i + " )", !a.isONE());
153        }
154    }
155
156
157    /**
158     * Test addition.
159     */
160    public void testAddition() {
161        a = fac.random(kl);
162        b = fac.random(kl);
163
164        c = a.sum(b);
165        d = b.sum(a);
166        assertEquals("a+b = b+a", c, d);
167
168        d = c.subtract(b);
169        assertEquals("a+b-b = a", a, d);
170
171        c = fac.random(kl);
172        d = a.sum(b.sum(c));
173        e = a.sum(b).sum(c);
174        assertEquals("a+(b+c) = (a+b)+c", d, e);
175    }
176
177
178    /**
179     * Test multiplication.
180     */
181    public void testMultiplication() {
182        a = fac.random(kl);
183        assertTrue("not isZERO( a )", !a.isZERO());
184
185        b = fac.random(kl);
186        assertTrue("not isZERO( b )", !b.isZERO());
187
188        c = b.multiply(a);
189        d = a.multiply(b);
190        assertTrue("not isZERO( c )", !c.isZERO());
191        assertTrue("not isZERO( d )", !d.isZERO());
192
193        //System.out.println("a = " + a);
194        //System.out.println("b = " + b);
195        e = d.subtract(c);
196        assertTrue("isZERO( a*b-b*a ) " + e, e.isZERO());
197
198        assertTrue("a*b = b*a", c.equals(d));
199        assertEquals("a*b = b*a", c, d);
200
201        c = fac.random(kl);
202        //System.out.println("c = " + c);
203        d = a.multiply(b.multiply(c));
204        e = (a.multiply(b)).multiply(c);
205
206        //System.out.println("d = " + d);
207        //System.out.println("e = " + e);
208
209        //System.out.println("d-e = " + d.subtract(c) );
210
211        assertEquals("a(bc) = (ab)c", d, e);
212        assertTrue("a(bc) = (ab)c", d.equals(e));
213    }
214
215
216    /**
217     * Test distributive law.
218     */
219    public void testDistributive() {
220        a = fac.random(kl, q);
221        b = fac.random(kl, q);
222        c = fac.random(kl, q);
223
224        d = a.multiply(b.sum(c));
225        e = a.multiply(b).sum(a.multiply(c));
226
227        assertEquals("a(b+c) = ab+ac", d, e);
228    }
229
230
231    /**
232     * Test object quotient and remainder.
233     */
234    public void testQuotRem() {
235        fac = new UnivPowerSeriesRing<BigRational>(new BigRational(1));
236
237        a = fac.random(kl);
238        assertTrue("not isZERO( a )", !a.isZERO());
239
240        b = fac.random(kl);
241        assertTrue("not isZERO( b )", !b.isZERO());
242
243        UnivPowerSeries<BigRational> g = fac.random(kl);
244        assertTrue("not isZERO( g )", !g.isZERO());
245        a = a.multiply(g);
246        b = b.multiply(g);
247        //System.out.println("a = " + a);
248        //System.out.println("b = " + b);
249        //System.out.println("g = " + g);
250
251        /*
252        UnivPowerSeries<BigRational>[] qr;
253        qr = b.divideAndRemainder(a);
254        c = qr[0];
255        d = qr[1];
256        //System.out.println("q = " + c);
257        //System.out.println("r = " + d);
258        e = c.multiply(a).sum(d);
259        assertEquals("b = q a + r", b, e );
260        */
261
262        // gcd tests ---
263        c = a.gcd(b);
264        //System.out.println("gcd = " + c);
265        assertTrue("a mod gcd(a,b) = 0", a.remainder(c).isZERO());
266        assertTrue("b mod gcd(a,b) = 0", b.remainder(c).isZERO());
267        //assertEquals("g = gcd(a,b)", c, g );
268    }
269
270
271    /**
272     * Test evaluation.
273     */
274    public void testEvaluation() {
275        a = fac.random(kl, q);
276        b = fac.random(kl, q);
277        BigRational fv = new BigRational(0);
278        BigRational v = fv.random(kl);
279
280        BigRational av = a.evaluate(v);
281        BigRational bv = b.evaluate(v);
282
283        c = a.sum(b);
284        BigRational cv = c.evaluate(v);
285        BigRational dv = av.sum(bv);
286        assertEquals("a(v)+b(v) = (a+b)(v) ", cv, dv);
287
288        c = fac.getZERO();
289        cv = c.evaluate(v);
290        dv = fv.getZERO();
291        assertEquals("0(v) = 0 ", cv, dv);
292
293        c = fac.getONE();
294        cv = c.evaluate(v);
295        dv = fv.getONE();
296        assertEquals("1(v) = 1 ", cv, dv);
297
298        // not true: 
299        //c = a.multiply(b);
300        //cv = c.evaluate(v);
301        //dv = av.multiply(bv);
302        //assertEquals("a(v)*b(v) = (a*b)(v) ", cv, dv);
303    }
304
305
306    /**
307     * Test polynomial constructions.
308     */
309    public void testPolynomial() {
310        GenPolynomialRing<BigRational> pr = fac.polyRing();
311        //System.out.println("pr = " + pr);
312
313        GenPolynomial<BigRational> p = pr.random(kl, 3, 3, q + q);
314        //System.out.println("p = " + p);
315
316        a = fac.fromPolynomial(p);
317        //System.out.println("a = " + a);
318
319        GenPolynomial<BigRational> s = a.asPolynomial();
320        //System.out.println("s = " + s);
321        assertEquals("asPolynomial(fromPolynomial(p)) = p ", p, s);
322
323        b = fac.fromPolynomial(s);
324        //System.out.println("b = " + b);
325        assertEquals("fromPolynomial(asPolynomial(s)) = s ", a, b);
326    }
327
328
329    /**
330     * Test vector constructions.
331     */
332    public void testVector() {
333        GenVectorModul<BigRational> pm = new GenVectorModul<BigRational>(fac.coFac, fac.truncate);
334        //System.out.println("pm = " + pm);
335
336        GenVector<BigRational> v = pm.random(kl, q);
337        //System.out.println("v = " + v);
338
339        a = fac.fromVector(v);
340        //System.out.println("a = " + a);
341
342        GenVector<BigRational> s = a.asVector();
343        //System.out.println("s = " + s);
344        assertEquals("asVector(fromVector(v)) = v ", v, s);
345
346        b = fac.fromVector(s);
347        //System.out.println("b = " + b);
348        assertEquals("fromVector(asVector(s)) = s ", a, b);
349    }
350
351}