001/*
002 * $Id$
003 */
004
005package edu.jas.ufd;
006
007
008import edu.jas.arith.BigRational;
009import edu.jas.kern.ComputerThreads;
010import edu.jas.poly.GenPolynomial;
011import edu.jas.poly.GenPolynomialRing;
012import edu.jas.ps.PolynomialTaylorFunction;
013import edu.jas.ps.TaylorFunction;
014import edu.jas.ps.UnivPowerSeries;
015import edu.jas.ps.UnivPowerSeriesRing;
016
017import junit.framework.Test;
018import junit.framework.TestCase;
019import junit.framework.TestSuite;
020
021
022/**
023 * Univariate power series tests with JUnit.
024 * @author Heinz Kredel
025 */
026
027public class UnivPowerSeriesTaylorTest extends TestCase {
028
029
030    /**
031     * main.
032     */
033    public static void main(String[] args) {
034        junit.textui.TestRunner.run(suite());
035    }
036
037
038    /**
039     * Constructs a <CODE>UnivPowerSeriesTaylorTest</CODE> object.
040     * @param name String.
041     */
042    public UnivPowerSeriesTaylorTest(String name) {
043        super(name);
044    }
045
046
047    /**
048     */
049    public static Test suite() {
050        TestSuite suite = new TestSuite(UnivPowerSeriesTaylorTest.class);
051        return suite;
052    }
053
054
055    BigRational cfac;
056
057
058    UnivPowerSeriesRing<BigRational> fac;
059
060
061    UnivPowerSeries<BigRational> a, b, c, d, e;
062
063
064    int kl = 10;
065
066
067    float q = 0.5f;
068
069
070    @Override
071    protected void setUp() {
072        a = b = c = d = e = null;
073        cfac = new BigRational(1);
074        fac = new UnivPowerSeriesRing<BigRational>(cfac);
075    }
076
077
078    @Override
079    protected void tearDown() {
080        a = b = c = d = e = null;
081        fac = null;
082        cfac = null;
083        ComputerThreads.terminate();
084    }
085
086
087    /**
088     * Test Taylor series of polynomials.
089     */
090    public void testTaylor() {
091        BigRational br = new BigRational(0);
092        GenPolynomialRing<BigRational> pr = fac.polyRing();
093        //System.out.println("pr  = " + pr);
094
095        GenPolynomial<BigRational> p = pr.random(kl, 3, 3, q + q);
096        //System.out.println("p   = " + p);
097
098        TaylorFunction<BigRational> F = new PolynomialTaylorFunction<BigRational>(p);
099
100        UnivPowerSeries<BigRational> ps = fac.seriesOfTaylor(F, br);
101        //System.out.println("ps  = " + ps);
102        UnivPowerSeries<BigRational> pps = fac.fromPolynomial(p);
103        //System.out.println("pps = " + pps);
104        assertEquals("taylor(p) == p", ps, pps);
105
106        for (GenPolynomial<BigRational> g : pr.generators()) {
107            F = new PolynomialTaylorFunction<BigRational>(g);
108            ps = fac.seriesOfTaylor(F, br);
109            //System.out.println("g   = " + g);
110            //System.out.println("ps  = " + ps);
111            pps = fac.fromPolynomial(g);
112            //System.out.println("pps = " + pps);
113            assertEquals("taylor(p) == p", ps, pps);
114        }
115    }
116
117
118    /**
119     * Test Taylor series of quotients of polynomials.
120     */
121    public void testQuotientTaylor() {
122        BigRational br = new BigRational(0);
123        GenPolynomialRing<BigRational> pr = fac.polyRing();
124        //System.out.println("pr  = " + pr);
125        QuotientRing<BigRational> qr = new QuotientRing<BigRational>(pr);
126        //System.out.println("qr  = " + qr.toScript());
127
128        Quotient<BigRational> p = qr.random(kl, 3, 3, q + q);
129        //System.out.println("p   = " + p);
130        //Quotient<BigRational> x = qr.generators().get(1);
131        //p = p.divide(x);
132        //System.out.println("p   = " + p);
133        if (p.den.trailingBaseCoefficient().isZERO()) { // divisible by x, evaluates to 0
134            return;
135        }
136        TaylorFunction<BigRational> F = new QuotientTaylorFunction<BigRational>(p);
137
138        UnivPowerSeries<BigRational> ps = fac.seriesOfTaylor(F, br);
139        //System.out.println("ps  = " + ps);
140        UnivPowerSeries<BigRational> pps = fac.fromPolynomial(p.num).divide(fac.fromPolynomial(p.den));
141        //System.out.println("pps = " + pps);
142        assertEquals("taylor(p) == p", ps, pps);
143
144        for (Quotient<BigRational> g : qr.generators()) {
145            F = new QuotientTaylorFunction<BigRational>(g);
146            ps = fac.seriesOfTaylor(F, br);
147            //System.out.println("g   = " + g);
148            //System.out.println("ps  = " + ps);
149            pps = fac.fromPolynomial(g.num).divide(fac.fromPolynomial(g.den));
150            //System.out.println("pps = " + pps);
151            assertEquals("taylor(p) == p", ps, pps);
152        }
153    }
154
155
156    /**
157     * Test Pade approximant of quotients of polynomials.
158     */
159    public void testQuotientPade() {
160        BigRational br = new BigRational(0);
161        GenPolynomialRing<BigRational> pr = fac.polyRing();
162        //System.out.println("pr  = " + pr.toScript());
163        QuotientRing<BigRational> qr = new QuotientRing<BigRational>(pr);
164        //System.out.println("qr  = " + qr.toScript());
165
166        final int M = 3, N = 4;
167        Quotient<BigRational> p = qr.random(kl, M, N, q + q);
168        Quotient<BigRational> x = qr.generators().get(1);
169        while (p.den.trailingBaseCoefficient().isZERO()) { // divisible by x, evaluates to 0
170            p = p.multiply(x);
171        }
172        while (p.num.trailingBaseCoefficient().isZERO()) { // divisible by x, evaluates to 0
173            p = p.divide(x);
174        }
175        //System.out.println("p   = " + p);
176        TaylorFunction<BigRational> F = new QuotientTaylorFunction<BigRational>(p);
177
178        int dm = (int) p.num.degree() + 1, dn = (int) p.den.degree() + 1;
179        //System.out.println("[" + dm + "," + dn + "]");
180        Quotient<BigRational> pa = null;
181        for (int m = 0; m < dm; m++) {
182            for (int n = 0; n < dn; n++) {
183                pa = PolyUfdUtil.<BigRational> approximantOfPade(fac, F, br, m, n);
184                //System.out.println("pa[" + m + "," + n + "]  = " + pa + "\n");
185                assertTrue("deg(num) <= m", pa.num.degree() <= m);
186                assertTrue("deg(den) <= n", pa.den.degree() <= n);
187            }
188        }
189        //System.out.println("pa[" + (dm-1) + "," + (dn-1) + "] = " + pa + "\n");
190        assertEquals("p == pa: ", p, pa);
191    }
192
193}