{-# LANGUAGE TypeFamilies #-}
{-# LANGUAGE TypeOperators #-}
{-# LANGUAGE Rank2Types #-}
{-# LANGUAGE RebindableSyntax #-}
{- |
<http://arxiv.org/abs/0911.5171>
-}
module Synthesizer.LLVM.Causal.Helix (
   -- * time and phase control based on the helix model
   static,
   staticPacked,
   dynamic,
   dynamicLimited,

   -- * useful control curves
   zigZag,
   zigZagPacked,
   zigZagLong,
   zigZagLongPacked,
   ) where

import qualified Synthesizer.LLVM.Causal.ProcessPacked as CausalPS
import qualified Synthesizer.LLVM.Causal.Private as CausalPriv
import qualified Synthesizer.LLVM.Causal.Process as Causal
import qualified Synthesizer.LLVM.Causal.Functional as Func
import qualified Synthesizer.LLVM.Generator.Source as Source
import qualified Synthesizer.LLVM.Generator.SignalPacked as SigPS
import qualified Synthesizer.LLVM.Generator.Private as SigPriv
import qualified Synthesizer.LLVM.Generator.Signal as Sig
import qualified Synthesizer.LLVM.Causal.RingBufferForward as RingBuffer
import qualified Synthesizer.LLVM.Frame.SerialVector as SerialExp
import qualified Synthesizer.LLVM.Frame.SerialVector.Code as Serial
import qualified Synthesizer.LLVM.Frame.SerialVector.Class as SerialClass
import qualified Synthesizer.LLVM.Interpolation as Ip
import Synthesizer.LLVM.Causal.Functional (($&), (&|&))
import Synthesizer.LLVM.Private (noLocalPtr)

import Synthesizer.Causal.Class (($*), ($<))

import qualified LLVM.DSL.Expression.Vector as ExprVec
import qualified LLVM.DSL.Expression as Expr
import LLVM.DSL.Expression (Exp, (<*), (>=*))

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

import qualified LLVM.Core as LLVM

import qualified Type.Data.Num.Decimal as TypeNum

import Data.Word (Word)

import Control.Arrow (first, (<<<))
import Control.Category (id)
import Control.Functor.HT (unzip)
import Data.Traversable (mapM)
import Data.Tuple.HT (mapPair, mapFst)

import qualified Algebra.Ring as Ring

import NumericPrelude.Numeric hiding (splitFraction)
import NumericPrelude.Base hiding (unzip, zip, mapM, id)

import Prelude ()


{- |
Inputs are @(shape, phase)@.

The shape parameter is limited at the beginning and at the end
such that only available data is used for interpolation.
Actually, we allow almost one step less than possible,
since the right boundary of the interval of admissible @shape@ values is open.
-}
static ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Storable.C vh, MultiValue.T vh ~ v) =>
   (Marshal.C a, MultiValue.Field a, MultiValue.RationalConstant a) =>
   (MultiValue.Fraction a, MultiValue.NativeFloating a ar) =>
   (MultiValueVec.NativeFloating a ar, MultiValue.T a ~ am) =>
   (forall r. Ip.T r nodesLeap am v) ->
   (forall r. Ip.T r nodesStep am v) ->
   Exp Int ->
   Exp a ->
   Exp (Source.StorableVector vh) ->
   Causal.T (am, am) v
static :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) vh v a ar am.
(C nodesStep, C nodesLeap, C vh, T vh ~ v, C a, Field a,
 RationalConstant a, Fraction a, NativeFloating a ar,
 NativeFloating a ar, T a ~ am) =>
(forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> Exp (StorableVector vh)
-> T (am, am) v
static forall r. T r nodesLeap am v
ipLeap forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period Exp (StorableVector vh)
vec =
   let periodWord :: Exp Word
periodWord = Exp Int -> Exp Word
wordFromInt Exp Int
periodInt
       cellMargin :: Exp (Margin (nodesLeap (nodesStep v)))
cellMargin = (forall r. T r nodesLeap (T a) v)
-> (forall r. T r nodesStep (T a) v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
combineMarginParams T r nodesLeap am v
T a -> nodesLeap v -> CodeGenFunction r v
forall r. T r nodesLeap am v
forall r. T r nodesLeap (T a) v
ipLeap T r nodesStep am v
T a -> nodesStep v -> CodeGenFunction r v
forall r. T r nodesStep am v
forall r. T r nodesStep (T a) v
ipStep Exp Int
periodInt
   in  (forall r. T r nodesLeap (T a) v)
-> (forall r. T r nodesStep (T a) v)
-> T (nodesLeap (nodesStep v), (T a, T a)) v
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> T (nodesLeap (nodesStep v), (a, a)) v
interpolateCell T r nodesLeap am v
T a -> nodesLeap v -> CodeGenFunction r v
forall r. T r nodesLeap am v
forall r. T r nodesLeap (T a) v
ipLeap T r nodesStep am v
T a -> nodesStep v -> CodeGenFunction r v
forall r. T r nodesStep am v
forall r. T r nodesStep (T a) v
ipStep
       T (nodesLeap (nodesStep v), (T a, T a)) v
-> T (am, am) (nodesLeap (nodesStep v), (T a, T a)) -> T (am, am) v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
       T (T Word) (nodesLeap (nodesStep v))
-> T (T Word, (T a, T a)) (nodesLeap (nodesStep v), (T a, T a))
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 (Exp (Margin (nodesLeap (nodesStep v)))
-> Exp Word
-> Exp (StorableVector vh)
-> T (T Word) (nodesLeap (nodesStep v))
forall a value (nodesLeap :: * -> *) (nodesStep :: * -> *).
(C a, T a ~ value, C nodesLeap, C nodesStep) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp Word
-> Exp (StorableVector a)
-> T (T Word) (nodesLeap (nodesStep value))
peekCell Exp (Margin (nodesLeap (nodesStep v)))
cellMargin Exp Word
periodWord Exp (StorableVector vh)
vec)
       T (T Word, (T a, T a)) (nodesLeap (nodesStep v), (T a, T a))
-> T (am, am) (T Word, (T a, T a))
-> T (am, am) (nodesLeap (nodesStep v), (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
<<<
       Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
forall a ar.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeFloating a ar) =>
Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
flattenShapePhaseProc Exp Word
periodWord Exp a
period
       T (T a, T a) (T Word, (T a, T a))
-> T (am, am) (T a, T a) -> T (am, am) (T Word, (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 am (T a) -> T (am, am) (T a, am)
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
          (Exp (Margin (nodesLeap (nodesStep v)))
-> Exp Int -> Exp Int -> MV a a
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr i value.
(C nodesStep, C nodesLeap, C t, Real t, NativeFloating t tr,
 i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> MV t t
limitShape Exp (Margin (nodesLeap (nodesStep v)))
cellMargin Exp Int
periodInt
              (Exp Word -> Exp Int
intFromWord (Exp Word -> Exp Int) -> Exp Word -> Exp Int
forall a b. (a -> b) -> a -> b
$ Exp (StorableVector vh) -> Exp Word
forall a. Exp (StorableVector a) -> Exp Word
Source.storableVectorLength Exp (StorableVector vh)
vec))

intFromWord :: Exp Word -> Exp Int
intFromWord :: Exp Word -> Exp Int
intFromWord = (forall r. Repr Word -> CodeGenFunction r (Repr Int))
-> Exp Word -> Exp Int
forall a b.
(forall r. Repr a -> CodeGenFunction r (Repr b)) -> Exp a -> Exp b
Expr.liftReprM Repr Word -> CodeGenFunction r (Repr Int)
Value Word -> CodeGenFunction r (Value Int)
forall r. Repr Word -> CodeGenFunction r (Repr Int)
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast

wordFromInt :: Exp Int -> Exp Word
wordFromInt :: Exp Int -> Exp Word
wordFromInt = (forall r. Repr Int -> CodeGenFunction r (Repr Word))
-> Exp Int -> Exp Word
forall a b.
(forall r. Repr a -> CodeGenFunction r (Repr b)) -> Exp a -> Exp b
Expr.liftReprM Repr Int -> CodeGenFunction r (Repr Word)
Value Int -> CodeGenFunction r (Value Word)
forall r. Repr Int -> CodeGenFunction r (Repr Word)
forall (value :: * -> *) a b r.
(ValueCons value, IsSized a, IsSized b, SizeOf a ~ SizeOf b) =>
value a -> CodeGenFunction r (value b)
LLVM.bitcast

staticPacked ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Storable.C vh, MultiValue.T vh ~ ve, SerialClass.Element v ~ ve) =>
   (SerialClass.Size (nodesLeap (nodesStep v)) ~ n,
    SerialClass.Write (nodesLeap (nodesStep v)),
    SerialClass.Element (nodesLeap (nodesStep v)) ~
       nodesLeap (nodesStep (SerialClass.Element v))) =>
   (TypeNum.Positive n) =>
   (Marshal.C a, MultiVector.Field a, MultiVector.Real a,
    MultiVector.Fraction a, MultiVector.RationalConstant a,
    MultiVector.NativeFloating n a ar) =>
   (forall r. Ip.T r nodesLeap (Serial.Value n a) v) ->
   (forall r. Ip.T r nodesStep (Serial.Value n a) v) ->
   Exp Int ->
   Exp a ->
   Exp (Source.StorableVector vh) ->
   Causal.T (Serial.Value n a, Serial.Value n a) v
staticPacked :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) vh ve v n a ar.
(C nodesStep, C nodesLeap, C vh, T vh ~ ve, Element v ~ ve,
 Size (nodesLeap (nodesStep v)) ~ n,
 Write (nodesLeap (nodesStep v)),
 Element (nodesLeap (nodesStep v))
 ~ nodesLeap (nodesStep (Element v)),
 Positive n, C a, Field a, Real a, Fraction a, RationalConstant a,
 NativeFloating n a ar) =>
(forall r. T r nodesLeap (Value n a) v)
-> (forall r. T r nodesStep (Value n a) v)
-> Exp Int
-> Exp a
-> Exp (StorableVector vh)
-> T (Value n a, Value n a) v
staticPacked forall r. T r nodesLeap (Value n a) v
ipLeap forall r. T r nodesStep (Value n a) v
ipStep Exp Int
periodInt Exp a
period Exp (StorableVector vh)
vec =
   let periodWord :: Exp Word
periodWord = Exp Int -> Exp Word
wordFromInt Exp Int
periodInt
       cellMargin :: Exp (Margin (nodesLeap (nodesStep v)))
cellMargin = (forall r. T r nodesLeap (Value n a) v)
-> (forall r. T r nodesStep (Value n a) v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
combineMarginParams T r nodesLeap (Value n a) v
forall r. T r nodesLeap (Value n a) v
ipLeap T r nodesStep (Value n a) v
forall r. T r nodesStep (Value n a) v
ipStep Exp Int
periodInt
   in  (forall r. T r nodesLeap (Value n a) v)
-> (forall r. T r nodesStep (Value n a) v)
-> T (nodesLeap (nodesStep v), (Value n a, Value n a)) v
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> T (nodesLeap (nodesStep v), (a, a)) v
interpolateCell T r nodesLeap (Value n a) v
forall r. T r nodesLeap (Value n a) v
ipLeap T r nodesStep (Value n a) v
forall r. T r nodesStep (Value n a) v
ipStep
       T (nodesLeap (nodesStep v), (Value n a, Value n a)) v
-> T (Value n a, Value n a)
     (nodesLeap (nodesStep v), (Value n a, Value n a))
-> T (Value n a, Value n a) v
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
       T (Value n Word) (nodesLeap (nodesStep v))
-> T (Value n Word, (Value n a, Value n a))
     (nodesLeap (nodesStep v), (Value n a, Value n a))
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 (T (T Word) (nodesLeap (nodesStep (T vh)))
-> T (Value n Word) (nodesLeap (nodesStep v))
forall va n a vb b.
(Read va, n ~ Size va, a ~ Element va, Write vb, n ~ Size vb,
 b ~ Element vb) =>
T a b -> T va vb
CausalPS.pack
          (Exp (Margin (nodesLeap (nodesStep (T vh))))
-> Exp Word
-> Exp (StorableVector vh)
-> T (T Word) (nodesLeap (nodesStep (T vh)))
forall a value (nodesLeap :: * -> *) (nodesStep :: * -> *).
(C a, T a ~ value, C nodesLeap, C nodesStep) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp Word
-> Exp (StorableVector a)
-> T (T Word) (nodesLeap (nodesStep value))
peekCell (Exp (Margin (nodesLeap (nodesStep v)))
-> Exp (Margin (nodesLeap (nodesStep (Element v))))
forall (nodesLeap :: * -> *) (nodesStep :: * -> *) v.
Exp (Margin (nodesLeap (nodesStep v)))
-> Exp (Margin (nodesLeap (nodesStep (Element v))))
elementMargin Exp (Margin (nodesLeap (nodesStep v)))
cellMargin) Exp Word
periodWord Exp (StorableVector vh)
vec))
       T (Value n Word, (Value n a, Value n a))
  (nodesLeap (nodesStep v), (Value n a, Value n a))
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
-> T (Value n a, Value n a)
     (nodesLeap (nodesStep v), (Value n a, Value n a))
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
       Exp Word
-> Exp a
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
forall n a ar.
(Positive n, Field a, RationalConstant a, Fraction a,
 NativeFloating n a ar) =>
Exp Word
-> Exp a
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
flattenShapePhaseProcPacked Exp Word
periodWord Exp a
period
       T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
-> T (Value n a, Value n a) (Value n a, Value n a)
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
       T (Value n a) (Value n a)
-> T (Value n a, Value n a) (Value n a, Value n a)
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
          (Exp (Margin (nodesLeap (nodesStep v)))
-> Exp Int -> Exp Int -> T (Value n a) (Value n a)
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr n i value.
(C nodesStep, C nodesLeap, C t, NativeFloating t tr, Positive n,
 Real t, i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (Value n t) (Value n t)
limitShapePacked Exp (Margin (nodesLeap (nodesStep v)))
cellMargin Exp Int
periodInt
              (Exp Word -> Exp Int
intFromWord (Exp Word -> Exp Int) -> Exp Word -> Exp Int
forall a b. (a -> b) -> a -> b
$ Exp (StorableVector vh) -> Exp Word
forall a. Exp (StorableVector a) -> Exp Word
Source.storableVectorLength Exp (StorableVector vh)
vec))


{- |
In contrast to 'dynamic' this one ends
when the end of the manipulated signal is reached.
-}
dynamicLimited ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C a, MultiValue.Field a, MultiValue.Fraction a,
    MultiValue.Select a, MultiValue.Comparison a,
    MultiValue.NativeFloating a ar,
    MultiValue.RationalConstant a,
    MultiValueVec.NativeFloating a ar) =>
   (MultiValue.T a ~ am) =>
   (Memory.C v) =>
   (forall r. Ip.T r nodesLeap am v) ->
   (forall r. Ip.T r nodesStep am v) ->
   Exp Int ->
   Exp a ->
   Sig.T v ->
   Causal.T (am, am) v
dynamicLimited :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a ar am v.
(C nodesStep, C nodesLeap, C a, Field a, Fraction a, Select a,
 Comparison a, NativeFloating a ar, RationalConstant a,
 NativeFloating a ar, T a ~ am, C v) =>
(forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T v
-> T (am, am) v
dynamicLimited forall r. T r nodesLeap am v
ipLeap forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period T v
sig =
   (Exp (Margin (nodesLeap (nodesStep v)))
 -> (T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T (am, am) v
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a ar am v.
(C nodesStep, C nodesLeap, C a, Field a, Fraction a, Select a,
 Comparison a, NativeFloating a ar, RationalConstant a,
 NativeFloating a ar, T a ~ am, C v) =>
(Exp (Margin (nodesLeap (nodesStep v)))
 -> (T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T (am, am) v
dynamicGen
      (\Exp (Margin (nodesLeap (nodesStep v)))
cellMargin (T (am, am) (T Word)
skips, T (am, am) am
fracs) ->
         let windows :: T (am, am) (T v)
windows =
               (Exp Word -> T v -> T (T Word) (T v)
forall a. C a => Exp Word -> T a -> T (T Word) (T a)
RingBuffer.trackSkip
                     (Exp Int -> Exp Word
wordFromInt (Exp Int -> Exp Word) -> Exp Int -> Exp Word
forall a b. (a -> b) -> a -> b
$ Exp (Margin (nodesLeap (nodesStep v))) -> Exp Int
forall (val :: * -> *) nodes.
Value val =>
val (Margin nodes) -> val Int
Ip.marginNumberExp Exp (Margin (nodesLeap (nodesStep v)))
cellMargin) T v
sig)
                  T (T Word) (T v) -> T (am, am) (T Word) -> T (am, am) (T v)
forall b c a. T b c -> T a b -> T a c
$& T (am, am) (T Word)
skips
         in  (T (am, am) (T v)
windows,
              Exp Word -> T (T Word) (T Word)
forall ae a. (Aggregate ae a, C a) => ae -> T a a
Causal.delay1 Exp Word
forall a. C a => a
zero T (T Word) (T Word) -> T (am, am) (T Word) -> T (am, am) (T Word)
forall b c a. T b c -> T a b -> T a c
$& T (am, am) (T Word)
skips,
              Exp a -> T am am
forall ae a. (Aggregate ae a, C a) => ae -> T a a
Causal.delay1 Exp a
forall a. C a => a
zero T am am -> T (am, am) am -> T (am, am) am
forall b c a. T b c -> T a b -> T a c
$& T (am, am) am
fracs))
      T r nodesLeap am v
forall r. T r nodesLeap am v
ipLeap am -> nodesStep v -> CodeGenFunction r v
forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period

{- |
If the time control exceeds the end of the input signal,
then the last waveform is locked.
This is analogous to 'static'.
-}
dynamic ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C a, MultiValue.Field a, MultiValue.Fraction a,
    MultiValue.Select a, MultiValue.Comparison a,
    MultiValue.NativeFloating a ar,
    MultiValue.RationalConstant a,
    MultiValueVec.NativeFloating a ar) =>
   (MultiValue.T a ~ am) =>
   (Memory.C v) =>
   (forall r. Ip.T r nodesLeap am v) ->
   (forall r. Ip.T r nodesStep am v) ->
   Exp Int ->
   Exp a ->
   Sig.T v ->
   Causal.T (am, am) v
dynamic :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a ar am v.
(C nodesStep, C nodesLeap, C a, Field a, Fraction a, Select a,
 Comparison a, NativeFloating a ar, RationalConstant a,
 NativeFloating a ar, T a ~ am, C v) =>
(forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T v
-> T (am, am) v
dynamic forall r. T r nodesLeap am v
ipLeap forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period T v
sig =
   (Exp (Margin (nodesLeap (nodesStep v)))
 -> (T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T (am, am) v
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a ar am v.
(C nodesStep, C nodesLeap, C a, Field a, Fraction a, Select a,
 Comparison a, NativeFloating a ar, RationalConstant a,
 NativeFloating a ar, T a ~ am, C v) =>
(Exp (Margin (nodesLeap (nodesStep v)))
 -> (T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T (am, am) v
dynamicGen
      (\Exp (Margin (nodesLeap (nodesStep v)))
cellMargin (T (am, am) (T Word)
skips, T (am, am) am
fracs) ->
         let {-
             For conformance with 'static'
             we stop one step before the definite end.
             We achieve this by using a buffer
             that is one step longer than necessary.
             -}
             ((T (am, am) (T Bool)
running, T (am, am) (T Word)
actualSkips), T (am, am) (T v)
windows) =
                (T (am, am) (T Bool, T Word)
 -> (T (am, am) (T Bool), T (am, am) (T Word)))
-> (T (am, am) (T Bool, T Word), T (am, am) (T v))
-> ((T (am, am) (T Bool), T (am, am) (T Word)), T (am, am) (T v))
forall a c b. (a -> c) -> (a, b) -> (c, b)
mapFst T (am, am) (T Bool, T Word)
-> (T (am, am) (T Bool), T (am, am) (T Word))
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
unzip ((T (am, am) (T Bool, T Word), T (am, am) (T v))
 -> ((T (am, am) (T Bool), T (am, am) (T Word)), T (am, am) (T v)))
-> (T (am, am) (T Bool, T Word), T (am, am) (T v))
-> ((T (am, am) (T Bool), T (am, am) (T Word)), T (am, am) (T v))
forall a b. (a -> b) -> a -> b
$ T (am, am) ((T Bool, T Word), T v)
-> (T (am, am) (T Bool, T Word), T (am, am) (T v))
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
unzip (T (am, am) ((T Bool, T Word), T v)
 -> (T (am, am) (T Bool, T Word), T (am, am) (T v)))
-> T (am, am) ((T Bool, T Word), T v)
-> (T (am, am) (T Bool, T Word), T (am, am) (T v))
forall a b. (a -> b) -> a -> b
$
                (Exp Word -> T v -> T (T Word) ((T Bool, T Word), T v)
forall a.
C a =>
Exp Word -> T a -> T (T Word) ((T Bool, T Word), T a)
RingBuffer.trackSkipHold
                   (Exp Int -> Exp Word
wordFromInt (Exp (Margin (nodesLeap (nodesStep v))) -> Exp Int
forall (val :: * -> *) nodes.
Value val =>
val (Margin nodes) -> val Int
Ip.marginNumberExp Exp (Margin (nodesLeap (nodesStep v)))
cellMargin) Exp Word -> Exp Word -> Exp Word
forall a. C a => a -> a -> a
+ Exp Word
1) T v
sig)
                   T (T Word) ((T Bool, T Word), T v)
-> T (am, am) (T Word) -> T (am, am) ((T Bool, T Word), T v)
forall b c a. T b c -> T a b -> T a c
$& T (am, am) (T Word)
skips
             holdFracs :: T (am, am) am
holdFracs =
                (Exp Bool -> Exp a -> Exp a) -> T (T Bool, am) am
forall ae a be b ce c.
(Aggregate ae a, Aggregate be b, Aggregate ce c) =>
(ae -> be -> ce) -> T (a, b) c
Causal.zipWith (\Exp Bool
r Exp a
fr -> Exp Bool -> Exp a -> Exp a -> Exp a
forall a. Select a => Exp Bool -> Exp a -> Exp a -> Exp a
Expr.select Exp Bool
r Exp a
fr Exp a
1)
                T (T Bool, am) am -> T (am, am) (T Bool, am) -> T (am, am) am
forall b c a. T b c -> T a b -> T a c
$&
                T (am, am) (T Bool)
running T (am, am) (T Bool) -> T (am, am) am -> T (am, am) (T Bool, am)
forall a b c. T a b -> T a c -> T a (b, c)
&|& (Exp a -> T am am
forall ae a. (Aggregate ae a, C a) => ae -> T a a
Causal.delay1 Exp a
forall a. C a => a
zero T am am -> T (am, am) am -> T (am, am) am
forall b c a. T b c -> T a b -> T a c
$& T (am, am) am
fracs)
         in  (T (am, am) (T v)
windows, T (am, am) (T Word)
actualSkips, T (am, am) am
holdFracs))
      T r nodesLeap am v
forall r. T r nodesLeap am v
ipLeap T r nodesStep am v
forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period

dynamicGen ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C a, MultiValue.Field a, MultiValue.Fraction a,
    MultiValue.Select a, MultiValue.Comparison a,
    MultiValue.NativeFloating a ar,
    MultiValue.RationalConstant a,
    MultiValueVec.NativeFloating a ar) =>
   (MultiValue.T a ~ am) =>
   (Memory.C v) =>
   (Exp (Ip.Margin (nodesLeap (nodesStep v))) ->
    (Func.T (am, am) (MultiValue.T Word),
     Func.T (am, am) am) ->
    (Func.T (am, am) (RingBuffer.T v),
     Func.T (am, am) (MultiValue.T Word),
     Func.T (am, am) am)) ->
   (forall r. Ip.T r nodesLeap am v) ->
   (forall r. Ip.T r nodesStep am v) ->
   Exp Int ->
   Exp a ->
   Causal.T (am, am) v
dynamicGen :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a ar am v.
(C nodesStep, C nodesLeap, C a, Field a, Fraction a, Select a,
 Comparison a, NativeFloating a ar, RationalConstant a,
 NativeFloating a ar, T a ~ am, C v) =>
(Exp (Margin (nodesLeap (nodesStep v)))
 -> (T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (forall r. T r nodesLeap am v)
-> (forall r. T r nodesStep am v)
-> Exp Int
-> Exp a
-> T (am, am) v
dynamicGen Exp (Margin (nodesLeap (nodesStep v)))
-> (T (am, am) (T Word), T (am, am) am)
-> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am)
limitMaxShape forall r. T r nodesLeap am v
ipLeap forall r. T r nodesStep am v
ipStep Exp Int
periodInt Exp a
period =
   let periodWord :: Exp Word
periodWord = Exp Int -> Exp Word
wordFromInt Exp Int
periodInt
       cellMargin :: Exp (Margin (nodesLeap (nodesStep v)))
cellMargin = (forall r. T r nodesLeap (T a) v)
-> (forall r. T r nodesStep (T a) v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
combineMarginParams T r nodesLeap am v
T a -> nodesLeap v -> CodeGenFunction r v
forall r. T r nodesLeap am v
forall r. T r nodesLeap (T a) v
ipLeap T r nodesStep am v
T a -> nodesStep v -> CodeGenFunction r v
forall r. T r nodesStep am v
forall r. T r nodesStep (T a) v
ipStep Exp Int
periodInt
       minShape :: Exp Word
minShape = Exp Int -> Exp Word
wordFromInt (Exp Int -> Exp Word) -> Exp Int -> Exp Word
forall a b. (a -> b) -> a -> b
$ (Exp Int, Exp Int) -> Exp Int
forall a b. (a, b) -> a
fst ((Exp Int, Exp Int) -> Exp Int) -> (Exp Int, Exp Int) -> Exp Int
forall a b. (a -> b) -> a -> b
$ Exp (Margin (nodesLeap (nodesStep v)))
-> Exp Int -> (Exp Int, Exp Int)
forall (nodesLeap :: * -> *) (nodesStep :: * -> *) i value.
(C nodesLeap, C nodesStep, Exp Int ~ i) =>
Exp (Margin (nodesLeap (nodesStep value))) -> i -> (i, i)
shapeMargin Exp (Margin (nodesLeap (nodesStep v)))
cellMargin Exp Int
periodInt

   in  (Arguments (T (am, am)) (am, am) -> T (am, am) v) -> T (am, am) v
forall inp out.
MakeArguments inp =>
(Arguments (T inp) inp -> T inp out) -> T inp out
Func.withArgs ((Arguments (T (am, am)) (am, am) -> T (am, am) v) -> T (am, am) v)
-> (Arguments (T (am, am)) (am, am) -> T (am, am) v)
-> T (am, am) v
forall a b. (a -> b) -> a -> b
$ \(T (am, am) (T a)
shape, T (am, am) (T a)
phase) ->
          let (T (am, am) (T v)
windows, T (am, am) (T Word)
skips, T (am, am) am
fracs) =
                 Exp (Margin (nodesLeap (nodesStep v)))
-> (T (am, am) (T Word), T (am, am) am)
-> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am)
limitMaxShape Exp (Margin (nodesLeap (nodesStep v)))
cellMargin ((T (am, am) (T Word), T (am, am) am)
 -> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am))
-> (T (am, am) (T Word), T (am, am) am)
-> (T (am, am) (T v), T (am, am) (T Word), T (am, am) am)
forall a b. (a -> b) -> a -> b
$
                 T (am, am) (T Word, am) -> (T (am, am) (T Word), T (am, am) am)
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
unzip (T (T a) (T Word, am)
T (T a) (T Word, T a)
forall a ar.
(C a, Additive a, NativeFloating a ar, IsPrimitive ar) =>
T (T a) (T Word, T a)
integrateFrac T (T a) (T Word, am) -> T (am, am) (T a) -> T (am, am) (T Word, am)
forall b c a. T b c -> T a b -> T a c
$& (Exp Word -> T (T a) (T a)
forall a ar.
(C a, Select a, Comparison a, NativeFloating a ar) =>
Exp Word -> T (T a) (T a)
limitMinShape Exp Word
minShape T (T a) (T a) -> T (am, am) (T a) -> T (am, am) (T a)
forall b c a. T b c -> T a b -> T a c
$& T (am, am) (T a)
shape))
              (T (am, am) (T Word)
offsets, T (am, am) (T a, T a)
shapePhases) =
                 T (am, am) (T Word, (T a, T a))
-> (T (am, am) (T Word), T (am, am) (T a, T a))
forall (f :: * -> *) a b. Functor f => f (a, b) -> (f a, f b)
unzip
                    (Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
forall a ar.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeFloating a ar) =>
Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
flattenShapePhaseProc Exp Word
periodWord Exp a
period T (T a, T a) (T Word, (T a, T a))
-> T (am, am) (T a, T a) -> T (am, am) (T Word, (T a, T a))
forall b c a. T b c -> T a b -> T a c
$&
                       (Exp Word -> T (am, am) (T a)
forall a ar inp. NativeFloating a ar => Exp Word -> T inp (T a)
constantFromWord Exp Word
minShape T (am, am) (T a) -> T (am, am) (T a) -> T (am, am) (T a)
forall a. C a => a -> a -> a
+ T (am, am) am
T (am, am) (T a)
fracs)
                       T (am, am) (T a) -> T (am, am) (T a) -> T (am, am) (T a, T a)
forall a b c. T a b -> T a c -> T a (b, c)
&|&
                       (T (T a, T a) (T a)
forall t. (C t, Fraction t) => T (t, t) t
Causal.osciCoreSync T (T a, T a) (T a) -> T (am, am) (T a, T a) -> T (am, am) (T a)
forall b c a. T b c -> T a b -> T a c
$&
                          T (am, am) (T a)
phase
                          T (am, am) (T a) -> T (am, am) (T a) -> T (am, am) (T a, T a)
forall a b c. T a b -> T a c -> T a (b, c)
&|&
                          T (am, am) (T a) -> T (am, am) (T a)
forall a. C a => a -> a
negate
                             ((Exp a -> Exp a) -> T (T a) (T a)
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map ((Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
/Exp a
period)) T (T a) (T a) -> T (am, am) (T a) -> T (am, am) (T a)
forall b c a. T b c -> T a b -> T a c
$&
                                ((Exp Word -> Exp a) -> T (T Word) (T a)
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map Exp Word -> Exp a
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral T (T Word) (T a) -> T (am, am) (T Word) -> T (am, am) (T a)
forall b c a. T b c -> T a b -> T a c
$& T (am, am) (T Word)
skips))))
          in (forall r. T r nodesLeap (T a) v)
-> (forall r. T r nodesStep (T a) v)
-> T (nodesLeap (nodesStep v), (T a, T a)) v
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> T (nodesLeap (nodesStep v), (a, a)) v
interpolateCell T r nodesLeap am v
T a -> nodesLeap v -> CodeGenFunction r v
forall r. T r nodesLeap am v
forall r. T r nodesLeap (T a) v
ipLeap T r nodesStep am v
T a -> nodesStep v -> CodeGenFunction r v
forall r. T r nodesStep am v
forall r. T r nodesStep (T a) v
ipStep T (nodesLeap (nodesStep v), (T a, T a)) v
-> T (am, am) (nodesLeap (nodesStep v), (T a, T a)) -> T (am, am) v
forall b c a. T b c -> T a b -> T a c
$&
                 ((forall r.
 (T v, T Word) -> CodeGenFunction r (nodesLeap (nodesStep v)))
-> T (T v, T Word) (nodesLeap (nodesStep v))
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map
                    (\(T v
buffer, T Word
offset) -> do
                       T Word
p <- Exp Word -> forall r. CodeGenFunction r (T Word)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp Word
periodWord
                       T Word
-> T v -> T Word -> CodeGenFunction r (nodesLeap (nodesStep v))
forall a (nodesLeap :: * -> *) (nodesStep :: * -> *) r.
(C a, C nodesLeap, C nodesStep) =>
T Word
-> T a -> T Word -> CodeGenFunction r (nodesLeap (nodesStep a))
cellFromBuffer T Word
p T v
buffer T Word
offset)
                  T (T v, T Word) (nodesLeap (nodesStep v))
-> T (am, am) (T v, T Word) -> T (am, am) (nodesLeap (nodesStep v))
forall b c a. T b c -> T a b -> T a c
$&
                  T (am, am) (T v)
windows
                  T (am, am) (T v) -> T (am, am) (T Word) -> T (am, am) (T v, T Word)
forall a b c. T a b -> T a c -> T a (b, c)
&|&
                  T (am, am) (T Word)
offsets)
                 T (am, am) (nodesLeap (nodesStep v))
-> T (am, am) (T a, T a)
-> T (am, am) (nodesLeap (nodesStep v), (T a, T a))
forall a b c. T a b -> T a c -> T a (b, c)
&|&
                 T (am, am) (T a, T a)
shapePhases

constantFromWord ::
   (MultiValue.NativeFloating a ar) =>
   Exp Word -> Func.T inp (MultiValue.T a)
constantFromWord :: forall a ar inp. NativeFloating a ar => Exp Word -> T inp (T a)
constantFromWord Exp Word
x =
   T (T a) -> T inp (T a)
forall out inp. T out -> T inp out
Func.fromSignal ((Exp Word -> Exp a) -> T (T Word) (T a)
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map Exp Word -> Exp a
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral T (T Word) (T a) -> SignalOf T (T Word) -> SignalOf T (T a)
forall (process :: * -> * -> *) a b.
C process =>
process a b -> SignalOf process a -> SignalOf process b
$* Exp Word -> T (T Word)
forall ae al. (Aggregate ae al, C al) => ae -> T al
Sig.constant Exp Word
x)

limitMinShape ::
   (Marshal.C a, MultiValue.Select a, MultiValue.Comparison a,
    MultiValue.NativeFloating a ar) =>
   Exp Word ->
   Causal.T (MultiValue.T a) (MultiValue.T a)
limitMinShape :: forall a ar.
(C a, Select a, Comparison a, NativeFloating a ar) =>
Exp Word -> T (T a) (T a)
limitMinShape Exp Word
xLim =
   (Exp a -> Exp a -> (Exp a, Exp a)) -> Exp a -> T (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
Causal.mapAccum
      (\Exp a
x Exp a
lim ->
         Exp (a, a) -> (Exp a, Exp a)
forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
Expr.unzip (Exp (a, a) -> (Exp a, Exp a)) -> Exp (a, a) -> (Exp a, Exp a)
forall a b. (a -> b) -> a -> b
$
         Exp Bool -> Exp (a, a) -> Exp (a, a) -> Exp (a, a)
forall a. Select a => Exp Bool -> Exp a -> Exp a -> Exp a
Expr.select (Exp a
xExp a -> Exp a -> Exp Bool
forall a. Comparison a => Exp a -> Exp a -> Exp Bool
>=*Exp a
lim) (Exp a -> Exp a -> Exp (a, a)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
Expr.zip (Exp a
xExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
-Exp a
lim) Exp a
forall a. C a => a
zero) (Exp a -> Exp a -> Exp (a, a)
forall (val :: * -> *) a b.
Value val =>
val a -> val b -> val (a, b)
Expr.zip Exp a
forall a. C a => a
zero (Exp a
limExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
-Exp a
x)))
      (Exp Word -> Exp a
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral Exp Word
xLim)

integrateFrac ::
   (Marshal.C a, MultiValue.Additive a,
    MultiValueVec.NativeFloating a ar, LLVM.IsPrimitive ar) =>
   Causal.T (MultiValue.T a) (MultiValue.T Word, MultiValue.T a)
integrateFrac :: forall a ar.
(C a, Additive a, NativeFloating a ar, IsPrimitive ar) =>
T (T a) (T Word, T a)
integrateFrac =
   (Exp a -> Exp a -> ((Exp Word, Exp a), Exp a))
-> Exp a -> T (T a) (T Word, 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
Causal.mapAccum
      (\Exp a
a Exp a
frac ->
         let s :: (Exp Word, Exp a)
s = Exp a -> (Exp Word, Exp a)
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
Exp a -> (Exp i, Exp a)
ExprVec.splitFractionToInt (Exp a
aExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
+Exp a
frac)
         in ((Exp Word, Exp a)
s, (Exp Word, Exp a) -> Exp a
forall a b. (a, b) -> b
snd (Exp Word, Exp a)
s))
      Exp a
forall a. C a => a
zero


interpolateCell ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (forall r. Ip.T r nodesLeap a v) ->
   (forall r. Ip.T r nodesStep a v) ->
   Causal.T (nodesLeap (nodesStep v), (a, a)) v
interpolateCell :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> T (nodesLeap (nodesStep v), (a, a)) v
interpolateCell forall r. T r nodesLeap a v
ipLeap forall r. T r nodesStep a v
ipStep =
   (forall r.
 (nodesLeap (nodesStep v), (a, a)) -> CodeGenFunction r v)
-> T (nodesLeap (nodesStep v), (a, a)) v
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map
      (\(nodesLeap (nodesStep v)
nodes, (a
leap,a
step)) ->
         T r nodesLeap a v
forall r. T r nodesLeap a v
ipLeap a
leap (nodesLeap v -> CodeGenFunction r v)
-> CodeGenFunction r (nodesLeap v) -> CodeGenFunction r v
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< (nodesStep v -> CodeGenFunction r v)
-> nodesLeap (nodesStep v) -> CodeGenFunction r (nodesLeap v)
forall (t :: * -> *) (m :: * -> *) a b.
(Traversable t, Monad m) =>
(a -> m b) -> t a -> m (t b)
forall (m :: * -> *) a b.
Monad m =>
(a -> m b) -> nodesLeap a -> m (nodesLeap b)
mapM (T r nodesStep a v
forall r. T r nodesStep a v
ipStep a
step) nodesLeap (nodesStep v)
nodes)

cellFromBuffer ::
   (Memory.C a, Ip.C nodesLeap, Ip.C nodesStep) =>
   MultiValue.T Word ->
   RingBuffer.T a ->
   MultiValue.T Word ->
   LLVM.CodeGenFunction r (nodesLeap (nodesStep a))
cellFromBuffer :: forall a (nodesLeap :: * -> *) (nodesStep :: * -> *) r.
(C a, C nodesLeap, C nodesStep) =>
T Word
-> T a -> T Word -> CodeGenFunction r (nodesLeap (nodesStep a))
cellFromBuffer T Word
periodInt T a
buffer T Word
offset =
   (T Word -> CodeGenFunction r (nodesStep a))
-> T Word -> T Word -> CodeGenFunction r (nodesLeap (nodesStep a))
forall (nodes :: * -> *) r v.
C nodes =>
(T Word -> CodeGenFunction r v)
-> T Word -> T Word -> CodeGenFunction r (nodes v)
Ip.indexNodesExp
      ((T Word -> CodeGenFunction r a)
-> T Word -> T Word -> CodeGenFunction r (nodesStep a)
forall (nodes :: * -> *) r v.
C nodes =>
(T Word -> CodeGenFunction r v)
-> T Word -> T Word -> CodeGenFunction r (nodes v)
Ip.indexNodesExp ((T Word -> T a -> CodeGenFunction r a)
-> T a -> T Word -> CodeGenFunction r a
forall a b c. (a -> b -> c) -> b -> a -> c
flip T Word -> T a -> CodeGenFunction r a
forall a r. C a => T Word -> T a -> CodeGenFunction r a
RingBuffer.index T a
buffer) T Word
forall a. IntegerConstant a => a
A.one)
      T Word
periodInt T Word
offset

elementMargin ::
   Exp (Ip.Margin (nodesLeap (nodesStep v))) ->
   Exp (Ip.Margin (nodesLeap (nodesStep (SerialClass.Element v))))
elementMargin :: forall (nodesLeap :: * -> *) (nodesStep :: * -> *) v.
Exp (Margin (nodesLeap (nodesStep v)))
-> Exp (Margin (nodesLeap (nodesStep (Element v))))
elementMargin = (forall r.
 Repr (Margin (nodesLeap (nodesStep v)))
 -> CodeGenFunction
      r (Repr (Margin (nodesLeap (nodesStep (Element v))))))
-> Exp (Margin (nodesLeap (nodesStep v)))
-> Exp (Margin (nodesLeap (nodesStep (Element v))))
forall a b.
(forall r. Repr a -> CodeGenFunction r (Repr b)) -> Exp a -> Exp b
Expr.liftReprM (Value Int, Value Int) -> CodeGenFunction r (Value Int, Value Int)
Repr (Margin (nodesLeap (nodesStep v)))
-> CodeGenFunction
     r (Repr (Margin (nodesLeap (nodesStep (Element v)))))
forall a. a -> CodeGenFunction r a
forall r.
Repr (Margin (nodesLeap (nodesStep v)))
-> CodeGenFunction
     r (Repr (Margin (nodesLeap (nodesStep (Element v)))))
forall (m :: * -> *) a. Monad m => a -> m a
return

peekCell ::
   (Storable.C a, MultiValue.T a ~ value, Ip.C nodesLeap, Ip.C nodesStep) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   Exp Word ->
   Exp (Source.StorableVector a) ->
   Causal.T (MultiValue.T Word) (nodesLeap (nodesStep value))
peekCell :: forall a value (nodesLeap :: * -> *) (nodesStep :: * -> *).
(C a, T a ~ value, C nodesLeap, C nodesStep) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp Word
-> Exp (StorableVector a)
-> T (T Word) (nodesLeap (nodesStep value))
peekCell Exp (Margin (nodesLeap (nodesStep value)))
margin Exp Word
periodWord Exp (StorableVector a)
vec =
   (forall r.
 T Word -> CodeGenFunction r (nodesLeap (nodesStep value)))
-> T (T Word) (nodesLeap (nodesStep value))
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map
      (\T Word
n -> do
         ~(MultiValue.Cons (Value (Ptr a)
ptr,Value Word
_l)) <- Exp (StorableVector a)
-> forall r. CodeGenFunction r (T (StorableVector a))
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp (StorableVector a)
vec
         ~(MultiValue.Cons Repr Int
offset) <-
            Exp Int -> forall r. CodeGenFunction r (T Int)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp (Exp Int -> forall r. CodeGenFunction r (T Int))
-> Exp Int -> forall r. CodeGenFunction r (T Int)
forall a b. (a -> b) -> a -> b
$ Exp Word -> Exp Int
intFromWord (T Word -> Exp Word
forall a. T a -> Exp a
forall (val :: * -> *) a. Value val => T a -> val a
Expr.lift0 T Word
n) Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
- Exp (Margin (nodesLeap (nodesStep value))) -> Exp Int
forall (val :: * -> *) nodes.
Value val =>
val (Margin nodes) -> val Int
Ip.marginOffsetExp Exp (Margin (nodesLeap (nodesStep value)))
margin
         T Int
perInt <- Exp Int -> forall r. CodeGenFunction r (T Int)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp (Exp Int -> forall r. CodeGenFunction r (T Int))
-> Exp Int -> forall r. CodeGenFunction r (T Int)
forall a b. (a -> b) -> a -> b
$ Exp Word -> Exp Int
intFromWord Exp Word
periodWord
         (Value (Ptr a) -> CodeGenFunction r (nodesStep value))
-> T Int
-> Value (Ptr a)
-> CodeGenFunction r (nodesLeap (nodesStep value))
forall (nodes :: * -> *) am r a.
(C nodes, Storable am) =>
(Value (Ptr am) -> CodeGenFunction r a)
-> T Int -> Value (Ptr am) -> CodeGenFunction r (nodes a)
Ip.loadNodesExp ((Value (Ptr a) -> CodeGenFunction r value)
-> T Int -> Value (Ptr a) -> CodeGenFunction r (nodesStep value)
forall (nodes :: * -> *) am r a.
(C nodes, Storable am) =>
(Value (Ptr am) -> CodeGenFunction r a)
-> T Int -> Value (Ptr am) -> CodeGenFunction r (nodes a)
Ip.loadNodesExp Value (Ptr a) -> CodeGenFunction r value
Value (Ptr a) -> CodeGenFunction r (T a)
forall a r. C a => Value (Ptr a) -> CodeGenFunction r (T a)
forall r. Value (Ptr a) -> CodeGenFunction r (T a)
Storable.load T Int
forall a. IntegerConstant a => a
A.one) T Int
perInt
            (Value (Ptr a) -> CodeGenFunction r (nodesLeap (nodesStep value)))
-> CodeGenFunction r (Value (Ptr a))
-> CodeGenFunction r (nodesLeap (nodesStep value))
forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
=<< Value Int -> Value (Ptr a) -> CodeGenFunction r (Value (Ptr a))
forall a ptr r.
(Storable a, Value (Ptr a) ~ ptr) =>
Value Int -> ptr -> CodeGenFunction r ptr
Storable.advancePtr Repr Int
Value Int
offset Value (Ptr a)
ptr)


flattenShapePhaseProc ::
   (MultiValue.Field a, MultiValue.RationalConstant a, MultiValue.Fraction a) =>
   (MultiValue.NativeFloating a ar, MultiValueVec.NativeFloating a ar) =>
   Exp Word ->
   Exp a ->
   Causal.T
      (MultiValue.T a, MultiValue.T a)
      (MultiValue.T Word, (MultiValue.T a, MultiValue.T a))
flattenShapePhaseProc :: forall a ar.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeFloating a ar) =>
Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
flattenShapePhaseProc Exp Word
periodInt Exp a
period =
   ((Exp a, Exp a) -> (Exp Word, (Exp a, Exp a)))
-> T (T a, T a) (T Word, (T a, T a))
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map
      (\(Exp a
shape, Exp a
phase) -> Exp Word -> Exp a -> Exp a -> Exp a -> (Exp Word, (Exp a, Exp a))
forall a ar i ir.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeInteger i ir, ShapeOf ir ~ ShapeOf ar) =>
Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a))
flattenShapePhase Exp Word
periodInt Exp a
period Exp a
shape Exp a
phase)

_flattenShapePhaseProc ::
   (MultiValue.Field a, MultiValue.RationalConstant a, MultiValue.Fraction a) =>
   (MultiValue.NativeFloating a ar) =>
   Exp Word ->
   Exp a ->
   Causal.T
      (MultiValue.T a, MultiValue.T a)
      (MultiValue.T Word, (MultiValue.T a, MultiValue.T a))
_flattenShapePhaseProc :: forall a ar.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar) =>
Exp Word -> Exp a -> T (T a, T a) (T Word, (T a, T a))
_flattenShapePhaseProc Exp Word
period32 Exp a
period =
   (forall r. (T a, T a) -> CodeGenFunction r (T Word, (T a, T a)))
-> T (T a, T a) (T Word, (T a, T a))
forall a b. (forall r. a -> CodeGenFunction r b) -> T a b
CausalPriv.map
      (\(T a
shape, T a
phase) -> do
         T Word
perInt <- Exp Word -> forall r. CodeGenFunction r (T Word)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp Word
period32
         T a
per <- Exp a -> forall r. CodeGenFunction r (T a)
forall a. Exp a -> forall r. CodeGenFunction r (T a)
Expr.unExp Exp a
period
         T Word
-> T a -> T a -> T a -> CodeGenFunction r (T Word, (T a, T a))
forall a ar i ir r.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeInteger i ir) =>
T i -> T a -> T a -> T a -> CodeGenFunction r (T i, (T a, T a))
_flattenShapePhase T Word
perInt T a
per T a
shape T a
phase)

flattenShapePhaseProcPacked ::
   (TypeNum.Positive n, MultiVector.Field a, MultiVector.RationalConstant a) =>
   (MultiVector.Fraction a, MultiVector.NativeFloating n a ar) =>
   Exp Word ->
   Exp a ->
   Causal.T
      (Serial.Value n a, Serial.Value n a)
      (Serial.Value n Word, (Serial.Value n a, Serial.Value n a))
flattenShapePhaseProcPacked :: forall n a ar.
(Positive n, Field a, RationalConstant a, Fraction a,
 NativeFloating n a ar) =>
Exp Word
-> Exp a
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
flattenShapePhaseProcPacked Exp Word
periodInt Exp a
period =
   (Exp (T n a)
 -> Exp (T n a) -> (Exp (T n Word), (Exp (T n a), Exp (T n a))))
-> T (Value n a, Value n a) (Value n Word, (Value n a, Value n a))
forall ae a be b ce c.
(Aggregate ae a, Aggregate be b, Aggregate ce c) =>
(ae -> be -> ce) -> T (a, b) c
Causal.zipWith
      (Exp (T n Word)
-> Exp (T n a)
-> Exp (T n a)
-> Exp (T n a)
-> (Exp (T n Word), (Exp (T n a), Exp (T n a)))
forall a ar i ir.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeInteger i ir, ShapeOf ir ~ ShapeOf ar) =>
Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a))
flattenShapePhase
         (Exp Word -> Exp (T n Word)
forall n a. (Positive n, C a) => Exp a -> Exp (T n a)
SerialExp.upsample Exp Word
periodInt) (Exp a -> Exp (T n a)
forall n a. (Positive n, C a) => Exp a -> Exp (T n a)
SerialExp.upsample Exp a
period))

flattenShapePhase ::
   (MultiValue.Field a, MultiValue.RationalConstant a, MultiValue.Fraction a) =>
   (MultiValueVec.NativeFloating a ar, MultiValueVec.NativeInteger i ir) =>
   (LLVM.ShapeOf ir ~ LLVM.ShapeOf ar) =>
   Exp i -> Exp a ->
   Exp a -> Exp a ->
   (Exp i, (Exp a, Exp a))
flattenShapePhase :: forall a ar i ir.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeInteger i ir, ShapeOf ir ~ ShapeOf ar) =>
Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a))
flattenShapePhase Exp i
periodInt Exp a
period Exp a
shape Exp a
phase =
   let qLeap :: Exp a
qLeap = Exp a -> Exp a
forall a. Fraction a => Exp a -> Exp a
Expr.fraction (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$ Exp a
shapeExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
/Exp a
period Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
- Exp a
phase
       (Exp i
n,Exp a
qStep) =
          Exp a -> (Exp i, Exp a)
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
Exp a -> (Exp i, Exp a)
ExprVec.splitFractionToInt (Exp a -> (Exp i, Exp a)) -> Exp a -> (Exp i, Exp a)
forall a b. (a -> b) -> a -> b
$
          {-
          If 'shape' is correctly limited,
          the value is always non-negative algebraically,
          but maybe not numerically.
          -}
          Exp a -> Exp a -> Exp a
forall a. Real a => Exp a -> Exp a -> Exp a
Expr.max Exp a
forall a. C a => a
zero (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$
          Exp a
shape Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
- Exp a
qLeap Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
* Exp i -> Exp a
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar,
 ShapeOf ir ~ ShapeOf ar) =>
Exp i -> Exp a
ExprVec.fromIntegral Exp i
periodInt
   in (Exp i
n,(Exp a
qLeap,Exp a
qStep))

_flattenShapePhase ::
   (MultiValue.Field a, MultiValue.RationalConstant a, MultiValue.Fraction a) =>
   (MultiValue.NativeFloating a ar, MultiValue.NativeInteger i ir) =>
   MultiValue.T i ->
   MultiValue.T a ->
   MultiValue.T a -> MultiValue.T a ->
   LLVM.CodeGenFunction r (MultiValue.T i, (MultiValue.T a, MultiValue.T a))
_flattenShapePhase :: forall a ar i ir r.
(Field a, RationalConstant a, Fraction a, NativeFloating a ar,
 NativeInteger i ir) =>
T i -> T a -> T a -> T a -> CodeGenFunction r (T i, (T a, T a))
_flattenShapePhase = (Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a)))
-> T i -> T a -> T a -> T a -> CodeGenFunction r (T i, (T a, T a))
forall ae am be bm ce cm de dm ee em r.
(Aggregate ae am, Aggregate be bm, Aggregate ce cm,
 Aggregate de dm, Aggregate ee em) =>
(ae -> be -> ce -> de -> ee)
-> am -> bm -> cm -> dm -> CodeGenFunction r em
Expr.unliftM4 ((Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a)))
 -> T i -> T a -> T a -> T a -> CodeGenFunction r (T i, (T a, T a)))
-> (Exp i -> Exp a -> Exp a -> Exp a -> (Exp i, (Exp a, Exp a)))
-> T i
-> T a
-> T a
-> T a
-> CodeGenFunction r (T i, (T a, T a))
forall a b. (a -> b) -> a -> b
$ \Exp i
periodInt Exp a
period Exp a
shape Exp a
phase ->
   let qLeap :: Exp a
qLeap = Exp a -> Exp a
forall a. Fraction a => Exp a -> Exp a
Expr.fraction (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$ Exp a
shapeExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
/Exp a
period Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
- Exp a
phase
       (Exp i
n,Exp a
qStep) =
          Exp a -> (Exp i, Exp a)
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp a -> (Exp i, Exp a)
Expr.splitFractionToInt (Exp a -> (Exp i, Exp a)) -> Exp a -> (Exp i, Exp a)
forall a b. (a -> b) -> a -> b
$
          {-
          If 'shape' is correctly limited,
          the value is always non-negative algebraically,
          but maybe not numerically.
          -}
          Exp a -> Exp a -> Exp a
forall a. Real a => Exp a -> Exp a -> Exp a
Expr.max Exp a
forall a. C a => a
zero (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$
          Exp a
shape Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
- Exp a
qLeap Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
* Exp i -> Exp a
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral Exp i
periodInt
   in  (Exp i
n,(Exp a
qLeap,Exp a
qStep))


limitShape ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C t, MultiValue.Real t, MultiValue.NativeFloating t tr) =>
   (i ~ Int) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   Exp i -> Exp i -> Causal.MV t t
limitShape :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr i value.
(C nodesStep, C nodesLeap, C t, Real t, NativeFloating t tr,
 i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> MV t t
limitShape Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len =
   ((Exp t, Exp t) -> Exp t -> Exp t) -> T ((T t, T t), T t) (T t)
forall ae a be b ce c.
(Aggregate ae a, Aggregate be b, Aggregate ce c) =>
(ae -> be -> ce) -> T (a, b) c
Causal.zipWith (Exp t, Exp t) -> Exp t -> Exp t
forall a. Real a => (Exp a, Exp a) -> Exp a -> Exp a
Expr.limit
   T ((T t, T t), T t) (T t) -> SignalOf T (T t, T t) -> T (T t) (T t)
forall (process :: * -> * -> *) a b c.
C process =>
process (a, b) c -> SignalOf process a -> process b c
$<
   Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (T t, T t)
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr i value.
(C nodesStep, C nodesLeap, C t, NativeFloating t tr, i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (T t, T t)
limitShapeSignal Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len

limitShapePacked ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C t, MultiValue.NativeFloating t tr) =>
   (TypeNum.Positive n, MultiVector.Real t) =>
   (i ~ Int) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   Exp i ->
   Exp i ->
   Causal.T (Serial.Value n t) (Serial.Value n t)
limitShapePacked :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr n i value.
(C nodesStep, C nodesLeap, C t, NativeFloating t tr, Positive n,
 Real t, i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (Value n t) (Value n t)
limitShapePacked Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len =
   ((Exp t, Exp t) -> Exp (T n t) -> Exp (T n t))
-> T ((T t, T t), Value n t) (Value n t)
forall ae a be b ce c.
(Aggregate ae a, Aggregate be b, Aggregate ce c) =>
(ae -> be -> ce) -> T (a, b) c
Causal.zipWith
      (\(Exp t
minShape,Exp t
maxShape) Exp (T n t)
shape ->
         (Exp (T n t), Exp (T n t)) -> Exp (T n t) -> Exp (T n t)
forall n a.
(Positive n, Real a) =>
(Exp (T n a), Exp (T n a)) -> Exp (T n a) -> Exp (T n a)
SerialExp.limit
            (Exp t -> Exp (T n t)
forall n a. (Positive n, C a) => Exp a -> Exp (T n a)
SerialExp.upsample Exp t
minShape,
             Exp t -> Exp (T n t)
forall n a. (Positive n, C a) => Exp a -> Exp (T n a)
SerialExp.upsample Exp t
maxShape)
            Exp (T n t)
shape)
   T ((T t, T t), Value n t) (Value n t)
-> SignalOf T (T t, T t) -> T (Value n t) (Value n t)
forall (process :: * -> * -> *) a b c.
C process =>
process (a, b) c -> SignalOf process a -> process b c
$<
   Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (T t, T t)
forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr i value.
(C nodesStep, C nodesLeap, C t, NativeFloating t tr, i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (T t, T t)
limitShapeSignal Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len

limitShapeSignal ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (Marshal.C t, MultiValue.NativeFloating t tr) =>
   (i ~ Int) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   Exp i ->
   Exp i ->
   Sig.T (MultiValue.T t, MultiValue.T t)
limitShapeSignal :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) t tr i value.
(C nodesStep, C nodesLeap, C t, NativeFloating t tr, i ~ Int) =>
Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> T (T t, T t)
limitShapeSignal Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len =
   (forall r c.
 Phi c =>
 (T t, T t)
 -> Value (Ptr (Struct ())) -> () -> T r c ((T t, T t), ()))
-> (forall r. CodeGenFunction r ((T t, T t), ()))
-> (forall r. (T t, T t) -> CodeGenFunction r ())
-> T (T t, T t)
forall a global local state.
(C global, IsSized local, C state) =>
(forall r c.
 Phi c =>
 global -> Value (Ptr local) -> state -> T r c (a, state))
-> (forall r. CodeGenFunction r (global, state))
-> (forall r. global -> CodeGenFunction r ())
-> T a
SigPriv.Cons
      (\(T t, T t)
minMax -> (() -> T r c ((T t, T t), ()))
-> Value (Ptr (Struct ())) -> () -> T r c ((T t, T t), ())
forall f. f -> Value (Ptr (Struct ())) -> f
noLocalPtr ((() -> T r c ((T t, T t), ()))
 -> Value (Ptr (Struct ())) -> () -> T r c ((T t, T t), ()))
-> (() -> T r c ((T t, T t), ()))
-> Value (Ptr (Struct ()))
-> ()
-> T r c ((T t, T t), ())
forall a b. (a -> b) -> a -> b
$ \() -> ((T t, T t), ()) -> T r c ((T t, T t), ())
forall a. a -> T r c a
forall (m :: * -> *) a. Monad m => a -> m a
return ((T t, T t)
minMax, ()))
      (do
         (T t, T t)
limits <-
            (Exp t, Exp t) -> CodeGenFunction r (T t, T t)
forall r. (Exp t, Exp t) -> CodeGenFunction r (T t, T t)
forall exp mv r. Aggregate exp mv => exp -> CodeGenFunction r mv
Expr.bundle
               ((Exp i -> Exp t, Exp i -> Exp t)
-> (Exp i, Exp i) -> (Exp t, Exp t)
forall a c b d. (a -> c, b -> d) -> (a, b) -> (c, d)
mapPair (Exp i -> Exp t
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral, Exp i -> Exp t
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral) ((Exp i, Exp i) -> (Exp t, Exp t))
-> (Exp i, Exp i) -> (Exp t, Exp t)
forall a b. (a -> b) -> a -> b
$
                Exp (Margin (nodesLeap (nodesStep value)))
-> Exp i -> Exp i -> (Exp i, Exp i)
forall (nodesLeap :: * -> *) (nodesStep :: * -> *) t value.
(C nodesLeap, C nodesStep, Exp Int ~ t) =>
Exp (Margin (nodesLeap (nodesStep value))) -> t -> t -> (t, t)
shapeLimits Exp (Margin (nodesLeap (nodesStep value)))
margin Exp i
periodInt Exp i
len)
         ((T t, T t), ()) -> CodeGenFunction r ((T t, T t), ())
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ((T t, T t)
limits, ()))
      (CodeGenFunction r () -> (T t, T t) -> CodeGenFunction r ()
forall a b. a -> b -> a
const (CodeGenFunction r () -> (T t, T t) -> CodeGenFunction r ())
-> CodeGenFunction r () -> (T t, T t) -> CodeGenFunction r ()
forall a b. (a -> b) -> a -> b
$ () -> CodeGenFunction r ()
forall a. a -> CodeGenFunction r a
forall (m :: * -> *) a. Monad m => a -> m a
return ())


shapeLimits ::
   (Ip.C nodesLeap, Ip.C nodesStep, Exp Int ~ t) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   t -> t -> (t, t)
shapeLimits :: forall (nodesLeap :: * -> *) (nodesStep :: * -> *) t value.
(C nodesLeap, C nodesStep, Exp Int ~ t) =>
Exp (Margin (nodesLeap (nodesStep value))) -> t -> t -> (t, t)
shapeLimits Exp (Margin (nodesLeap (nodesStep value)))
margin t
periodInt t
len =
   case Exp (Margin (nodesLeap (nodesStep value))) -> t -> (t, t)
forall (nodesLeap :: * -> *) (nodesStep :: * -> *) i value.
(C nodesLeap, C nodesStep, Exp Int ~ i) =>
Exp (Margin (nodesLeap (nodesStep value))) -> i -> (i, i)
shapeMargin Exp (Margin (nodesLeap (nodesStep value)))
margin t
periodInt of
      (t
leftMargin, t
rightMargin) -> (t
leftMargin, t
len t -> t -> t
forall a. C a => a -> a -> a
- t
rightMargin)

shapeMargin ::
   (Ip.C nodesLeap, Ip.C nodesStep, Exp Int ~ i) =>
   Exp (Ip.Margin (nodesLeap (nodesStep value))) ->
   i -> (i, i)
shapeMargin :: forall (nodesLeap :: * -> *) (nodesStep :: * -> *) i value.
(C nodesLeap, C nodesStep, Exp Int ~ i) =>
Exp (Margin (nodesLeap (nodesStep value))) -> i -> (i, i)
shapeMargin Exp (Margin (nodesLeap (nodesStep value)))
margin i
periodInt =
   let (Exp Int
marginNumber, Exp Int
marginOffset) =
         Exp (Int, Int) -> (Exp Int, Exp Int)
forall (val :: * -> *) a b.
Value val =>
val (a, b) -> (val a, val b)
Expr.unzip (Exp (Int, Int) -> (Exp Int, Exp Int))
-> Exp (Int, Int) -> (Exp Int, Exp Int)
forall a b. (a -> b) -> a -> b
$
         (T (Margin (nodesLeap (nodesStep value))) -> T (Int, Int))
-> Exp (Margin (nodesLeap (nodesStep value))) -> Exp (Int, Int)
forall a b. (T a -> T b) -> Exp a -> Exp b
forall (val :: * -> *) a b.
Value val =>
(T a -> T b) -> val a -> val b
Expr.lift1 ((T Int -> T Int -> T (Int, Int)) -> (T Int, T Int) -> T (Int, Int)
forall a b c. (a -> b -> c) -> (a, b) -> c
uncurry T Int -> T Int -> T (Int, Int)
forall a b. T a -> T b -> T (a, b)
MultiValue.zip ((T Int, T Int) -> T (Int, Int))
-> (T (Margin (nodesLeap (nodesStep value))) -> (T Int, T Int))
-> T (Margin (nodesLeap (nodesStep value)))
-> T (Int, Int)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. T (Margin (nodesLeap (nodesStep value))) -> (T Int, T Int)
forall nodes. T (Margin nodes) -> (T Int, T Int)
Ip.unzipMargin) Exp (Margin (nodesLeap (nodesStep value)))
margin
       leftMargin :: Exp Int
leftMargin = Exp Int
marginOffset Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
+ i
Exp Int
periodInt
       rightMargin :: Exp Int
rightMargin = Exp Int
marginNumber Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
- Exp Int
leftMargin
   in  (i
Exp Int
leftMargin, i
Exp Int
rightMargin)

_shapeLimits ::
   (Ip.C nodesLeap, Ip.C nodesStep) =>
   (MultiValue.NativeFloating t tr) =>
   (MultiValue.Additive t) =>
   Ip.Margin (nodesLeap (nodesStep value)) ->
   Exp Word -> Exp t -> (Exp t, Exp t)
_shapeLimits :: forall (nodesLeap :: * -> *) (nodesStep :: * -> *) t tr value.
(C nodesLeap, C nodesStep, NativeFloating t tr, Additive t) =>
Margin (nodesLeap (nodesStep value))
-> Exp Word -> Exp t -> (Exp t, Exp t)
_shapeLimits Margin (nodesLeap (nodesStep value))
margin Exp Word
periodInt Exp t
len =
   let (Exp Word
leftMargin, Exp Word
rightMargin) = Margin (nodesLeap (nodesStep value))
-> Exp Word -> (Exp Word, Exp Word)
forall (nodesLeap :: * -> *) (nodesStep :: * -> *) i value.
(C nodesLeap, C nodesStep, C i) =>
Margin (nodesLeap (nodesStep value)) -> i -> (i, i)
_shapeMargin Margin (nodesLeap (nodesStep value))
margin Exp Word
periodInt
   in  (Exp Word -> Exp t
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral Exp Word
leftMargin, Exp t
len Exp t -> Exp t -> Exp t
forall a. C a => a -> a -> a
- Exp Word -> Exp t
forall i ir a ar.
(NativeInteger i ir, NativeFloating a ar) =>
Exp i -> Exp a
Expr.fromIntegral Exp Word
rightMargin)

_shapeMargin ::
   (Ip.C nodesLeap, Ip.C nodesStep, Ring.C i) =>
   Ip.Margin (nodesLeap (nodesStep value)) ->
   i -> (i, i)
_shapeMargin :: forall (nodesLeap :: * -> *) (nodesStep :: * -> *) i value.
(C nodesLeap, C nodesStep, C i) =>
Margin (nodesLeap (nodesStep value)) -> i -> (i, i)
_shapeMargin Margin (nodesLeap (nodesStep value))
margin i
periodInt =
   let leftMargin :: i
leftMargin = Int -> i
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesLeap (nodesStep value)) -> Int
forall nodes. Margin nodes -> Int
Ip.marginOffset Margin (nodesLeap (nodesStep value))
margin) i -> i -> i
forall a. C a => a -> a -> a
+ i
periodInt
       rightMargin :: i
rightMargin = Int -> i
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesLeap (nodesStep value)) -> Int
forall nodes. Margin nodes -> Int
Ip.marginNumber Margin (nodesLeap (nodesStep value))
margin) i -> i -> i
forall a. C a => a -> a -> a
- i
leftMargin
   in  (i
leftMargin, i
rightMargin)

combineMarginParams ::
   (Ip.C nodesStep, Ip.C nodesLeap) =>
   (forall r. Ip.T r nodesLeap a v) ->
   (forall r. Ip.T r nodesStep a v) ->
   Exp Int ->
   Exp (Ip.Margin (nodesLeap (nodesStep v)))
combineMarginParams :: forall (nodesStep :: * -> *) (nodesLeap :: * -> *) a v.
(C nodesStep, C nodesLeap) =>
(forall r. T r nodesLeap a v)
-> (forall r. T r nodesStep a v)
-> Exp Int
-> Exp (Margin (nodesLeap (nodesStep v)))
combineMarginParams forall r. T r nodesLeap a v
ipLeap forall r. T r nodesStep a v
ipStep Exp Int
periodInt =
   let marginLeap :: Margin (nodesLeap v)
marginLeap = (forall r. T r nodesLeap a v) -> Margin (nodesLeap v)
forall (nodes :: * -> *) a v.
C nodes =>
(forall r. T r nodes a v) -> Margin (nodes v)
Ip.toMargin T r nodesLeap a v
forall r. T r nodesLeap a v
ipLeap in
   let marginStep :: Margin (nodesStep v)
marginStep = (forall r. T r nodesStep a v) -> Margin (nodesStep v)
forall (nodes :: * -> *) a v.
C nodes =>
(forall r. T r nodes a v) -> Margin (nodes v)
Ip.toMargin T r nodesStep a v
forall r. T r nodesStep a v
ipStep in
   (T Int -> T Int -> T (Margin (nodesLeap (nodesStep v))))
-> Exp Int -> Exp Int -> Exp (Margin (nodesLeap (nodesStep v)))
forall a b c. (T a -> T b -> T c) -> Exp a -> Exp b -> Exp c
forall (val :: * -> *) a b c.
Value val =>
(T a -> T b -> T c) -> val a -> val b -> val c
Expr.lift2 T Int -> T Int -> T (Margin (nodesLeap (nodesStep v)))
forall nodes. T Int -> T Int -> T (Margin nodes)
Ip.zipMargin
      (Int -> Exp Int
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesStep v) -> Int
forall nodes. Margin nodes -> Int
Ip.marginNumber Margin (nodesStep v)
marginStep) Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
+
       Int -> Exp Int
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesLeap v) -> Int
forall nodes. Margin nodes -> Int
Ip.marginNumber Margin (nodesLeap v)
marginLeap) Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
* Exp Int
periodInt)
      (Int -> Exp Int
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesStep v) -> Int
forall nodes. Margin nodes -> Int
Ip.marginOffset Margin (nodesStep v)
marginStep) Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
+
       Int -> Exp Int
forall a b. (C a, C b) => a -> b
fromIntegral (Margin (nodesLeap v) -> Int
forall nodes. Margin nodes -> Int
Ip.marginOffset Margin (nodesLeap v)
marginLeap) Exp Int -> Exp Int -> Exp Int
forall a. C a => a -> a -> a
* Exp Int
periodInt)

_combineMargins ::
   Ip.Margin (nodesLeap value) ->
   Ip.Margin (nodesStep value) ->
   Int ->
   Ip.Margin (nodesLeap (nodesStep value))
_combineMargins :: forall (nodesLeap :: * -> *) value (nodesStep :: * -> *).
Margin (nodesLeap value)
-> Margin (nodesStep value)
-> Int
-> Margin (nodesLeap (nodesStep value))
_combineMargins Margin (nodesLeap value)
marginLeap Margin (nodesStep value)
marginStep Int
periodInt =
   Ip.Margin {
      marginNumber :: Int
Ip.marginNumber =
         Margin (nodesStep value) -> Int
forall nodes. Margin nodes -> Int
Ip.marginNumber Margin (nodesStep value)
marginStep Int -> Int -> Int
forall a. C a => a -> a -> a
+
         Margin (nodesLeap value) -> Int
forall nodes. Margin nodes -> Int
Ip.marginNumber Margin (nodesLeap value)
marginLeap Int -> Int -> Int
forall a. C a => a -> a -> a
* Int
periodInt,
      marginOffset :: Int
Ip.marginOffset =
         Margin (nodesStep value) -> Int
forall nodes. Margin nodes -> Int
Ip.marginOffset Margin (nodesStep value)
marginStep Int -> Int -> Int
forall a. C a => a -> a -> a
+
         Margin (nodesLeap value) -> Int
forall nodes. Margin nodes -> Int
Ip.marginOffset Margin (nodesLeap value)
marginLeap Int -> Int -> Int
forall a. C a => a -> a -> a
* Int
periodInt
   }


{- |
@zigZagLong loopStart loopLength@
creates a curve that starts at 0
and is linear until it reaches @loopStart+loopLength@.
Then it begins looping in a ping-pong manner
between @loopStart+loopLength@ and @loopStart@.
It is useful as @shape@ control for looping a sound.
Input of the causal process is the slope (or frequency) control.
Slope values must not be negative.

*Main> Sig.renderChunky SVL.defaultChunkSize (Causal.take 25 <<< Helix.zigZagLong 6 10 $* 2) () :: SVL.Vector Float
VectorLazy.fromChunks [Vector.pack [0.0,1.999999,3.9999995,6.0,8.0,10.0,12.0,14.0,15.999999,14.000001,12.0,10.0,7.999999,6.0,8.0,10.0,12.0,14.0,16.0,14.0,11.999999,9.999998,7.999998,6.0000024,8.000002]]
-}
zigZagLong ::
   (Marshal.C a) =>
   (MultiValue.Select a, MultiValue.Comparison a, MultiValue.Fraction a) =>
   (MultiValue.Field a, MultiValue.RationalConstant a) =>
   Exp a -> Exp a -> Causal.MV a a
zigZagLong :: forall a.
(C a, Select a, Comparison a, Fraction a, Field a,
 RationalConstant a) =>
Exp a -> Exp a -> MV a a
zigZagLong =
   (Exp a -> T (T a) (T a))
-> (Exp a -> T (T a) (T a)) -> Exp a -> Exp a -> T (T a) (T a)
forall a al.
(RationalConstant a, Field a, RationalConstant al, Field al) =>
(Exp a -> T al al)
-> (Exp a -> T al al) -> Exp a -> Exp a -> T al al
zigZagLongGen (SignalOf T (T a) -> T (T a) (T a)
T (T a) -> T (T a) (T a)
forall b a. SignalOf T b -> T a b
forall (process :: * -> * -> *) b a.
C process =>
SignalOf process b -> process a b
Causal.fromSignal (T (T a) -> T (T a) (T a))
-> (Exp a -> T (T a)) -> Exp a -> T (T a) (T a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp a -> T (T a)
forall ae al. (Aggregate ae al, C al) => ae -> T al
Sig.constant) Exp a -> T (T a) (T a)
forall a.
(C a, Select a, Comparison a, Fraction a, Field a,
 RationalConstant a) =>
Exp a -> MV a a
zigZag

zigZagLongPacked ::
   (Marshal.Vector n a) =>
   (MultiVector.Field a, MultiVector.Fraction a) =>
   (MultiVector.RationalConstant a) =>
   (MultiVector.Select a, MultiVector.Comparison a) =>
   Exp a -> Exp a -> Causal.T (Serial.Value n a) (Serial.Value n a)
zigZagLongPacked :: forall n a.
(Vector n a, Field a, Fraction a, RationalConstant a, Select a,
 Comparison a) =>
Exp a -> Exp a -> T (Value n a) (Value n a)
zigZagLongPacked =
   (Exp a -> T (Value n a) (Value n a))
-> (Exp a -> T (Value n a) (Value n a))
-> Exp a
-> Exp a
-> T (Value n a) (Value n a)
forall a al.
(RationalConstant a, Field a, RationalConstant al, Field al) =>
(Exp a -> T al al)
-> (Exp a -> T al al) -> Exp a -> Exp a -> T al al
zigZagLongGen (SignalOf T (Value n a) -> T (Value n a) (Value n a)
T (Value n a) -> T (Value n a) (Value n a)
forall b a. SignalOf T b -> T a b
forall (process :: * -> * -> *) b a.
C process =>
SignalOf process b -> process a b
Causal.fromSignal (T (Value n a) -> T (Value n a) (Value n a))
-> (Exp a -> T (Value n a)) -> Exp a -> T (Value n a) (Value n a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. Exp a -> T (Value n a)
forall n a. Vector n a => Exp a -> T (Serial n a)
SigPS.constant) Exp a -> T (Value n a) (Value n a)
forall n a.
(Positive n, C a, Field a, Fraction a, RationalConstant a,
 Select a, Comparison a) =>
Exp a -> T (Value n a) (Value n a)
zigZagPacked

zigZagLongGen ::
   (MultiValue.RationalConstant a, MultiValue.Field a) =>
   (A.RationalConstant al, A.Field al) =>
   (Exp a -> Causal.T al al) ->
   (Exp a -> Causal.T al al) ->
   Exp a -> Exp a -> Causal.T al al
zigZagLongGen :: forall a al.
(RationalConstant a, Field a, RationalConstant al, Field al) =>
(Exp a -> T al al)
-> (Exp a -> T al al) -> Exp a -> Exp a -> T al al
zigZagLongGen Exp a -> T al al
constant Exp a -> T al al
zz Exp a
prefix Exp a
loop =
   Exp a -> T al al
zz (Exp a -> Exp a
forall a. C a => a -> a
negate (Exp a -> Exp a) -> Exp a -> Exp a
forall a b. (a -> b) -> a -> b
$ Exp a
prefixExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
/Exp a
loop) T al al -> T al al -> T al al
forall a. C a => a -> a -> a
* Exp a -> T al al
constant Exp a
loop T al al -> T al al -> T al al
forall a. C a => a -> a -> a
+ Exp a -> T al al
constant Exp a
prefix
   T al al -> T al al -> T al al
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
   T al al
forall a. T a a
forall {k} (cat :: k -> k -> *) (a :: k). Category cat => cat a a
id T al al -> T al al -> T al al
forall a. C a => a -> a -> a
/ Exp a -> T al al
constant Exp a
loop

{- |
@zigZag start@ creates a zig-zag curve with values between 0 and 1, inclusively,
that is useful as @shape@ control for looping a sound.
Input of the causal process is the slope (or frequency) control.
Slope values must not be negative.
The start value must be at most 2 and may be negative.
-}
zigZag ::
   (Marshal.C a) =>
   (MultiValue.Select a, MultiValue.Comparison a, MultiValue.Fraction a) =>
   (MultiValue.Field a, MultiValue.RationalConstant a) =>
   Exp a -> Causal.MV a a
zigZag :: forall a.
(C a, Select a, Comparison a, Fraction a, Field a,
 RationalConstant a) =>
Exp a -> MV a a
zigZag Exp a
start =
   (Exp a -> Exp a) -> T (T a) (T a)
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map (\Exp a
x -> Exp a
1 Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
- Exp a -> Exp a
forall a. C a => a -> a
abs (Exp a
1Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
-Exp a
x))
   T (T a) (T a) -> T (T a) (T a) -> T (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
<<<
   (Exp a -> Exp a -> (Exp a, Exp a)) -> Exp a -> T (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
Causal.mapAccum
      (\Exp a
d Exp a
t0 -> let t1 :: Exp a
t1 = Exp a
t0Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
+Exp a
d in (Exp a
t0, (Exp Bool -> Exp a -> Exp a -> Exp a)
-> (Exp a -> Exp Bool) -> Exp a -> Exp a
forall a b.
(Field a, Fraction a, RationalConstant a) =>
(Exp b -> Exp a -> Exp a -> Exp a)
-> (Exp a -> Exp b) -> Exp a -> Exp a
wrap Exp Bool -> Exp a -> Exp a -> Exp a
forall a. Select a => Exp Bool -> Exp a -> Exp a -> Exp a
Expr.select (Exp a
0Exp a -> Exp a -> Exp Bool
forall a. Comparison a => Exp a -> Exp a -> Exp Bool
<*) Exp a
t1))
      Exp a
start

zigZagPacked ::
   (TypeNum.Positive n) =>
   (Marshal.C a) =>
   (MultiVector.Field a, MultiVector.Fraction a) =>
   (MultiVector.RationalConstant a) =>
   (MultiVector.Select a, MultiVector.Comparison a) =>
   Exp a -> Causal.T (Serial.Value n a) (Serial.Value n a)
zigZagPacked :: forall n a.
(Positive n, C a, Field a, Fraction a, RationalConstant a,
 Select a, Comparison a) =>
Exp a -> T (Value n a) (Value n a)
zigZagPacked Exp a
start =
   (Exp (T n a) -> Exp (T n a)) -> T (T (T n a)) (T (T n a))
forall ae a be b.
(Aggregate ae a, Aggregate be b) =>
(ae -> be) -> T a b
Causal.map (\Exp (T n a)
x -> Exp (T n a)
1 Exp (T n a) -> Exp (T n a) -> Exp (T n a)
forall a. C a => a -> a -> a
- Exp (T n a) -> Exp (T n a)
forall a. C a => a -> a
abs (Exp (T n a)
1Exp (T n a) -> Exp (T n a) -> Exp (T n a)
forall a. C a => a -> a -> a
-Exp (T n a)
x))
   T (T (T n a)) (T (T n a))
-> T (T (T n a)) (T (T n a)) -> T (T (T n a)) (T (T n a))
forall {k} (cat :: k -> k -> *) (b :: k) (c :: k) (a :: k).
Category cat =>
cat b c -> cat a b -> cat a c
<<<
   (Exp (T n a) -> Exp a -> (Exp (T n a), Exp a))
-> Exp a -> T (T (T n a)) (T (T n 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
Causal.mapAccum
      (\Exp (T n a)
d Exp a
t0 ->
         let (Exp a
t1,Exp (T n a)
cum) = Exp a -> Exp (T n a) -> (Exp a, Exp (T n a))
forall n a.
(Positive n, Additive a) =>
Exp a -> Exp (T n a) -> (Exp a, Exp (T n a))
SerialExp.cumulate Exp a
t0 Exp (T n a)
d
         in ((Exp (T n Bool) -> Exp (T n a) -> Exp (T n a) -> Exp (T n a))
-> (Exp (T n a) -> Exp (T n Bool)) -> Exp (T n a) -> Exp (T n a)
forall a b.
(Field a, Fraction a, RationalConstant a) =>
(Exp b -> Exp a -> Exp a -> Exp a)
-> (Exp a -> Exp b) -> Exp a -> Exp a
wrap Exp (T n Bool) -> Exp (T n a) -> Exp (T n a) -> Exp (T n a)
forall n a.
(Positive n, Select a) =>
Exp (T n Bool) -> Exp (T n a) -> Exp (T n a) -> Exp (T n a)
SerialExp.select (CmpPredicate -> Exp (T n a) -> Exp (T n a) -> Exp (T n Bool)
forall n a.
(Positive n, Comparison a) =>
CmpPredicate -> Exp (T n a) -> Exp (T n a) -> Exp (T n Bool)
SerialExp.cmp CmpPredicate
LLVM.CmpLT Exp (T n a)
forall a. C a => a
zero) Exp (T n a)
cum, Exp a
t1))
      Exp a
start

wrap ::
   (MultiValue.Field a, MultiValue.Fraction a, MultiValue.RationalConstant a) =>
   (Exp b -> Exp a -> Exp a -> Exp a) ->
   (Exp a -> Exp b) ->
   Exp a -> Exp a
wrap :: forall a b.
(Field a, Fraction a, RationalConstant a) =>
(Exp b -> Exp a -> Exp a -> Exp a)
-> (Exp a -> Exp b) -> Exp a -> Exp a
wrap Exp b -> Exp a -> Exp a -> Exp a
select Exp a -> Exp b
positive Exp a
a = Exp b -> Exp a -> Exp a -> Exp a
select (Exp a -> Exp b
positive Exp a
a) (Exp a
2 Exp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
* Exp a -> Exp a
forall a. Fraction a => Exp a -> Exp a
Expr.fraction (Exp a
aExp a -> Exp a -> Exp a
forall a. C a => a -> a -> a
/Exp a
2)) Exp a
a