Safe Haskell	None
Language	Haskell2010

Synthesizer.Storable.Signal

Description

Chunky signal stream build on StorableVector.

Hints for fusion: - Higher order functions should always be inlined in the end in order to turn them into machine loops instead of calling a function in an inner loop.

Synopsis

type T = Vector
hPut :: Storable a => Handle -> Vector a -> IO ()
data ChunkSize
chunkSize :: Int -> ChunkSize
defaultChunkSize :: ChunkSize
scanL :: (Storable a, Storable b) => (a -> b -> a) -> a -> T b -> T a
map :: (Storable x, Storable y) => (x -> y) -> Vector x -> Vector y
iterate :: Storable a => ChunkSize -> (a -> a) -> a -> Vector a
zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c
append :: Storable a => Vector a -> Vector a -> Vector a
concat :: Storable a => [Vector a] -> Vector a
span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a)
splitAt :: Storable a => Int -> Vector a -> (Vector a, Vector a)
viewL :: Storable a => Vector a -> Maybe (a, Vector a)
viewR :: Storable a => Vector a -> Maybe (Vector a, a)
switchL :: Storable a => b -> (a -> Vector a -> b) -> Vector a -> b
unfoldr :: Storable b => ChunkSize -> (a -> Maybe (b, a)) -> a -> Vector b
reverse :: Storable a => Vector a -> Vector a
crochetL :: (Storable x, Storable y) => (x -> acc -> Maybe (y, acc)) -> acc -> Vector x -> Vector y
writeFile :: Storable a => FilePath -> Vector a -> IO ()
mix :: (C x, Storable x) => T x -> T x -> T x
mixSndPattern :: (C x, Storable x) => T x -> T x -> T x
mixSize :: (C x, Storable x) => ChunkSize -> T x -> T x -> T x
splitAtPad :: (C x, Storable x) => ChunkSize -> Int -> T x -> (T x, T x)
null :: Storable a => Vector a -> Bool
fromChunks :: Storable a => [Vector a] -> Vector a
foldr :: Storable b => (b -> a -> a) -> a -> Vector b -> a
delay :: Storable y => ChunkSize -> y -> Int -> T y -> T y
delayLoop :: Storable y => (T y -> T y) -> T y -> T y
delayLoopOverlap :: (C y, Storable y) => Int -> (T y -> T y) -> T y -> T y
empty :: Storable a => Vector a
cons :: Storable a => a -> Vector a -> Vector a
replicate :: Storable a => ChunkSize -> Int -> a -> Vector a
repeat :: Storable a => ChunkSize -> a -> Vector a
drop :: Storable a => Int -> Vector a -> Vector a
take :: Storable a => Int -> Vector a -> Vector a
takeCrochet :: Storable a => Int -> T a -> T a
fromList :: Storable a => ChunkSize -> [a] -> T a
zipWithRest :: (Storable c, Storable x) => (x -> x -> c) -> T x -> T x -> (Vector c, (Bool, T x))
zipWithAppend :: Storable x => (x -> x -> x) -> T x -> T x -> T x
switchR :: Storable a => b -> (Vector a -> a -> b) -> Vector a -> b
toList :: Storable a => T a -> [a]
chunks :: Vector a -> [Vector a]
genericLength :: C i => T x -> i

Documentation

type T = Vector Source #

hPut :: Storable a => Handle -> Vector a -> IO () #

data ChunkSize #

Instances

Eq ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods (==) :: ChunkSize -> ChunkSize -> Bool # (/=) :: ChunkSize -> ChunkSize -> Bool #
Num ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods (+) :: ChunkSize -> ChunkSize -> ChunkSize # (-) :: ChunkSize -> ChunkSize -> ChunkSize # (*) :: ChunkSize -> ChunkSize -> ChunkSize # negate :: ChunkSize -> ChunkSize # abs :: ChunkSize -> ChunkSize # signum :: ChunkSize -> ChunkSize # fromInteger :: Integer -> ChunkSize #
Ord ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods compare :: ChunkSize -> ChunkSize -> Ordering # (<) :: ChunkSize -> ChunkSize -> Bool # (<=) :: ChunkSize -> ChunkSize -> Bool # (>) :: ChunkSize -> ChunkSize -> Bool # (>=) :: ChunkSize -> ChunkSize -> Bool # max :: ChunkSize -> ChunkSize -> ChunkSize # min :: ChunkSize -> ChunkSize -> ChunkSize #
Show ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods showsPrec :: Int -> ChunkSize -> ShowS # show :: ChunkSize -> String # showList :: [ChunkSize] -> ShowS #
Semigroup ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods (<>) :: ChunkSize -> ChunkSize -> ChunkSize # sconcat :: NonEmpty ChunkSize -> ChunkSize # stimes :: Integral b => b -> ChunkSize -> ChunkSize #
Monoid ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods mempty :: ChunkSize # mappend :: ChunkSize -> ChunkSize -> ChunkSize # mconcat :: [ChunkSize] -> ChunkSize #
Arbitrary ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods arbitrary :: Gen ChunkSize # shrink :: ChunkSize -> [ChunkSize] #
C ChunkSize
Instance details Defined in Data.StorableVector.Lazy Methods split :: ChunkSize -> ChunkSize -> (ChunkSize, (Bool, ChunkSize)) #

chunkSize :: Int -> ChunkSize #

defaultChunkSize :: ChunkSize Source #

scanL :: (Storable a, Storable b) => (a -> b -> a) -> a -> T b -> T a Source #

map :: (Storable x, Storable y) => (x -> y) -> Vector x -> Vector y #

iterate :: Storable a => ChunkSize -> (a -> a) -> a -> Vector a #

zipWith :: (Storable a, Storable b, Storable c) => (a -> b -> c) -> Vector a -> Vector b -> Vector c #

Generates laziness breaks wherever one of the input signals has a chunk boundary.

append :: Storable a => Vector a -> Vector a -> Vector a infixr 5 #

concat :: Storable a => [Vector a] -> Vector a #

span :: Storable a => (a -> Bool) -> Vector a -> (Vector a, Vector a) #

splitAt :: Storable a => Int -> Vector a -> (Vector a, Vector a) #

viewL :: Storable a => Vector a -> Maybe (a, Vector a) #

viewR :: Storable a => Vector a -> Maybe (Vector a, a) #

switchL :: Storable a => b -> (a -> Vector a -> b) -> Vector a -> b #

unfoldr :: Storable b => ChunkSize -> (a -> Maybe (b, a)) -> a -> Vector b #

reverse :: Storable a => Vector a -> Vector a #

crochetL :: (Storable x, Storable y) => (x -> acc -> Maybe (y, acc)) -> acc -> Vector x -> Vector y #

writeFile :: Storable a => FilePath -> Vector a -> IO () #

mix :: (C x, Storable x) => T x -> T x -> T x Source #

This implementation generates laziness breaks whereever one of the original sequences has laziness breaks. It should be commutative in this respect.

It is more efficient than mixSize since it appends the rest of the longer signal without copying.

mixSndPattern :: (C x, Storable x) => T x -> T x -> T x Source #

Mix while maintaining the pattern of the second operand. This is closer to the behavior of Vector.zipWithLastPattern.

mixSize :: (C x, Storable x) => ChunkSize -> T x -> T x -> T x Source #

splitAtPad :: (C x, Storable x) => ChunkSize -> Int -> T x -> (T x, T x) Source #

null :: Storable a => Vector a -> Bool #

fromChunks :: Storable a => [Vector a] -> Vector a #

foldr :: Storable b => (b -> a -> a) -> a -> Vector b -> a #

delay :: Storable y => ChunkSize -> y -> Int -> T y -> T y Source #

delayLoop Source #

Arguments

:: Storable y
=> (T y -> T y)	processor that shall be run in a feedback loop
-> T y	prefix of the output, its length determines the delay
-> T y

delayLoopOverlap Source #

Arguments

:: (C y, Storable y)
=> Int
-> (T y -> T y)	Processor that shall be run in a feedback loop. It's absolutely necessary that this function preserves the chunk structure and that it does not look a chunk ahead. That's guaranteed for processes that do not look ahead at all, like `map`, `crochetL` and all of type `Causal.Process`.
-> T y	input
-> T y	output has the same length as the input

empty :: Storable a => Vector a #

cons :: Storable a => a -> Vector a -> Vector a #

replicate :: Storable a => ChunkSize -> Int -> a -> Vector a #

repeat :: Storable a => ChunkSize -> a -> Vector a #

drop :: Storable a => Int -> Vector a -> Vector a #

take :: Storable a => Int -> Vector a -> Vector a #

takeCrochet :: Storable a => Int -> T a -> T a Source #

fromList :: Storable a => ChunkSize -> [a] -> T a Source #

zipWithRest :: (Storable c, Storable x) => (x -> x -> c) -> T x -> T x -> (Vector c, (Bool, T x)) Source #

zipWithAppend :: Storable x => (x -> x -> x) -> T x -> T x -> T x Source #

switchR :: Storable a => b -> (Vector a -> a -> b) -> Vector a -> b #

toList :: Storable a => T a -> [a] Source #

chunks :: Vector a -> [Vector a] #

genericLength :: C i => T x -> i Source #