{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FlexibleContexts #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
{-# LANGUAGE DeriveTraversable #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Synthesizer.LLVM.Filter.Allpass (
   Parameter, Allpass.parameter,
   CascadeParameter(CascadeParameter), flangerParameter,
   cascadeParameterMultiValue, cascadeParameterUnMultiValue,
   causal, cascade, phaser,
   cascadePipeline, phaserPipeline,
   causalPacked, cascadePacked, phaserPacked,
   ) where

import Synthesizer.Plain.Filter.Recursive.Allpass (Parameter(Parameter))
import qualified Synthesizer.Plain.Filter.Recursive.Allpass as Allpass
import qualified Synthesizer.Plain.Filter.Recursive.FirstOrder as Filt1

import qualified Synthesizer.LLVM.Filter.FirstOrder as Filt1L

import qualified Synthesizer.LLVM.Causal.Private as CausalPriv
import qualified Synthesizer.LLVM.Causal.Process as Causal
import qualified Synthesizer.LLVM.Causal.Functional as F
import qualified Synthesizer.LLVM.Frame.SerialVector.Class as Serial

import qualified LLVM.DSL.Expression as Expr

import qualified LLVM.Extra.Multi.Value.Marshal as MarshalMV
import qualified LLVM.Extra.Multi.Vector as MultiVector
import qualified LLVM.Extra.Multi.Value as MultiValue
import qualified LLVM.Extra.Vector as Vector
import qualified LLVM.Extra.Scalar as Scalar
import qualified LLVM.Extra.Storable as Storable
import qualified LLVM.Extra.Marshal as Marshal
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Tuple as Tuple
import qualified LLVM.Extra.Arithmetic as A

import qualified Type.Data.Num.Decimal as TypeNum
import Type.Base.Proxy (Proxy(Proxy))

import Foreign.Storable (Storable)

import qualified Control.Category as Cat
import qualified Control.Applicative as App
import Control.Arrow ((<<<), (^<<), (<<^), (&&&), arr, first, second)

import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold
import Data.Tuple.HT (mapFst)

import qualified Algebra.Transcendental as Trans
import qualified Algebra.Module as Module

import NumericPrelude.Numeric
import NumericPrelude.Base


instance (Tuple.Phi a) => Tuple.Phi (Parameter a) where
   phi :: forall r.
BasicBlock -> Parameter a -> CodeGenFunction r (Parameter a)
phi = BasicBlock -> Parameter a -> CodeGenFunction r (Parameter a)
forall a (f :: * -> *) r.
(Phi a, Traversable f) =>
BasicBlock -> f a -> CodeGenFunction r (f a)
Tuple.phiTraversable
   addPhi :: forall r.
BasicBlock -> Parameter a -> Parameter a -> CodeGenFunction r ()
addPhi = BasicBlock -> Parameter a -> Parameter a -> CodeGenFunction r ()
forall a (f :: * -> *) r.
(Phi a, Foldable f, Applicative f) =>
BasicBlock -> f a -> f a -> CodeGenFunction r ()
Tuple.addPhiFoldable

instance Tuple.Undefined a => Tuple.Undefined (Parameter a) where
   undef :: Parameter a
undef = Parameter a
forall a (f :: * -> *). (Undefined a, Applicative f) => f a
Tuple.undefPointed

instance Tuple.Zero a => Tuple.Zero (Parameter a) where
   zero :: Parameter a
zero = Parameter a
forall a (f :: * -> *). (Zero a, Applicative f) => f a
Tuple.zeroPointed

instance
   (Expr.Aggregate e mv) =>
      Expr.Aggregate (Parameter e) (Parameter mv) where
   type MultiValuesOf (Parameter e) = Parameter (Expr.MultiValuesOf e)
   type ExpressionsOf (Parameter mv) = Parameter (Expr.ExpressionsOf mv)
   bundle :: forall r. Parameter e -> CodeGenFunction r (Parameter mv)
bundle = (e -> CodeGenFunction r mv)
-> Parameter e -> CodeGenFunction r (Parameter mv)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Parameter a -> f (Parameter b)
Trav.traverse e -> CodeGenFunction r mv
forall r. e -> CodeGenFunction r mv
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
Expr.bundle
   dissect :: Parameter mv -> Parameter e
dissect = (mv -> e) -> Parameter mv -> Parameter e
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap mv -> e
forall exp mv. Aggregate exp mv => mv -> exp
Expr.dissect

instance (Memory.C a) => Memory.C (Parameter a) where
   type Struct (Parameter a) = Memory.Struct a
   load :: forall r.
Value (Ptr (Struct (Parameter a)))
-> CodeGenFunction r (Parameter a)
load = (a -> Parameter a)
-> Value (Ptr (Struct a)) -> CodeGenFunction r (Parameter a)
forall a llvmValue r.
C a =>
(a -> llvmValue)
-> Value (Ptr (Struct a)) -> CodeGenFunction r llvmValue
Memory.loadNewtype a -> Parameter a
forall a. a -> Parameter a
Parameter
   store :: forall r.
Parameter a
-> Value (Ptr (Struct (Parameter a))) -> CodeGenFunction r ()
store = (Parameter a -> a)
-> Parameter a -> Value (Ptr (Struct a)) -> CodeGenFunction r ()
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> Value (Ptr (Struct a)) -> CodeGenFunction r ()
Memory.storeNewtype (\(Parameter a
k) -> a
k)
   decompose :: forall r.
Value (Struct (Parameter a)) -> CodeGenFunction r (Parameter a)
decompose = (a -> Parameter a)
-> Value (Struct a) -> CodeGenFunction r (Parameter a)
forall a llvmValue r.
C a =>
(a -> llvmValue) -> Value (Struct a) -> CodeGenFunction r llvmValue
Memory.decomposeNewtype a -> Parameter a
forall a. a -> Parameter a
Parameter
   compose :: forall r.
Parameter a -> CodeGenFunction r (Value (Struct (Parameter a)))
compose = (Parameter a -> a)
-> Parameter a -> CodeGenFunction r (Value (Struct a))
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> CodeGenFunction r (Value (Struct a))
Memory.composeNewtype (\(Parameter a
k) -> a
k)

instance (Marshal.C a) => Marshal.C (Parameter a) where
   pack :: Parameter a -> Struct (Parameter a)
pack (Parameter a
k) = a -> Struct a
forall a. C a => a -> Struct a
Marshal.pack a
k
   unpack :: Struct (Parameter a) -> Parameter a
unpack = a -> Parameter a
forall a. a -> Parameter a
Parameter (a -> Parameter a) -> (Struct a -> a) -> Struct a -> Parameter a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct a -> a
forall a. C a => Struct a -> a
Marshal.unpack

instance (MarshalMV.C a) => MarshalMV.C (Parameter a) where
   pack :: Parameter a -> Struct (Parameter a)
pack (Parameter a
k) = a -> Struct a
forall a. C a => a -> Struct a
MarshalMV.pack a
k
   unpack :: Struct (Parameter a) -> Parameter a
unpack = a -> Parameter a
forall a. a -> Parameter a
Parameter (a -> Parameter a) -> (Struct a -> a) -> Struct a -> Parameter a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct a -> a
forall a. C a => Struct a -> a
MarshalMV.unpack

instance (Storable.C a) => Storable.C (Parameter a) where
   load :: forall r.
Value (Ptr (Parameter a))
-> CodeGenFunction r (ValueOf (Parameter a))
load = (a -> Parameter a)
-> (ValueOf a -> Parameter (ValueOf a))
-> Value (Ptr (Parameter a))
-> CodeGenFunction r (Parameter (ValueOf a))
forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (al -> wrappedl)
-> Value (Ptr wrapped)
-> CodeGenFunction r wrappedl
Storable.loadNewtype a -> Parameter a
forall a. a -> Parameter a
Parameter ValueOf a -> Parameter (ValueOf a)
forall a. a -> Parameter a
Parameter
   store :: forall r.
ValueOf (Parameter a)
-> Value (Ptr (Parameter a)) -> CodeGenFunction r ()
store = (a -> Parameter a)
-> (Parameter (ValueOf a) -> ValueOf a)
-> Parameter (ValueOf a)
-> Value (Ptr (Parameter a))
-> CodeGenFunction r ()
forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (wrappedl -> al)
-> wrappedl
-> Value (Ptr wrapped)
-> CodeGenFunction r ()
Storable.storeNewtype a -> Parameter a
forall a. a -> Parameter a
Parameter (\(Parameter ValueOf a
k) -> ValueOf a
k)


instance (Tuple.Value a) => Tuple.Value (Parameter a) where
   type ValueOf (Parameter a) = Parameter (Tuple.ValueOf a)
   valueOf :: Parameter a -> ValueOf (Parameter a)
valueOf = Parameter a -> ValueOf (Parameter a)
Parameter a -> Parameter (ValueOf a)
forall h (f :: * -> *).
(Value h, Functor f) =>
f h -> f (ValueOf h)
Tuple.valueOfFunctor

instance (Tuple.VectorValue n a) => Tuple.VectorValue n (Parameter a) where
   type VectorValueOf n (Parameter a) = Parameter (Tuple.VectorValueOf n a)
   vectorValueOf :: Vector n (Parameter a) -> VectorValueOf n (Parameter a)
vectorValueOf = (Vector n a -> VectorValueOf n a)
-> Parameter (Vector n a) -> Parameter (VectorValueOf n a)
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector n a -> VectorValueOf n a
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
Tuple.vectorValueOf (Parameter (Vector n a) -> Parameter (VectorValueOf n a))
-> (Vector n (Parameter a) -> Parameter (Vector n a))
-> Vector n (Parameter a)
-> Parameter (VectorValueOf n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n (Parameter a) -> Parameter (Vector n a)
forall (t :: * -> *) (f :: * -> *) a.
(Traversable t, Applicative f) =>
t (f a) -> f (t a)
forall (f :: * -> *) a.
Applicative f =>
Vector n (f a) -> f (Vector n a)
Trav.sequenceA

instance (MultiValue.C a) => MultiValue.C (Allpass.Parameter a) where
   type Repr (Parameter a) = Parameter (MultiValue.Repr a)
   cons :: Parameter a -> T (Parameter a)
cons = T a -> T (Parameter a)
forall a. T a -> T (Parameter a)
paramFromPlainValue (T a -> T (Parameter a))
-> (Parameter a -> T a) -> Parameter a -> T (Parameter a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. a -> T a
forall a. C a => a -> T a
MultiValue.cons (a -> T a) -> (Parameter a -> a) -> Parameter a -> T a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Parameter a -> a
forall a. Parameter a -> a
Allpass.getParameter

   undef :: T (Parameter a)
undef = T a -> T (Parameter a)
forall a. T a -> T (Parameter a)
paramFromPlainValue T a
forall a. C a => T a
MultiValue.undef
   zero :: T (Parameter a)
zero = T a -> T (Parameter a)
forall a. T a -> T (Parameter a)
paramFromPlainValue T a
forall a. C a => T a
MultiValue.zero

   phi :: forall r.
BasicBlock
-> T (Parameter a) -> CodeGenFunction r (T (Parameter a))
phi BasicBlock
bb =
      (T a -> T (Parameter a))
-> CodeGenFunction r (T a) -> CodeGenFunction r (T (Parameter a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T a -> T (Parameter a)
forall a. T a -> T (Parameter a)
paramFromPlainValue (CodeGenFunction r (T a) -> CodeGenFunction r (T (Parameter a)))
-> (T (Parameter a) -> CodeGenFunction r (T a))
-> T (Parameter a)
-> CodeGenFunction r (T (Parameter a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      BasicBlock -> T a -> CodeGenFunction r (T a)
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r. BasicBlock -> T a -> CodeGenFunction r (T a)
MultiValue.phi BasicBlock
bb (T a -> CodeGenFunction r (T a))
-> (T (Parameter a) -> T a)
-> T (Parameter a)
-> CodeGenFunction r (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      T (Parameter a) -> T a
forall a. T (Parameter a) -> T a
plainFromParamValue
   addPhi :: forall r.
BasicBlock
-> T (Parameter a) -> T (Parameter a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Parameter a)
a T (Parameter a)
b =
      BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r. BasicBlock -> T a -> T a -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb
         (T (Parameter a) -> T a
forall a. T (Parameter a) -> T a
plainFromParamValue T (Parameter a)
a)
         (T (Parameter a) -> T a
forall a. T (Parameter a) -> T a
plainFromParamValue T (Parameter a)
b)

instance (MultiVector.C a) => MultiVector.C (Allpass.Parameter a) where
   type Repr n (Parameter a) = Parameter (MultiVector.Repr n a)
   cons :: forall n. Positive n => Vector n (Parameter a) -> T n (Parameter a)
cons = T n a -> T n (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector (T n a -> T n (Parameter a))
-> (Vector n (Parameter a) -> T n a)
-> Vector n (Parameter a)
-> T n (Parameter a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n a -> T n a
forall a n. (C a, Positive n) => Vector n a -> T n a
forall n. Positive n => Vector n a -> T n a
MultiVector.cons (Vector n a -> T n a)
-> (Vector n (Parameter a) -> Vector n a)
-> Vector n (Parameter a)
-> T n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (Parameter a -> a) -> Vector n (Parameter a) -> Vector n a
forall a b. (a -> b) -> Vector n a -> Vector n b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Parameter a -> a
forall a. Parameter a -> a
Allpass.getParameter
   undef :: forall n. Positive n => T n (Parameter a)
undef = T n a -> T n (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector T n a
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n a
MultiVector.undef
   zero :: forall n. Positive n => T n (Parameter a)
zero = T n a -> T n (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector T n a
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n a
MultiVector.zero

   phi :: forall n r.
Positive n =>
BasicBlock
-> T n (Parameter a) -> CodeGenFunction r (T n (Parameter a))
phi BasicBlock
bb =
      (T n a -> T n (Parameter a))
-> CodeGenFunction r (T n a)
-> CodeGenFunction r (T n (Parameter a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n a -> T n (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector (CodeGenFunction r (T n a)
 -> CodeGenFunction r (T n (Parameter a)))
-> (T n (Parameter a) -> CodeGenFunction r (T n a))
-> T n (Parameter a)
-> CodeGenFunction r (T n (Parameter a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      BasicBlock -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
BasicBlock -> T n a -> CodeGenFunction r (T n a)
MultiVector.phi BasicBlock
bb (T n a -> CodeGenFunction r (T n a))
-> (T n (Parameter a) -> T n a)
-> T n (Parameter a)
-> CodeGenFunction r (T n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector
   addPhi :: forall n r.
Positive n =>
BasicBlock
-> T n (Parameter a) -> T n (Parameter a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T n (Parameter a)
a T n (Parameter a)
b =
      BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
forall n r.
Positive n =>
BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
MultiVector.addPhi BasicBlock
bb
         (T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
a)
         (T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
b)

   shuffle :: forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T m (Parameter a))
shuffle ConstValue (Vector m Word32)
is T n (Parameter a)
a T n (Parameter a)
b =
      (T m a -> T m (Parameter a))
-> CodeGenFunction r (T m a)
-> CodeGenFunction r (T m (Parameter a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T m a -> T m (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector (CodeGenFunction r (T m a)
 -> CodeGenFunction r (T m (Parameter a)))
-> CodeGenFunction r (T m a)
-> CodeGenFunction r (T m (Parameter a))
forall a b. (a -> b) -> a -> b
$
      ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
forall a n m r.
(C a, Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
MultiVector.shuffle ConstValue (Vector m Word32)
is (T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
a) (T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
b)
   extract :: forall n r.
Positive n =>
Value Word32
-> T n (Parameter a) -> CodeGenFunction r (T (Parameter a))
extract Value Word32
i T n (Parameter a)
v =
      (T a -> T (Parameter a))
-> CodeGenFunction r (T a) -> CodeGenFunction r (T (Parameter a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T a -> T (Parameter a)
forall a. T a -> T (Parameter a)
paramFromPlainValue (CodeGenFunction r (T a) -> CodeGenFunction r (T (Parameter a)))
-> CodeGenFunction r (T a) -> CodeGenFunction r (T (Parameter a))
forall a b. (a -> b) -> a -> b
$
      Value Word32 -> T n a -> CodeGenFunction r (T a)
forall a n r.
(C a, Positive n) =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
forall n r.
Positive n =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
MultiVector.extract Value Word32
i (T n a -> CodeGenFunction r (T a))
-> T n a -> CodeGenFunction r (T a)
forall a b. (a -> b) -> a -> b
$
      T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
v
   insert :: forall n r.
Positive n =>
Value Word32
-> T (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T n (Parameter a))
insert Value Word32
i T (Parameter a)
a T n (Parameter a)
v =
      (T n a -> T n (Parameter a))
-> CodeGenFunction r (T n a)
-> CodeGenFunction r (T n (Parameter a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n a -> T n (Parameter a)
forall n a. T n a -> T n (Parameter a)
paramFromPlainVector (CodeGenFunction r (T n a)
 -> CodeGenFunction r (T n (Parameter a)))
-> CodeGenFunction r (T n a)
-> CodeGenFunction r (T n (Parameter a))
forall a b. (a -> b) -> a -> b
$
      Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall a n r.
(C a, Positive n) =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
MultiVector.insert Value Word32
i (T (Parameter a) -> T a
forall a. T (Parameter a) -> T a
plainFromParamValue T (Parameter a)
a) (T n a -> CodeGenFunction r (T n a))
-> T n a -> CodeGenFunction r (T n a)
forall a b. (a -> b) -> a -> b
$
      T n (Parameter a) -> T n a
forall n a. T n (Parameter a) -> T n a
plainFromParamVector T n (Parameter a)
v

paramFromPlainVector ::
   MultiVector.T n a ->
   MultiVector.T n (Allpass.Parameter a)
paramFromPlainVector :: forall n a. T n a -> T n (Parameter a)
paramFromPlainVector =
   (Repr n a -> Repr n (Parameter a)) -> T n a -> T n (Parameter a)
forall n a b. (Repr n a -> Repr n b) -> T n a -> T n b
MultiVector.lift1 Repr n a -> Repr n (Parameter a)
Repr n a -> Parameter (Repr n a)
forall a. a -> Parameter a
Allpass.Parameter

plainFromParamVector ::
   MultiVector.T n (Allpass.Parameter a) ->
   MultiVector.T n a
plainFromParamVector :: forall n a. T n (Parameter a) -> T n a
plainFromParamVector =
   (Repr n (Parameter a) -> Repr n a) -> T n (Parameter a) -> T n a
forall n a b. (Repr n a -> Repr n b) -> T n a -> T n b
MultiVector.lift1 Repr n (Parameter a) -> Repr n a
Parameter (Repr n a) -> Repr n a
forall a. Parameter a -> a
Allpass.getParameter

paramFromPlainValue ::
   MultiValue.T a ->
   MultiValue.T (Allpass.Parameter a)
paramFromPlainValue :: forall a. T a -> T (Parameter a)
paramFromPlainValue =
   (Repr a -> Repr (Parameter a)) -> T a -> T (Parameter a)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr a -> Repr (Parameter a)
Repr a -> Parameter (Repr a)
forall a. a -> Parameter a
Allpass.Parameter

plainFromParamValue ::
   MultiValue.T (Allpass.Parameter a) ->
   MultiValue.T a
plainFromParamValue :: forall a. T (Parameter a) -> T a
plainFromParamValue =
   (Repr (Parameter a) -> Repr a) -> T (Parameter a) -> T a
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr (Parameter a) -> Repr a
Parameter (Repr a) -> Repr a
forall a. Parameter a -> a
Allpass.getParameter


instance (Vector.Simple v) => Vector.Simple (Parameter v) where
   type Element (Parameter v) = Parameter (Vector.Element v)
   type Size (Parameter v) = Vector.Size v
   shuffleMatch :: forall r.
ConstValue (Vector (Size (Parameter v)) Word32)
-> Parameter v -> CodeGenFunction r (Parameter v)
shuffleMatch = ConstValue (Vector (Size v) Word32)
-> Parameter v -> CodeGenFunction r (Parameter v)
ConstValue (Vector (Size (Parameter v)) Word32)
-> Parameter v -> CodeGenFunction r (Parameter v)
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
ConstValue (Vector (Size v) Word32)
-> f v -> CodeGenFunction r (f v)
Vector.shuffleMatchTraversable
   extract :: forall r.
Value Word32
-> Parameter v -> CodeGenFunction r (Element (Parameter v))
extract = Value Word32
-> Parameter v -> CodeGenFunction r (Element (Parameter v))
Value Word32
-> Parameter v -> CodeGenFunction r (Parameter (Element v))
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
Vector.extractTraversable

instance (Vector.C v) => Vector.C (Parameter v) where
   insert :: forall r.
Value Word32
-> Element (Parameter v)
-> Parameter v
-> CodeGenFunction r (Parameter v)
insert = Value Word32
-> Element (Parameter v)
-> Parameter v
-> CodeGenFunction r (Parameter v)
Value Word32
-> Parameter (Element v)
-> Parameter v
-> CodeGenFunction r (Parameter v)
forall v (f :: * -> *) r.
(C v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
Vector.insertTraversable

type instance F.Arguments f (Parameter a) = f (Parameter a)
instance F.MakeArguments (Parameter a) where
   makeArgs :: forall (f :: * -> *).
Functor f =>
f (Parameter a) -> Arguments f (Parameter a)
makeArgs = f (Parameter a) -> f (Parameter a)
f (Parameter a) -> Arguments f (Parameter a)
forall a. a -> a
id


newtype CascadeParameter n a =
   CascadeParameter (Allpass.Parameter a)
      deriving
         (CascadeParameter n a
CascadeParameter n a -> Undefined (CascadeParameter n a)
forall a. a -> Undefined a
forall n a. Undefined a => CascadeParameter n a
$cundef :: forall n a. Undefined a => CascadeParameter n a
undef :: CascadeParameter n a
Tuple.Undefined, CascadeParameter n a
CascadeParameter n a -> Zero (CascadeParameter n a)
forall a. a -> Zero a
forall n a. Zero a => CascadeParameter n a
$czero :: forall n a. Zero a => CascadeParameter n a
zero :: CascadeParameter n a
Tuple.Zero, Ptr (CascadeParameter n a) -> IO (CascadeParameter n a)
Ptr (CascadeParameter n a) -> Int -> IO (CascadeParameter n a)
Ptr (CascadeParameter n a) -> Int -> CascadeParameter n a -> IO ()
Ptr (CascadeParameter n a) -> CascadeParameter n a -> IO ()
CascadeParameter n a -> Int
(CascadeParameter n a -> Int)
-> (CascadeParameter n a -> Int)
-> (Ptr (CascadeParameter n a) -> Int -> IO (CascadeParameter n a))
-> (Ptr (CascadeParameter n a)
    -> Int -> CascadeParameter n a -> IO ())
-> (forall b. Ptr b -> Int -> IO (CascadeParameter n a))
-> (forall b. Ptr b -> Int -> CascadeParameter n a -> IO ())
-> (Ptr (CascadeParameter n a) -> IO (CascadeParameter n a))
-> (Ptr (CascadeParameter n a) -> CascadeParameter n a -> IO ())
-> Storable (CascadeParameter n a)
forall b. Ptr b -> Int -> IO (CascadeParameter n a)
forall b. Ptr b -> Int -> CascadeParameter n a -> IO ()
forall a.
(a -> Int)
-> (a -> Int)
-> (Ptr a -> Int -> IO a)
-> (Ptr a -> Int -> a -> IO ())
-> (forall b. Ptr b -> Int -> IO a)
-> (forall b. Ptr b -> Int -> a -> IO ())
-> (Ptr a -> IO a)
-> (Ptr a -> a -> IO ())
-> Storable a
forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> IO (CascadeParameter n a)
forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> Int -> IO (CascadeParameter n a)
forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> Int -> CascadeParameter n a -> IO ()
forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> CascadeParameter n a -> IO ()
forall n a. Storable a => CascadeParameter n a -> Int
forall n a b.
Storable a =>
Ptr b -> Int -> IO (CascadeParameter n a)
forall n a b.
Storable a =>
Ptr b -> Int -> CascadeParameter n a -> IO ()
$csizeOf :: forall n a. Storable a => CascadeParameter n a -> Int
sizeOf :: CascadeParameter n a -> Int
$calignment :: forall n a. Storable a => CascadeParameter n a -> Int
alignment :: CascadeParameter n a -> Int
$cpeekElemOff :: forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> Int -> IO (CascadeParameter n a)
peekElemOff :: Ptr (CascadeParameter n a) -> Int -> IO (CascadeParameter n a)
$cpokeElemOff :: forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> Int -> CascadeParameter n a -> IO ()
pokeElemOff :: Ptr (CascadeParameter n a) -> Int -> CascadeParameter n a -> IO ()
$cpeekByteOff :: forall n a b.
Storable a =>
Ptr b -> Int -> IO (CascadeParameter n a)
peekByteOff :: forall b. Ptr b -> Int -> IO (CascadeParameter n a)
$cpokeByteOff :: forall n a b.
Storable a =>
Ptr b -> Int -> CascadeParameter n a -> IO ()
pokeByteOff :: forall b. Ptr b -> Int -> CascadeParameter n a -> IO ()
$cpeek :: forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> IO (CascadeParameter n a)
peek :: Ptr (CascadeParameter n a) -> IO (CascadeParameter n a)
$cpoke :: forall n a.
Storable a =>
Ptr (CascadeParameter n a) -> CascadeParameter n a -> IO ()
poke :: Ptr (CascadeParameter n a) -> CascadeParameter n a -> IO ()
Storable,
          (forall a b.
 (a -> b) -> CascadeParameter n a -> CascadeParameter n b)
-> (forall a b. a -> CascadeParameter n b -> CascadeParameter n a)
-> Functor (CascadeParameter n)
forall a b. a -> CascadeParameter n b -> CascadeParameter n a
forall a b.
(a -> b) -> CascadeParameter n a -> CascadeParameter n b
forall n a b. a -> CascadeParameter n b -> CascadeParameter n a
forall n a b.
(a -> b) -> CascadeParameter n a -> CascadeParameter n b
forall (f :: * -> *).
(forall a b. (a -> b) -> f a -> f b)
-> (forall a b. a -> f b -> f a) -> Functor f
$cfmap :: forall n a b.
(a -> b) -> CascadeParameter n a -> CascadeParameter n b
fmap :: forall a b.
(a -> b) -> CascadeParameter n a -> CascadeParameter n b
$c<$ :: forall n a b. a -> CascadeParameter n b -> CascadeParameter n a
<$ :: forall a b. a -> CascadeParameter n b -> CascadeParameter n a
Functor, Functor (CascadeParameter n)
Functor (CascadeParameter n)
-> (forall a. a -> CascadeParameter n a)
-> (forall a b.
    CascadeParameter n (a -> b)
    -> CascadeParameter n a -> CascadeParameter n b)
-> (forall a b c.
    (a -> b -> c)
    -> CascadeParameter n a
    -> CascadeParameter n b
    -> CascadeParameter n c)
-> (forall a b.
    CascadeParameter n a
    -> CascadeParameter n b -> CascadeParameter n b)
-> (forall a b.
    CascadeParameter n a
    -> CascadeParameter n b -> CascadeParameter n a)
-> Applicative (CascadeParameter n)
forall n. Functor (CascadeParameter n)
forall a. a -> CascadeParameter n a
forall n a. a -> CascadeParameter n a
forall a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n a
forall a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n b
forall a b.
CascadeParameter n (a -> b)
-> CascadeParameter n a -> CascadeParameter n b
forall n a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n a
forall n a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n b
forall n a b.
CascadeParameter n (a -> b)
-> CascadeParameter n a -> CascadeParameter n b
forall a b c.
(a -> b -> c)
-> CascadeParameter n a
-> CascadeParameter n b
-> CascadeParameter n c
forall n a b c.
(a -> b -> c)
-> CascadeParameter n a
-> CascadeParameter n b
-> CascadeParameter n c
forall (f :: * -> *).
Functor f
-> (forall a. a -> f a)
-> (forall a b. f (a -> b) -> f a -> f b)
-> (forall a b c. (a -> b -> c) -> f a -> f b -> f c)
-> (forall a b. f a -> f b -> f b)
-> (forall a b. f a -> f b -> f a)
-> Applicative f
$cpure :: forall n a. a -> CascadeParameter n a
pure :: forall a. a -> CascadeParameter n a
$c<*> :: forall n a b.
CascadeParameter n (a -> b)
-> CascadeParameter n a -> CascadeParameter n b
<*> :: forall a b.
CascadeParameter n (a -> b)
-> CascadeParameter n a -> CascadeParameter n b
$cliftA2 :: forall n a b c.
(a -> b -> c)
-> CascadeParameter n a
-> CascadeParameter n b
-> CascadeParameter n c
liftA2 :: forall a b c.
(a -> b -> c)
-> CascadeParameter n a
-> CascadeParameter n b
-> CascadeParameter n c
$c*> :: forall n a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n b
*> :: forall a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n b
$c<* :: forall n a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n a
<* :: forall a b.
CascadeParameter n a
-> CascadeParameter n b -> CascadeParameter n a
App.Applicative, (forall m. Monoid m => CascadeParameter n m -> m)
-> (forall m a. Monoid m => (a -> m) -> CascadeParameter n a -> m)
-> (forall m a. Monoid m => (a -> m) -> CascadeParameter n a -> m)
-> (forall a b. (a -> b -> b) -> b -> CascadeParameter n a -> b)
-> (forall a b. (a -> b -> b) -> b -> CascadeParameter n a -> b)
-> (forall b a. (b -> a -> b) -> b -> CascadeParameter n a -> b)
-> (forall b a. (b -> a -> b) -> b -> CascadeParameter n a -> b)
-> (forall a. (a -> a -> a) -> CascadeParameter n a -> a)
-> (forall a. (a -> a -> a) -> CascadeParameter n a -> a)
-> (forall a. CascadeParameter n a -> [a])
-> (forall a. CascadeParameter n a -> Bool)
-> (forall a. CascadeParameter n a -> Int)
-> (forall a. Eq a => a -> CascadeParameter n a -> Bool)
-> (forall a. Ord a => CascadeParameter n a -> a)
-> (forall a. Ord a => CascadeParameter n a -> a)
-> (forall a. Num a => CascadeParameter n a -> a)
-> (forall a. Num a => CascadeParameter n a -> a)
-> Foldable (CascadeParameter n)
forall a. Eq a => a -> CascadeParameter n a -> Bool
forall a. Num a => CascadeParameter n a -> a
forall a. Ord a => CascadeParameter n a -> a
forall m. Monoid m => CascadeParameter n m -> m
forall a. CascadeParameter n a -> Bool
forall a. CascadeParameter n a -> Int
forall a. CascadeParameter n a -> [a]
forall a. (a -> a -> a) -> CascadeParameter n a -> a
forall n a. Eq a => a -> CascadeParameter n a -> Bool
forall n a. Num a => CascadeParameter n a -> a
forall n a. Ord a => CascadeParameter n a -> a
forall m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
forall n m. Monoid m => CascadeParameter n m -> m
forall n a. CascadeParameter n a -> Bool
forall n a. CascadeParameter n a -> Int
forall n a. CascadeParameter n a -> [a]
forall b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
forall a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
forall n a. (a -> a -> a) -> CascadeParameter n a -> a
forall n m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
forall n b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
forall n a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
forall (t :: * -> *).
(forall m. Monoid m => t m -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall m a. Monoid m => (a -> m) -> t a -> m)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall a b. (a -> b -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall b a. (b -> a -> b) -> b -> t a -> b)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. (a -> a -> a) -> t a -> a)
-> (forall a. t a -> [a])
-> (forall a. t a -> Bool)
-> (forall a. t a -> Int)
-> (forall a. Eq a => a -> t a -> Bool)
-> (forall a. Ord a => t a -> a)
-> (forall a. Ord a => t a -> a)
-> (forall a. Num a => t a -> a)
-> (forall a. Num a => t a -> a)
-> Foldable t
$cfold :: forall n m. Monoid m => CascadeParameter n m -> m
fold :: forall m. Monoid m => CascadeParameter n m -> m
$cfoldMap :: forall n m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
foldMap :: forall m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
$cfoldMap' :: forall n m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
foldMap' :: forall m a. Monoid m => (a -> m) -> CascadeParameter n a -> m
$cfoldr :: forall n a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
foldr :: forall a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
$cfoldr' :: forall n a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
foldr' :: forall a b. (a -> b -> b) -> b -> CascadeParameter n a -> b
$cfoldl :: forall n b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
foldl :: forall b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
$cfoldl' :: forall n b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
foldl' :: forall b a. (b -> a -> b) -> b -> CascadeParameter n a -> b
$cfoldr1 :: forall n a. (a -> a -> a) -> CascadeParameter n a -> a
foldr1 :: forall a. (a -> a -> a) -> CascadeParameter n a -> a
$cfoldl1 :: forall n a. (a -> a -> a) -> CascadeParameter n a -> a
foldl1 :: forall a. (a -> a -> a) -> CascadeParameter n a -> a
$ctoList :: forall n a. CascadeParameter n a -> [a]
toList :: forall a. CascadeParameter n a -> [a]
$cnull :: forall n a. CascadeParameter n a -> Bool
null :: forall a. CascadeParameter n a -> Bool
$clength :: forall n a. CascadeParameter n a -> Int
length :: forall a. CascadeParameter n a -> Int
$celem :: forall n a. Eq a => a -> CascadeParameter n a -> Bool
elem :: forall a. Eq a => a -> CascadeParameter n a -> Bool
$cmaximum :: forall n a. Ord a => CascadeParameter n a -> a
maximum :: forall a. Ord a => CascadeParameter n a -> a
$cminimum :: forall n a. Ord a => CascadeParameter n a -> a
minimum :: forall a. Ord a => CascadeParameter n a -> a
$csum :: forall n a. Num a => CascadeParameter n a -> a
sum :: forall a. Num a => CascadeParameter n a -> a
$cproduct :: forall n a. Num a => CascadeParameter n a -> a
product :: forall a. Num a => CascadeParameter n a -> a
Fold.Foldable, Functor (CascadeParameter n)
Foldable (CascadeParameter n)
Functor (CascadeParameter n)
-> Foldable (CascadeParameter n)
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b))
-> (forall (f :: * -> *) a.
    Applicative f =>
    CascadeParameter n (f a) -> f (CascadeParameter n a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> CascadeParameter n a -> m (CascadeParameter n b))
-> (forall (m :: * -> *) a.
    Monad m =>
    CascadeParameter n (m a) -> m (CascadeParameter n a))
-> Traversable (CascadeParameter n)
forall n. Functor (CascadeParameter n)
forall n. Foldable (CascadeParameter n)
forall n (m :: * -> *) a.
Monad m =>
CascadeParameter n (m a) -> m (CascadeParameter n a)
forall n (f :: * -> *) a.
Applicative f =>
CascadeParameter n (f a) -> f (CascadeParameter n a)
forall n (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CascadeParameter n a -> m (CascadeParameter n b)
forall n (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b)
forall (t :: * -> *).
Functor t
-> Foldable t
-> (forall (f :: * -> *) a b.
    Applicative f =>
    (a -> f b) -> t a -> f (t b))
-> (forall (f :: * -> *) a. Applicative f => t (f a) -> f (t a))
-> (forall (m :: * -> *) a b.
    Monad m =>
    (a -> m b) -> t a -> m (t b))
-> (forall (m :: * -> *) a. Monad m => t (m a) -> m (t a))
-> Traversable t
forall (m :: * -> *) a.
Monad m =>
CascadeParameter n (m a) -> m (CascadeParameter n a)
forall (f :: * -> *) a.
Applicative f =>
CascadeParameter n (f a) -> f (CascadeParameter n a)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CascadeParameter n a -> m (CascadeParameter n b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b)
$ctraverse :: forall n (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b)
traverse :: forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b)
$csequenceA :: forall n (f :: * -> *) a.
Applicative f =>
CascadeParameter n (f a) -> f (CascadeParameter n a)
sequenceA :: forall (f :: * -> *) a.
Applicative f =>
CascadeParameter n (f a) -> f (CascadeParameter n a)
$cmapM :: forall n (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CascadeParameter n a -> m (CascadeParameter n b)
mapM :: forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> CascadeParameter n a -> m (CascadeParameter n b)
$csequence :: forall n (m :: * -> *) a.
Monad m =>
CascadeParameter n (m a) -> m (CascadeParameter n a)
sequence :: forall (m :: * -> *) a.
Monad m =>
CascadeParameter n (m a) -> m (CascadeParameter n a)
Trav.Traversable)

instance (Tuple.Phi a) => Tuple.Phi (CascadeParameter n a) where
   phi :: forall r.
BasicBlock
-> CascadeParameter n a -> CodeGenFunction r (CascadeParameter n a)
phi BasicBlock
bb (CascadeParameter Parameter a
v) = (Parameter a -> CascadeParameter n a)
-> CodeGenFunction r (Parameter a)
-> CodeGenFunction r (CascadeParameter n a)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter (CodeGenFunction r (Parameter a)
 -> CodeGenFunction r (CascadeParameter n a))
-> CodeGenFunction r (Parameter a)
-> CodeGenFunction r (CascadeParameter n a)
forall a b. (a -> b) -> a -> b
$ BasicBlock -> Parameter a -> CodeGenFunction r (Parameter a)
forall a r. Phi a => BasicBlock -> a -> CodeGenFunction r a
forall r.
BasicBlock -> Parameter a -> CodeGenFunction r (Parameter a)
Tuple.phi BasicBlock
bb Parameter a
v
   addPhi :: forall r.
BasicBlock
-> CascadeParameter n a
-> CascadeParameter n a
-> CodeGenFunction r ()
addPhi BasicBlock
bb (CascadeParameter Parameter a
x) (CascadeParameter Parameter a
y) = BasicBlock -> Parameter a -> Parameter a -> CodeGenFunction r ()
forall a r. Phi a => BasicBlock -> a -> a -> CodeGenFunction r ()
forall r.
BasicBlock -> Parameter a -> Parameter a -> CodeGenFunction r ()
Tuple.addPhi BasicBlock
bb Parameter a
x Parameter a
y


instance (Memory.C a) => Memory.C (CascadeParameter n a) where
   type Struct (CascadeParameter n a) = Memory.Struct a
   load :: forall r.
Value (Ptr (Struct (CascadeParameter n a)))
-> CodeGenFunction r (CascadeParameter n a)
load = (Parameter a -> CascadeParameter n a)
-> Value (Ptr (Struct (Parameter a)))
-> CodeGenFunction r (CascadeParameter n a)
forall a llvmValue r.
C a =>
(a -> llvmValue)
-> Value (Ptr (Struct a)) -> CodeGenFunction r llvmValue
Memory.loadNewtype Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter
   store :: forall r.
CascadeParameter n a
-> Value (Ptr (Struct (CascadeParameter n a)))
-> CodeGenFunction r ()
store = (CascadeParameter n a -> Parameter a)
-> CascadeParameter n a
-> Value (Ptr (Struct (Parameter a)))
-> CodeGenFunction r ()
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> Value (Ptr (Struct a)) -> CodeGenFunction r ()
Memory.storeNewtype (\(CascadeParameter Parameter a
k) -> Parameter a
k)
   decompose :: forall r.
Value (Struct (CascadeParameter n a))
-> CodeGenFunction r (CascadeParameter n a)
decompose = (Parameter a -> CascadeParameter n a)
-> Value (Struct (Parameter a))
-> CodeGenFunction r (CascadeParameter n a)
forall a llvmValue r.
C a =>
(a -> llvmValue) -> Value (Struct a) -> CodeGenFunction r llvmValue
Memory.decomposeNewtype Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter
   compose :: forall r.
CascadeParameter n a
-> CodeGenFunction r (Value (Struct (CascadeParameter n a)))
compose = (CascadeParameter n a -> Parameter a)
-> CascadeParameter n a
-> CodeGenFunction r (Value (Struct (Parameter a)))
forall a llvmValue r.
C a =>
(llvmValue -> a)
-> llvmValue -> CodeGenFunction r (Value (Struct a))
Memory.composeNewtype (\(CascadeParameter Parameter a
k) -> Parameter a
k)

instance (Marshal.C a) => Marshal.C (CascadeParameter n a) where
   pack :: CascadeParameter n a -> Struct (CascadeParameter n a)
pack (CascadeParameter Parameter a
k) = Parameter a -> Struct (Parameter a)
forall a. C a => a -> Struct a
Marshal.pack Parameter a
k
   unpack :: Struct (CascadeParameter n a) -> CascadeParameter n a
unpack = Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter (Parameter a -> CascadeParameter n a)
-> (Struct a -> Parameter a) -> Struct a -> CascadeParameter n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct a -> Parameter a
Struct (Parameter a) -> Parameter a
forall a. C a => Struct a -> a
Marshal.unpack

instance (MarshalMV.C a) => MarshalMV.C (CascadeParameter n a) where
   pack :: CascadeParameter n a -> Struct (CascadeParameter n a)
pack (CascadeParameter Parameter a
k) = Parameter a -> Struct (Parameter a)
forall a. C a => a -> Struct a
MarshalMV.pack Parameter a
k
   unpack :: Struct (CascadeParameter n a) -> CascadeParameter n a
unpack = Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter (Parameter a -> CascadeParameter n a)
-> (Struct a -> Parameter a) -> Struct a -> CascadeParameter n a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Struct a -> Parameter a
Struct (Parameter a) -> Parameter a
forall a. C a => Struct a -> a
MarshalMV.unpack

instance (Storable.C a) => Storable.C (CascadeParameter n a) where
   load :: forall r.
Value (Ptr (CascadeParameter n a))
-> CodeGenFunction r (ValueOf (CascadeParameter n a))
load = (Parameter a -> CascadeParameter n a)
-> (Parameter (ValueOf a) -> Parameter (ValueOf a))
-> Value (Ptr (CascadeParameter n a))
-> CodeGenFunction r (Parameter (ValueOf a))
forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (al -> wrappedl)
-> Value (Ptr wrapped)
-> CodeGenFunction r wrappedl
Storable.loadNewtype Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter Parameter (ValueOf a) -> Parameter (ValueOf a)
forall a. a -> a
id
   store :: forall r.
ValueOf (CascadeParameter n a)
-> Value (Ptr (CascadeParameter n a)) -> CodeGenFunction r ()
store = (Parameter a -> CascadeParameter n a)
-> (Parameter (ValueOf a) -> Parameter (ValueOf a))
-> Parameter (ValueOf a)
-> Value (Ptr (CascadeParameter n a))
-> CodeGenFunction r ()
forall a al wrapped wrappedl r.
(C a, ValueOf a ~ al) =>
(a -> wrapped)
-> (wrappedl -> al)
-> wrappedl
-> Value (Ptr wrapped)
-> CodeGenFunction r ()
Storable.storeNewtype Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter Parameter (ValueOf a) -> Parameter (ValueOf a)
forall a. a -> a
id


instance (Tuple.Value a) => Tuple.Value (CascadeParameter n a) where
   type ValueOf (CascadeParameter n a) = Parameter (Tuple.ValueOf a)
   valueOf :: CascadeParameter n a -> ValueOf (CascadeParameter n a)
valueOf (CascadeParameter Parameter a
a) = Parameter a -> ValueOf (Parameter a)
forall a. Value a => a -> ValueOf a
Tuple.valueOf Parameter a
a

instance
   (Tuple.VectorValue n a) =>
      Tuple.VectorValue n (CascadeParameter m a) where
   type VectorValueOf n (CascadeParameter m a) =
            Parameter (Tuple.VectorValueOf n a)
   vectorValueOf :: Vector n (CascadeParameter m a)
-> VectorValueOf n (CascadeParameter m a)
vectorValueOf =
      (Vector n a -> VectorValueOf n a)
-> Parameter (Vector n a) -> Parameter (VectorValueOf n a)
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Vector n a -> VectorValueOf n a
forall n a. VectorValue n a => Vector n a -> VectorValueOf n a
Tuple.vectorValueOf (Parameter (Vector n a) -> Parameter (VectorValueOf n a))
-> (Vector n (CascadeParameter m a) -> Parameter (Vector n a))
-> Vector n (CascadeParameter m a)
-> Parameter (VectorValueOf n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (CascadeParameter m a -> Parameter a)
-> Vector n (CascadeParameter m a) -> Parameter (Vector n a)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> Vector n a -> f (Vector n b)
Trav.traverse (\(CascadeParameter Parameter a
k) -> Parameter a
k)

instance (MultiValue.C a) => MultiValue.C (CascadeParameter n a) where
   type Repr (CascadeParameter n a) = Parameter (MultiValue.Repr a)
   cons :: CascadeParameter n a -> T (CascadeParameter n a)
cons (CascadeParameter Parameter a
a) = T (Parameter a) -> T (CascadeParameter n a)
forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue (T (Parameter a) -> T (CascadeParameter n a))
-> T (Parameter a) -> T (CascadeParameter n a)
forall a b. (a -> b) -> a -> b
$ Parameter a -> T (Parameter a)
forall a. C a => a -> T a
MultiValue.cons Parameter a
a

   undef :: T (CascadeParameter n a)
undef = T (Parameter a) -> T (CascadeParameter n a)
forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue T (Parameter a)
forall a. C a => T a
MultiValue.undef
   zero :: T (CascadeParameter n a)
zero = T (Parameter a) -> T (CascadeParameter n a)
forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue T (Parameter a)
forall a. C a => T a
MultiValue.zero

   phi :: forall r.
BasicBlock
-> T (CascadeParameter n a)
-> CodeGenFunction r (T (CascadeParameter n a))
phi BasicBlock
bb =
      (T (Parameter a) -> T (CascadeParameter n a))
-> CodeGenFunction r (T (Parameter a))
-> CodeGenFunction r (T (CascadeParameter n a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T (Parameter a) -> T (CascadeParameter n a)
forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue (CodeGenFunction r (T (Parameter a))
 -> CodeGenFunction r (T (CascadeParameter n a)))
-> (T (CascadeParameter n a)
    -> CodeGenFunction r (T (Parameter a)))
-> T (CascadeParameter n a)
-> CodeGenFunction r (T (CascadeParameter n a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      BasicBlock
-> T (Parameter a) -> CodeGenFunction r (T (Parameter a))
forall a r. C a => BasicBlock -> T a -> CodeGenFunction r (T a)
forall r.
BasicBlock
-> T (Parameter a) -> CodeGenFunction r (T (Parameter a))
MultiValue.phi BasicBlock
bb (T (Parameter a) -> CodeGenFunction r (T (Parameter a)))
-> (T (CascadeParameter n a) -> T (Parameter a))
-> T (CascadeParameter n a)
-> CodeGenFunction r (T (Parameter a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      T (CascadeParameter n a) -> T (Parameter a)
forall m a. T (CascadeParameter m a) -> T (Parameter a)
paramFromCascadeValue
   addPhi :: forall r.
BasicBlock
-> T (CascadeParameter n a)
-> T (CascadeParameter n a)
-> CodeGenFunction r ()
addPhi BasicBlock
bb T (CascadeParameter n a)
a T (CascadeParameter n a)
b =
      BasicBlock
-> T (Parameter a) -> T (Parameter a) -> CodeGenFunction r ()
forall a r. C a => BasicBlock -> T a -> T a -> CodeGenFunction r ()
forall r.
BasicBlock
-> T (Parameter a) -> T (Parameter a) -> CodeGenFunction r ()
MultiValue.addPhi BasicBlock
bb
         (T (CascadeParameter n a) -> T (Parameter a)
forall m a. T (CascadeParameter m a) -> T (Parameter a)
paramFromCascadeValue T (CascadeParameter n a)
a)
         (T (CascadeParameter n a) -> T (Parameter a)
forall m a. T (CascadeParameter m a) -> T (Parameter a)
paramFromCascadeValue T (CascadeParameter n a)
b)

instance (MultiVector.C a) => MultiVector.C (CascadeParameter m a) where
   type Repr n (CascadeParameter m a) = Parameter (MultiVector.Repr n a)
   cons :: forall n.
Positive n =>
Vector n (CascadeParameter m a) -> T n (CascadeParameter m a)
cons =
      T n (Parameter a) -> T n (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector (T n (Parameter a) -> T n (CascadeParameter m a))
-> (Vector n (CascadeParameter m a) -> T n (Parameter a))
-> Vector n (CascadeParameter m a)
-> T n (CascadeParameter m a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Vector n (Parameter a) -> T n (Parameter a)
forall a n. (C a, Positive n) => Vector n a -> T n a
forall n. Positive n => Vector n (Parameter a) -> T n (Parameter a)
MultiVector.cons (Vector n (Parameter a) -> T n (Parameter a))
-> (Vector n (CascadeParameter m a) -> Vector n (Parameter a))
-> Vector n (CascadeParameter m a)
-> T n (Parameter a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (CascadeParameter m a -> Parameter a)
-> Vector n (CascadeParameter m a) -> Vector n (Parameter a)
forall a b. (a -> b) -> Vector n a -> Vector n b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(CascadeParameter Parameter a
a) -> Parameter a
a)
   undef :: forall n. Positive n => T n (CascadeParameter m a)
undef = T n (Parameter a) -> T n (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector T n (Parameter a)
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n (Parameter a)
MultiVector.undef
   zero :: forall n. Positive n => T n (CascadeParameter m a)
zero = T n (Parameter a) -> T n (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector T n (Parameter a)
forall a n. (C a, Positive n) => T n a
forall n. Positive n => T n (Parameter a)
MultiVector.zero

   phi :: forall n r.
Positive n =>
BasicBlock
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T n (CascadeParameter m a))
phi BasicBlock
bb =
      (T n (Parameter a) -> T n (CascadeParameter m a))
-> CodeGenFunction r (T n (Parameter a))
-> CodeGenFunction r (T n (CascadeParameter m a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n (Parameter a) -> T n (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector (CodeGenFunction r (T n (Parameter a))
 -> CodeGenFunction r (T n (CascadeParameter m a)))
-> (T n (CascadeParameter m a)
    -> CodeGenFunction r (T n (Parameter a)))
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T n (CascadeParameter m a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      BasicBlock
-> T n (Parameter a) -> CodeGenFunction r (T n (Parameter a))
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
BasicBlock
-> T n (Parameter a) -> CodeGenFunction r (T n (Parameter a))
MultiVector.phi BasicBlock
bb (T n (Parameter a) -> CodeGenFunction r (T n (Parameter a)))
-> (T n (CascadeParameter m a) -> T n (Parameter a))
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T n (Parameter a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector
   addPhi :: forall n r.
Positive n =>
BasicBlock
-> T n (CascadeParameter m a)
-> T n (CascadeParameter m a)
-> CodeGenFunction r ()
addPhi BasicBlock
bb T n (CascadeParameter m a)
a T n (CascadeParameter m a)
b =
      BasicBlock
-> T n (Parameter a) -> T n (Parameter a) -> CodeGenFunction r ()
forall a n r.
(C a, Positive n) =>
BasicBlock -> T n a -> T n a -> CodeGenFunction r ()
forall n r.
Positive n =>
BasicBlock
-> T n (Parameter a) -> T n (Parameter a) -> CodeGenFunction r ()
MultiVector.addPhi BasicBlock
bb
         (T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
a)
         (T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
b)

   shuffle :: forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n (CascadeParameter m a)
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T m (CascadeParameter m a))
shuffle ConstValue (Vector m Word32)
is T n (CascadeParameter m a)
a T n (CascadeParameter m a)
b =
      (T m (Parameter a) -> T m (CascadeParameter m a))
-> CodeGenFunction r (T m (Parameter a))
-> CodeGenFunction r (T m (CascadeParameter m a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T m (Parameter a) -> T m (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector (CodeGenFunction r (T m (Parameter a))
 -> CodeGenFunction r (T m (CascadeParameter m a)))
-> CodeGenFunction r (T m (Parameter a))
-> CodeGenFunction r (T m (CascadeParameter m a))
forall a b. (a -> b) -> a -> b
$
      ConstValue (Vector m Word32)
-> T n (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T m (Parameter a))
forall a n m r.
(C a, Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n a -> T n a -> CodeGenFunction r (T m a)
forall n m r.
(Positive n, Positive m) =>
ConstValue (Vector m Word32)
-> T n (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T m (Parameter a))
MultiVector.shuffle ConstValue (Vector m Word32)
is
         (T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
a) (T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
b)
   extract :: forall n r.
Positive n =>
Value Word32
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T (CascadeParameter m a))
extract Value Word32
i T n (CascadeParameter m a)
v =
      (T (Parameter a) -> T (CascadeParameter m a))
-> CodeGenFunction r (T (Parameter a))
-> CodeGenFunction r (T (CascadeParameter m a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T (Parameter a) -> T (CascadeParameter m a)
forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue (CodeGenFunction r (T (Parameter a))
 -> CodeGenFunction r (T (CascadeParameter m a)))
-> CodeGenFunction r (T (Parameter a))
-> CodeGenFunction r (T (CascadeParameter m a))
forall a b. (a -> b) -> a -> b
$
      Value Word32
-> T n (Parameter a) -> CodeGenFunction r (T (Parameter a))
forall a n r.
(C a, Positive n) =>
Value Word32 -> T n a -> CodeGenFunction r (T a)
forall n r.
Positive n =>
Value Word32
-> T n (Parameter a) -> CodeGenFunction r (T (Parameter a))
MultiVector.extract Value Word32
i (T n (Parameter a) -> CodeGenFunction r (T (Parameter a)))
-> T n (Parameter a) -> CodeGenFunction r (T (Parameter a))
forall a b. (a -> b) -> a -> b
$
      T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
v
   insert :: forall n r.
Positive n =>
Value Word32
-> T (CascadeParameter m a)
-> T n (CascadeParameter m a)
-> CodeGenFunction r (T n (CascadeParameter m a))
insert Value Word32
i T (CascadeParameter m a)
a T n (CascadeParameter m a)
v =
      (T n (Parameter a) -> T n (CascadeParameter m a))
-> CodeGenFunction r (T n (Parameter a))
-> CodeGenFunction r (T n (CascadeParameter m a))
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T n (Parameter a) -> T n (CascadeParameter m a)
forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector (CodeGenFunction r (T n (Parameter a))
 -> CodeGenFunction r (T n (CascadeParameter m a)))
-> CodeGenFunction r (T n (Parameter a))
-> CodeGenFunction r (T n (CascadeParameter m a))
forall a b. (a -> b) -> a -> b
$
      Value Word32
-> T (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T n (Parameter a))
forall a n r.
(C a, Positive n) =>
Value Word32 -> T a -> T n a -> CodeGenFunction r (T n a)
forall n r.
Positive n =>
Value Word32
-> T (Parameter a)
-> T n (Parameter a)
-> CodeGenFunction r (T n (Parameter a))
MultiVector.insert Value Word32
i (T (CascadeParameter m a) -> T (Parameter a)
forall m a. T (CascadeParameter m a) -> T (Parameter a)
paramFromCascadeValue T (CascadeParameter m a)
a) (T n (Parameter a) -> CodeGenFunction r (T n (Parameter a)))
-> T n (Parameter a) -> CodeGenFunction r (T n (Parameter a))
forall a b. (a -> b) -> a -> b
$
      T n (CascadeParameter m a) -> T n (Parameter a)
forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector T n (CascadeParameter m a)
v

cascadeFromParamVector ::
   MultiVector.T n (Allpass.Parameter a) ->
   MultiVector.T n (CascadeParameter m a)
cascadeFromParamVector :: forall n a m. T n (Parameter a) -> T n (CascadeParameter m a)
cascadeFromParamVector = (Repr n (Parameter a) -> Repr n (CascadeParameter m a))
-> T n (Parameter a) -> T n (CascadeParameter m a)
forall n a b. (Repr n a -> Repr n b) -> T n a -> T n b
MultiVector.lift1 Repr n (Parameter a) -> Repr n (CascadeParameter m a)
Parameter (Repr n a) -> Parameter (Repr n a)
forall a. a -> a
id

paramFromCascadeVector ::
   MultiVector.T n (CascadeParameter m a) ->
   MultiVector.T n (Allpass.Parameter a)
paramFromCascadeVector :: forall n m a. T n (CascadeParameter m a) -> T n (Parameter a)
paramFromCascadeVector = (Repr n (CascadeParameter m a) -> Repr n (Parameter a))
-> T n (CascadeParameter m a) -> T n (Parameter a)
forall n a b. (Repr n a -> Repr n b) -> T n a -> T n b
MultiVector.lift1 Repr n (CascadeParameter m a) -> Repr n (Parameter a)
Parameter (Repr n a) -> Parameter (Repr n a)
forall a. a -> a
id

cascadeFromParamValue ::
   MultiValue.T (Allpass.Parameter a) ->
   MultiValue.T (CascadeParameter m a)
cascadeFromParamValue :: forall a m. T (Parameter a) -> T (CascadeParameter m a)
cascadeFromParamValue = (Repr (Parameter a) -> Repr (CascadeParameter m a))
-> T (Parameter a) -> T (CascadeParameter m a)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr (Parameter a) -> Repr (CascadeParameter m a)
Parameter (Repr a) -> Parameter (Repr a)
forall a. a -> a
id

paramFromCascadeValue ::
   MultiValue.T (CascadeParameter m a) ->
   MultiValue.T (Allpass.Parameter a)
paramFromCascadeValue :: forall m a. T (CascadeParameter m a) -> T (Parameter a)
paramFromCascadeValue = (Repr (CascadeParameter m a) -> Repr (Parameter a))
-> T (CascadeParameter m a) -> T (Parameter a)
forall a b. (Repr a -> Repr b) -> T a -> T b
MultiValue.lift1 Repr (CascadeParameter m a) -> Repr (Parameter a)
Parameter (Repr a) -> Parameter (Repr a)
forall a. a -> a
id


instance (Vector.Simple v) => Vector.Simple (CascadeParameter n v) where
   type Element (CascadeParameter n v) = CascadeParameter n (Vector.Element v)
   type Size (CascadeParameter n v) = Vector.Size v
   shuffleMatch :: forall r.
ConstValue (Vector (Size (CascadeParameter n v)) Word32)
-> CascadeParameter n v -> CodeGenFunction r (CascadeParameter n v)
shuffleMatch = ConstValue (Vector (Size v) Word32)
-> CascadeParameter n v -> CodeGenFunction r (CascadeParameter n v)
ConstValue (Vector (Size (CascadeParameter n v)) Word32)
-> CascadeParameter n v -> CodeGenFunction r (CascadeParameter n v)
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
ConstValue (Vector (Size v) Word32)
-> f v -> CodeGenFunction r (f v)
Vector.shuffleMatchTraversable
   extract :: forall r.
Value Word32
-> CascadeParameter n v
-> CodeGenFunction r (Element (CascadeParameter n v))
extract = Value Word32
-> CascadeParameter n v
-> CodeGenFunction r (Element (CascadeParameter n v))
Value Word32
-> CascadeParameter n v
-> CodeGenFunction r (CascadeParameter n (Element v))
forall v (f :: * -> *) r.
(Simple v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
Vector.extractTraversable

instance (Vector.C v) => Vector.C (CascadeParameter n v) where
   insert :: forall r.
Value Word32
-> Element (CascadeParameter n v)
-> CascadeParameter n v
-> CodeGenFunction r (CascadeParameter n v)
insert  = Value Word32
-> Element (CascadeParameter n v)
-> CascadeParameter n v
-> CodeGenFunction r (CascadeParameter n v)
Value Word32
-> CascadeParameter n (Element v)
-> CascadeParameter n v
-> CodeGenFunction r (CascadeParameter n v)
forall v (f :: * -> *) r.
(C v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
Vector.insertTraversable

type instance F.Arguments f (CascadeParameter n a) = f (CascadeParameter n a)
instance F.MakeArguments (CascadeParameter n a) where
   makeArgs :: forall (f :: * -> *).
Functor f =>
f (CascadeParameter n a) -> Arguments f (CascadeParameter n a)
makeArgs = f (CascadeParameter n a) -> f (CascadeParameter n a)
f (CascadeParameter n a) -> Arguments f (CascadeParameter n a)
forall a. a -> a
id


instance
   (Expr.Aggregate e mv, n ~ m) =>
      Expr.Aggregate (CascadeParameter n e) (CascadeParameter m mv) where
   type MultiValuesOf (CascadeParameter n e) =
            CascadeParameter n (Expr.MultiValuesOf e)
   type ExpressionsOf (CascadeParameter m mv) =
            CascadeParameter m (Expr.ExpressionsOf mv)
   bundle :: forall r.
CascadeParameter n e -> CodeGenFunction r (CascadeParameter m mv)
bundle = (e -> CodeGenFunction r mv)
-> CascadeParameter n e
-> CodeGenFunction r (CascadeParameter n mv)
forall (t :: * -> *) (f :: * -> *) a b.
(Traversable t, Applicative f) =>
(a -> f b) -> t a -> f (t b)
forall (f :: * -> *) a b.
Applicative f =>
(a -> f b) -> CascadeParameter n a -> f (CascadeParameter n b)
Trav.traverse e -> CodeGenFunction r mv
forall r. e -> CodeGenFunction r mv
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
Expr.bundle
   dissect :: CascadeParameter m mv -> CascadeParameter n e
dissect = (mv -> e) -> CascadeParameter m mv -> CascadeParameter m e
forall a b.
(a -> b) -> CascadeParameter m a -> CascadeParameter m b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap mv -> e
forall exp mv. Aggregate exp mv => mv -> exp
Expr.dissect


flangerParameter ::
   (Trans.C a, TypeNum.Natural n) =>
   Proxy n -> a -> CascadeParameter n a
flangerParameter :: forall a n.
(C a, Natural n) =>
Proxy n -> a -> CascadeParameter n a
flangerParameter Proxy n
order a
freq =
   Parameter a -> CascadeParameter n a
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter (Parameter a -> CascadeParameter n a)
-> Parameter a -> CascadeParameter n a
forall a b. (a -> b) -> a -> b
$
   Int -> a -> Parameter a
forall a. C a => Int -> a -> Parameter a
Allpass.flangerParameter (Proxy n -> Int
forall n a. (Integer n, Num a) => Proxy n -> a
TypeNum.integralFromProxy Proxy n
order) a
freq


causal ::
   (Module.C ae ve, Expr.Aggregate ae a, Expr.Aggregate ve v, Memory.C v) =>
   Causal.T (Parameter a, v) v
causal :: forall ae ve a v.
(C ae ve, Aggregate ae a, Aggregate ve v, C v) =>
T (Parameter a, v) v
causal = Simple (State ve) (Parameter ae) ve ve -> T (Parameter a, v) v
forall ae al be bl ce cl se sl.
(Aggregate ae al, Aggregate be bl, Aggregate ce cl,
 Aggregate se sl, C sl) =>
Simple se ce ae be -> T (cl, al) bl
Causal.fromModifier Simple (State ve) (Parameter ae) ve ve
forall a v. (C a, C a v) => Simple (State v) (Parameter a) v v
Allpass.firstOrderModifier


replicateStage ::
   (TypeNum.Natural n) =>
   (Tuple.Phi a, Tuple.Undefined a) =>
   (Tuple.Phi b, Tuple.Undefined b) =>
   Proxy n ->
   Causal.T (Parameter a, b) b ->
   Causal.T (CascadeParameter n a, b) b
replicateStage :: forall n a b.
(Natural n, Phi a, Undefined a, Phi b, Undefined b) =>
Proxy n -> T (Parameter a, b) b -> T (CascadeParameter n a, b) b
replicateStage Proxy n
order T (Parameter a, b) b
stg =
   Exp Word
-> T (CascadeParameter n a, b) b -> T (CascadeParameter n a, b) b
forall a c.
(Undefined a, Phi a) =>
Exp Word -> T (c, a) a -> T (c, a) a
Causal.replicateControlled
      (Proxy n -> Exp Word
forall n a. (Integer n, Num a) => Proxy n -> a
TypeNum.integralFromProxy Proxy n
order)
      (T (Parameter a, b) b
stg T (Parameter a, b) b
-> T (CascadeParameter n a, b) (Parameter a, b)
-> T (CascadeParameter n a, b) b
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< T (CascadeParameter n a) (Parameter a)
-> T (CascadeParameter n a, b) (Parameter a, b)
forall b c d. T b c -> T (b, d) (c, d)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (b, d) (c, d)
first ((CascadeParameter n a -> Parameter a)
-> T (CascadeParameter n a) (Parameter a)
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (\(CascadeParameter Parameter a
p) -> Parameter a
p)))

cascade ::
   (TypeNum.Natural n) =>
   (Module.C ae ve, Expr.Aggregate ae a, Expr.Aggregate ve v, Memory.C v) =>
   (Tuple.Phi a, Tuple.Undefined a) =>
   (Tuple.Phi v, Tuple.Undefined v) =>
   Causal.T (CascadeParameter n a, v) v
cascade :: forall n ae ve a v.
(Natural n, C ae ve, Aggregate ae a, Aggregate ve v, C v, Phi a,
 Undefined a, Phi v, Undefined v) =>
T (CascadeParameter n a, v) v
cascade = Proxy n -> T (Parameter a, v) v -> T (CascadeParameter n a, v) v
forall n a b.
(Natural n, Phi a, Undefined a, Phi b, Undefined b) =>
Proxy n -> T (Parameter a, b) b -> T (CascadeParameter n a, b) b
replicateStage Proxy n
forall a. Proxy a
Proxy T (Parameter a, v) v
forall ae ve a v.
(C ae ve, Aggregate ae a, Aggregate ve v, C v) =>
T (Parameter a, v) v
causal

halfVector ::
   (A.RationalConstant a, a ~ A.Scalar v, A.PseudoModule v) =>
   Causal.T v v
halfVector :: forall a v.
(RationalConstant a, a ~ Scalar v, PseudoModule v) =>
T v v
halfVector = (forall r. v -> CodeGenFunction r v) -> T v v
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map (Scalar v -> v -> CodeGenFunction r v
forall v r. PseudoModule v => Scalar v -> v -> CodeGenFunction r v
forall r. Scalar v -> v -> CodeGenFunction r v
A.scale (Scalar v -> v -> CodeGenFunction r v)
-> Scalar v -> v -> CodeGenFunction r v
forall a b. (a -> b) -> a -> b
$ Rational -> a
forall a. RationalConstant a => Rational -> a
A.fromRational' Rational
0.5)

phaser ::
   (TypeNum.Natural n) =>
   (Module.C ae ve, Expr.Aggregate ae a, Expr.Aggregate ve v, Memory.C v) =>
   (Tuple.Phi a, Tuple.Undefined a) =>
   (Tuple.Phi v, Tuple.Undefined v) =>
   (A.RationalConstant a, a ~ A.Scalar v, A.PseudoModule v) =>
   Causal.T (CascadeParameter n a, v) v
phaser :: forall n ae ve a v.
(Natural n, C ae ve, Aggregate ae a, Aggregate ve v, C v, Phi a,
 Undefined a, Phi v, Undefined v, RationalConstant a, a ~ Scalar v,
 PseudoModule v) =>
T (CascadeParameter n a, v) v
phaser = (T (CascadeParameter n a, v) v
forall n ae ve a v.
(Natural n, C ae ve, Aggregate ae a, Aggregate ve v, C v, Phi a,
 Undefined a, Phi v, Undefined v) =>
T (CascadeParameter n a, v) v
cascade T (CascadeParameter n a, v) v
-> T (CascadeParameter n a, v) v -> T (CascadeParameter n a, v) v
forall a. C a => a -> a -> a
+ ((CascadeParameter n a, v) -> v) -> T (CascadeParameter n a, v) v
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (CascadeParameter n a, v) -> v
forall a b. (a, b) -> b
snd) T (CascadeParameter n a, v) v
-> T (CascadeParameter n a, v) (CascadeParameter n a, v)
-> T (CascadeParameter n a, v) v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<< T v v -> T (CascadeParameter n a, v) (CascadeParameter n a, v)
forall b c d. T b c -> T (d, b) (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second T v v
forall a v.
(RationalConstant a, a ~ Scalar v, PseudoModule v) =>
T v v
halfVector


paramFromCascadeParam ::
   MultiValue.T (CascadeParameter n a) ->
   Allpass.Parameter (MultiValue.T a)
paramFromCascadeParam :: forall n a. T (CascadeParameter n a) -> Parameter (T a)
paramFromCascadeParam (MultiValue.Cons Repr (CascadeParameter n a)
a) =
   (Repr a -> T a) -> Parameter (Repr a) -> Parameter (T a)
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons Repr (CascadeParameter n a)
Parameter (Repr a)
a

{-
It shouldn't be too hard to use vector operations for the code we generate,
but LLVM-2.6 does not yet do it.
-}
stage ::
   (TypeNum.Positive n, MultiVector.C a,
    MultiVector.T n (CascadeParameter n a, a) ~ v,
    MultiValue.PseudoRing a, MultiValue.IntegerConstant a,
    MarshalMV.C a) =>
   Proxy n -> Causal.T v v
stage :: forall n a v.
(Positive n, C a, T n (CascadeParameter n a, a) ~ v, PseudoRing a,
 IntegerConstant a, C a) =>
Proxy n -> T v v
stage Proxy n
_ =
   T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
-> T v v
forall n x a va y b vb.
(Positive n, C x, T x ~ a, T n x ~ va, C y, T y ~ b, T n y ~ vb) =>
T a b -> T va vb
Causal.vectorize (T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
 -> T v v)
-> T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
-> T v v
forall a b. (a -> b) -> a -> b
$
      (T (CascadeParameter n a) -> T a -> T (CascadeParameter n a, a))
-> (T (CascadeParameter n a), T a) -> T (CascadeParameter n a, a)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T (CascadeParameter n a) -> T a -> T (CascadeParameter n a, a)
forall a b. T a -> T b -> T (a, b)
MultiValue.zip
      ((T (CascadeParameter n a), T a) -> T (CascadeParameter n a, a))
-> T (T (CascadeParameter n a, a)) (T (CascadeParameter n a), T a)
-> T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
forall (a :: * -> * -> *) c d b.
Arrow a =>
(c -> d) -> a b c -> a b d
^<<
      (((T (CascadeParameter n a), T a) -> T (CascadeParameter n a))
-> T (T (CascadeParameter n a), T a) (T (CascadeParameter n a))
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (T (CascadeParameter n a), T a) -> T (CascadeParameter n a)
forall a b. (a, b) -> a
fst T (T (CascadeParameter n a), T a) (T (CascadeParameter n a))
-> T (T (CascadeParameter n a), T a) (T a)
-> T (T (CascadeParameter n a), T a)
     (T (CascadeParameter n a), T a)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&&
       (T (T a) -> T a
forall a. T a -> a
Scalar.decons
        (T (T a) -> T a)
-> T (T (CascadeParameter n a), T a) (T (T a))
-> T (T (CascadeParameter n a), T a) (T a)
forall (a :: * -> * -> *) c d b.
Arrow a =>
(c -> d) -> a b c -> a b d
^<<
        T (Parameter (T (T a)), T (T a)) (T (T a))
forall ae ve a v.
(C ae ve, Aggregate ae a, Aggregate ve v, C v) =>
T (Parameter a, v) v
causal
        T (Parameter (T (T a)), T (T a)) (T (T a))
-> ((T (CascadeParameter n a), T a)
    -> (Parameter (T (T a)), T (T a)))
-> T (T (CascadeParameter n a), T a) (T (T a))
forall (a :: * -> * -> *) c d b.
Arrow a =>
a c d -> (b -> c) -> a b d
<<^
        (\(T (CascadeParameter n a)
p, T a
v) ->
           ((T a -> T (T a)) -> Parameter (T a) -> Parameter (T (T a))
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap T a -> T (T a)
forall a. a -> T a
Scalar.Cons (Parameter (T a) -> Parameter (T (T a)))
-> Parameter (T a) -> Parameter (T (T a))
forall a b. (a -> b) -> a -> b
$ T (CascadeParameter n a) -> Parameter (T a)
forall n a. T (CascadeParameter n a) -> Parameter (T a)
paramFromCascadeParam T (CascadeParameter n a)
p, T a -> T (T a)
forall a. a -> T a
Scalar.Cons T a
v))))
      T (T (CascadeParameter n a), T a) (T (CascadeParameter n a), T a)
-> (T (CascadeParameter n a, a) -> (T (CascadeParameter n a), T a))
-> T (T (CascadeParameter n a, a)) (T (CascadeParameter n a), T a)
forall (a :: * -> * -> *) c d b.
Arrow a =>
a c d -> (b -> c) -> a b d
<<^
      T (CascadeParameter n a, a) -> (T (CascadeParameter n a), T a)
forall a b. T (a, b) -> (T a, T b)
MultiValue.unzip

withSize ::
   (Proxy n -> Causal.T (mv (CascadeParameter n a), b) c) ->
   Causal.T (mv (CascadeParameter n a), b) c
withSize :: forall n (mv :: * -> *) a b c.
(Proxy n -> T (mv (CascadeParameter n a), b) c)
-> T (mv (CascadeParameter n a), b) c
withSize Proxy n -> T (mv (CascadeParameter n a), b) c
f = Proxy n -> T (mv (CascadeParameter n a), b) c
f Proxy n
forall a. Proxy a
Proxy

{- |
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.
-}
cascadePipeline ::
   (TypeNum.Positive n, MultiVector.C a,
    Tuple.ValueOf a ~ ar,
    MultiValue.PseudoRing a, MultiValue.IntegerConstant a,
    MarshalMV.C a, MarshalMV.Vector n a) =>
   Causal.T
      (MultiValue.T (CascadeParameter n a), MultiValue.T a)
      (MultiValue.T a)
cascadePipeline :: forall n a ar.
(Positive n, C a, ValueOf a ~ ar, PseudoRing a, IntegerConstant a,
 C a, Vector n a) =>
T (T (CascadeParameter n a), T a) (T a)
cascadePipeline = (Proxy n -> T (T (CascadeParameter n a), T a) (T a))
-> T (T (CascadeParameter n a), T a) (T a)
forall n (mv :: * -> *) a b c.
(Proxy n -> T (mv (CascadeParameter n a), b) c)
-> T (mv (CascadeParameter n a), b) c
withSize ((Proxy n -> T (T (CascadeParameter n a), T a) (T a))
 -> T (T (CascadeParameter n a), T a) (T a))
-> (Proxy n -> T (T (CascadeParameter n a), T a) (T a))
-> T (T (CascadeParameter n a), T a) (T a)
forall a b. (a -> b) -> a -> b
$ \Proxy n
order ->
   T (CascadeParameter n a, a) -> T a
forall a b. T (a, b) -> T b
MultiValue.snd
   (T (CascadeParameter n a, a) -> T a)
-> T (T (CascadeParameter n a), T a) (T (CascadeParameter n a, a))
-> T (T (CascadeParameter n a), T a) (T a)
forall (a :: * -> * -> *) c d b.
Arrow a =>
(c -> d) -> a b c -> a b d
^<<
   T (T n (CascadeParameter n a, a)) (T n (CascadeParameter n a, a))
-> T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
forall n x v a.
(Positive n, C x, v ~ T n x, a ~ T x, Zero v, C v) =>
T v v -> T a a
Causal.pipeline (Proxy n
-> T (T n (CascadeParameter n a, a))
     (T n (CascadeParameter n a, a))
forall n a v.
(Positive n, C a, T n (CascadeParameter n a, a) ~ v, PseudoRing a,
 IntegerConstant a, C a) =>
Proxy n -> T v v
stage Proxy n
order)
   T (T (CascadeParameter n a, a)) (T (CascadeParameter n a, a))
-> ((T (CascadeParameter n a), T a) -> T (CascadeParameter n a, a))
-> T (T (CascadeParameter n a), T a) (T (CascadeParameter n a, a))
forall (a :: * -> * -> *) c d b.
Arrow a =>
a c d -> (b -> c) -> a b d
<<^
   (T (CascadeParameter n a) -> T a -> T (CascadeParameter n a, a))
-> (T (CascadeParameter n a), T a) -> T (CascadeParameter n a, a)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T (CascadeParameter n a) -> T a -> T (CascadeParameter n a, a)
forall a b. T a -> T b -> T (a, b)
MultiValue.zip

vectorId ::
   Proxy n -> Causal.T (MultiVector.T n a) (MultiVector.T n a)
vectorId :: forall n a. Proxy n -> T (T n a) (T n a)
vectorId Proxy n
_ = T (T n a) (T n a)
forall a. T a a
forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
Cat.id

half ::
   (A.RationalConstant a, A.PseudoRing a) =>
   Causal.T a a
half :: forall a. (RationalConstant a, PseudoRing a) => T a a
half = (forall r. a -> CodeGenFunction r a) -> T a a
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul (Rational -> a
forall a. RationalConstant a => Rational -> a
A.fromRational' Rational
0.5))


causalPacked,
  causalNonRecursivePacked ::
   (Serial.Write v, Serial.Element v ~ a,
    A.PseudoRing a, A.IntegerConstant a, Memory.C a,
    A.PseudoRing v, A.IntegerConstant v) =>
   Causal.T (Parameter a, v) v

causalPacked :: forall v a.
(Write v, Element v ~ a, PseudoRing a, IntegerConstant a, C a,
 PseudoRing v, IntegerConstant v) =>
T (Parameter a, v) v
causalPacked =
   T (Parameter a, v) v
forall v a.
(Write v, Element v ~ a, PseudoRing v, IntegerConstant v,
 PseudoRing a, IntegerConstant a, C a) =>
T (Parameter a, v) v
Filt1L.causalRecursivePacked T (Parameter a, v) v
-> T (Parameter a, v) (Parameter a, v) -> T (Parameter a, v) v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
   ((forall r. (Parameter a, v) -> CodeGenFunction r (Parameter a))
-> T (Parameter a, v) (Parameter a)
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map (\(Parameter a
k, v
_) -> (a -> Parameter a)
-> CodeGenFunction r a -> CodeGenFunction r (Parameter a)
forall a b. (a -> b) -> CodeGenFunction r a -> CodeGenFunction r b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> Parameter a
forall a. a -> Parameter a
Filt1.Parameter (CodeGenFunction r a -> CodeGenFunction r (Parameter a))
-> CodeGenFunction r a -> CodeGenFunction r (Parameter a)
forall a b. (a -> b) -> a -> b
$ a -> CodeGenFunction r a
forall r. a -> CodeGenFunction r a
forall a r. Additive a => a -> CodeGenFunction r a
A.neg a
k) T (Parameter a, v) (Parameter a)
-> T (Parameter a, v) v -> T (Parameter a, v) (Parameter a, v)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&&
    T (Parameter a, v) v
forall v a.
(Write v, Element v ~ a, PseudoRing a, IntegerConstant a, C a,
 PseudoRing v, IntegerConstant v) =>
T (Parameter a, v) v
causalNonRecursivePacked)

causalNonRecursivePacked :: forall v a.
(Write v, Element v ~ a, PseudoRing a, IntegerConstant a, C a,
 PseudoRing v, IntegerConstant v) =>
T (Parameter a, v) v
causalNonRecursivePacked =
   (forall r. (Parameter a, v) -> a -> CodeGenFunction r (v, a))
-> (forall r. CodeGenFunction r a) -> T (Parameter a, v) v
forall state a b.
C state =>
(forall r. a -> state -> CodeGenFunction r (b, state))
-> (forall r. CodeGenFunction r state) -> T a b
CausalPriv.mapAccum
      (\(Parameter a
k, v
v0) a
x1 -> do
         (a
_,v
v1) <- Element v -> v -> CodeGenFunction r (Element v, v)
forall v r.
Write v =>
Element v -> v -> CodeGenFunction r (Element v, v)
Serial.shiftUp a
Element v
x1 v
v0
         v
y <- v -> v -> CodeGenFunction r v
forall r. v -> v -> CodeGenFunction r v
forall a r. Additive a => a -> a -> CodeGenFunction r a
A.add v
v1 (v -> CodeGenFunction r v)
-> CodeGenFunction r v -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< v -> v -> CodeGenFunction r v
forall r. v -> v -> CodeGenFunction r v
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul v
v0 (v -> CodeGenFunction r v)
-> CodeGenFunction r v -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Element v -> CodeGenFunction r v
forall v r. Write v => Element v -> CodeGenFunction r v
Serial.upsample a
Element v
k
         a
u0 <- v -> CodeGenFunction r (Element v)
forall v r. Read v => v -> CodeGenFunction r (Element v)
Serial.last v
v0
         (v, a) -> CodeGenFunction r (v, a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (v
y, a
u0))
      (a -> CodeGenFunction r a
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return a
forall a. Additive a => a
A.zero)

cascadePacked, phaserPacked ::
   (TypeNum.Natural n,
    Serial.Write v, Serial.Element v ~ a,
    A.PseudoRing a, A.IntegerConstant a, Memory.C a,
    A.PseudoRing v, A.RationalConstant v) =>
   Causal.T (CascadeParameter n a, v) v
cascadePacked :: forall n v a.
(Natural n, Write v, Element v ~ a, PseudoRing a,
 IntegerConstant a, C a, PseudoRing v, RationalConstant v) =>
T (CascadeParameter n a, v) v
cascadePacked = Proxy n -> T (Parameter a, v) v -> T (CascadeParameter n a, v) v
forall n a b.
(Natural n, Phi a, Undefined a, Phi b, Undefined b) =>
Proxy n -> T (Parameter a, b) b -> T (CascadeParameter n a, b) b
replicateStage Proxy n
forall a. Proxy a
Proxy T (Parameter a, v) v
forall v a.
(Write v, Element v ~ a, PseudoRing a, IntegerConstant a, C a,
 PseudoRing v, IntegerConstant v) =>
T (Parameter a, v) v
causalPacked

phaserPacked :: forall n v a.
(Natural n, Write v, Element v ~ a, PseudoRing a,
 IntegerConstant a, C a, PseudoRing v, RationalConstant v) =>
T (CascadeParameter n a, v) v
phaserPacked =
   (T (CascadeParameter n a, v) v
forall n v a.
(Natural n, Write v, Element v ~ a, PseudoRing a,
 IntegerConstant a, C a, PseudoRing v, RationalConstant v) =>
T (CascadeParameter n a, v) v
cascadePacked T (CascadeParameter n a, v) v
-> T (CascadeParameter n a, v) v -> T (CascadeParameter n a, v) v
forall a. C a => a -> a -> a
+ ((CascadeParameter n a, v) -> v) -> T (CascadeParameter n a, v) v
forall b c. (b -> c) -> T b c
forall (a :: * -> * -> *) b c. Arrow a => (b -> c) -> a b c
arr (CascadeParameter n a, v) -> v
forall a b. (a, b) -> b
snd) T (CascadeParameter n a, v) v
-> T (CascadeParameter n a, v) (CascadeParameter n a, v)
-> T (CascadeParameter n a, v) v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
   T v v -> T (CascadeParameter n a, v) (CascadeParameter n a, v)
forall b c d. T b c -> T (d, b) (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second ((forall r. v -> CodeGenFunction r v) -> T v v
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map (v -> v -> CodeGenFunction r v
forall r. v -> v -> CodeGenFunction r v
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul (Rational -> v
forall a. RationalConstant a => Rational -> a
A.fromRational' Rational
0.5)))


-- ToDo: consistent naming with Exponential2
cascadeParameterMultiValue ::
   CascadeParameter n (MultiValue.T a) ->
   MultiValue.T (CascadeParameter n a)
cascadeParameterMultiValue :: forall n a. CascadeParameter n (T a) -> T (CascadeParameter n a)
cascadeParameterMultiValue (CascadeParameter Parameter (T a)
k) =
   Repr (CascadeParameter n a) -> T (CascadeParameter n a)
forall a. Repr a -> T a
MultiValue.Cons (Repr (CascadeParameter n a) -> T (CascadeParameter n a))
-> Repr (CascadeParameter n a) -> T (CascadeParameter n a)
forall a b. (a -> b) -> a -> b
$ (T a -> Repr a) -> Parameter (T a) -> Parameter (Repr a)
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr a
a) -> Repr a
a) Parameter (T a)
k

cascadeParameterUnMultiValue ::
   MultiValue.T (CascadeParameter n a) ->
   CascadeParameter n (MultiValue.T a)
cascadeParameterUnMultiValue :: forall n a. T (CascadeParameter n a) -> CascadeParameter n (T a)
cascadeParameterUnMultiValue (MultiValue.Cons Repr (CascadeParameter n a)
k) =
   Parameter (T a) -> CascadeParameter n (T a)
forall n a. Parameter a -> CascadeParameter n a
CascadeParameter (Parameter (T a) -> CascadeParameter n (T a))
-> Parameter (T a) -> CascadeParameter n (T a)
forall a b. (a -> b) -> a -> b
$ (Repr a -> T a) -> Parameter (Repr a) -> Parameter (T a)
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Repr a -> T a
forall a. Repr a -> T a
MultiValue.Cons Repr (CascadeParameter n a)
Parameter (Repr a)
k


phaserPipelineMV ::
   (TypeNum.Positive n,
    MultiValue.PseudoRing a, MultiValue.RationalConstant a,
    Marshal.C a, MarshalMV.Vector n a) =>
   Causal.T
      (MultiValue.T (CascadeParameter n a), MultiValue.T a)
      (MultiValue.T a)
phaserPipelineMV :: forall n a.
(Positive n, PseudoRing a, RationalConstant a, C a, Vector n a) =>
T (T (CascadeParameter n a), T a) (T a)
phaserPipelineMV = (Proxy n -> T (T (CascadeParameter n a), T a) (T a))
-> T (T (CascadeParameter n a), T a) (T a)
forall n (mv :: * -> *) a b c.
(Proxy n -> T (mv (CascadeParameter n a), b) c)
-> T (mv (CascadeParameter n a), b) c
withSize ((Proxy n -> T (T (CascadeParameter n a), T a) (T a))
 -> T (T (CascadeParameter n a), T a) (T a))
-> (Proxy n -> T (T (CascadeParameter n a), T a) (T a))
-> T (T (CascadeParameter n a), T a) (T a)
forall a b. (a -> b) -> a -> b
$ \Proxy n
order ->
   T (T a, T a) (T a)
forall a. Additive a => T (a, a) a
Causal.mix T (T a, T a) (T a)
-> T (T (CascadeParameter n a), T a) (T a, T a)
-> T (T (CascadeParameter n a), T a) (T a)
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
   T (T (CascadeParameter n a), T a) (T a)
forall n a ar.
(Positive n, C a, ValueOf a ~ ar, PseudoRing a, IntegerConstant a,
 C a, Vector n a) =>
T (T (CascadeParameter n a), T a) (T a)
cascadePipeline T (T (CascadeParameter n a), T a) (T a)
-> T (T (CascadeParameter n a), T a) (T a)
-> T (T (CascadeParameter n a), T a) (T a, T a)
forall b c c'. T b c -> T b c' -> T b (c, c')
forall (a :: * -> * -> *) b c c'.
Arrow a =>
a b c -> a b c' -> a b (c, c')
&&&
   (T (T n a) (T n a) -> T (T a) (T a)
forall n x v a.
(Positive n, C x, v ~ T n x, a ~ T x, Zero v, C v) =>
T v v -> T a a
Causal.pipeline (Proxy n -> T (T n a) (T n a)
forall n a. Proxy n -> T (T n a) (T n a)
vectorId Proxy n
order) T (T a) (T a)
-> ((T (CascadeParameter n a), T a) -> T a)
-> T (T (CascadeParameter n a), T a) (T a)
forall (a :: * -> * -> *) c d b.
Arrow a =>
a c d -> (b -> c) -> a b d
<<^ (T (CascadeParameter n a), T a) -> T a
forall a b. (a, b) -> b
snd) T (T (CascadeParameter n a), T a) (T a, T a)
-> T (T (CascadeParameter n a), T a)
     (T (CascadeParameter n a), T a)
-> T (T (CascadeParameter n a), T a) (T a, T a)
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
--   (Causal.delay (const zero) (const $ TypeNum.integralFromProxy order) <<^ snd) <<<
   T (T a) (T a)
-> T (T (CascadeParameter n a), T a)
     (T (CascadeParameter n a), T a)
forall b c d. T b c -> T (d, b) (d, c)
forall (a :: * -> * -> *) b c d.
Arrow a =>
a b c -> a (d, b) (d, c)
second T (T a) (T a)
forall a. (RationalConstant a, PseudoRing a) => T a a
half

phaserPipeline ::
   (TypeNum.Positive n,
    MultiValue.PseudoRing a, MultiValue.RationalConstant a,
    Marshal.C a, MarshalMV.Vector n a) =>
   Causal.T
      (CascadeParameter n (MultiValue.T a), MultiValue.T a)
      (MultiValue.T a)
phaserPipeline :: forall n a.
(Positive n, PseudoRing a, RationalConstant a, C a, Vector n a) =>
T (CascadeParameter n (T a), T a) (T a)
phaserPipeline = T (T (CascadeParameter n a), T a) (T a)
forall n a.
(Positive n, PseudoRing a, RationalConstant a, C a, Vector n a) =>
T (T (CascadeParameter n a), T a) (T a)
phaserPipelineMV T (T (CascadeParameter n a), T a) (T a)
-> ((CascadeParameter n (T a), T a)
    -> (T (CascadeParameter n a), T a))
-> T (CascadeParameter n (T a), T a) (T a)
forall (a :: * -> * -> *) c d b.
Arrow a =>
a c d -> (b -> c) -> a b d
<<^ (CascadeParameter n (T a) -> T (CascadeParameter n a))
-> (CascadeParameter n (T a), T a)
-> (T (CascadeParameter n a), T a)
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst CascadeParameter n (T a) -> T (CascadeParameter n a)
forall n a. CascadeParameter n (T a) -> T (CascadeParameter n a)
cascadeParameterMultiValue