Synthesizer.LLVM.Parameterized.Signal

Documentation

data T p a

Instances

Functor (T p)

Applicative (T p)

ZipList semantics

C (T p)

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

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

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

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

Additive a => C (T p a)

type ProcessOf (T p) = T p

adjacentNodes02 :: (C a, Undefined a) => T p a -> T p (Nodes02 a)

adjacentNodes13 :: (MakeValueTuple ah, Storable ah, ValueTuple ah ~ a, C a, Undefined a) => T p ah -> T p a -> T p (Nodes13 a)

amplify :: (PseudoRing al, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al) => T p a -> T p al -> T p al

amplifyStereo :: (PseudoRing al, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al) => T p a -> T p (T al) -> T p (T al)

append :: (Phi a, Undefined a) => T p a -> T p a -> T p a

Appending many signals is inefficient, since in cascadingly appended signals the parts are counted in an unary way. Concatenating infinitely many signals is impossible. If you want to concatenate a lot of signals, please render them to lazy storable vectors first.

cycle :: (Phi a, Undefined a) => T p a -> T p a

drop :: T p Int -> T p a -> T p a

exponential2 :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ Value a, FirstClass a, IsSized (Stored a), IsArithmetic a, IsConst a) => T p a -> T p a -> T p (Value a)

exponentialCore :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al) => T p a -> T p a -> T p al

exponentialBounded2 :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ Value a, FirstClass a, IsSized (Stored a), Real a, IsConst a) => T p a -> T p a -> T p a -> T p (Value a)

Exponential curve that remains at the bound value if it would fall below otherwise. This way you can avoid extremal values, e.g. denormalized ones. The initial value and the bound value must be positive.

exponentialBoundedCore :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, Real al) => T p a -> T p a -> T p a -> T p al

interpolateConstant :: (C a, IsFloating b, IntegerConstant b, CmpRet b, CmpResult b ~ Bool, Storable b, MakeValueTuple b, ValueTuple b ~ Value b, FirstClass b, IsSized (Stored b)) => T p b -> T p a -> T p a

Stretch signal in time by a certain factor.

This can be used for doing expensive computations of filter parameters at a lower rate. Alternatively, we could provide an adaptive map that recomputes output values only if the input value changes, or if the input value differs from the last processed one by a certain amount.

iterate :: (Storable ph, MakeValueTuple ph, ValueTuple ph ~ pl, C pl, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al) => (forall r. pl -> al -> CodeGenFunction r al) -> T p ph -> T p a -> T p al

lazySize :: T p LazySize -> T p ()

Turns a lazy chunky size into a signal generator with unit element type. The signal length is the only information that the generator provides. Using zipWith you can use this signal as a lazy take.

map :: (Storable ph, MakeValueTuple ph, ValueTuple ph ~ pl, C pl) => (forall r. pl -> a -> CodeGenFunction r b) -> T p ph -> T p a -> T p b

mapSimple :: (forall r. a -> CodeGenFunction r b) -> T p a -> T p b

mapAccum :: (Storable pnh, MakeValueTuple pnh, ValueTuple pnh ~ pnl, C pnl, Storable psh, MakeValueTuple psh, ValueTuple psh ~ psl, C psl, C s) => (forall r. pnl -> a -> s -> CodeGenFunction r (b, s)) -> (forall r. psl -> CodeGenFunction r s) -> T p pnh -> T p psh -> T p a -> T p b

mix :: (C signal, Additive a) => signal a -> signal a -> signal a

noise :: (C a, IsFloating a, IsConst a, NumberOfElements a ~ D1, C (Value a), MakeValueTuple a, ValueTuple a ~ Value a, Storable a) => T p Word32 -> T p a -> T p (Value a)

noise seed rate

The rate parameter is for adjusting the amplitude such that it is uniform across different sample rates and after frequency filters. The rate is the ratio of the current sample rate to the default sample rate, where the variance of the samples would be one. If you want that at sample rate 22050 the variance is 1, then in order to get a consistent volume at sample rate 44100 you have to set rate = 2.

I use the variance as quantity and not the amplitude, because the amplitude makes only sense for uniformly distributed samples. However, frequency filters transform the probabilistic density of the samples towards the normal distribution according to the central limit theorem.

noiseCore :: T p Word32 -> T p (Value Word32)

osci :: (Storable t, MakeValueTuple t, ValueTuple t ~ tl, Storable c, MakeValueTuple c, ValueTuple c ~ cl, C cl, C tl, Fraction tl, IntegerConstant tl) => (forall r. cl -> tl -> CodeGenFunction r y) -> T p c -> T p t -> T p t -> T p y

osciCore :: (Storable t, MakeValueTuple t, ValueTuple t ~ tl, C tl, Fraction tl) => T p t -> T p t -> T p tl

osciSaw :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, Fraction al, IntegerConstant al) => T p a -> T p a -> T p al

osciSimple :: (Storable t, MakeValueTuple t, ValueTuple t ~ tl, C tl, Fraction tl, IntegerConstant tl) => (forall r. tl -> CodeGenFunction r y) -> T p t -> T p t -> T p y

parabolaCore :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p a -> T p a -> T p al

parabolaFadeIn :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, IntegerConstant al) => T p a -> T p al

parabolaFadeInInf :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p al

parabolaFadeInMap :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, IntegerConstant al) => T p a -> T p al

parabolaFadeOut :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, IntegerConstant al) => T p a -> T p al

parabolaFadeOutInf :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p al

parabolaFadeOutMap :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, IntegerConstant al) => T p a -> T p al

piecewiseConstant :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p (T Int a) -> T p value

ramp :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, PseudoRing al, IntegerConstant al) => T p a -> T p al

rampCore :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p a -> T p al

rampInf :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p al

rampSlope :: (C a, Storable a, MakeValueTuple a, ValueTuple a ~ al, C al, Additive al, IntegerConstant al) => T p a -> T p al

reparameterize :: T q p -> T p a -> T q a

tail :: T p a -> T p a

tail empty generates the empty signal.

constant :: (Storable a, MakeValueTuple a, ValueTuple a ~ al, C al) => T p a -> T p al

envelope :: (C signal, PseudoRing a) => signal a -> signal a -> signal a

envelopeStereo :: (C signal, PseudoRing a) => signal a -> signal (T a) -> signal (T a)

simple :: (Storable parameters, MakeValueTuple parameters, C (ValueTuple parameters), C context, C state) => (forall r c. Phi c => context -> state -> T r c (al, state)) -> (forall r. ValueTuple parameters -> CodeGenFunction r (context, state)) -> T p parameters -> T p al

zip :: T p a -> T p b -> T p (a, b)

zipWith :: (Storable ph, MakeValueTuple ph, ValueTuple ph ~ pl, C pl) => (forall r. pl -> a -> b -> CodeGenFunction r c) -> T p ph -> T p a -> T p b -> T p c

zipWithSimple :: (forall r. a -> b -> CodeGenFunction r c) -> T p a -> T p b -> T p c

fromStorableVector :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p (Vector a) -> T p value

fromStorableVectorLazy :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p (Vector a) -> T p value

render :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p value -> Int -> p -> Vector a

This is not really a function, see renderChunky.

renderChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => ChunkSize -> T p value -> p -> Vector a

This looks like a function, but it is not a function since it depends on LLVM being initialized with LLVM.initializeNativeTarget before. It is also problematic since you cannot control when and how often the underlying LLVM code is compiled. The compilation cannot be observed, thus it is referential transparent. But this influences performance considerably and I assume that you use this package exclusively for performance reasons.

run :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p value -> IO (Int -> p -> Vector a)

runChunky :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p value -> IO (ChunkSize -> p -> Vector a)

runChunkyPattern :: (Storable a, MakeValueTuple a, ValueTuple a ~ value, C value) => T p value -> IO (LazySize -> p -> Vector a)

Renders a signal generator to a chunky storable vector with given pattern. If the pattern is shorter than the generated signal this means that the signal is shortened.

noiseCoreAlt :: T p Word32 -> T p (Value Word32)