Synthesizer.LLVM.Filter.Allpass

Documentation

data Parameter a :: * -> *

Instances

Functor Parameter

Applicative Parameter

Foldable Parameter

Traversable Parameter

C n a => C n (Parameter a)

C a v => C a (Parameter v)

Show a => Show (Parameter a)

Storable a => Storable (Parameter a)

C a => C (Parameter a)

C a => C (Parameter a)

C a => C (Parameter a)

C v => C (Parameter v)

Simple v => Simple (Parameter v)

Undefined a => Undefined (Parameter a)

Zero a => Zero (Parameter a)

MakeValueTuple a => MakeValueTuple (Parameter a)

Phi a => Phi (Parameter a)

Flatten a => Flatten (Parameter a)

((~) * a (Scalar v), PseudoModule v, RationalConstant a, C a, C v) => C (Parameter a) v v

(C v, (~) * (Element v) a, C a, IntegerConstant a, PseudoRing v, PseudoRing a) => C (Parameter a) v v

type Struct n (Parameter a) = Struct n a

type Repr f (Parameter a) = Parameter (Repr f a)

type Struct (Parameter a) = Struct a

type Size (Parameter v) = Size v

type Element (Parameter v) = Parameter (Element v)

type ValueTuple (Parameter a) = Parameter (ValueTuple a)

type Registers (Parameter a) = Parameter (Registers a)

type Input (Parameter a) v = v

type Output (Parameter a) v = v

parameter :: (Transcendental a, RationalConstant a) => a -> a -> CodeGenFunction r (Parameter a)

data CascadeParameter n a

Instances

C n a => C n (CascadeParameter n a)

Functor (CascadeParameter n)

Applicative (CascadeParameter n)

Foldable (CascadeParameter n)

Traversable (CascadeParameter n)

Storable a => Storable (CascadeParameter n a)

C a => C (CascadeParameter n a)

C a => C (CascadeParameter n a)

C a => C (CascadeParameter n a)

C v => C (CascadeParameter n v)

Simple v => Simple (CascadeParameter n v)

Undefined a => Undefined (CascadeParameter n a)

Zero a => Zero (CascadeParameter n a)

MakeValueTuple a => MakeValueTuple (CascadeParameter n a)

Phi a => Phi (CascadeParameter n a)

Flatten a => Flatten (CascadeParameter n a)

MakeArguments (CascadeParameter n a)

((~) * a (Scalar v), PseudoModule v, RationalConstant a, C a, C v, Natural n) => C (CascadeParameter n a) v v

(Natural n, C v, (~) * (Element v) a, PseudoRing a, IntegerConstant a, C a, PseudoRing v, RationalConstant v) => C (CascadeParameter n a) v v

type Struct n (CascadeParameter n a) = Struct n (Parameter a)

type Repr f (CascadeParameter n a) = Repr f (Parameter a)

type Arguments f (CascadeParameter n a) = f (CascadeParameter n a)

type Struct (CascadeParameter n a) = Struct a

type Size (CascadeParameter n v) = Size v

type Element (CascadeParameter n v) = CascadeParameter n (Element v)

type ValueTuple (CascadeParameter n a) = CascadeParameter n (ValueTuple a)

type Registers (CascadeParameter n a) = CascadeParameter n (Registers a)

type Input (CascadeParameter n a) v = v

type Output (CascadeParameter n a) v = v

flangerParameter :: (Transcendental a, RationalConstant a, Natural n) => Proxy n -> a -> CodeGenFunction r (CascadeParameter n a)

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

causal :: (C process, IntegerConstant a, a ~ Scalar v, PseudoModule v, C v) => process (Parameter a, v) v

cascade :: (C process, RationalConstant a, a ~ Scalar v, PseudoModule v, C v, Natural n) => process (CascadeParameter n a, v) v

phaser :: (C process, RationalConstant a, RationalConstant v, a ~ Scalar v, PseudoModule v, C v, Natural n) => process (CascadeParameter n a, v) v

cascadePipeline :: (C process, Positive n, C a, Repr Value a ~ ar, PseudoRing a, IntegerConstant a, C a, C n a) => process (T (CascadeParameter n a), T a) (T a)

Fast implementation of cascade using vector instructions. However, there must be at least one pipeline stage, primitive element types and we get a delay by the number of pipeline stages.

phaserPipeline :: (C process, Positive n, PseudoRing a, RationalConstant a, C a, C n a, Repr Value a ~ Value a) => process (CascadeParameter n (Value a), Value a) (Value a)

causalPacked :: (C process, C v, Element v ~ a, C a, IntegerConstant a, PseudoRing v, PseudoRing a) => process (Parameter a, v) v

cascadePacked :: (C process, Natural n, C v, Element v ~ a, PseudoRing a, IntegerConstant a, C a, PseudoRing v, RationalConstant v) => process (CascadeParameter n a, v) v

phaserPacked :: (C process, Natural n, C v, Element v ~ a, PseudoRing a, IntegerConstant a, C a, PseudoRing v, RationalConstant v) => process (CascadeParameter n a, v) v

causalP :: (RationalConstant a, a ~ Scalar v, PseudoModule v, C v) => T p (Parameter a, v) v

Deprecated: use causal instead

cascadeP :: (RationalConstant a, a ~ Scalar v, PseudoModule v, C v, Natural n) => T p (CascadeParameter n a, v) v

Deprecated: use cascade instead

phaserP :: (RationalConstant a, RationalConstant v, a ~ Scalar v, PseudoModule v, C v, Natural n) => T p (CascadeParameter n a, v) v

Deprecated: use phaser instead

causalPackedP :: (C v, Element v ~ a, C a, IntegerConstant a, PseudoRing v, PseudoRing a) => T p (Parameter a, v) v

Deprecated: use causalPacked instead

cascadePackedP :: (Natural n, C v, Element v ~ a, PseudoRing a, IntegerConstant a, C a, PseudoRing v, RationalConstant v) => T p (CascadeParameter n a, v) v

Deprecated: use cascadePacked instead

phaserPackedP :: (Natural n, C v, Element v ~ a, PseudoRing a, IntegerConstant a, C a, PseudoRing v, RationalConstant v) => T p (CascadeParameter n a, v) v

Deprecated: use phaserPacked instead