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