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.
- 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
data ChunkSize
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.
mix :: (C x, Storable x) => T x -> T x -> T xSource
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 xSource
Mix while maintaining the pattern of the second operand. This is closer to the behavior of Vector.zipWithLastPattern.
fromChunks :: Storable a => [Vector a] -> Vector a
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 |
| -> T y | input |
| -> T y | output has the same length as the input |
zipWithRest :: (Storable c, Storable x) => (x -> x -> c) -> T x -> T x -> (Vector c, (Bool, T x))Source
genericLength :: C i => T x -> iSource