Feldspar.Stream

Documentation

data Stream a

Infinite streams.

Instances

RandomAccess (Stream a)

head :: Computable a => Stream a -> a

Take the first element of a stream

tail :: Computable a => Stream a -> Stream a

Drop the first element of a stream

map :: (Computable a, Computable b) => (a -> b) -> Stream a -> Stream b

'map f str' transforms every element of the stream str using the function f

intersperse :: a -> Stream a -> Stream a

'intersperse a str' inserts an a between each element of the stream str.

interleave :: Stream a -> Stream a -> Stream a

Create a new stream by alternating between the elements from the two input streams

scan :: Computable a => (a -> b -> a) -> a -> Stream b -> Stream a

'scan f a str' produces a stream by successively applying f to each element of the input stream str and the previous element of the output stream.

mapAccum :: (Computable acc, Computable b) => (acc -> a -> (acc, b)) -> acc -> Stream a -> Stream b

Maps a function over a stream using an accumulator.

iterate :: Computable a => (a -> a) -> a -> Stream a

Iteratively applies a function to a starting element. All the successive results are used to create a stream.

iterate f a == [a, f a, f (f a), f (f (f a)) ...]

repeat :: Computable a => a -> Stream a

Repeat an element indefinitely.

repeat a = [a, a, a, ...]

unfold :: (Computable a, Computable c) => (c -> (a, c)) -> c -> Stream a

unfold f acc creates a new stream by successively applying f to to the accumulator acc.

drop :: Data Unsigned32 -> Stream a -> Stream a

Drop a number of elements from the front of a stream

dropWhile :: (t -> Data Bool) -> Stream t -> Stream t

filter :: (a -> Data Bool) -> Stream a -> Stream a

dropWhile p str drops element from the stream str as long as the elements fulfill the predicate p.

'filter p str' removes elements from the stream str if they are false according to the predicate p

partition :: (a -> Data Bool) -> Stream a -> (Stream a, Stream a)

Splits a stream in two according to the predicate function. All elements which return true go in the first stream, the rest go in the second.

zip :: Stream a -> Stream b -> Stream (a, b)

Pairs together two streams into one.

zipWith :: Computable c => (a -> b -> c) -> Stream a -> Stream b -> Stream c

Pairs together two streams using a function to combine the corresponding elements.

unzip :: (Computable a, Computable b) => Stream (a, b) -> (Stream a, Stream b)

Given a stream of pairs, split it into two stream.

take :: Storable a => Data Int -> Stream (Data a) -> Data [a]

'take n str' allocates n elements from the stream str into a core array.

splitAt :: Storable a => Data Int -> Stream (Data a) -> (Data [a], Stream (Data a))

'splitAt n str' allocates n elements from the stream str into a core array and returns the rest of the stream continuing from element 'n+1'.

cycle :: Computable a => Vector a -> Stream a

Loops through a vector indefinitely to produce a stream.

recurrence :: Storable a => DVector a -> ((Int -> Data a) -> Data a) -> Stream (Data a)

A combinator for descibing recurrence equations, or feedback loops. It uses memory proportional to the input vector

For exaple one can define the fibonacci sequence as follows:

 fib = recurrence (vector [0,1]) (\fib -> fib 1 + fib 2)

The expressions fib 1 and fib 2 refer to previous elements in the stream defined one step back and two steps back respectively.

recurrenceI :: (Storable a, Storable b) => DVector a -> Stream (Data a) -> DVector b -> ((Data Int -> Data a) -> (Data Int -> Data b) -> Data b) -> Stream (Data b)

A recurrence combinator with input

The sliding average of a stream can easily be implemented using recurrenceI.

 slidingAvg :: Data Int -> Stream (Data Int) -> Stream (Data Int)
 slidingAvg n str = recurrenceI (replicate n 0) str (vector [])
                    (\input _ -> sum (indexed n input) `quot` n)

iir :: Data Float -> DVector Float -> DVector Float -> Stream (Data Float) -> Stream (Data Float)

An iir filter on streams

fir :: DVector Float -> Stream (Data Float) -> Stream (Data Float)

A fir filter on streams