{-# LANGUAGE NoImplicitPrelude #-}
{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
module Synthesizer.LLVM.Filter.ComplexFirstOrder (
   Parameter(Parameter), parameter, causal,
   parameterCode, causalExp,
   ) where

import qualified Synthesizer.LLVM.Causal.Process as CausalExp
import qualified Synthesizer.LLVM.Causal.Private as Causal
import qualified Synthesizer.LLVM.Value as Value

import qualified Synthesizer.LLVM.Frame.Stereo as Stereo
import qualified Synthesizer.LLVM.Complex as Complex

import qualified LLVM.DSL.Expression as Expr

import qualified LLVM.Extra.Arithmetic as A
import qualified LLVM.Extra.Memory as Memory
import qualified LLVM.Extra.Tuple as Tuple

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

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

import qualified Control.Applicative as App
import Control.Applicative (liftA2, liftA3, (<*>))

import qualified Data.Traversable as Trav
import qualified Data.Foldable as Fold

import qualified Algebra.Transcendental as Trans
import qualified Algebra.Ring as Ring

import NumericPrelude.Numeric
import NumericPrelude.Base


data Parameter a =
   Parameter a (Complex.T a)

instance Functor Parameter where
   {-# INLINE fmap #-}
   fmap :: forall a b. (a -> b) -> Parameter a -> Parameter b
fmap a -> b
f (Parameter a
k T a
c) =
      b -> T b -> Parameter b
forall a. a -> T a -> Parameter a
Parameter (a -> b
f a
k) ((a -> b) -> T a -> T b
forall a b. (a -> b) -> T a -> T b
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap a -> b
f T a
c)

instance App.Applicative Parameter where
   {-# INLINE pure #-}
   pure :: forall a. a -> Parameter a
pure a
x = a -> T a -> Parameter a
forall a. a -> T a -> Parameter a
Parameter a
x (a
x a -> a -> T a
forall a. a -> a -> T a
Complex.+: a
x)
   {-# INLINE (<*>) #-}
   Parameter a -> b
fk T (a -> b)
fc <*> :: forall a b. Parameter (a -> b) -> Parameter a -> Parameter b
<*> Parameter a
pk T a
pc =
      b -> T b -> Parameter b
forall a. a -> T a -> Parameter a
Parameter (a -> b
fk a
pk) (T b -> Parameter b) -> T b -> Parameter b
forall a b. (a -> b) -> a -> b
$
         (T (a -> b) -> a -> b
forall a. T a -> a
Complex.real T (a -> b)
fc (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ T a -> a
forall a. T a -> a
Complex.real T a
pc)
         b -> b -> T b
forall a. a -> a -> T a
Complex.+:
         (T (a -> b) -> a -> b
forall a. T a -> a
Complex.imag T (a -> b)
fc (a -> b) -> a -> b
forall a b. (a -> b) -> a -> b
$ T a -> a
forall a. T a -> a
Complex.imag T a
pc)

instance Fold.Foldable Parameter where
   {-# INLINE foldMap #-}
   foldMap :: forall m a. Monoid m => (a -> m) -> Parameter a -> m
foldMap = (a -> m) -> Parameter a -> m
forall (t :: * -> *) m a.
(Traversable t, Monoid m) =>
(a -> m) -> t a -> m
Trav.foldMapDefault

instance Trav.Traversable Parameter where
   {-# INLINE sequenceA #-}
   sequenceA :: forall (f :: * -> *) a.
Applicative f =>
Parameter (f a) -> f (Parameter a)
sequenceA (Parameter f a
k T (f a)
c) =
      (a -> T a -> Parameter a) -> f a -> f (T a) -> f (Parameter a)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> T a -> Parameter a
forall a. a -> T a -> Parameter a
Parameter f a
k (f (T a) -> f (Parameter a)) -> f (T a) -> f (Parameter a)
forall a b. (a -> b) -> a -> b
$
      (a -> a -> T a) -> f a -> f a -> f (T a)
forall a b c. (a -> b -> c) -> f a -> f b -> f c
forall (f :: * -> *) a b c.
Applicative f =>
(a -> b -> c) -> f a -> f b -> f c
liftA2 a -> a -> T a
forall a. a -> a -> T a
(Complex.+:) (T (f a) -> f a
forall a. T a -> a
Complex.real T (f a)
c) (T (f a) -> f a
forall a. T a -> a
Complex.imag T (f a)
c)


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

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 -> 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) (Parameter a)
forall (f :: * -> *) a b c d.
Applicative f =>
(a -> b -> c -> d) -> f a -> f b -> f c -> f d
liftA3 (\a
amp a
kr a
ki -> a -> T a -> Parameter a
forall a. a -> T a -> Parameter a
Parameter a
amp (a
kr a -> a -> T a
forall a. a -> a -> T a
Complex.+: a
ki))
      ((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
amp T a
_) -> a
amp) 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
_amp T a
k) -> T a -> a
forall a. T a -> a
Complex.real T a
k) 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
_amp T a
k) -> T a -> a
forall a. T a -> a
Complex.imag T a
k) Proxy D2
d2)

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


parameterCode, _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 a
reson a
freq =
   let amp :: T a
amp = T a -> T a
forall a. C a => a -> a
recip (T a -> T a) -> T a -> T a
forall a b. (a -> b) -> a -> b
$ Registers (T a) -> T a
forall value. Flatten value => Registers value -> value
Value.unfold a
Registers (T a)
reson
   in  Parameter (T a) -> CodeGenFunction r (Registers (Parameter (T a)))
forall value r.
Flatten value =>
value -> CodeGenFunction r (Registers value)
Value.flatten (Parameter (T a)
 -> CodeGenFunction r (Registers (Parameter (T a))))
-> Parameter (T a)
-> CodeGenFunction r (Registers (Parameter (T a)))
forall a b. (a -> b) -> a -> b
$ T a -> T (T a) -> Parameter (T a)
forall a. a -> T a -> Parameter a
Parameter T a
amp (T (T a) -> Parameter (T a)) -> T (T a) -> Parameter (T a)
forall a b. (a -> b) -> a -> b
$
       T a -> T (T a) -> T (T a)
forall a. C a => a -> T a -> T a
Complex.scale (T a
1T a -> T a -> T a
forall a. C a => a -> a -> a
-T a
amp) (T (T a) -> T (T a)) -> T (T a) -> T (T a)
forall a b. (a -> b) -> a -> b
$ T a -> T (T a)
forall a. C a => a -> T a
Complex.cis (T a -> T (T a)) -> T a -> T (T a)
forall a b. (a -> b) -> a -> b
$
       Registers (T a) -> T a
forall value. Flatten value => Registers value -> value
Value.unfold a
Registers (T a)
freq T a -> T a -> T a
forall a. C a => a -> a -> a
* T a
forall a. (Transcendental a, RationalConstant a) => T a
Value.tau

_parameterCode :: forall a r.
(Transcendental a, RationalConstant a) =>
a -> a -> CodeGenFunction r (Parameter a)
_parameterCode a
reson a
freq = do
   a
amp <- a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. Field a => a -> a -> CodeGenFunction r a
A.fdiv a
forall a. IntegerConstant a => a
A.one a
reson
   a
k   <- a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. Additive a => a -> a -> CodeGenFunction r a
A.sub  a
forall a. IntegerConstant a => a
A.one a
amp
   a
w  <- a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
freq (a -> CodeGenFunction r a)
-> CodeGenFunction r a -> CodeGenFunction r a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< T a -> forall r. CodeGenFunction r a
forall a. T a -> forall r. CodeGenFunction r a
Value.decons T a
forall a. (Transcendental a, RationalConstant a) => T a
Value.tau
   a
kr <- a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
k (a -> CodeGenFunction r a)
-> CodeGenFunction r a -> CodeGenFunction r a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> CodeGenFunction r a
forall r. a -> CodeGenFunction r a
forall a r. Transcendental a => a -> CodeGenFunction r a
A.cos a
w
   a
ki <- a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
k (a -> CodeGenFunction r a)
-> CodeGenFunction r a -> CodeGenFunction r a
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< a -> CodeGenFunction r a
forall r. a -> CodeGenFunction r a
forall a r. Transcendental a => a -> CodeGenFunction r a
A.sin a
w
   Parameter a -> CodeGenFunction r (Parameter a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> T a -> Parameter a
forall a. a -> T a -> Parameter a
Parameter a
amp (a
kr a -> a -> T a
forall a. a -> a -> T a
Complex.+: a
ki))

parameter :: (Trans.C a) => a -> a -> Parameter a
parameter :: forall a. C a => a -> a -> Parameter a
parameter a
reson a
freq =
   let amp :: a
amp = a -> a
forall a. C a => a -> a
recip a
reson
   in a -> T a -> Parameter a
forall a. a -> T a -> Parameter a
Parameter a
amp (T a -> Parameter a) -> T a -> Parameter a
forall a b. (a -> b) -> a -> b
$
      a -> T a -> T a
forall a. C a => a -> T a -> T a
Complex.scale (a
1a -> a -> a
forall a. C a => a -> a -> a
-a
amp) (T a -> T a) -> T a -> T a
forall a b. (a -> b) -> a -> b
$ a -> T a
forall a. C a => a -> T a
Complex.cis (a -> T a) -> a -> T a
forall a b. (a -> b) -> a -> b
$ a
freq a -> a -> a
forall a. C a => a -> a -> a
* a
2a -> a -> a
forall a. C a => a -> a -> a
*a
forall a. C a => a
pi


{-
Synthesizer.Plain.Filter.Recursive.FirstOrderComplex.step
cannot be used directly, because Filt1C has complex amplitude
-}
next, _next ::
   (A.PseudoRing a, A.IntegerConstant a) =>
   (Parameter a, Stereo.T a) ->
   Complex.T a ->
   CodeGenFunction r (Stereo.T a, Complex.T a)
next :: forall a r.
(PseudoRing a, IntegerConstant a) =>
(Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a)
next (Parameter a, T a)
inp T a
state =
   let stereoFromComplexVal :: Complex.T (Value.T a) -> Stereo.T (Value.T a)
       stereoFromComplexVal :: forall a. T (T a) -> T (T a)
stereoFromComplexVal = T (T a) -> T (T a)
forall a. T a -> T a
stereoFromComplex
       (Parameter T a
amp T (T a)
k, T (T a)
x) = Registers (Parameter (T a), T (T a)) -> (Parameter (T a), T (T a))
forall value. Flatten value => Registers value -> value
Value.unfold (Parameter a, T a)
Registers (Parameter (T a), T (T a))
inp
       xc :: T (T a)
xc = T (T a) -> T a
forall a. T a -> a
Stereo.left T (T a)
x  T a -> T a -> T (T a)
forall a. a -> a -> T a
Complex.+:  T (T a) -> T a
forall a. T a -> a
Stereo.right T (T a)
x
       y :: T (T a)
y = T a -> T (T a) -> T (T a)
forall a. C a => a -> T a -> T a
Complex.scale T a
amp T (T a)
xc T (T a) -> T (T a) -> T (T a)
forall a. C a => a -> a -> a
+ T (T a)
k T (T a) -> T (T a) -> T (T a)
forall a. C a => a -> a -> a
* Registers (T (T a)) -> T (T a)
forall value. Flatten value => Registers value -> value
Value.unfold Registers (T (T a))
T a
state
   in  (T (T a), T (T a))
-> CodeGenFunction r (Registers (T (T a), T (T a)))
forall value r.
Flatten value =>
value -> CodeGenFunction r (Registers value)
Value.flatten (T (T a) -> T (T a)
forall a. T (T a) -> T (T a)
stereoFromComplexVal T (T a)
y, T (T a)
y)

_next :: forall a r.
(PseudoRing a, IntegerConstant a) =>
(Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a)
_next (Parameter a
amp T a
k, T a
x) T a
s = do
   let kr :: a
kr = T a -> a
forall a. T a -> a
Complex.real T a
k
       ki :: a
ki = T a -> a
forall a. T a -> a
Complex.imag T a
k
       sr :: a
sr = T a -> a
forall a. T a -> a
Complex.real T a
s
       si :: a
si = T a -> a
forall a. T a -> a
Complex.imag T a
s
   a
yr <- T a -> forall r. CodeGenFunction r a
forall a. T a -> forall r. CodeGenFunction r a
Value.decons (T a -> forall r. CodeGenFunction r a)
-> T a -> forall r. CodeGenFunction r a
forall a b. (a -> b) -> a -> b
$
      (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul (T a -> a
forall a. T a -> a
Stereo.left T a
x) a
amp) T a -> T a -> T a
forall a. C a => a -> a -> a
+
      (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
kr a
sr) T a -> T a -> T a
forall a. C a => a -> a -> a
- (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
ki a
si)
   a
yi <- T a -> forall r. CodeGenFunction r a
forall a. T a -> forall r. CodeGenFunction r a
Value.decons (T a -> forall r. CodeGenFunction r a)
-> T a -> forall r. CodeGenFunction r a
forall a b. (a -> b) -> a -> b
$
      (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul (T a -> a
forall a. T a -> a
Stereo.right T a
x) a
amp) T a -> T a -> T a
forall a. C a => a -> a -> a
+
      (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
kr a
si) T a -> T a -> T a
forall a. C a => a -> a -> a
+ (forall r. CodeGenFunction r a) -> T a
forall a. (forall r. CodeGenFunction r a) -> T a
Value.lift0 (a -> a -> CodeGenFunction r a
forall r. a -> a -> CodeGenFunction r a
forall a r. PseudoRing a => a -> a -> CodeGenFunction r a
A.mul a
ki a
sr)
   (T a, T a) -> CodeGenFunction r (T a, T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> a -> T a
forall a. a -> a -> T a
Stereo.cons a
yr a
yi, a
yr a -> a -> T a
forall a. a -> a -> T a
Complex.+: a
yi)


start ::
   (A.Additive a) =>
   CodeGenFunction r (Complex.T a)
start :: forall a r. Additive a => CodeGenFunction r (T a)
start =
   T a -> CodeGenFunction r (T a)
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return (a
forall a. Additive a => a
A.zero a -> a -> T a
forall a. a -> a -> T a
Complex.+: a
forall a. Additive a => a
A.zero)

causal ::
   (A.PseudoRing a, A.IntegerConstant a, Memory.C a) =>
   Causal.T
      (Parameter a, Stereo.T a)
      (Stereo.T a)
causal :: forall a.
(PseudoRing a, IntegerConstant a, C a) =>
T (Parameter a, T a) (T a)
causal =
   (forall r.
 (Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a))
-> (forall r. CodeGenFunction r (T a))
-> T (Parameter a, T a) (T a)
forall state a b.
C state =>
(forall r. a -> state -> CodeGenFunction r (b, state))
-> (forall r. CodeGenFunction r state) -> T a b
Causal.mapAccum (Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a)
forall r. (Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a)
forall a r.
(PseudoRing a, IntegerConstant a) =>
(Parameter a, T a) -> T a -> CodeGenFunction r (T a, T a)
next CodeGenFunction r (T a)
forall r. CodeGenFunction r (T a)
forall a r. Additive a => CodeGenFunction r (T a)
start


stereoFromComplex :: Complex.T a -> Stereo.T a
stereoFromComplex :: forall a. T a -> T a
stereoFromComplex T a
c = a -> a -> T a
forall a. a -> a -> T a
Stereo.cons (T a -> a
forall a. T a -> a
Complex.real T a
c) (T a -> a
forall a. T a -> a
Complex.imag T a
c)

nextPlain ::
   (Ring.C a) =>
   (Parameter a, Stereo.T a) -> Complex.T a -> (Stereo.T a, Complex.T a)
nextPlain :: forall a. C a => (Parameter a, T a) -> T a -> (T a, T a)
nextPlain (Parameter a
amp T a
k, T a
x) T a
state =
   let xc :: T a
xc = T a -> a
forall a. T a -> a
Stereo.left T a
x  a -> a -> T a
forall a. a -> a -> T a
Complex.+:  T a -> a
forall a. T a -> a
Stereo.right T a
x
       y :: T a
y = a -> T a -> T a
forall a. C a => a -> T a -> T a
Complex.scale a
amp T a
xc T a -> T a -> T a
forall a. C a => a -> a -> a
+ T a
k T a -> T a -> T a
forall a. C a => a -> a -> a
* T a
state
   in (T a -> T a
forall a. T a -> T a
stereoFromComplex T a
y, T a
y)

causalExp ::
   (Ring.C ae, Expr.Aggregate ae a, Memory.C a) =>
   CausalExp.T (Parameter a, Stereo.T a) (Stereo.T a)
causalExp :: forall ae a.
(C ae, Aggregate ae a, C a) =>
T (Parameter a, T a) (T a)
causalExp =
   ((Parameter ae, T ae) -> T ae -> (T ae, T ae))
-> T ae -> T (Parameter a, T a) (T a)
forall state statel a al b bl.
(Aggregate state statel, C statel, Aggregate a al,
 Aggregate b bl) =>
(a -> state -> (b, state)) -> state -> T al bl
CausalExp.mapAccum (Parameter ae, T ae) -> T ae -> (T ae, T ae)
forall a. C a => (Parameter a, T a) -> T a -> (T a, T a)
nextPlain T ae
forall a. C a => a
zero