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

}
private static LinkedStream fibonacci(
final int a, final int b){
return new LinkedStream(
a,
new LinkedStream.LazyTail () {
public LinkedStream eval(){
return fibonacci(b, a+b);
}
}
);
}
public static void main(String[] args) {
Stream integers = integersFrom(0);
System.out.println(integers);
}
Stream squares = integers.map(
new Stream.UnaryFunctor(){
public Integer eval(Integer x){
return x*x;
}
}
);
System.out.println(squares);
Stream fibonaccy = fibonacci(0, 1);
System.out.println(fibonaccy);
This program generates the following output:
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ...
0 1 4 9 16 25 36 49 64 81 100 121 144 169 196 ...
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 ...
3. ARRAY STREAMS
In class LinkedStream an infinite stream is represented
as a linked list. Accessing the n th element requires O(n)
operations. An alternative would be to store the stream elements
in an array or a hash table where they can be accessed
in constant time. This is how array lists are implemented
in the Java collection framework. This strategy can also
be applied to infinite streams. Instead of a functor for the
computation of the remainder of a stream a functor for the
computation of the n th term of the stream is provided.
We present a simple implementation of this approach.
Class ArrayStream contains only a minimal set of methods;
additional methods of the Stream interface are discussed below.
import java.util.HashMap;
public class ArrayStream implements Stream {
public interface Coefficients {
E get(int index);
}
private Coefficients lazyCoeff;
private HashMap coeff =
new HashMap();
public ArrayStream(Coefficients lazyCoeff){
if(lazyCoeff == null) throw
new IllegalArgumentException();
this.lazyCoeff = lazyCoeff;
}
public E get(int index){
if (index < 0) yhrow new
IndexOutOfBoundsException("negative index");
Integer n = index;
}
}
if(!coeff.containsKey(n))
coeff.put(n, lazyCoeff.get(index));
return coeff.get(n);
public E getHead(){ return get(0); }
public ArrayStream getTail(){
return new ArrayStream(
new Coefficients(){
public E get(int index){
return ArrayStream.this.get(index+1);
}
}
);
}
Method get first checks whether the requested term of the
stream has already be computed. If not, it is computed with
the provided coefficient method. getHead simply returns the
first term, and getTail constructs a new ArrayStream which
returns the terms shifted by one. Note, that the terms of
the tail stream are stored in that stream’s coefficient map
as well. This waste of storage could be avoided (at the cost
of an additional method call) with a no-cache flag added to
class ArrayStream.
We present the implementation of two additional methods
of the Stream interface. The prepend method defines a new
coefficient method which returns the new head element and
the terms of the original stream shifted by one. In contrast
to the prepend method of LinkedStream the evaluation of
the head element of the this stream is not forced.
public Stream prepend(final E head){
return new ArrayStream(
new Coefficients(){
public E get(int index){
if(index == 0) return head;
else return ArrayStream.this.get(index-1);
}
}
);
}
The select function is more tricky for array streams than
for linked streams. If the k th element is accessed, the elements
with index 0 up to k − 1 already have to be known.
This is ensured in the implementation below by accessing
the directly preceding element which is either taken out of
the hash map or computed. Moreover, the coefficient procedure
has to maintain an index into the original stream.
public Stream select(final Selector< super E> s){
final ArrayStream stream = new ArrayStream();
stream.lazyCoeff = new Coefficients(){
int pos = 0;
public E get(int index){
if(index > 0) stream.get(index-1);
E x = null;
do {x = ArrayStream.this.get(pos++);}
while(!s.select(x));
return x;
}
};
return stream;
}
Unfortunately, the use of select operations leads to deeper
recursion levels with this stream representation and may end
earlier in a StackOverflowError. Moreover, random access
is not used in typical stream applications.
184