Source code

001/*
002 * $Id: UnivPowerSeriesTest.java 5688 2017-01-03 08:45:09Z kredel $
003 */
004
005package edu.jas.ps;
006
007
008import edu.jas.arith.BigRational;
009import edu.jas.poly.GenPolynomial;
010import edu.jas.poly.GenPolynomialRing;
011
012import junit.framework.Test;
013import junit.framework.TestCase;
014import junit.framework.TestSuite;
015
016
017/**
018 * Univariate power series tests with JUnit.
019 * @author Heinz Kredel
020 */
021
022public class UnivPowerSeriesTest extends TestCase {
023
024
025    /**
026     * main.
027     */
028    public static void main(String[] args) {
029        junit.textui.TestRunner.run(suite());
030    }
031
032
033    /**
034     * Constructs a <CODE>UnivPowerSeriesTest</CODE> object.
035     * @param name String.
036     */
037    public UnivPowerSeriesTest(String name) {
038        super(name);
039    }
040
041
042    /**
043     */
044    public static Test suite() {
045        TestSuite suite = new TestSuite(UnivPowerSeriesTest.class);
046        return suite;
047    }
048
049
050    BigRational cfac;
051
052
053    UnivPowerSeriesRing<BigRational> fac;
054
055
056    UnivPowerSeries<BigRational> a, b, c, d, e;
057
058
059    int kl = 10;
060
061
062    float q = 0.5f;
063
064
065    @Override
066    protected void setUp() {
067        a = b = c = d = e = null;
068        cfac = new BigRational(1);
069        fac = new UnivPowerSeriesRing<BigRational>(cfac);
070    }
071
072
073    @Override
074    protected void tearDown() {
075        a = b = c = d = e = null;
076        fac = null;
077        cfac = null;
078    }
079
080
081    /**
082     * Test constructor and toString.
083     * 
084     */
085    public void testConstruction() {
086        c = fac.getONE();
087        assertTrue("isZERO( c )", !c.isZERO());
088        assertTrue("isONE( c )", c.isONE());
089        //System.out.println("c = " + c);
090
091        d = fac.getZERO();
092        assertTrue("isZERO( d )", d.isZERO());
093        assertTrue("isONE( d )", !d.isONE());
094
095        e = fac.generate((i) -> i == 0 ? cfac.getONE() : cfac.getZERO());
096        //System.out.println("e = " + e);
097        assertTrue("isZERO( e )", !e.isZERO());
098        assertTrue("isONE( e )", e.isONE());
099    }
100
101
102    /**
103     * Test random polynomial.
104     */
105    public void testRandom() {
106        for (int i = 0; i < 5; i++) {
107            a = fac.random(i + 2);
108            //System.out.println("a = " + a);
109            assertTrue(" not isZERO( a" + i + " )", !a.isZERO());
110            assertTrue(" not isONE( a" + i + " )", !a.isONE());
111        }
112    }
113
114
115    /**
116     * Test addition.
117     * 
118     */
119    public void testAddition() {
120        a = fac.random(kl);
121        b = fac.random(kl);
122
123        c = a.sum(b);
124        d = b.sum(a);
125        assertEquals("a+b = b+a", c, d);
126
127        d = c.subtract(b);
128        assertEquals("a+b-b = a", a, d);
129
130        c = fac.random(kl);
131        d = a.sum(b.sum(c));
132        e = a.sum(b).sum(c);
133        assertEquals("a+(b+c) = (a+b)+c", d, e);
134    }
135
136
137    /**
138     * Test multiplication.
139     * 
140     */
141    public void testMultiplication() {
142        a = fac.random(kl);
143        assertTrue("not isZERO( a )", !a.isZERO());
144
145        b = fac.random(kl);
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(kl);
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
175
176    /**
177     * Test distributive law.
178     * 
179     */
180    public void testDistributive() {
181        a = fac.random(kl, q);
182        b = fac.random(kl, q);
183        c = fac.random(kl, q);
184
185        d = a.multiply(b.sum(c));
186        e = a.multiply(b).sum(a.multiply(c));
187
188        assertEquals("a(b+c) = ab+ac", d, e);
189    }
190
191
192    /**
193     * Test object quotient and remainder.
194     * 
195     */
196    public void testQuotRem() {
197        fac = new UnivPowerSeriesRing<BigRational>(new BigRational(1));
198
199        a = fac.random(kl);
200        assertTrue("not isZERO( a )", !a.isZERO());
201
202        b = fac.random(kl);
203        assertTrue("not isZERO( b )", !b.isZERO());
204
205        UnivPowerSeries<BigRational> g = fac.random(kl);
206        assertTrue("not isZERO( g )", !g.isZERO());
207        a = a.multiply(g);
208        b = b.multiply(g);
209        //System.out.println("a = " + a);
210        //System.out.println("b = " + b);
211        //System.out.println("g = " + g);
212
213        /*
214        UnivPowerSeries<BigRational>[] qr;
215        qr = b.divideAndRemainder(a);
216        c = qr[0];
217        d = qr[1];
218        //System.out.println("q = " + c);
219        //System.out.println("r = " + d);
220        e = c.multiply(a).sum(d);
221        assertEquals("b = q a + r", b, e );
222        */
223
224        // gcd tests -------------------------------
225        c = a.gcd(b);
226        //System.out.println("gcd = " + c);
227        assertTrue("a mod gcd(a,b) = 0", a.remainder(c).isZERO());
228        assertTrue("b mod gcd(a,b) = 0", b.remainder(c).isZERO());
229        //assertEquals("g = gcd(a,b)", c, g );
230    }
231
232
233    /**
234     * Test evaluation.
235     * 
236     */
237    public void testEvaluation() {
238        a = fac.random(kl, q);
239        b = fac.random(kl, q);
240        BigRational fv = new BigRational(0);
241        BigRational v = fv.random(kl);
242
243        BigRational av = a.evaluate(v);
244        BigRational bv = b.evaluate(v);
245
246        c = a.sum(b);
247        BigRational cv = c.evaluate(v);
248        BigRational dv = av.sum(bv);
249        assertEquals("a(v)+b(v) = (a+b)(v) ", cv, dv);
250
251        c = fac.getZERO();
252        cv = c.evaluate(v);
253        dv = fv.getZERO();
254        assertEquals("0(v) = 0 ", cv, dv);
255
256        c = fac.getONE();
257        cv = c.evaluate(v);
258        dv = fv.getONE();
259        assertEquals("1(v) = 1 ", cv, dv);
260
261        // not true: 
262        //c = a.multiply(b);
263        //cv = c.evaluate(v);
264        //dv = av.multiply(bv);
265        //assertEquals("a(v)*b(v) = (a*b)(v) ", cv, dv);
266    }
267
268
269    /**
270     * Test Taylor series.
271     * 
272     */
273    public void testTaylor() {
274        BigRational br = new BigRational(0);
275        GenPolynomialRing<BigRational> pr = fac.polyRing();
276        //System.out.println("pr  = " + pr);
277
278        GenPolynomial<BigRational> p = pr.random(kl, 3, 3, q + q);
279        //System.out.println("p   = " + p);
280
281        TaylorFunction<BigRational> F = new PolynomialTaylorFunction<BigRational>(p);
282
283        UnivPowerSeries<BigRational> ps = fac.seriesOfTaylor(F, br);
284        //System.out.println("ps  = " + ps);
285        UnivPowerSeries<BigRational> pps = fac.fromPolynomial(p);
286        //System.out.println("pps = " + pps);
287        assertEquals("taylor(p) == p", ps, pps);
288
289        for (GenPolynomial<BigRational> g : pr.generators()) {
290            F = new PolynomialTaylorFunction<BigRational>(g);
291            ps = fac.seriesOfTaylor(F, br);
292            //System.out.println("g   = " + g);
293            //System.out.println("ps  = " + ps);
294            pps = fac.fromPolynomial(g);
295            //System.out.println("pps = " + pps);
296            assertEquals("taylor(p) == p", ps, pps);
297        }
298    }
299}