Source code

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