Copyright | Copyright (c) 2009-2017 David Sorokin <david.sorokin@gmail.com> |
---|---|

License | BSD3 |

Maintainer | David Sorokin <david.sorokin@gmail.com> |

Stability | experimental |

Safe Haskell | None |

Language | Haskell2010 |

Tested with: GHC 8.0.1

This module defines memoization transforms. The memoization creates such `Dynamics`

computations, which values are cached in the integration time points. Then
these values are interpolated in all other time points.

## Synopsis

- memoTransform :: MonadSD m => Transform m e e
- memo0Transform :: MonadSD m => Transform m e e
- iteratingTransform :: MonadSD m => Transform m () ()

# Documentation

memoTransform :: MonadSD m => Transform m e e Source #

A transform that memoizes and order the computation in the integration time points
using the interpolation that knows of the Runge-Kutta method. The values are
calculated sequentially starting from `starttime`

.

memo0Transform :: MonadSD m => Transform m e e Source #

A transform that memoizes and order the computation in the integration time points using
the `discreteDynamics`

interpolation. It consumes less memory than the `memoTransform`

computation but it is not aware of the Runge-Kutta method. There is a subtle
difference when we request for values in the intermediate time points
that are used by this method to integrate. In general case you should
prefer the `memo0Transform`

computation above `memoTransform`

.

iteratingTransform :: MonadSD m => Transform m () () Source #

A transform that iterates sequentially the dynamic process with side effects in
the integration time points. It is equivalent to the `memo0Transform`

computation
but significantly more efficient, for the internal array is not created.