001/*
002 * $Id: Examples.java 3987 2012-07-14 11:58:20Z kredel $
003 */
004
005package edu.jas.ps;
006
007
008import edu.jas.arith.BigComplex;
009import edu.jas.arith.BigDecimal;
010import edu.jas.arith.BigInteger;
011import edu.jas.arith.BigRational;
012import edu.jas.structure.BinaryFunctor;
013import edu.jas.structure.RingElem;
014import edu.jas.structure.RingFactory;
015import edu.jas.structure.Selector;
016import edu.jas.structure.UnaryFunctor;
017
018
019/**
020 * Examples for univariate power series implementations.
021 * @author Heinz Kredel
022 */
023
024public 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 = this.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}