Synthesizer.LLVM.Filter.Allpass

Documentation

data Parameter a

Instances

Functor Parameter

Applicative Parameter

Foldable Parameter

Traversable Parameter

ShuffleMatch n v => ShuffleMatch n (Parameter v)

C a v => C a (Parameter v)

Access n a v => Access n (Parameter a) (Parameter v)

Show a => Show (Parameter a)

Storable a => Storable (Parameter a)

Zero a => Zero (Parameter a)

Phi a => Phi (Parameter a)

ValueTuple a => ValueTuple (Parameter a)

Undefined a => Undefined (Parameter a)

IsTuple a => IsTuple (Parameter a)

(Memory a s, IsSized s ss) => Memory (Parameter a) s

MakeValueTuple ah al => MakeValueTuple (Parameter ah) (Parameter al)

Flatten ah al => Flatten (Parameter ah) (Parameter al)

(C a, IsFirstClass a, IsArithmetic a, IsConst a, IsPowerOf2 n, IsPrimitive a, IsSized a as) => C (Parameter (Value a)) (Value (Vector n a)) (Value (Vector n a))

(C a, C (T a) (T v), IsFirstClass a, IsSized a as, IsConst a, IsArithmetic a, IsFirstClass v, IsSized v vs, IsConst v, IsArithmetic v) => C (Parameter (Value a)) (Value v) (Value v)

parameter :: (C a, IsConst a, IsFloating a) => Value a -> Value a -> CodeGenFunction r (Parameter (Value a))

data CascadeParameter n a

Instances

ShuffleMatch m v => ShuffleMatch m (CascadeParameter n v)

Access m a v => Access m (CascadeParameter n a) (CascadeParameter n v)

Functor (CascadeParameter n)

Applicative (CascadeParameter n)

Foldable (CascadeParameter n)

Traversable (CascadeParameter n)

Storable a => Storable (CascadeParameter n a)

Zero a => Zero (CascadeParameter n a)

Phi a => Phi (CascadeParameter n a)

ValueTuple a => ValueTuple (CascadeParameter n a)

Undefined a => Undefined (CascadeParameter n a)

IsTuple a => IsTuple (CascadeParameter n a)

(Memory a s, IsSized s ss) => Memory (CascadeParameter n a) s

(C a, IsFirstClass a, IsArithmetic a, IsConst a, IsPowerOf2 d, IsPrimitive a, IsSized a as, Nat n) => C (CascadeParameter n (Value a)) (Value (Vector d a)) (Value (Vector d a))

(C a, C (T a) (T v), IsFirstClass a, IsSized a as, IsConst a, IsArithmetic a, IsFirstClass v, IsSized v vs, IsConst v, IsArithmetic v, Nat n) => C (CascadeParameter n (Value a)) (Value v) (Value v)

MakeValueTuple ah al => MakeValueTuple (CascadeParameter n ah) (CascadeParameter n al)

Flatten ah al => Flatten (CascadeParameter n ah) (CascadeParameter n al)

flangerParameter :: (C a, IsConst a, IsFloating a, Nat n) => n -> Value a -> CodeGenFunction r (CascadeParameter n (Value a))

flangerParameterPlain :: (C a, Nat n) => n -> a -> CascadeParameter n a

causalP :: (C a, C (T a) (T v), IsFirstClass a, IsSized a as, IsConst a, IsFirstClass v, IsSized v vs, IsConst v, IsArithmetic a) => T p (Parameter (Value a), Value v) (Value v)

cascadeP :: (C a, C (T a) (T v), IsFirstClass a, IsSized a as, IsConst a, IsFirstClass v, IsSized v vs, IsConst v, IsArithmetic a, Nat n) => T p (CascadeParameter n (Value a), Value v) (Value v)

phaserP :: (C a, C (T a) (T v), IsFirstClass a, IsSized a as, IsConst a, IsFirstClass v, IsSized v vs, IsConst v, IsFloating a, IsArithmetic v, Nat n) => T p (CascadeParameter n (Value a), Value v) (Value v)

cascadePipelineP :: (C a, IsFirstClass a, IsSized a as, Mul n as vas, Pos vas, IsPowerOf2 n, IsArithmetic a, IsPrimitive a, IsConst a) => T p (CascadeParameter n (Value a), Value a) (Value a)

Fast implementation of cascadeP using vector instructions. However, we are currently limited to powers of two, primitive element types and we get a delay by the number of pipeline stages.

phaserPipelineP :: (C a, IsFirstClass a, IsSized a as, IsSized (Vector n a) vas, Mul n as vas, IsPowerOf2 n, IsFloating a, IsPrimitive a, IsConst a) => T p (CascadeParameter n (Value a), Value a) (Value a)

causalPackedP :: (C a, IsFirstClass a, IsArithmetic a, IsConst a, IsPowerOf2 n, IsPrimitive a, IsSized a as) => T p (Parameter (Value a), Value (Vector n a)) (Value (Vector n a))

cascadePackedP :: (C a, IsFirstClass a, IsArithmetic a, IsConst a, IsPowerOf2 m, IsPrimitive a, IsSized a as, Nat n) => T p (CascadeParameter n (Value a), Value (Vector m a)) (Value (Vector m a))

phaserPackedP :: (C a, IsFirstClass a, IsArithmetic a, IsConst a, IsPowerOf2 m, IsPrimitive a, IsSized a as, Nat n) => T p (CascadeParameter n (Value a), Value (Vector m a)) (Value (Vector m a))