- data Stream a
- head :: Computable a => Stream a -> a
- tail :: Computable a => Stream a -> Stream a
- map :: (Computable a, Computable b) => (a -> b) -> Stream a -> Stream b
- intersperse :: a -> Stream a -> Stream a
- interleave :: Stream a -> Stream a -> Stream a
- scan :: Computable a => (a -> b -> a) -> a -> Stream b -> Stream a
- mapAccum :: (Computable acc, Computable b) => (acc -> a -> (acc, b)) -> acc -> Stream a -> Stream b
- iterate :: Computable a => (a -> a) -> a -> Stream a
- repeat :: Computable a => a -> Stream a
- unfold :: (Computable a, Computable c) => (c -> (a, c)) -> c -> Stream a
- drop :: Data Unsigned32 -> Stream a -> Stream a
- dropWhile :: (t -> Data Bool) -> Stream t -> Stream t
- filter :: (a -> Data Bool) -> Stream a -> Stream a
- partition :: (a -> Data Bool) -> Stream a -> (Stream a, Stream a)
- zip :: Stream a -> Stream b -> Stream (a, b)
- zipWith :: Computable c => (a -> b -> c) -> Stream a -> Stream b -> Stream c
- unzip :: (Computable a, Computable b) => Stream (a, b) -> (Stream a, Stream b)
- take :: Storable a => Data Int -> Stream (Data a) -> Data [a]
- splitAt :: Storable a => Data Int -> Stream (Data a) -> (Data [a], Stream (Data a))
- cycle :: Computable a => Vector a -> Stream a
- recurrence :: Storable a => DVector a -> ((Int -> Data a) -> Data a) -> Stream (Data a)
- 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)
- iir :: Data Float -> DVector Float -> DVector Float -> Stream (Data Float) -> Stream (Data Float)
- fir :: DVector Float -> Stream (Data Float) -> Stream (Data Float)

# Documentation

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

Take the first element of a stream

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

Drop the first element of a stream

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

'map f str' transforms every element of the stream `str`

using the
function `f`

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

'intersperse a str' inserts an `a`

between each element of the stream
`str`

.

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

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

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

'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 bSource

Maps a function over a stream using an accumulator.

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

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 aSource

Repeat an element indefinitely.

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

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

`unfold f acc`

creates a new stream by successively applying `f`

to
to the accumulator `acc`

.

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

Drop a number of elements from the front of a stream

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

`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)Source

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.

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

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

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

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

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

'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))Source

'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 aSource

Loops through a vector indefinitely to produce a stream.

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

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)Source

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)