4th International Conference on Principles and Practices ... - MADOC

of the f stream in order to compute the head element of the
resulting stream.
With the alternative map
f ibs → (+ (0 : f ibs) (0 : (1 : f ibs)))
the fixed point can be computed with both implementations.
The two head elements which are accessed in the zip function
within class LinkedStream are defined.
Stream fibonacci = fixedPoint(
new StreamMap() {
public Stream map(Stream f){
return f.prepend(0).zip(new Add(),
f.prepend(1).prepend(0));
}
}
);
If we print out the stream fibonacci we receive the following
result:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 ...
One advantage of fixed point definitions is that the recursively
referenced data structure is not reevaluated (in contrast
to the definition with methods which are recursively
called in the lazily evaluated part as shown in sections 2 and
3). This leads to more efficient programs than those where
a stream is reconstructed by a method call [7].
5. INFINITE POWER SERIES
In order to apply the streams derived in this article we define
infinite power series, i.e. power series where any number
of terms can be asked. This is useful because the number of
terms required is often not known in advance.
Infinite power series use a stream to store their coefficients.
It turns out, that many series operations have extremely
simple implementations when using lazy evaluation
and fixed point definitions.
The interface of class PowerSeries is shown below. The
rational coefficients are implemented in class Rational. With
the methods diff and integrate a series can be differentiated
and integrated. The integration constant can be provided
as an optional parameter. The shift method allows
to multiply a power series with the factor x (and to add a
constant term).
public interface PowerSeries {
}
public Rational coeff(int index);
public PowerSeries add(PowerSeries value);
public PowerSeries subtract(PowerSeries value);
public PowerSeries negate();
public PowerSeries multiply(Rational value);
public PowerSeries multiply(PowerSeries value);
public PowerSeries divide(PowerSeries value);
public PowerSeries diff();
public PowerSeries integrate();
public PowerSeries integrate(Rational c);
public PowerSeries shift(Rational c);
In the implementing class the coefficients are stored in the
field coefficients of type ArrayStream. As an
example we show the method integrate which integrates a
power series term by term.
public PowerSeries integrate(final Rational c){
return new PowerSeries(
new ArrayStream(
new ArrayStream.Coefficients(){
public Rational get(int k){
if(k==0) return c;
else return coeff(k-1).divide(
new Rational(k)
);
}
}
)
);
}
Moreover, the power series class also defines a fixedpoint
method which allows to define power series as fixed points
of a power series map.
interface PowerSeriesMap {
PowerSeries map(PowerSeries series);
}
public PowerSeries fixedpoint(PowerSeriesMap map){
PowerSeries s1 = new PowerSeries();
PowerSeries s2 = map.map(s1);
s1.coefficients = s2.coefficients;
return s2;
}
The fixedpoint method works as long as all methods
used in the power series map do not access the coefficients
field in an eagerly evaluated part. For example, the multiply
method which scales a power series which a rational number
must not call the map function on the coefficients but rather
has to define a new coefficient function.
As an example we define the power series for exp(x). The
equation
exp(x) =
Z
exp(x) dx + exp(0)
can directly be used to define the exponential series at x = 0
using a fixed point:
PowerSeries exp = PowerSeries.fixedpoint(
new PowerSeriesMap(){
public PowerSeries map(PowerSeries exp){
return exp.integrate(Rational.ONE);
}
}
);
System.out.println(exp);
=> 1 + x + 1/2 x^2 + 1/6 x^3 + 1/24 x^4 + O(x^5)
As another example we show the definition of the power
series for tan(x) which is the fixed point of the map
tan(x) →
Z
1 + tan(x)
2¡
dx
which leads to the following definition in Java:
PowerSeries tan = fixedpoint(
new PowerSeriesMap(){
public PowerSeries map(PowerSeries tan){
return tan.multiply(tan)
.add(new PowerSeries(Rational.ONE))
.integrate();
}
}
);
System.out.println(tan.toString(9));
=> x + 1/3 x^3 + 2/15 x^5 + 17/315 x^7 + O(x^9)
186