001/*
002 * $Id$
003 */
004
005package edu.jas.ps;
006
007
008import java.util.ArrayList;
009import java.util.List;
010import java.util.Map;
011import java.util.Set;
012import java.util.HashSet;
013
014import edu.jas.arith.BigRational;
015import edu.jas.poly.ExpVector;
016import edu.jas.poly.GenPolynomial;
017import edu.jas.poly.GenPolynomialRing;
018
019import junit.framework.Test;
020import junit.framework.TestCase;
021import junit.framework.TestSuite;
022
023
024/**
025 * Standard base of multivariate power series tests with JUnit.
026 * @author Heinz Kredel
027 */
028public class STDMultiPSTest extends TestCase {
029
030
031    /**
032     * main.
033     */
034    public static void main(String[] args) {
035        junit.textui.TestRunner.run(suite());
036    }
037
038
039    /**
040     * Constructs a <CODE>STDMultiPSTest</CODE> object.
041     * @param name String.
042     */
043    public STDMultiPSTest(String name) {
044        super(name);
045    }
046
047
048    /**
049     */
050    public static Test suite() {
051        TestSuite suite = new TestSuite(STDMultiPSTest.class);
052        return suite;
053    }
054
055
056    BigRational cfac;
057
058
059    MultiVarPowerSeriesRing<BigRational> fac;
060
061
062    MultiVarPowerSeries<BigRational> a, b, c, d, e, f;
063
064
065    int rl = 3;
066
067
068    int kl = 5;
069
070
071    float q = 0.3f;
072
073
074    @Override
075    protected void setUp() {
076        a = b = c = d = e = null;
077        String[] vars = new String[] { "x", "y", "z" };
078        cfac = new BigRational(1);
079        fac = new MultiVarPowerSeriesRing<BigRational>(cfac, rl, vars);
080        //System.out.println("fac = " + fac);
081        //System.out.println("fac = " + fac.toScript());
082    }
083
084
085    @Override
086    protected void tearDown() {
087        a = b = c = d = e = null;
088        fac = null;
089    }
090
091
092    /**
093     * Test fix point constructions.
094     */
095    public void testFixpoints() {
096        int r = 0;
097        UnivPowerSeriesRing<BigRational> ufac = new UnivPowerSeriesRing<BigRational>(fac.coFac, fac.vars[r]);
098        UnivPowerSeries<BigRational> exp = ufac.getEXP();
099        //System.out.println("exp = " + exp);
100
101        a = fac.fromPowerSeries(exp, 0);
102        b = fac.fromPowerSeries(exp, 1);
103        //System.out.println("a = " + a);
104        //System.out.println("b = " + b);
105
106        c = fac.getEXP(0);
107        d = fac.getEXP(1);
108        //System.out.println("c = " + c);
109        //System.out.println("d = " + d);
110        assertEquals("a == c ", a, c);
111        assertEquals("b == d ", b, d);
112
113        e = d.differentiate(0);
114        //System.out.println("e = " + e);
115        assertTrue("isZERO( e )", e.isZERO());
116        e = d.differentiate(1);
117        //System.out.println("e = " + e);
118        assertEquals("e == d ", d, e);
119    }
120
121
122    /**
123     * Test gcd.
124     */
125    public void testGcd() {
126        a = fac.random(kl);
127        //System.out.println("a = " + a);
128
129        b = fac.random(kl);
130        //System.out.println("b = " + b);
131
132        c = a.gcd(b);
133        //System.out.println("c = " + c);
134
135        d = a.divide(c);
136        //System.out.println("d = " + d);
137
138        e = b.divide(c);
139        //System.out.println("e = " + e);
140
141        f = d.gcd(e);
142        //System.out.println("f = " + f);
143        assertTrue("gcd(a/gcd(a,b),b/gcd(a,b)) == 1 ", f.isONE());
144    }
145
146
147    /**
148     * Test Taylor series.
149     */
150    public void testTaylor() {
151        BigRational ar = new BigRational(5);
152        BigRational br = new BigRational(0);
153        BigRational cr = new BigRational(-5);
154        List<BigRational> Ar = new ArrayList<BigRational>(rl);
155        List<BigRational> Br = new ArrayList<BigRational>(rl);
156        List<BigRational> Cr = new ArrayList<BigRational>(rl);
157        for (int i = 0; i < rl; i++) {
158            Ar.add(ar);
159            Br.add(br);
160            Cr.add(cr);
161        }
162        GenPolynomialRing<BigRational> pr = fac.polyRing();
163        //System.out.println("pr  = " + pr.toScript());
164
165        GenPolynomial<BigRational> p = pr.random(kl, 3, 3, q + q);
166        //System.out.println("p   = " + p);
167        int tdeg = (int) p.degree();
168        fac.setTruncate(tdeg + 1);
169
170        TaylorFunction<BigRational> F = new PolynomialTaylorFunction<BigRational>(p);
171
172        MultiVarPowerSeries<BigRational> pps = fac.fromPolynomial(p);
173        //System.out.println("pps = " + pps);
174        MultiVarPowerSeries<BigRational> ps = fac.seriesOfTaylor(F, Br);
175        //System.out.println("ps  = " + ps);
176        assertEquals("taylor(p) == p", ps, pps);
177
178        MultiVarPowerSeries<BigRational> psa = fac.seriesOfTaylor(F, Ar);
179        //System.out.println("psa  = " + psa);
180        F = new PolynomialTaylorFunction<BigRational>(psa.asPolynomial());
181        MultiVarPowerSeries<BigRational> psc = fac.seriesOfTaylor(F, Cr);
182        //System.out.println("psc  = " + psc);
183        assertEquals("taylor(taylor(p,5),-5) == p", ps, psc);
184
185        for (GenPolynomial<BigRational> g : pr.generators()) {
186            F = new PolynomialTaylorFunction<BigRational>(g);
187            ps = fac.seriesOfTaylor(F, Br);
188            //System.out.println("g   = " + g);
189            //System.out.println("ps  = " + ps);
190            pps = fac.fromPolynomial(g);
191            //System.out.println("pps = " + pps);
192            assertEquals("taylor(p) == p", ps, pps);
193
194            psa = fac.seriesOfTaylor(F, Ar);
195            //System.out.println("psa  = " + psa);
196            F = new PolynomialTaylorFunction<BigRational>(psa.asPolynomial());
197            psc = fac.seriesOfTaylor(F, Cr);
198            //System.out.println("psc  = " + psc);
199            assertEquals("taylor(taylor(p,5),-5) == p", ps, psc);
200        }
201    }
202
203
204    /**
205     * Test evaluation.
206     */
207    public void testEvaluation() {
208        a = fac.random(kl, q);
209        b = fac.random(kl, q);
210        BigRational fv = new BigRational(0);
211        List<BigRational> v = new ArrayList<BigRational>(rl);
212        for (int i = 0; i < rl; i++) {
213            v.add(fv.random(kl));
214        }
215
216        BigRational av = a.evaluate(v);
217        BigRational bv = b.evaluate(v);
218
219        c = a.sum(b);
220        BigRational cv = c.evaluate(v);
221        BigRational dv = av.sum(bv);
222
223        assertEquals("a(v)+b(v) = (a+b)(v) ", cv, dv);
224
225        c = fac.getZERO();
226        cv = c.evaluate(v);
227        dv = fv.getZERO();
228        assertEquals("0(v) = 0 ", cv, dv);
229
230        c = fac.getONE();
231        cv = c.evaluate(v);
232        dv = fv.getONE();
233        assertEquals("1(v) = 1 ", cv, dv);
234    }
235
236
237    /**
238     * Test standard base.
239     * Example from CLO(UAG), 4.4.
240     */
241    public void testSTD() {
242        GenPolynomialRing<BigRational> pfac = fac.polyRing();
243        //System.out.println("pfac  = " + pfac.toScript());
244
245        GenPolynomial<BigRational> ap, bp, cp;
246        ap = pfac.parse("x**5 - x * y**6 - z**7");
247        //System.out.println("ap = " + ap);
248        bp = pfac.parse("x * y + y**3 + z**3");
249        //System.out.println("bp = " + bp);
250        cp = pfac.parse("x**2 + y**2 - z**2");
251        //System.out.println("cp = " + cp);
252
253        a = fac.fromPolynomial(ap);
254        //System.out.println("a = " + a);
255        b = fac.fromPolynomial(bp);
256        //System.out.println("b = " + b);
257        c = fac.fromPolynomial(cp);
258        //System.out.println("c = " + c);
259
260        List<MultiVarPowerSeries<BigRational>> L, S;
261        L = new ArrayList<MultiVarPowerSeries<BigRational>>();
262        L.add(a);
263        L.add(b);
264        L.add(c);
265        //System.out.println("L = " + L);
266
267        StandardBaseSeq<BigRational> tm = new StandardBaseSeq<BigRational>();
268        //assertFalse("isSTD(L): ", tm.isSTD(L));
269        S = tm.STD(L);
270        //System.out.println("S = " + S);
271        assertTrue("isSTD(S): ", tm.isSTD(S));
272    }
273
274}