{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# OPTIONS_GHC -fno-warn-orphans #-}
module Synthesizer.LLVM.Filter.Universal (
   Result(Result, lowpass, highpass, bandpass, bandlimit),
   Parameter, parameter, causal,
   parameterCode, causalExp,
   multiValueResult, unMultiValueResult,
   multiValueParameter, unMultiValueParameter,
   ) where

import qualified Synthesizer.Plain.Filter.Recursive.Universal as Universal
import Synthesizer.Plain.Filter.Recursive.Universal
          (Parameter(Parameter), Result(..))
import Synthesizer.Plain.Filter.Recursive (Pole(..))

import qualified Synthesizer.Plain.Modifier as Modifier

import qualified Synthesizer.LLVM.Causal.Process as CausalExp
import qualified Synthesizer.LLVM.Causal.ProcessValue as Causal
import qualified Synthesizer.LLVM.Frame.SerialVector.Class as Serial
import qualified Synthesizer.LLVM.Value as Value

import qualified LLVM.DSL.Expression as Expr

import qualified LLVM.Extra.Multi.Value.Marshal as MarshalMV
import qualified LLVM.Extra.Multi.Value as MultiValue
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.Vector as Vector
import qualified LLVM.Extra.Arithmetic as A

import qualified LLVM.Core as LLVM
import LLVM.Core (CodeGenFunction)

import Type.Data.Num.Decimal (d0, d1, d2, d3, d4, d5)

import qualified Control.Applicative.HT as App
import Control.Applicative (liftA2, (<$>))

import qualified Data.Foldable as Fold
import Data.Traversable (traverse)

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


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


type ParameterStruct a = LLVM.Struct (a, (a, (a, (a, (a, (a, ()))))))

parameterMemory ::
   (Memory.C a) =>
   Memory.Record r (ParameterStruct (Memory.Struct a)) (Parameter a)
parameterMemory :: forall a r.
C a =>
Record r (ParameterStruct (Struct a)) (Parameter a)
parameterMemory =
   (a -> a -> a -> a -> a -> a -> Parameter a)
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
-> Element
     r (ParameterStruct (Struct a)) (Parameter a) (Parameter a)
forall (m :: * -> *) a b c d e f r.
Applicative m =>
(a -> b -> c -> d -> e -> f -> r)
-> m a -> m b -> m c -> m d -> m e -> m f -> m r
App.lift6 a -> a -> a -> a -> a -> a -> Parameter a
forall a. a -> a -> a -> a -> a -> a -> Parameter a
Parameter
      ((Parameter a -> a)
-> Proxy D0
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.k1       Proxy D0
d0)
      ((Parameter a -> a)
-> Proxy D1
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.k2       Proxy D1
d1)
      ((Parameter a -> a)
-> Proxy D2
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.ampIn    Proxy D2
d2)
      ((Parameter a -> a)
-> Proxy D3
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.ampI1    Proxy D3
d3)
      ((Parameter a -> a)
-> Proxy D4
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.ampI2    Proxy D4
d4)
      ((Parameter a -> a)
-> Proxy D5
-> Element r (ParameterStruct (Struct a)) (Parameter a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Parameter a -> a
forall a. Parameter a -> a
Universal.ampLimit Proxy D5
d5)


instance (Memory.C a) => Memory.C (Parameter a) where
   type Struct (Parameter a) = ParameterStruct (Memory.Struct a)
   load :: forall r.
Value (Ptr (Struct (Parameter a)))
-> CodeGenFunction r (Parameter a)
load = Record r (ParameterStruct (Struct a)) (Parameter a)
-> Value (Ptr (ParameterStruct (Struct a)))
-> CodeGenFunction r (Parameter a)
forall r o llvmValue.
Record r o llvmValue
-> Value (Ptr o) -> CodeGenFunction r llvmValue
Memory.loadRecord Record r (ParameterStruct (Struct a)) (Parameter a)
forall a r.
C a =>
Record r (ParameterStruct (Struct a)) (Parameter a)
parameterMemory
   store :: forall r.
Parameter a
-> Value (Ptr (Struct (Parameter a))) -> CodeGenFunction r ()
store = Record r (ParameterStruct (Struct a)) (Parameter a)
-> Parameter a
-> Value (Ptr (ParameterStruct (Struct a)))
-> CodeGenFunction r ()
forall r o llvmValue.
Record r o llvmValue
-> llvmValue -> Value (Ptr o) -> CodeGenFunction r ()
Memory.storeRecord Record r (ParameterStruct (Struct a)) (Parameter a)
forall a r.
C a =>
Record r (ParameterStruct (Struct a)) (Parameter a)
parameterMemory
   decompose :: forall r.
Value (Struct (Parameter a)) -> CodeGenFunction r (Parameter a)
decompose = Record r (ParameterStruct (Struct a)) (Parameter a)
-> Value (ParameterStruct (Struct a))
-> CodeGenFunction r (Parameter a)
forall r o llvmValue.
Record r o llvmValue -> Value o -> CodeGenFunction r llvmValue
Memory.decomposeRecord Record r (ParameterStruct (Struct a)) (Parameter a)
forall a r.
C a =>
Record r (ParameterStruct (Struct a)) (Parameter a)
parameterMemory
   compose :: forall r.
Parameter a -> CodeGenFunction r (Value (Struct (Parameter a)))
compose = Record r (ParameterStruct (Struct a)) (Parameter a)
-> Parameter a
-> CodeGenFunction r (Value (ParameterStruct (Struct a)))
forall o r llvmValue.
IsType o =>
Record r o llvmValue -> llvmValue -> CodeGenFunction r (Value o)
Memory.composeRecord Record r (ParameterStruct (Struct a)) (Parameter a)
forall a r.
C a =>
Record r (ParameterStruct (Struct a)) (Parameter a)
parameterMemory

instance (Marshal.C a) => Marshal.C (Parameter a) where
   pack :: Parameter a -> Struct (Parameter a)
pack Parameter a
p =
      case a -> Struct a
forall a. C a => a -> Struct a
Marshal.pack (a -> Struct a) -> Parameter a -> Parameter (Struct a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parameter a
p of
         Parameter Struct a
k1 Struct a
k2 Struct a
ampIn Struct a
ampI1 Struct a
ampI2 Struct a
ampLimit ->
            Struct a
-> Struct a
-> Struct a
-> Struct a
-> Struct a
-> Struct a
-> ParameterStruct (Struct a)
forall f. (ConsStruct f, ConsResult f ~ PartialStruct f) => f
LLVM.consStruct Struct a
k1 Struct a
k2 Struct a
ampIn Struct a
ampI1 Struct a
ampI2 Struct a
ampLimit
   unpack :: Struct (Parameter a) -> Parameter a
unpack = (Struct a -> a) -> Parameter (Struct a) -> Parameter a
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Struct a -> a
forall a. C a => Struct a -> a
Marshal.unpack (Parameter (Struct a) -> Parameter a)
-> (ParameterStruct (Struct a) -> Parameter (Struct a))
-> ParameterStruct (Struct a)
-> Parameter a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Curried
  (Struct a,
   (Struct a, (Struct a, (Struct a, (Struct a, (Struct a, ()))))))
  (Parameter (Struct a))
-> ParameterStruct (Struct a) -> Parameter (Struct a)
forall a b. CurryStruct a => Curried a b -> Struct a -> b
LLVM.uncurryStruct Curried
  (Struct a,
   (Struct a, (Struct a, (Struct a, (Struct a, (Struct a, ()))))))
  (Parameter (Struct a))
Struct a
-> Struct a
-> Struct a
-> Struct a
-> Struct a
-> Struct a
-> Parameter (Struct a)
forall a. a -> a -> a -> a -> a -> a -> Parameter a
Parameter

instance (Storable.C a) => Storable.C (Parameter a) where
   load :: forall r.
Value (Ptr (Parameter a))
-> CodeGenFunction r (ValueOf (Parameter a))
load = Value (Ptr (Parameter a))
-> CodeGenFunction r (ValueOf (Parameter a))
Value (Ptr (Parameter a))
-> CodeGenFunction r (Parameter (ValueOf a))
forall (f :: * -> *) a al r.
(Applicative f, Traversable f, C a, ValueOf a ~ al) =>
Value (Ptr (f a)) -> CodeGenFunction r (f al)
Storable.loadApplicative
   store :: forall r.
ValueOf (Parameter a)
-> Value (Ptr (Parameter a)) -> CodeGenFunction r ()
store = ValueOf (Parameter a)
-> Value (Ptr (Parameter a)) -> CodeGenFunction r ()
Parameter (ValueOf a)
-> Value (Ptr (Parameter a)) -> CodeGenFunction r ()
forall (f :: * -> *) a al r.
(Foldable f, C a, ValueOf a ~ al) =>
f al -> Value (Ptr (f a)) -> CodeGenFunction r ()
Storable.storeFoldable



type ResultStruct a = LLVM.Struct (a, (a, (a, (a, ()))))

resultMemory ::
   (Memory.C a) =>
   Memory.Record r (ResultStruct (Memory.Struct a)) (Result a)
resultMemory :: forall a r. C a => Record r (ResultStruct (Struct a)) (Result a)
resultMemory =
   (a -> a -> a -> a -> Result a)
-> Element r (ResultStruct (Struct a)) (Result a) a
-> Element r (ResultStruct (Struct a)) (Result a) a
-> Element r (ResultStruct (Struct a)) (Result a) a
-> Element r (ResultStruct (Struct a)) (Result a) a
-> Element r (ResultStruct (Struct a)) (Result a) (Result a)
forall (m :: * -> *) a b c d r.
Applicative m =>
(a -> b -> c -> d -> r) -> m a -> m b -> m c -> m d -> m r
App.lift4 a -> a -> a -> a -> Result a
forall a. a -> a -> a -> a -> Result a
Result
      ((Result a -> a)
-> Proxy D0 -> Element r (ResultStruct (Struct a)) (Result a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Result a -> a
forall a. Result a -> a
Universal.highpass  Proxy D0
d0)
      ((Result a -> a)
-> Proxy D1 -> Element r (ResultStruct (Struct a)) (Result a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Result a -> a
forall a. Result a -> a
Universal.bandpass  Proxy D1
d1)
      ((Result a -> a)
-> Proxy D2 -> Element r (ResultStruct (Struct a)) (Result a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Result a -> a
forall a. Result a -> a
Universal.lowpass   Proxy D2
d2)
      ((Result a -> a)
-> Proxy D3 -> Element r (ResultStruct (Struct a)) (Result a) a
forall x o n v r.
(C x, GetValue o n, ValueType o n ~ Struct x,
 GetElementPtr o (n, ()), ElementPtrType o (n, ()) ~ Struct x) =>
(v -> x) -> n -> Element r o v x
Memory.element Result a -> a
forall a. Result a -> a
Universal.bandlimit Proxy D3
d3)


instance (Memory.C a) => Memory.C (Result a) where
   type Struct (Result a) = ResultStruct (Memory.Struct a)
   load :: forall r.
Value (Ptr (Struct (Result a))) -> CodeGenFunction r (Result a)
load = Record r (ResultStruct (Struct a)) (Result a)
-> Value (Ptr (ResultStruct (Struct a)))
-> CodeGenFunction r (Result a)
forall r o llvmValue.
Record r o llvmValue
-> Value (Ptr o) -> CodeGenFunction r llvmValue
Memory.loadRecord Record r (ResultStruct (Struct a)) (Result a)
forall a r. C a => Record r (ResultStruct (Struct a)) (Result a)
resultMemory
   store :: forall r.
Result a -> Value (Ptr (Struct (Result a))) -> CodeGenFunction r ()
store = Record r (ResultStruct (Struct a)) (Result a)
-> Result a
-> Value (Ptr (ResultStruct (Struct a)))
-> CodeGenFunction r ()
forall r o llvmValue.
Record r o llvmValue
-> llvmValue -> Value (Ptr o) -> CodeGenFunction r ()
Memory.storeRecord Record r (ResultStruct (Struct a)) (Result a)
forall a r. C a => Record r (ResultStruct (Struct a)) (Result a)
resultMemory
   decompose :: forall r. Value (Struct (Result a)) -> CodeGenFunction r (Result a)
decompose = Record r (ResultStruct (Struct a)) (Result a)
-> Value (ResultStruct (Struct a)) -> CodeGenFunction r (Result a)
forall r o llvmValue.
Record r o llvmValue -> Value o -> CodeGenFunction r llvmValue
Memory.decomposeRecord Record r (ResultStruct (Struct a)) (Result a)
forall a r. C a => Record r (ResultStruct (Struct a)) (Result a)
resultMemory
   compose :: forall r. Result a -> CodeGenFunction r (Value (Struct (Result a)))
compose = Record r (ResultStruct (Struct a)) (Result a)
-> Result a -> CodeGenFunction r (Value (ResultStruct (Struct a)))
forall o r llvmValue.
IsType o =>
Record r o llvmValue -> llvmValue -> CodeGenFunction r (Value o)
Memory.composeRecord Record r (ResultStruct (Struct a)) (Result a)
forall a r. C a => Record r (ResultStruct (Struct a)) (Result a)
resultMemory

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

instance (Value.Flatten a) => Value.Flatten (Result a) where
   type Registers (Result a) = Result (Value.Registers a)
   flattenCode :: forall r. Result a -> Compute r (Registers (Result a))
flattenCode = Result a -> StateT Vault (CodeGenFunction r) (Registers (Result a))
Result a -> Compute r (Result (Registers a))
forall value (f :: * -> *) r.
(Flatten value, Traversable f) =>
f value -> Compute r (f (Registers value))
Value.flattenCodeTraversable
   unfoldCode :: T (Registers (Result a)) -> Result a
unfoldCode = T (Registers (Result a)) -> Result a
T (Result (Registers a)) -> Result a
forall value (f :: * -> *).
(Flatten value, Traversable f, Applicative f) =>
T (f (Registers value)) -> f value
Value.unfoldCodeTraversable

instance (MultiValue.C a) => MultiValue.C (Result a) where
   type Repr (Result a) = Result (MultiValue.Repr a)
   cons :: Result a -> T (Result a)
cons = Result (T a) -> T (Result a)
forall a. Result (T a) -> T (Result a)
multiValueResult (Result (T a) -> T (Result a))
-> (Result a -> Result (T a)) -> Result a -> T (Result a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> T a) -> Result a -> Result (T a)
forall a b. (a -> b) -> Result a -> Result b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> T a
forall a. C a => a -> T a
MultiValue.cons
   undef :: T (Result a)
undef = Result (T a) -> T (Result a)
forall a. Result (T a) -> T (Result a)
multiValueResult (Result (T a) -> T (Result a)) -> Result (T a) -> T (Result a)
forall a b. (a -> b) -> a -> b
$ T a -> Result (T a)
forall a. a -> Result a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T a
forall a. C a => T a
MultiValue.undef
   zero :: T (Result a)
zero = Result (T a) -> T (Result a)
forall a. Result (T a) -> T (Result a)
multiValueResult (Result (T a) -> T (Result a)) -> Result (T a) -> T (Result a)
forall a b. (a -> b) -> a -> b
$ T a -> Result (T a)
forall a. a -> Result a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T a
forall a. C a => T a
MultiValue.zero
   phi :: forall r.
BasicBlock -> T (Result a) -> CodeGenFunction r (T (Result a))
phi BasicBlock
bb =
      (Result (T a) -> T (Result a))
-> CodeGenFunction r (Result (T a))
-> CodeGenFunction r (T (Result 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 Result (T a) -> T (Result a)
forall a. Result (T a) -> T (Result a)
multiValueResult (CodeGenFunction r (Result (T a))
 -> CodeGenFunction r (T (Result a)))
-> (T (Result a) -> CodeGenFunction r (Result (T a)))
-> T (Result a)
-> CodeGenFunction r (T (Result a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (T a -> CodeGenFunction r (T a))
-> Result (T a) -> CodeGenFunction r (Result (T 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) -> Result a -> f (Result b)
traverse (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) (Result (T a) -> CodeGenFunction r (Result (T a)))
-> (T (Result a) -> Result (T a))
-> T (Result a)
-> CodeGenFunction r (Result (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Result a) -> Result (T a)
forall a. T (Result a) -> Result (T a)
unMultiValueResult
   addPhi :: forall r.
BasicBlock -> T (Result a) -> T (Result a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Result a)
a T (Result a)
b =
      Result (CodeGenFunction r ()) -> CodeGenFunction r ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
Fold.sequence_ (Result (CodeGenFunction r ()) -> CodeGenFunction r ())
-> Result (CodeGenFunction r ()) -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
      (T a -> T a -> CodeGenFunction r ())
-> Result (T a) -> Result (T a) -> Result (CodeGenFunction r ())
forall a b c. (a -> b -> c) -> Result a -> Result b -> Result c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (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 (Result a) -> Result (T a)
forall a. T (Result a) -> Result (T a)
unMultiValueResult T (Result a)
a) (T (Result a) -> Result (T a)
forall a. T (Result a) -> Result (T a)
unMultiValueResult T (Result a)
b)

multiValueResult ::
   Result (MultiValue.T a) -> MultiValue.T (Result a)
multiValueResult :: forall a. Result (T a) -> T (Result a)
multiValueResult = Repr (Result a) -> T (Result a)
Result (Repr a) -> T (Result a)
forall a. Repr a -> T a
MultiValue.Cons (Result (Repr a) -> T (Result a))
-> (Result (T a) -> Result (Repr a))
-> Result (T a)
-> T (Result a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (T a -> Repr a) -> Result (T a) -> Result (Repr a)
forall a b. (a -> b) -> Result a -> Result b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap (\(MultiValue.Cons Repr a
a) -> Repr a
a)

unMultiValueResult ::
   MultiValue.T (Result a) -> Result (MultiValue.T a)
unMultiValueResult :: forall a. T (Result a) -> Result (T a)
unMultiValueResult (MultiValue.Cons Repr (Result a)
x) = (Repr a -> T a) -> Result (Repr a) -> Result (T a)
forall a b. (a -> b) -> Result a -> Result 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 (Result a)
Result (Repr a)
x

instance (MarshalMV.C a) => MarshalMV.C (Result a) where
   pack :: Result a -> Struct (Result a)
pack Result a
p =
      case a -> Struct (Repr a)
forall a. C a => a -> Struct a
MarshalMV.pack (a -> Struct (Repr a)) -> Result a -> Result (Struct (Repr a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Result a
p of
         Result Struct (Repr a)
hp Struct (Repr a)
bp Struct (Repr a)
lp Struct (Repr a)
bl -> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> ResultStruct (Struct (Repr a))
forall f. (ConsStruct f, ConsResult f ~ PartialStruct f) => f
LLVM.consStruct Struct (Repr a)
hp Struct (Repr a)
bp Struct (Repr a)
lp Struct (Repr a)
bl
   unpack :: Struct (Result a) -> Result a
unpack = (Struct (Repr a) -> a) -> Result (Struct (Repr a)) -> Result a
forall a b. (a -> b) -> Result a -> Result b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Struct (Repr a) -> a
forall a. C a => Struct a -> a
MarshalMV.unpack (Result (Struct (Repr a)) -> Result a)
-> (ResultStruct (Struct (Repr a)) -> Result (Struct (Repr a)))
-> ResultStruct (Struct (Repr a))
-> Result a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Curried
  (Struct (Repr a),
   (Struct (Repr a), (Struct (Repr a), (Struct (Repr a), ()))))
  (Result (Struct (Repr a)))
-> ResultStruct (Struct (Repr a)) -> Result (Struct (Repr a))
forall a b. CurryStruct a => Curried a b -> Struct a -> b
LLVM.uncurryStruct Curried
  (Struct (Repr a),
   (Struct (Repr a), (Struct (Repr a), (Struct (Repr a), ()))))
  (Result (Struct (Repr a)))
Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Result (Struct (Repr a))
forall a. a -> a -> a -> a -> Result a
Result

instance (Expr.Aggregate e mv) => Expr.Aggregate (Result e) (Result mv) where
   type MultiValuesOf (Result e) = Result (Expr.MultiValuesOf e)
   type ExpressionsOf (Result mv) = Result (Expr.ExpressionsOf mv)
   bundle :: forall r. Result e -> CodeGenFunction r (Result mv)
bundle = (e -> CodeGenFunction r mv)
-> Result e -> CodeGenFunction r (Result 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) -> Result a -> f (Result b)
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 :: Result mv -> Result e
dissect = (mv -> e) -> Result mv -> Result e
forall a b. (a -> b) -> Result a -> Result 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 (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 (Value.Flatten a) => Value.Flatten (Parameter a) where
   type Registers (Parameter a) = Parameter (Value.Registers a)
   flattenCode :: forall r. Parameter a -> Compute r (Registers (Parameter a))
flattenCode = Parameter a
-> StateT Vault (CodeGenFunction r) (Registers (Parameter a))
Parameter a -> Compute r (Parameter (Registers a))
forall value (f :: * -> *) r.
(Flatten value, Traversable f) =>
f value -> Compute r (f (Registers value))
Value.flattenCodeTraversable
   unfoldCode :: T (Registers (Parameter a)) -> Parameter a
unfoldCode = T (Registers (Parameter a)) -> Parameter a
T (Parameter (Registers a)) -> Parameter a
forall value (f :: * -> *).
(Flatten value, Traversable f, Applicative f) =>
T (f (Registers value)) -> f value
Value.unfoldCodeTraversable

instance (MultiValue.C a) => MultiValue.C (Parameter a) where
   type Repr (Parameter a) = Parameter (MultiValue.Repr a)
   cons :: Parameter a -> T (Parameter a)
cons = Parameter (T a) -> T (Parameter a)
forall a. Parameter (T a) -> T (Parameter a)
multiValueParameter (Parameter (T a) -> T (Parameter a))
-> (Parameter a -> Parameter (T a))
-> Parameter a
-> T (Parameter a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (a -> T a) -> Parameter 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 a -> T a
forall a. C a => a -> T a
MultiValue.cons
   undef :: T (Parameter a)
undef = Parameter (T a) -> T (Parameter a)
forall a. Parameter (T a) -> T (Parameter a)
multiValueParameter (Parameter (T a) -> T (Parameter a))
-> Parameter (T a) -> T (Parameter a)
forall a b. (a -> b) -> a -> b
$ T a -> Parameter (T a)
forall a. a -> Parameter a
forall (f :: * -> *) a. Applicative f => a -> f a
pure T a
forall a. C a => T a
MultiValue.undef
   zero :: T (Parameter a)
zero = Parameter (T a) -> T (Parameter a)
forall a. Parameter (T a) -> T (Parameter a)
multiValueParameter (Parameter (T a) -> T (Parameter a))
-> Parameter (T a) -> T (Parameter a)
forall a b. (a -> b) -> a -> b
$ T a -> Parameter (T a)
forall a. a -> Parameter a
forall (f :: * -> *) a. Applicative f => a -> f a
pure 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 =
      (Parameter (T a) -> T (Parameter a))
-> CodeGenFunction r (Parameter (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 Parameter (T a) -> T (Parameter a)
forall a. Parameter (T a) -> T (Parameter a)
multiValueParameter (CodeGenFunction r (Parameter (T a))
 -> CodeGenFunction r (T (Parameter a)))
-> (T (Parameter a) -> CodeGenFunction r (Parameter (T a)))
-> T (Parameter a)
-> CodeGenFunction r (T (Parameter a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
.
      (T a -> CodeGenFunction r (T a))
-> Parameter (T a) -> CodeGenFunction r (Parameter (T 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) -> Parameter a -> f (Parameter b)
traverse (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) (Parameter (T a) -> CodeGenFunction r (Parameter (T a)))
-> (T (Parameter a) -> Parameter (T a))
-> T (Parameter a)
-> CodeGenFunction r (Parameter (T a))
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Parameter a) -> Parameter (T a)
forall a. T (Parameter a) -> Parameter (T a)
unMultiValueParameter
   addPhi :: forall r.
BasicBlock
-> T (Parameter a) -> T (Parameter a) -> CodeGenFunction r ()
addPhi BasicBlock
bb T (Parameter a)
a T (Parameter a)
b =
      Parameter (CodeGenFunction r ()) -> CodeGenFunction r ()
forall (t :: * -> *) (m :: * -> *) a.
(Foldable t, Monad m) =>
t (m a) -> m ()
Fold.sequence_ (Parameter (CodeGenFunction r ()) -> CodeGenFunction r ())
-> Parameter (CodeGenFunction r ()) -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$
      (T a -> T a -> CodeGenFunction r ())
-> Parameter (T a)
-> Parameter (T a)
-> Parameter (CodeGenFunction r ())
forall a b c.
(a -> b -> c) -> Parameter a -> Parameter b -> Parameter c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 (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) -> Parameter (T a)
forall a. T (Parameter a) -> Parameter (T a)
unMultiValueParameter T (Parameter a)
a) (T (Parameter a) -> Parameter (T a)
forall a. T (Parameter a) -> Parameter (T a)
unMultiValueParameter T (Parameter a)
b)

multiValueParameter ::
   Parameter (MultiValue.T a) -> MultiValue.T (Parameter a)
multiValueParameter :: forall a. Parameter (T a) -> T (Parameter a)
multiValueParameter = Repr (Parameter a) -> T (Parameter a)
Parameter (Repr a) -> T (Parameter a)
forall a. Repr a -> T a
MultiValue.Cons (Parameter (Repr a) -> T (Parameter a))
-> (Parameter (T a) -> Parameter (Repr a))
-> Parameter (T a)
-> T (Parameter a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. (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)

unMultiValueParameter ::
   MultiValue.T (Parameter a) -> Parameter (MultiValue.T a)
unMultiValueParameter :: forall a. T (Parameter a) -> Parameter (T a)
unMultiValueParameter (MultiValue.Cons Repr (Parameter a)
x) = (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 (Parameter a)
Parameter (Repr a)
x

instance (MarshalMV.C a) => MarshalMV.C (Parameter a) where
   pack :: Parameter a -> Struct (Parameter a)
pack Parameter a
p =
      case a -> Struct (Repr a)
forall a. C a => a -> Struct a
MarshalMV.pack (a -> Struct (Repr a))
-> Parameter a -> Parameter (Struct (Repr a))
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> Parameter a
p of
         Parameter Struct (Repr a)
k1 Struct (Repr a)
k2 Struct (Repr a)
ampIn Struct (Repr a)
ampI1 Struct (Repr a)
ampI2 Struct (Repr a)
ampLimit ->
            Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> ParameterStruct (Struct (Repr a))
forall f. (ConsStruct f, ConsResult f ~ PartialStruct f) => f
LLVM.consStruct Struct (Repr a)
k1 Struct (Repr a)
k2 Struct (Repr a)
ampIn Struct (Repr a)
ampI1 Struct (Repr a)
ampI2 Struct (Repr a)
ampLimit
   unpack :: Struct (Parameter a) -> Parameter a
unpack = (Struct (Repr a) -> a)
-> Parameter (Struct (Repr a)) -> Parameter a
forall a b. (a -> b) -> Parameter a -> Parameter b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Struct (Repr a) -> a
forall a. C a => Struct a -> a
MarshalMV.unpack (Parameter (Struct (Repr a)) -> Parameter a)
-> (ParameterStruct (Struct (Repr a))
    -> Parameter (Struct (Repr a)))
-> ParameterStruct (Struct (Repr a))
-> Parameter a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Curried
  (Struct (Repr a),
   (Struct (Repr a),
    (Struct (Repr a),
     (Struct (Repr a), (Struct (Repr a), (Struct (Repr a), ()))))))
  (Parameter (Struct (Repr a)))
-> ParameterStruct (Struct (Repr a)) -> Parameter (Struct (Repr a))
forall a b. CurryStruct a => Curried a b -> Struct a -> b
LLVM.uncurryStruct Curried
  (Struct (Repr a),
   (Struct (Repr a),
    (Struct (Repr a),
     (Struct (Repr a), (Struct (Repr a), (Struct (Repr a), ()))))))
  (Parameter (Struct (Repr a)))
Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Struct (Repr a)
-> Parameter (Struct (Repr a))
forall a. a -> a -> a -> a -> a -> a -> Parameter a
Parameter

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)
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 (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


instance (Tuple.Phi a) => Tuple.Phi (Result a) where
   phi :: forall r. BasicBlock -> Result a -> CodeGenFunction r (Result a)
phi = BasicBlock -> Result a -> CodeGenFunction r (Result a)
forall a (f :: * -> *) r.
(Phi a, Traversable f) =>
BasicBlock -> f a -> CodeGenFunction r (f a)
Tuple.phiTraversable
   addPhi :: forall r.
BasicBlock -> Result a -> Result a -> CodeGenFunction r ()
addPhi = BasicBlock -> Result a -> Result 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 (Result a) where
   undef :: Result a
undef = Result a
forall a (f :: * -> *). (Undefined a, Applicative f) => f a
Tuple.undefPointed

instance (Vector.Simple v) => Vector.Simple (Result v) where
   type Element (Result v) = Result (Vector.Element v)
   type Size (Result v) = Vector.Size v
   shuffleMatch :: forall r.
ConstValue (Vector (Size (Result v)) Word32)
-> Result v -> CodeGenFunction r (Result v)
shuffleMatch = ConstValue (Vector (Size v) Word32)
-> Result v -> CodeGenFunction r (Result v)
ConstValue (Vector (Size (Result v)) Word32)
-> Result v -> CodeGenFunction r (Result 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 -> Result v -> CodeGenFunction r (Element (Result v))
extract = Value Word32 -> Result v -> CodeGenFunction r (Element (Result v))
Value Word32 -> Result v -> CodeGenFunction r (Result (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 (Result v) where
   insert :: forall r.
Value Word32
-> Element (Result v) -> Result v -> CodeGenFunction r (Result v)
insert  = Value Word32
-> Element (Result v) -> Result v -> CodeGenFunction r (Result v)
Value Word32
-> Result (Element v) -> Result v -> CodeGenFunction r (Result v)
forall v (f :: * -> *) r.
(C v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
Vector.insertTraversable

instance (Serial.Sized v) => Serial.Sized (Result v) where
   type Size (Result v) = Serial.Size v

instance (Serial.Read v) => Serial.Read (Result v) where
   type Element (Result v) = Result (Serial.Element v)
   type ReadIt (Result v) = Result (Serial.ReadIt v)
   extract :: forall r.
Value Word32 -> Result v -> CodeGenFunction r (Element (Result v))
extract = Value Word32 -> Result v -> CodeGenFunction r (Result (Element v))
Value Word32 -> Result v -> CodeGenFunction r (Element (Result v))
forall v (f :: * -> *) r.
(Read v, Traversable f) =>
Value Word32 -> f v -> CodeGenFunction r (f (Element v))
Serial.extractTraversable
   readStart :: forall r.
Result v
-> CodeGenFunction r (ReadIterator (ReadIt (Result v)) (Result v))
readStart = Result v
-> CodeGenFunction r (ReadIterator (Result (ReadIt v)) (Result v))
Result v
-> CodeGenFunction r (ReadIterator (ReadIt (Result v)) (Result v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
f v -> CodeGenFunction r (ReadIterator (f (ReadIt v)) (f v))
Serial.readStartTraversable
   readNext :: forall r.
ReadIterator (ReadIt (Result v)) (Result v)
-> CodeGenFunction
     r (Element (Result v), ReadIterator (ReadIt (Result v)) (Result v))
readNext = ReadIterator (Result (ReadIt v)) (Result v)
-> CodeGenFunction
     r (Result (Element v), ReadIterator (Result (ReadIt v)) (Result v))
ReadIterator (ReadIt (Result v)) (Result v)
-> CodeGenFunction
     r (Element (Result v), ReadIterator (ReadIt (Result v)) (Result v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Read v) =>
ReadIterator (f (ReadIt v)) (f v)
-> CodeGenFunction
     r (f (Element v), ReadIterator (f (ReadIt v)) (f v))
Serial.readNextTraversable

instance (Serial.Write v) => Serial.Write (Result v) where
   type WriteIt (Result v) = Result (Serial.WriteIt v)
   insert :: forall r.
Value Word32
-> Element (Result v) -> Result v -> CodeGenFunction r (Result v)
insert  = Value Word32
-> Result (Element v) -> Result v -> CodeGenFunction r (Result v)
Value Word32
-> Element (Result v) -> Result v -> CodeGenFunction r (Result v)
forall v (f :: * -> *) r.
(Write v, Traversable f, Applicative f) =>
Value Word32 -> f (Element v) -> f v -> CodeGenFunction r (f v)
Serial.insertTraversable
   writeStart :: forall r.
CodeGenFunction r (WriteIterator (WriteIt (Result v)) (Result v))
writeStart = CodeGenFunction r (WriteIterator (Result (WriteIt v)) (Result v))
CodeGenFunction r (WriteIterator (WriteIt (Result v)) (Result v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
Serial.writeStartTraversable
   writeNext :: forall r.
Element (Result v)
-> WriteIterator (WriteIt (Result v)) (Result v)
-> CodeGenFunction
     r (WriteIterator (WriteIt (Result v)) (Result v))
writeNext = Result (Element v)
-> WriteIterator (Result (WriteIt v)) (Result v)
-> CodeGenFunction
     r (WriteIterator (Result (WriteIt v)) (Result v))
Element (Result v)
-> WriteIterator (WriteIt (Result v)) (Result v)
-> CodeGenFunction
     r (WriteIterator (WriteIt (Result v)) (Result v))
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
f (Element v)
-> WriteIterator (f (WriteIt v)) (f v)
-> CodeGenFunction r (WriteIterator (f (WriteIt v)) (f v))
Serial.writeNextTraversable
   writeStop :: forall r.
WriteIterator (WriteIt (Result v)) (Result v)
-> CodeGenFunction r (Result v)
writeStop = WriteIterator (Result (WriteIt v)) (Result v)
-> CodeGenFunction r (Result v)
WriteIterator (WriteIt (Result v)) (Result v)
-> CodeGenFunction r (Result v)
forall (f :: * -> *) v r.
(Traversable f, Applicative f, Write v) =>
WriteIterator (f (WriteIt v)) (f v) -> CodeGenFunction r (f v)
Serial.writeStopTraversable


parameterCode ::
   (A.Transcendental a, A.RationalConstant a) =>
   a -> a -> CodeGenFunction r (Parameter a)
parameterCode :: forall a r.
(Transcendental a, RationalConstant a) =>
a -> a -> CodeGenFunction r (Parameter a)
parameterCode =
   (T a -> T a -> Parameter (T a))
-> forall r.
   a -> a -> CodeGenFunction r (Registers (Parameter (T a)))
forall value a b.
Flatten value =>
(T a -> T b -> value)
-> forall r. a -> b -> CodeGenFunction r (Registers value)
Value.unlift2 ((T a -> T a -> Parameter (T a))
 -> forall r.
    a -> a -> CodeGenFunction r (Registers (Parameter (T a))))
-> (T a -> T a -> Parameter (T a))
-> forall r.
   a -> a -> CodeGenFunction r (Registers (Parameter (T a)))
forall a b. (a -> b) -> a -> b
$ \T a
reson T a
freq ->
   Pole (T a) -> Parameter (T a)
forall a. C a => Pole a -> Parameter a
Universal.parameter (T a -> T a -> Pole (T a)
forall a. a -> a -> Pole a
Pole T a
reson T a
freq)

parameter :: (Trans.C a) => a -> a -> Parameter a
parameter :: forall a. C a => a -> a -> Parameter a
parameter a
reson a
freq = Pole a -> Parameter a
forall a. C a => Pole a -> Parameter a
Universal.parameter (a -> a -> Pole a
forall a. a -> a -> Pole a
Pole a
reson a
freq)


modifier ::
   (a ~ A.Scalar v, A.PseudoModule v, A.IntegerConstant a) =>
   Modifier.Simple
      (Universal.State (Value.T v))
      (Parameter (Value.T a))
      (Value.T v) (Result (Value.T v))
modifier :: forall a v.
(a ~ Scalar v, PseudoModule v, IntegerConstant a) =>
Simple (State (T v)) (Parameter (T a)) (T v) (Result (T v))
modifier =
   Simple (State (T v)) (Parameter (T a)) (T v) (Result (T v))
forall a v.
(C a, C a v) =>
Simple (State v) (Parameter a) v (Result v)
Universal.modifier

causal ::
   (a ~ A.Scalar v, A.PseudoModule v, A.IntegerConstant a, Memory.C v) =>
   Causal.T (Parameter a, v) (Result v)
causal :: forall a v.
(a ~ Scalar v, PseudoModule v, IntegerConstant a, C v) =>
T (Parameter a, v) (Result v)
causal = Simple (State (T v)) (Parameter (T a)) (T v) (Result (T v))
-> T (Parameter a, v) (Result v)
forall ah al bh bl ch cl sh sl.
(Flatten ah, Registers ah ~ al, Flatten bh, Registers bh ~ bl,
 Flatten ch, Registers ch ~ cl, Flatten sh, Registers sh ~ sl,
 C sl) =>
Simple sh ch ah bh -> T (cl, al) bl
Causal.fromModifier Simple (State (T v)) (Parameter (T a)) (T v) (Result (T v))
forall a v.
(a ~ Scalar v, PseudoModule v, IntegerConstant a) =>
Simple (State (T v)) (Parameter (T a)) (T v) (Result (T v))
modifier

causalExp ::
   (Module.C ae ve, Expr.Aggregate ae a, Expr.Aggregate ve v, Memory.C v) =>
   CausalExp.T (Parameter a, v) (Result v)
causalExp :: forall ae ve a v.
(C ae ve, Aggregate ae a, Aggregate ve v, C v) =>
T (Parameter a, v) (Result v)
causalExp = Simple (State ve) (Parameter ae) ve (Result ve)
-> T (Parameter a, v) (Result 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
CausalExp.fromModifier Simple (State ve) (Parameter ae) ve (Result ve)
forall a v.
(C a, C a v) =>
Simple (State v) (Parameter a) v (Result v)
Universal.modifier

{-
The state variable filter could be vectorised
by writing the integrator network as matrix recursion
and applying the doubling trick to that recursion.
However the initially sparse matrix with several 1s in it
has dense power matrices with no nice structure.
This will only payoff for large vectors.

We could write another version,
that expresses the state variable filter in terms of the general second order filter.
The general second order filter is already vectorized.
-}