rhine 0.5.1.1 → 0.6.0
raw patch · 6 files changed
+79/−71 lines, 6 filesdep +simple-affine-spacedep ~basedep ~dunaidep ~timePVP ok
version bump matches the API change (PVP)
Dependencies added: simple-affine-space
Dependency ranges changed: base, dunai, time
API changes (from Hackage documentation)
- FRP.Rhine: (^*) :: RModule v => v -> Groundring v -> v
- FRP.Rhine: FractionalVectorSpace :: a -> FractionalVectorSpace a
- FRP.Rhine: [getFractional] :: FractionalVectorSpace a -> a
- FRP.Rhine: break3Tuple :: () => (a, b, c) -> ((a, b), c)
- FRP.Rhine: break4Tuple :: () => (a, b, c, d) -> ((a, b), (c, d))
- FRP.Rhine: break5Tuple :: () => (a, b, c, d, e) -> ((a, b), (c, d, e))
- FRP.Rhine: class RModule v => InnerProductSpace v
- FRP.Rhine: class (Floating Groundfield v, InnerProductSpace v, VectorSpace v) => NormedSpace v
- FRP.Rhine: class Num Groundring v => RModule v where {
- FRP.Rhine: infix 6 `dot`
- FRP.Rhine: infixl 5 ^-^
- FRP.Rhine: join3Tuple :: () => ((a, b), c) -> (a, b, c)
- FRP.Rhine: join4Tuple :: () => ((a, b), (c, d)) -> (a, b, c, d)
- FRP.Rhine: join5Tuple :: () => ((a, b), (c, d, e)) -> (a, b, c, d, e)
- FRP.Rhine: newtype FractionalVectorSpace a
- FRP.Rhine: type Groundfield v = Groundring v
+ FRP.Rhine: infix 7 `dot`
+ FRP.Rhine: infixl 9 ^/
+ FRP.Rhine: infixr 9 *^
- FRP.Rhine: (*^) :: RModule v => Groundring v -> v -> v
+ FRP.Rhine: (*^) :: VectorSpace v a => a -> v -> v
- FRP.Rhine: (^+^) :: RModule v => v -> v -> v
+ FRP.Rhine: (^+^) :: VectorSpace v a => v -> v -> v
- FRP.Rhine: (^-^) :: RModule v => v -> v -> v
+ FRP.Rhine: (^-^) :: VectorSpace v a => v -> v -> v
- FRP.Rhine: (^/) :: VectorSpace v => v -> Groundfield v -> v
+ FRP.Rhine: (^/) :: VectorSpace v a => v -> a -> v
- FRP.Rhine: average :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: average :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: averageFrom :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => v -> Diff td -> BehaviorF m td v v
+ FRP.Rhine: averageFrom :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => v -> Diff td -> BehaviorF m td v v
- FRP.Rhine: averageLin :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: averageLin :: (Monad m, VectorSpace v s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: averageLinFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> Diff td -> BehaviourF m td v v
+ FRP.Rhine: averageLinFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> Diff td -> BehaviourF m td v v
- FRP.Rhine: bandPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: bandPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: bandStop :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: bandStop :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: class (Fractional Groundring v, RModule v) => VectorSpace v
+ FRP.Rhine: class (Eq a, Floating a) => VectorSpace v a | v -> a
- FRP.Rhine: cubic :: (Monad m, VectorSpace v, Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine: cubic :: (Monad m, VectorSpace v s, Floating v, Eq v, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => ResamplingBuffer m cl1 cl2 v v
- FRP.Rhine: delayBy :: (Monad m, Ord (Diff (Time cl)), TimeDomain (Time cl)) => Diff (Time cl) -> ClSF m cl a a
+ FRP.Rhine: delayBy :: (Monad m, Ord (Diff td), TimeDomain td) => Diff td -> BehaviorF m td a a
- FRP.Rhine: derivative :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine: derivative :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine: derivativeFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine: derivativeFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine: dot :: InnerProductSpace v => v -> v -> Groundfield v
+ FRP.Rhine: dot :: VectorSpace v a => v -> v -> a
- FRP.Rhine: highPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: highPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: integral :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine: integral :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine: integralFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine: integralFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine: linear :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v, Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => v -> v -> ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine: linear :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v s, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => v -> v -> ResamplingBuffer m cl1 cl2 v v
- FRP.Rhine: lowPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine: lowPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine: negateVector :: RModule v => v -> v
+ FRP.Rhine: negateVector :: VectorSpace v a => v -> v
- FRP.Rhine: norm :: NormedSpace v => v -> Groundfield v
+ FRP.Rhine: norm :: VectorSpace v a => v -> a
- FRP.Rhine: normalize :: (Eq (Groundfield v), NormedSpace v) => v -> v
+ FRP.Rhine: normalize :: VectorSpace v a => v -> v
- FRP.Rhine: sinc :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v, Ord (Groundfield v), Floating (Groundfield v), Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => Groundfield v -> ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine: sinc :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v s, Ord s, Floating s, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => s -> ResamplingBuffer m cl1 cl2 v v
- FRP.Rhine: sumFrom :: (RModule v, Monad m) => v -> MSF m v v
+ FRP.Rhine: sumFrom :: (VectorSpace v s, Monad m) => v -> MSF m v v
- FRP.Rhine: sumS :: (RModule v, Monad m) => MSF m v v
+ FRP.Rhine: sumS :: (VectorSpace v s, Monad m) => MSF m v v
- FRP.Rhine: threePointDerivative :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine: threePointDerivative :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine: threePointDerivativeFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine: threePointDerivativeFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine: weightedAverageFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td (v, Groundfield v) v
+ FRP.Rhine: weightedAverageFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td (v, s) v
- FRP.Rhine: zeroVector :: RModule v => v
+ FRP.Rhine: zeroVector :: VectorSpace v a => v
- FRP.Rhine.ClSF.Core: sumFrom :: (RModule v, Monad m) => v -> MSF m v v
+ FRP.Rhine.ClSF.Core: sumFrom :: (VectorSpace v s, Monad m) => v -> MSF m v v
- FRP.Rhine.ClSF.Core: sumS :: (RModule v, Monad m) => MSF m v v
+ FRP.Rhine.ClSF.Core: sumS :: (VectorSpace v s, Monad m) => MSF m v v
- FRP.Rhine.ClSF.Util: average :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: average :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: averageFrom :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => v -> Diff td -> BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: averageFrom :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => v -> Diff td -> BehaviorF m td v v
- FRP.Rhine.ClSF.Util: averageLin :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: averageLin :: (Monad m, VectorSpace v s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: averageLinFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: averageLinFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: bandPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: bandPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: bandStop :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: bandStop :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: delayBy :: (Monad m, Ord (Diff (Time cl)), TimeDomain (Time cl)) => Diff (Time cl) -> ClSF m cl a a
+ FRP.Rhine.ClSF.Util: delayBy :: (Monad m, Ord (Diff td), TimeDomain td) => Diff td -> BehaviorF m td a a
- FRP.Rhine.ClSF.Util: derivative :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: derivative :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine.ClSF.Util: derivativeFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: derivativeFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine.ClSF.Util: highPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: highPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: integral :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: integral :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine.ClSF.Util: integralFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: integralFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine.ClSF.Util: lowPass :: (Monad m, VectorSpace v, Floating (Groundfield v), Groundfield v ~ Diff td) => Diff td -> BehaviourF m td v v
+ FRP.Rhine.ClSF.Util: lowPass :: (Monad m, VectorSpace v s, Floating s, s ~ Diff td) => Diff td -> BehaviourF m td v v
- FRP.Rhine.ClSF.Util: threePointDerivative :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: threePointDerivative :: (Monad m, VectorSpace v s, s ~ Diff td) => BehaviorF m td v v
- FRP.Rhine.ClSF.Util: threePointDerivativeFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td v v
+ FRP.Rhine.ClSF.Util: threePointDerivativeFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td v v
- FRP.Rhine.ClSF.Util: weightedAverageFrom :: (Monad m, VectorSpace v, Groundfield v ~ Diff td) => v -> BehaviorF m td (v, Groundfield v) v
+ FRP.Rhine.ClSF.Util: weightedAverageFrom :: (Monad m, VectorSpace v s, s ~ Diff td) => v -> BehaviorF m td (v, s) v
- FRP.Rhine.Clock: sumFrom :: (RModule v, Monad m) => v -> MSF m v v
+ FRP.Rhine.Clock: sumFrom :: (VectorSpace v s, Monad m) => v -> MSF m v v
- FRP.Rhine.Clock: sumS :: (RModule v, Monad m) => MSF m v v
+ FRP.Rhine.Clock: sumS :: (VectorSpace v s, Monad m) => MSF m v v
- FRP.Rhine.ResamplingBuffer.Interpolation: cubic :: (Monad m, VectorSpace v, Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine.ResamplingBuffer.Interpolation: cubic :: (Monad m, VectorSpace v s, Floating v, Eq v, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => ResamplingBuffer m cl1 cl2 v v
- FRP.Rhine.ResamplingBuffer.Interpolation: linear :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v, Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => v -> v -> ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine.ResamplingBuffer.Interpolation: linear :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v s, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => v -> v -> ResamplingBuffer m cl1 cl2 v v
- FRP.Rhine.ResamplingBuffer.Interpolation: sinc :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v, Ord (Groundfield v), Floating (Groundfield v), Groundfield v ~ Diff (Time cl1), Groundfield v ~ Diff (Time cl2)) => Groundfield v -> ResamplingBuffer m cl1 cl2 v v
+ FRP.Rhine.ResamplingBuffer.Interpolation: sinc :: (Monad m, Clock m cl1, Clock m cl2, VectorSpace v s, Ord s, Floating s, s ~ Diff (Time cl1), s ~ Diff (Time cl2)) => s -> ResamplingBuffer m cl1 cl2 v v
Files
- ChangeLog.md +4/−0
- rhine.cabal +13/−12
- src/FRP/Rhine/ClSF/Util.hs +44/−42
- src/FRP/Rhine/Clock/Periodic.hs +1/−1
- src/FRP/Rhine/ResamplingBuffer/Interpolation.hs +16/−15
- src/FRP/Rhine/Type.hs +1/−1
ChangeLog.md view
@@ -4,6 +4,10 @@ Since `rhine` reexports modules from `dunai`, every major version in `dunai` triggers a major version in `rhine`. +## 0.6.0++* Synced with `dunai` version numbers+* Supported GHC 8.8.3 ## 0.5.1.0
rhine.cabal view
@@ -1,6 +1,6 @@ name: rhine -version: 0.5.1.1+version: 0.6.0 synopsis: Functional Reactive Programming with type-level clocks @@ -46,7 +46,7 @@ source-repository this type: git location: git@github.com:turion/rhine.git- tag: v0.5.1.1+ tag: v0.6.0 library@@ -98,16 +98,17 @@ -- other-extensions: -- Other library packages from which modules are imported.- build-depends: base >= 4.9 && < 4.13- , dunai == 0.5.1.*- , transformers == 0.5.*- , time == 1.8.*- , free == 5.1.*- , containers == 0.6.*- , vector-sized == 1.4.*- , deepseq == 1.4.*- , random == 1.1.*- , MonadRandom == 0.5.*+ build-depends: base >= 4.9 && < 5+ , dunai >= 0.6+ , transformers == 0.5.*+ , time >= 1.8+ , free == 5.1.*+ , containers == 0.6.*+ , vector-sized == 1.4.*+ , deepseq == 1.4.*+ , random == 1.1.*+ , MonadRandom == 0.5.*+ , simple-affine-space -- Directories containing source files. hs-source-dirs: src
src/FRP/Rhine/ClSF/Util.hs view
@@ -31,6 +31,8 @@ import Control.Monad.Trans.MSF.Reader (readerS) import Data.MonadicStreamFunction (constM, sumFrom, iPre, feedback) import Data.MonadicStreamFunction.Instances.VectorSpace ()++-- simple-affine-space import Data.VectorSpace -- rhine@@ -143,8 +145,8 @@ -- | The output of @integralFrom v0@ is the numerical Euler integral -- of the input, with initial offset @v0@. integralFrom- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => v -> BehaviorF m td v v integralFrom v0 = proc v -> do _sinceLast <- timeInfoOf sinceLast -< ()@@ -152,8 +154,8 @@ -- | Euler integration, with zero initial offset. integral- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => BehaviorF m td v v integral = integralFrom zeroVector @@ -162,8 +164,8 @@ -- with a Newton difference quotient. -- The input is initialised with @v0@. derivativeFrom- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => v -> BehaviorF m td v v derivativeFrom v0 = proc v -> do vLast <- iPre v0 -< v@@ -172,16 +174,16 @@ -- | Numerical derivative with input initialised to zero. derivative- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => BehaviorF m td v v derivative = derivativeFrom zeroVector -- | Like 'derivativeFrom', but uses three samples to compute the derivative. -- Consequently, it is delayed by one sample. threePointDerivativeFrom- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => v -- ^ The initial position -> BehaviorF m td v v threePointDerivativeFrom v0 = proc v -> do@@ -192,8 +194,8 @@ -- | Like 'threePointDerivativeFrom', -- but with the initial position initialised to 'zeroVector'. threePointDerivative- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => BehaviorF m td v v threePointDerivative = threePointDerivativeFrom zeroVector @@ -207,10 +209,10 @@ -- so a weight of 1 simply repeats the past value unchanged, -- whereas a weight of 0 outputs the current value. weightedAverageFrom- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => v -- ^ The initial position- -> BehaviorF m td (v, Groundfield v) v+ -> BehaviorF m td (v, s) v weightedAverageFrom v0 = feedback v0 $ proc ((v, weight), vAvg) -> do let vAvg' = weight *^ vAvg ^+^ (1 - weight) *^ v@@ -221,9 +223,9 @@ -- all features below a given time constant @t@. -- (Equivalently, it filters out frequencies above @1 / (2 * pi * t)@.) averageFrom- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => v -- ^ The initial position -> Diff td -- ^ The time scale on which the signal is averaged -> BehaviorF m td v v@@ -236,9 +238,9 @@ -- | An average, or low pass, initialised to zero. average- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => Diff td -- ^ The time scale on which the signal is averaged -> BehaviourF m td v v average = averageFrom zeroVector@@ -248,8 +250,8 @@ -- if the supplied time scale is much bigger -- than the average time difference between two ticks. averageLinFrom- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => v -- ^ The initial position -> Diff td -- ^ The time scale on which the signal is averaged -> BehaviourF m td v v@@ -261,8 +263,8 @@ -- | Linearised version of 'average'. averageLin- :: ( Monad m, VectorSpace v- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , s ~ Diff td) => Diff td -- ^ The time scale on which the signal is averaged -> BehaviourF m td v v averageLin = averageLinFrom zeroVector@@ -271,36 +273,36 @@ -- | Alias for 'average'. lowPass- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => Diff td -> BehaviourF m td v v lowPass = average -- | Filters out frequencies below @1 / (2 * pi * t)@. highPass- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => Diff td -- ^ The time constant @t@ -> BehaviourF m td v v highPass t = clId ^-^ lowPass t -- | Filters out frequencies other than @1 / (2 * pi * t)@. bandPass- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => Diff td -- ^ The time constant @t@ -> BehaviourF m td v v bandPass t = lowPass t >>> highPass t -- | Filters out the frequency @1 / (2 * pi * t)@. bandStop- :: ( Monad m, VectorSpace v- , Floating (Groundfield v)- , Groundfield v ~ Diff td)+ :: ( Monad m, VectorSpace v s+ , Floating s+ , s ~ Diff td) => Diff td -- ^ The time constant @t@ -> BehaviourF m td v v bandStop t = clId ^-^ bandPass t@@ -326,16 +328,16 @@ appendValue (ti, a) tias = takeWhileL (recentlySince ti) $ (ti, a) <| tias recentlySince ti (ti', _) = diffTime (absolute ti) (absolute ti') < dTime --- | Delay a signal by certain time span.+-- | Delay a signal by certain time span,+-- initialising with the first input. delayBy- :: (Monad m, Ord (Diff (Time cl)), TimeDomain (Time cl))- => Diff (Time cl) -- ^ The time span to delay the signal- -> ClSF m cl a a+ :: (Monad m, Ord (Diff td), TimeDomain td)+ => Diff td -- ^ The time span to delay the signal+ -> BehaviorF m td a a delayBy dTime = historySince dTime >>> arr (viewr >>> safeHead) >>> lastS undefined >>> arr snd where safeHead EmptyR = Nothing safeHead (_ :> a) = Just a--- TODO Think about how to do it without undefined (maybe exceptions) -- * Timers
src/FRP/Rhine/Clock/Periodic.hs view
@@ -45,7 +45,7 @@ type Time (Periodic v) = Integer type Tag (Periodic v) = () initClock cl = return- ( cycleS (theList cl) >>> withSideEffect wait >>> sumS &&& arr (const ())+ ( cycleS (theList cl) >>> withSideEffect wait >>> (accumulateWith (+) 0) &&& arr (const ()) , 0 )
src/FRP/Rhine/ResamplingBuffer/Interpolation.hs view
@@ -11,7 +11,7 @@ -- containers import Data.Sequence --- dunai+-- simple-affine-space import Data.VectorSpace -- rhine@@ -23,9 +23,9 @@ -- | A simple linear interpolation based on the last calculated position and velocity. linear :: ( Monad m, Clock m cl1, Clock m cl2- , VectorSpace v- , Groundfield v ~ Diff (Time cl1)- , Groundfield v ~ Diff (Time cl2)+ , VectorSpace v s+ , s ~ Diff (Time cl1)+ , s ~ Diff (Time cl2) ) => v -- ^ The initial velocity (derivative of the signal) -> v -- ^ The initial position@@ -36,7 +36,7 @@ >>-^ proc ((velocity, lastPosition), sinceInit1) -> do sinceInit2 <- timeInfoOf sinceInit -< () let diff = sinceInit2 - sinceInit1- returnA -< lastPosition ^+^ velocity ^* diff+ returnA -< lastPosition ^+^ diff *^ velocity {- | sinc-Interpolation, or Whittaker-Shannon-Interpolation.@@ -51,13 +51,13 @@ -} sinc :: ( Monad m, Clock m cl1, Clock m cl2- , VectorSpace v- , Ord (Groundfield v)- , Floating (Groundfield v)- , Groundfield v ~ Diff (Time cl1)- , Groundfield v ~ Diff (Time cl2)+ , VectorSpace v s+ , Ord (s)+ , Floating (s)+ , s ~ Diff (Time cl1)+ , s ~ Diff (Time cl2) )- => Groundfield v+ => s -- ^ The size of the interpolation window -- (for how long in the past to remember incoming values) -> ResamplingBuffer m cl1 cl2 v v@@ -67,7 +67,7 @@ where mkSinc sinceInit2 (TimeInfo {..}, as) = let t = pi * (sinceInit2 - sinceInit) / sinceLast- in as ^* (sin t / t)+ in (sin t / t) *^ as vectorSum = foldr (^+^) zeroVector -- TODO Do we want to give initial values?@@ -80,9 +80,10 @@ -- if the ticks of @cl2@ are delayed by two ticks of @cl1@. cubic :: ( Monad m- , VectorSpace v- , Groundfield v ~ Diff (Time cl1)- , Groundfield v ~ Diff (Time cl2)+ , VectorSpace v s+ , Floating v, Eq v+ , s ~ Diff (Time cl1)+ , s ~ Diff (Time cl2) ) => ResamplingBuffer m cl1 cl2 v v cubic = ((iPre zeroVector &&& threePointDerivative) &&& (sinceInitS >-> iPre 0))
src/FRP/Rhine/Type.hs view
@@ -8,7 +8,7 @@ import FRP.Rhine.SN {- |-A 'Rhine' consists of un 'SN' together with a clock of matching type 'cl'.+A 'Rhine' consists of a 'SN' together with a clock of matching type 'cl'. It is a reactive program, possibly with open inputs and outputs. If the input and output types 'a' and 'b' are both '()', that is, the 'Rhine' is "closed",