001 /*
002 * $Id: Examples.java 3352 2010-10-23 12:01:39Z kredel $
003 */
004
005 package edu.jas.ps;
006
007
008 import edu.jas.arith.BigComplex;
009 import edu.jas.arith.BigDecimal;
010 import edu.jas.arith.BigInteger;
011 import edu.jas.arith.BigRational;
012 import edu.jas.structure.BinaryFunctor;
013 import edu.jas.structure.RingElem;
014 import edu.jas.structure.RingFactory;
015 import edu.jas.structure.Selector;
016 import edu.jas.structure.UnaryFunctor;
017
018
019 /**
020 * Examples for univariate power series implementations.
021 * @author Heinz Kredel
022 */
023
024 public class Examples {
025
026
027 public static void main(String[] args) {
028 example2();
029 example4();
030 example6();
031 example8();
032 example9();
033 example10();
034 example11();
035 example1();
036 example3();
037 example5();
038 example7();
039 if ( args.length > 0 ) {
040 example12();
041 }
042 example13();
043 }
044
045
046 static UnivPowerSeries<BigInteger> integersFrom(final int start) {
047 UnivPowerSeriesRing<BigInteger> pfac = new UnivPowerSeriesRing<BigInteger>(new BigInteger());
048 return new UnivPowerSeries<BigInteger>(pfac, new Coefficients<BigInteger>() {
049
050
051 @Override
052 public BigInteger generate(int i) {
053 return new BigInteger(start + i);
054 }
055 });
056 }
057
058
059 //----------------------
060
061
062 static class Sum<C extends RingElem<C>> implements BinaryFunctor<C, C, C> {
063
064
065 public C eval(C c1, C c2) {
066 return c1.sum(c2);
067 }
068 }
069
070
071 static class Odds<C extends RingElem<C>> implements Selector<C> {
072
073
074 C two;
075
076
077 RingFactory<C> fac;
078
079
080 public Odds(RingFactory<C> fac) {
081 this.fac = fac;
082 two = fac.fromInteger(2);
083 //System.out.println("two = " + two);
084 }
085
086
087 public boolean select(C c) {
088 //System.out.print("c = " + c);
089 if (c.remainder(two).isONE()) {
090 //System.out.println(" odd");
091 return true;
092 }
093 //System.out.println(" even");
094 return false;
095 }
096 }
097
098
099 //----------------------
100
101
102 public static void example1() {
103 UnivPowerSeries<BigInteger> integers = integersFrom(0);
104
105 BigInteger e = new BigInteger(1);
106 BigInteger v = integers.evaluate(e);
107 System.out.println("integers(" + e + ") = " + v);
108 e = new BigInteger(0);
109 v = integers.evaluate(e);
110 System.out.println("integers(" + e + ") = " + v);
111 e = new BigInteger(2);
112 v = integers.evaluate(e);
113 System.out.println("integers(" + e + ") = " + v);
114 }
115
116
117 public static void example2() {
118 UnivPowerSeries<BigInteger> integers = integersFrom(0);
119
120 System.out.print("integer coefficients = ");
121 UnivPowerSeries<BigInteger> s = integers;
122 for (int i = 0; i < 20; i++) {
123 BigInteger c = s.leadingCoefficient();
124 System.out.print(c.toString() + ", ");
125 s = s.reductum();
126 }
127 System.out.println("...");
128 }
129
130
131 public static void example3() {
132 RingFactory<BigInteger> fac = new BigInteger(1);
133 UnivPowerSeriesRing<BigInteger> ups = new UnivPowerSeriesRing<BigInteger>(fac);
134 System.out.println("ups = " + ups);
135 System.out.println("ups.isCommutative() = " + ups.isCommutative());
136 System.out.println("ups.isAssociative() = " + ups.isAssociative());
137 System.out.println("ups.isField() = " + ups.isField());
138
139 System.out.println("ups.getZERO() = " + ups.getZERO());
140 System.out.println("ups.getONE() = " + ups.getONE());
141
142 UnivPowerSeries<BigInteger> rnd = ups.random();
143 System.out.println("rnd = " + rnd);
144 System.out.println("rnd = " + rnd);
145 System.out.println("rnd.isUnit() = " + rnd.isUnit());
146 }
147
148
149 public static void example4() {
150 UnivPowerSeries<BigInteger> integers = integersFrom(0);
151 System.out.println("integers = " + integers);
152 }
153
154
155 public static void example6() {
156 UnivPowerSeriesRing<BigInteger> pfac = new UnivPowerSeriesRing<BigInteger>(new BigInteger());
157 UnivPowerSeries<BigInteger> integers;
158 integers = pfac.fixPoint(new UnivPowerSeriesMap<BigInteger>() {
159
160
161 public UnivPowerSeries<BigInteger> map(UnivPowerSeries<BigInteger> ps) {
162 return ps.map(new UnaryFunctor<BigInteger, BigInteger>() {
163
164
165 public BigInteger eval(BigInteger s) {
166 return s.sum(new BigInteger(1));
167 }
168 }).prepend(new BigInteger(0));
169 }
170 });
171 System.out.println("integers1 = " + integers);
172 System.out.println("integers2 = " + integers);
173 }
174
175
176 public static void example8() {
177 final BigInteger z = new BigInteger(0);
178 final BigInteger one = new BigInteger(1);
179 UnivPowerSeriesRing<BigInteger> pfac = new UnivPowerSeriesRing<BigInteger>(z);
180 UnivPowerSeries<BigInteger> fibs;
181 fibs = pfac.fixPoint(new UnivPowerSeriesMap<BigInteger>() {
182
183
184 public UnivPowerSeries<BigInteger> map(UnivPowerSeries<BigInteger> ps) {
185 return ps.zip(new Sum<BigInteger>(), ps.prepend(one)).prepend(z);
186 }
187 });
188 System.out.println("fibs1 = " + fibs.toString(/*20*/));
189 System.out.println("fibs2 = " + fibs.toString(/*20*/));
190 }
191
192
193 public static void example9() {
194 UnivPowerSeries<BigInteger> integers = integersFrom(0);
195 System.out.println(" integers = " + integers);
196 UnivPowerSeries<BigInteger> doubleintegers = integers.sum(integers);
197 System.out.println("doubleintegers = " + doubleintegers);
198 UnivPowerSeries<BigInteger> nulls = integers.subtract(integers);
199 System.out.println("null integers = " + nulls);
200 doubleintegers = integers.multiply(new BigInteger(2));
201 System.out.println("doubleintegers = " + doubleintegers);
202 nulls = integers.multiply(new BigInteger(0));
203 System.out.println("null integers = " + nulls);
204 UnivPowerSeries<BigInteger> odds = integers.select(new Odds<BigInteger>(new BigInteger()));
205 System.out.println("odd integers = " + odds);
206 }
207
208
209 public static void example10() {
210 final BigInteger fac = new BigInteger();
211 UnivPowerSeriesRing<BigInteger> pfac = new UnivPowerSeriesRing<BigInteger>(fac);
212 UnivPowerSeries<BigInteger> integers = integersFrom(0);
213 System.out.println(" integers = " + integers);
214 UnivPowerSeries<BigInteger> ONE = new UnivPowerSeries<BigInteger>(pfac,
215 new Coefficients<BigInteger>() {
216
217
218 @Override
219 public BigInteger generate(int i) {
220 if (i == 0) {
221 return fac.getONE();
222 }
223 return fac.getZERO();
224 }
225 }//, null
226 );
227 System.out.println("ONE = " + ONE);
228 UnivPowerSeries<BigInteger> ZERO = new UnivPowerSeries<BigInteger>(pfac,
229 new Coefficients<BigInteger>() {
230
231
232 @Override
233 public BigInteger generate(int i) {
234 return fac.getZERO();
235 }
236 }//, null
237 );
238 System.out.println("ZERO = " + ZERO);
239 UnivPowerSeries<BigInteger> ints = integers.multiply(ONE);
240 System.out.println("integers = " + ints);
241 UnivPowerSeries<BigInteger> nulls = integers.multiply(ZERO);
242 System.out.println("null integers = " + nulls);
243 UnivPowerSeries<BigInteger> nints = integers.negate();
244 System.out.println("-integers = " + nints);
245 UnivPowerSeries<BigInteger> one = ONE.multiply(ONE);
246 System.out.println("integers one = " + one);
247 UnivPowerSeries<BigInteger> ints2 = integers.multiply(integers);
248 System.out.println("integers 2 = " + ints2);
249 UnivPowerSeries<BigInteger> inv1 = ONE.inverse();
250 System.out.println("integers inv1 = " + inv1);
251 UnivPowerSeries<BigInteger> int1 = integers.reductum();
252 System.out.println("integers int1 = " + int1);
253 UnivPowerSeries<BigInteger> intinv = int1.inverse();
254 System.out.println("integers intinv = " + intinv);
255 UnivPowerSeries<BigInteger> one1 = int1.multiply(intinv);
256 System.out.println("integers one1 = " + one1);
257 UnivPowerSeries<BigInteger> ii = intinv.inverse();
258 System.out.println("integers ii = " + ii);
259 UnivPowerSeries<BigInteger> rem = integers.subtract(integers.divide(int1).multiply(int1));
260 System.out.println("integers rem = " + rem);
261 }
262
263
264 public static void example11() {
265 //final BigInteger fac = new BigInteger();
266 UnivPowerSeries<BigInteger> integers = integersFrom(0);
267 System.out.println(" integers = " + integers);
268 UnivPowerSeries<BigInteger> int2 = integers.multiply(new BigInteger(2));
269 System.out.println(" 2*integers = " + int2);
270 System.out.println("integers < 2*integers = " + integers.compareTo(int2));
271 System.out.println("2*integers > integers = " + int2.compareTo(integers));
272 System.out.println("2*integers == integers = " + int2.equals(integers));
273 System.out.println("integers == integers = " + integers.equals(integers));
274 System.out.println("integers.hashCode() = " + integers.hashCode());
275 }
276
277
278 public static void example5() {
279 //final BigInteger fac = new BigInteger();
280 //UnivPowerSeriesRing<BigInteger> pfac = new UnivPowerSeriesRing<BigInteger>(fac);
281 UnivPowerSeries<BigInteger> integers = integersFrom(0);
282 System.out.println(" integers = " + integers);
283 UnivPowerSeries<BigInteger> ints2 = integers.multiply(integers);
284 System.out.println("integers 2 = " + ints2);
285
286 UnivPowerSeries<BigInteger> q1 = ints2.divide(integers);
287 System.out.println("q1 = " + q1);
288 UnivPowerSeries<BigInteger> q2 = integers.divide(ints2);
289 System.out.println("q2 = " + q2);
290
291 UnivPowerSeries<BigInteger> r1 = ints2.remainder(integers);
292 System.out.println("r1 = " + r1);
293 UnivPowerSeries<BigInteger> r2 = integers.remainder(ints2);
294 System.out.println("r2 = " + r2);
295
296 UnivPowerSeries<BigInteger> qr1 = q1.multiply(integers).sum(r1);
297 System.out.println("qr1 = " + qr1);
298 UnivPowerSeries<BigInteger> qr2 = q2.multiply(ints2).sum(r2);
299 System.out.println("qr2 = " + qr2);
300
301 System.out.println("sign(qr1-ints2) = " + qr1.compareTo(ints2));
302 System.out.println("sign(qr2-integers) = " + qr2.compareTo(integers));
303
304 UnivPowerSeries<BigInteger> g = ints2.gcd(integers);
305 System.out.println("g = " + g);
306 }
307
308
309 public static void example7() {
310 final BigRational fac = new BigRational();
311 final UnivPowerSeriesRing<BigRational> pfac = new UnivPowerSeriesRing<BigRational>(fac, 11, "y");
312 UnivPowerSeries<BigRational> exp = pfac.fixPoint(new UnivPowerSeriesMap<BigRational>() {
313
314
315 public UnivPowerSeries<BigRational> map(UnivPowerSeries<BigRational> e) {
316 return e.integrate(fac.getONE());
317 }
318 });
319 System.out.println("exp = " + exp);
320 UnivPowerSeries<BigRational> tan = pfac.fixPoint(new UnivPowerSeriesMap<BigRational>() {
321
322
323 public UnivPowerSeries<BigRational> map(UnivPowerSeries<BigRational> t) {
324 return t.multiply(t).sum(pfac.getONE()).integrate(fac.getZERO());
325 }
326 });
327 System.out.println("tan = " + tan);
328 UnivPowerSeries<BigRational> sin = new UnivPowerSeries<BigRational>(pfac,
329 new Coefficients<BigRational>() {
330
331
332 @Override
333 public BigRational generate(int i) {
334 BigRational c;
335 if (i == 0) {
336 c = fac.getZERO();
337 } else if (i == 1) {
338 c = fac.getONE();
339 } else {
340 c = get(i - 2).negate();
341 c = c.divide(fac.fromInteger(i)).divide(fac.fromInteger(i - 1));
342 }
343 return c;
344 }
345 });
346 System.out.println("sin = " + sin);
347 UnivPowerSeries<BigRational> sin1 = pfac.fixPoint(new UnivPowerSeriesMap<BigRational>() {
348
349
350 public UnivPowerSeries<BigRational> map(UnivPowerSeries<BigRational> e) {
351 return e.negate().integrate(fac.getONE()).integrate(fac.getZERO());
352 }
353 });
354 System.out.println("sin1 = " + sin1);
355
356 UnivPowerSeries<BigRational> cos = new UnivPowerSeries<BigRational>(pfac,
357 new Coefficients<BigRational>() {
358
359
360 @Override
361 public BigRational generate(int i) {
362 BigRational c;
363 if (i == 0) {
364 c = fac.getONE();
365 } else if (i == 1) {
366 c = fac.getZERO();
367 } else {
368 c = get(i - 2).negate();
369 c = c.divide(fac.fromInteger(i)).divide(fac.fromInteger(i - 1));
370 }
371 return c;
372 }
373 });
374 System.out.println("cos = " + cos);
375 UnivPowerSeries<BigRational> cos1 = pfac.fixPoint(new UnivPowerSeriesMap<BigRational>() {
376
377
378 public UnivPowerSeries<BigRational> map(UnivPowerSeries<BigRational> e) {
379 return e.negate().integrate(fac.getZERO()).integrate(fac.getONE());
380 }
381 });
382 System.out.println("cos1 = " + cos1);
383
384 UnivPowerSeries<BigRational> cos2 = pfac.solveODE(sin1.negate(), fac.getONE());
385 System.out.println("cos2 = " + cos2);
386
387 UnivPowerSeries<BigRational> sin2 = pfac.solveODE(cos1, fac.getZERO());
388 System.out.println("sin2 = " + sin2);
389
390 UnivPowerSeries<BigRational> sinh = new UnivPowerSeries<BigRational>(pfac,
391 new Coefficients<BigRational>() {
392
393
394 @Override
395 public BigRational generate(int i) {
396 BigRational c;
397 if (i == 0) {
398 c = fac.getZERO();
399 } else if (i == 1) {
400 c = fac.getONE();
401 } else {
402 c = get(i - 2);
403 c = c.divide(fac.fromInteger(i)).divide(fac.fromInteger(i - 1));
404 }
405 return c;
406 }
407 });
408 System.out.println("sinh = " + sinh);
409 UnivPowerSeries<BigRational> cosh = new UnivPowerSeries<BigRational>(pfac,
410 new Coefficients<BigRational>() {
411
412
413 @Override
414 public BigRational generate(int i) {
415 BigRational c;
416 if (i == 0) {
417 c = fac.getONE();
418 } else if (i == 1) {
419 c = fac.getZERO();
420 } else {
421 c = get(i - 2);
422 c = c.divide(fac.fromInteger(i)).divide(fac.fromInteger(i - 1));
423 }
424 return c;
425 }
426 }//, null
427 );
428 System.out.println("cosh = " + cosh);
429
430 UnivPowerSeries<BigRational> sinhcosh = sinh.sum(cosh);
431 System.out.println("sinh+cosh = " + sinhcosh);
432 System.out.println("sinh+cosh == exp: " + sinhcosh.equals(exp));
433 }
434
435
436 public static void example12() {
437 final BigComplex fac = new BigComplex();
438 final BigComplex I = BigComplex.I;
439 final UnivPowerSeriesRing<BigComplex> pfac = new UnivPowerSeriesRing<BigComplex>(fac);
440 UnivPowerSeries<BigComplex> exp = pfac.fixPoint(new UnivPowerSeriesMap<BigComplex>() {
441
442
443 public UnivPowerSeries<BigComplex> map(UnivPowerSeries<BigComplex> e) {
444 return e.integrate(I);
445 }
446 });
447 System.out.println("exp = " + exp);
448
449 UnivPowerSeries<BigComplex> sin = pfac.fixPoint(new UnivPowerSeriesMap<BigComplex>() {
450
451
452 public UnivPowerSeries<BigComplex> map(UnivPowerSeries<BigComplex> e) {
453 return e.negate().integrate(fac.getONE()).integrate(fac.getZERO());
454 }
455 });
456 System.out.println("sin = " + sin);
457
458 UnivPowerSeries<BigComplex> cos = pfac.fixPoint(new UnivPowerSeriesMap<BigComplex>() {
459
460
461 public UnivPowerSeries<BigComplex> map(UnivPowerSeries<BigComplex> e) {
462 return e.negate().integrate(fac.getZERO()).integrate(fac.getONE());
463 }
464 });
465 System.out.println("cos = " + cos);
466
467 UnivPowerSeries<BigComplex> cpis = cos.sum(sin.multiply(I));
468 System.out.println("cpis = " + cpis);
469 }
470
471
472 public static void example13() {
473 BigRational fac = new BigRational();
474 UnivPowerSeriesRing<BigRational> pfac = new UnivPowerSeriesRing<BigRational>(fac, 11, "y");
475 UnivPowerSeries<BigRational> exp = pfac.getEXP();
476 System.out.println("exp = " + exp);
477 System.out.println("exp(1) = " + exp.evaluate(fac.getONE()));
478 System.out.println("exp(0) = " + exp.evaluate(fac.getZERO()));
479
480 BigDecimal dfac = new BigDecimal();
481 UnivPowerSeriesRing<BigDecimal> dpfac = new UnivPowerSeriesRing<BigDecimal>(dfac, 11, "z");
482 UnivPowerSeries<BigDecimal> dexp = dpfac.getEXP();
483 System.out.println("exp = " + dexp);
484 System.out.println("exp(1) = " + dexp.evaluate(dfac.getONE()));
485 System.out.println("exp(0) = " + dexp.evaluate(dfac.getZERO()));
486 }
487
488 }