module Synthesizer.LLVM.Server.CommonPacked where

import Synthesizer.LLVM.Server.Common

import qualified Synthesizer.LLVM.Frame.SerialVector.Code as Serial

import qualified Data.NonEmpty as NonEmpty

import qualified Type.Data.Num.Decimal as TypeNum

import qualified Algebra.Field as Field
import qualified Algebra.Additive as Additive

import NumericPrelude.Numeric
import NumericPrelude.Base
import Prelude ()


sumNested :: (Additive.C a) => [a] -> a
sumNested :: forall a. C a => [a] -> a
sumNested =
   a -> (T [] a -> a) -> Maybe (T [] a) -> a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe a
forall a. C a => a
Additive.zero ((a -> a -> a) -> T [] a -> a
forall a. (a -> a -> a) -> T [] a -> a
NonEmpty.foldBalanced a -> a -> a
forall a. C a => a -> a -> a
(+)) (Maybe (T [] a) -> a) -> ([a] -> Maybe (T [] a)) -> [a] -> a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. [a] -> Maybe (T [] a)
forall (f :: * -> *) a. ViewL f => f a -> Maybe (T f a)
NonEmpty.fetch


-- maybe this can be merged into a PCS.controllerDiscrete
stair :: Real -> Real
stair :: Real -> Real
stair Real
i =
   let n :: Real
n = Int -> Real
forall a b. (C a, C b) => a -> b
fromIntegral (Real -> Int
forall b. C b => Real -> b
forall a b. (C a, C b) => a -> b
round Real
i :: Int)
       r :: Real
r = Real
i Real -> Real -> Real
forall a. C a => a -> a -> a
- Real
n
   in  Real
n Real -> Real -> Real
forall a. C a => a -> a -> a
+ Real
0.01Real -> Real -> Real
forall a. C a => a -> a -> a
*Real
r


type Vector = Serial.T VectorSize Real
type VectorValue = Serial.Value VectorSize Real
type VectorSize = TypeNum.D4


-- ToDo: generalize to Integral class
vectorSize :: Int
vectorSize :: Int
vectorSize =
   Singleton VectorSize -> Int
forall n a. (Integer n, Num a) => Singleton n -> a
TypeNum.integralFromSingleton
      (Singleton VectorSize
forall x. Integer x => Singleton x
TypeNum.singleton :: TypeNum.Singleton VectorSize)

vectorRate :: (Field.C a) => SampleRate a -> a
vectorRate :: forall a. C a => SampleRate a -> a
vectorRate (SampleRate a
sr) = a
sr a -> a -> a
forall a. C a => a -> a -> a
/ Int -> a
forall a b. (C a, C b) => a -> b
fromIntegral Int
vectorSize

vectorTime :: (Field.C a) => SampleRate a -> a -> a
vectorTime :: forall a. C a => SampleRate a -> a -> a
vectorTime (SampleRate a
sr) a
param = a
param a -> a -> a
forall a. C a => a -> a -> a
* a
sr a -> a -> a
forall a. C a => a -> a -> a
/ Int -> a
forall a b. (C a, C b) => a -> b
fromIntegral Int
vectorSize