Synthesizer.LLVM.Causal.Process

Documentation

class (C process, C (SignalOf process)) => C process where

Methods

simple :: C state => (forall r c. Phi c => a -> state -> T r c (b, state)) -> (forall r. CodeGenFunction r state) -> process a b

replicateControlled :: (Undefined x, Phi x) => Int -> process (c, x) x -> process (c, x) x

Instances

C T

C (T p)

data T a b

Instances

Arrow T

Category T

C T

C T

Functor (T a)

Applicative (T a)

(Field b, Real b, RationalConstant b) => Fractional (T a b)

(PseudoRing b, Real b, IntegerConstant b) => Num (T a b)

(Field b, RationalConstant b) => C (T a b)

(PseudoRing b, IntegerConstant b) => C (T a b)

Additive b => C (T a b)

amplify :: (C process, IsArithmetic a, IsConst a) => a -> process (Value a) (Value a)

amplifyStereo :: (C process, IsArithmetic a, IsConst a) => a -> process (T (Value a)) (T (Value a))

apply :: T a b -> T a -> T b

applyFst :: T (a, b) c -> T a -> T b c

applySnd :: T (a, b) c -> T b -> T a c

applyConst :: (MakeValueTuple a, ValueTuple a ~ al) => T al b -> a -> T b

applyConstFst :: (MakeValueTuple a, ValueTuple a ~ al) => T (al, b) c -> a -> T b c

applyConstSnd :: (MakeValueTuple b, ValueTuple b ~ bl) => T (a, bl) c -> b -> T a c

($<) :: C process => process (a, b) c -> SignalOf process a -> process b c

($>) :: C process => process (a, b) c -> SignalOf process b -> process a c

($*) :: C process => process a b -> SignalOf process a -> SignalOf process b

($<#) :: (C process, Storable ah, MakeValueTuple ah, ValueTuple ah ~ a, C a) => process (a, b) c -> ah -> process b c

($>#) :: (C process, Storable bh, MakeValueTuple bh, ValueTuple bh ~ b, C b) => process (a, b) c -> bh -> process a c

($*#) :: (C process, SignalOf process ~ signal, Storable ah, MakeValueTuple ah, ValueTuple ah ~ a, C a) => process a b -> ah -> signal b

provide constant input in a comfortable way

feedFst :: T a -> T b (a, b)

feedSnd :: T a -> T b (b, a)

feedConstFst :: (MakeValueTuple a, ValueTuple a ~ al) => a -> T b (al, b)

feedConstSnd :: (MakeValueTuple a, ValueTuple a ~ al) => a -> T b (b, al)

first :: C process => process b c -> process (b, d) (c, d)

envelope :: (C process, PseudoRing a) => process (a, a) a

You may also use '(*)'.

envelopeStereo :: (C process, PseudoRing a) => process (a, T a) (T a)

fromModifier :: C process => (Flatten ah, Registers ah ~ al, Flatten bh, Registers bh ~ bl, Flatten ch, Registers ch ~ cl, Flatten sh, Registers sh ~ sl, C sl) => Simple sh ch ah bh -> process (cl, al) bl

fromSignal :: T b -> T a b

toSignal :: T () a -> T a

loopConst :: (C process, C c) => c -> process (a, c) (b, c) -> process a b

loopZero :: (C process, Additive c, C c) => process (a, c) (b, c) -> process a b

Like loop but uses zero as initial value and it does not need a zero as Haskell value.

delay1Zero :: (C process, Additive a, C a) => process a a

feedbackControlledZero :: (C process, Additive c, C c) => process ((ctrl, a), c) b -> process (ctrl, b) c -> process (ctrl, a) b

map :: C process => (forall r. a -> CodeGenFunction r b) -> process a b

mapAccum :: (C process, C state) => (forall r. a -> state -> CodeGenFunction r (b, state)) -> (forall r. CodeGenFunction r state) -> process a b

zipWith :: C process => (forall r. a -> b -> CodeGenFunction r c) -> process (a, b) c

mapProc :: C process => (forall r. b -> CodeGenFunction r c) -> process a b -> process a c

zipProcWith :: C process => (forall r. b -> c -> CodeGenFunction r d) -> process a b -> process a c -> process a d

mix :: (C process, Additive a) => process (a, a) a

You may also use '(+)'.

pipeline :: (C process, Positive n, C x, v ~ T n x, a ~ T x, Zero v, C v) => process v v -> process a a

This allows to compute a chain of equal processes efficiently, if all of these processes can be bundled in one vectorial process. Applications are an allpass cascade or an FM operator cascade.

The function expects that the vectorial input process works like parallel scalar processes. The different pipeline stages may be controlled by different parameters, but the structure of all pipeline stages must be equal. Our function feeds the input of the pipelined process to the zeroth element of the Vector. The result of processing the i-th element (the i-th channel, so to speak) is fed to the (i+1)-th element. The (n-1)-th element of the vectorial process is emitted as output of the pipelined process.

The pipeline necessarily introduces a delay of (n-1) values. For simplification we extend this to n values delay. If you need to combine the resulting signal from the pipeline with another signal in a zip-like way, you may delay that signal with pipeline id. The first input values in later stages of the pipeline are initialized with zero. If this is not appropriate for your application, then we may add a more sensible initialization.

stereoFromVector :: (C process, IsPrimitive a, IsPrimitive b) => process (Value (Vector D2 a)) (Value (Vector D2 b)) -> process (T (Value a)) (T (Value b))

vectorize :: (C process, Positive n, C x, T x ~ a, T n x ~ va, C y, T y ~ b, T n y ~ vb) => process a b -> process va vb

replaceChannel :: (C process, Positive n, C x, T x ~ a, T n x ~ va, C y, T y ~ b, T n y ~ vb) => Int -> process a b -> process va vb -> process va vb

Given a vector process, replace the i-th output by output that is generated by a scalar process from the i-th input.

arrayElement :: (C process, IsFirstClass a, Natural index, Natural dim, index :<: dim) => Proxy index -> process (Value (Array dim a)) (Value a)

Read the i-th element from each array.

element :: (C process, IsFirstClass a, GetValue agg index, ValueType agg index ~ a) => index -> process (Value agg) (Value a)

Read the i-th element from an aggregate type.

osciCoreSync :: (C process, C t, Fraction t) => process (t, t) t

Compute the phases from phase distortions and frequencies.

It's like integrate but with wrap-around performed by fraction. For FM synthesis we need also negative phase distortions, thus we use addToPhase which supports that.

osciCore :: (C process, C t, Fraction t) => process (t, t) t

Compute the phases from phase distortions and frequencies.

It's like integrate but with wrap-around performed by fraction. For FM synthesis we need also negative phase distortions, thus we use addToPhase which supports that.

osci :: (C process, C t, Fraction t) => (forall r. t -> CodeGenFunction r y) -> process (t, t) y

shapeModOsci :: (C process, C t, Fraction t) => (forall r. c -> t -> CodeGenFunction r y) -> process (c, (t, t)) y

skip :: (C process, SignalOf process ~ signal, Undefined a, Phi a, C a) => signal a -> process (Value Word32) a

Feeds a signal into a causal process while holding or skipping signal elements according to the process input. The skip happens after a value is passed from the fed signal.

skip x $* 0 repeats the first signal value in the output. skip x $* 1 feeds the signal to the output as is. skip x $* 2 feeds the signal to the output with double speed.

foldChunks :: (C process, SignalOf process ~ signal, Undefined b, Phi b) => T a b -> signal a -> process (Value Word32) b

The input of the process is a sequence of chunk sizes. The signal is chopped into chunks of these sizes and each chunk is folded using the given initial value and the accumulation function. A trailing incomplete chunk will be ignored.

foldChunksPartial :: (C process, SignalOf process ~ signal, Undefined a, Phi a, Undefined b, Phi b) => T a b -> signal a -> process (Value Word32) b

Like foldChunks but an incomplete chunk at the end is treated like a complete one.

frequencyModulation :: (C process, SignalOf process ~ signal, IntegerConstant a, IsFloating a, CmpRet a, CmpResult a ~ Bool, FirstClass a, Stored a ~ am, IsSized am, Undefined nodes, Phi nodes, C nodes) => (forall r. Value a -> nodes -> CodeGenFunction r v) -> signal nodes -> process (Value a) v

interpolateConstant :: (C process, SignalOf process ~ signal, C a, FirstClass b, Stored b ~ bm, IsSized bm, IntegerConstant b, IsFloating b, CmpRet b, CmpResult b ~ Bool) => signal a -> process (Value b) a

Stretch signal in time by a time-varying factor.

quantizeLift :: (C process, C b, IntegerConstant c, IsFloating c, CmpRet c, CmpResult c ~ Bool, FirstClass c, Stored c ~ cm, IsSized cm) => process a b -> process (Value c, a) b

applyStorable :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> Vector a -> Vector b

applyStorableChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> Vector a -> Vector b

runStorableChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ valueA, C valueA, Storable b, MakeValueTuple b, ValueTuple b ~ valueB, C valueB) => T valueA valueB -> IO (Vector a -> Vector b)