Yampa-0.13: Elegant Functional Reactive Programming Language for Hybrid Systems

Copyright (c) Antony Courtney and Henrik Nilsson Yale University 2003 BSD-style (see the LICENSE file in the distribution) ivan.perez@keera.co.uk provisional non-portable (GHC extensions) None Haskell98

FRP.Yampa.Integration

Contents

Description

Integration and derivation of input signals.

In continuous time, these primitives define SFs that integrate/derive the input signal. Since this is subject to the sampling resolution, simple versions are implemented (like the rectangle rule for the integral).

In discrete time, all we do is count the number of events.

The combinator iterFrom gives enough flexibility to program your own leak-free integration and derivation SFs.

Synopsis

# Integration

integral :: VectorSpace a s => SF a a #

Integration using the rectangle rule.

imIntegral :: VectorSpace a s => a -> SF a a #

"Immediate" integration (using the function's value at the current time)

impulseIntegral :: VectorSpace a k => SF (a, Event a) a #

Integrate the first input signal and add the discrete accumulation (sum) of the second, discrete, input signal.

count :: Integral b => SF (Event a) (Event b) #

Count the occurrences of input events.

>>> embed count (deltaEncode 1 [Event 'a', NoEvent, Event 'b'])
[Event 1,NoEvent,Event 2]


# Differentiation

derivative :: VectorSpace a s => SF a a #

A very crude version of a derivative. It simply divides the value difference by the time difference. Use at your own risk.

iterFrom :: (a -> a -> DTime -> b -> b) -> b -> SF a b #

Integrate using an auxiliary function that takes the current and the last input, the time between those samples, and the last output, and returns a new output.