Safe Haskell	None
Language	Haskell98

Data.Function.ArrayMemoize

Contents

Orphan instances

Synopsis

Documentation

arrayMemo :: (Ix a, ArrayMemoizable b) => (a, a) -> (a -> b) -> a -> b #

Memoize a function over a finite (sub)domain, using an array (boxed), e.g., arrayMemo (0, 20) f memoizes f between from 0 to 20.

arrayMemoFix :: (Ix a, ArrayMemoizable b) => (a, a) -> ((a -> b) -> a -> b) -> a -> b #

Memoize a fixed point of a function over a sub domain. Similar to fix, but over arrayMemo, passing a function a memoized version of itself.

arrayMemoFixMutual :: (ArrayMemoizable b, ArrayMemoizable d, Ix a, Ix c) => (a, a) -> (c, c) -> ((a -> b) -> (c -> d) -> a -> b) -> ((a -> b) -> (c -> d) -> c -> d) -> a -> b #

Memoize a mutual fixed point for two functions (over sub domains of these functions).

arrayMemoFixMutual3 :: (ArrayMemoizable b, ArrayMemoizable d, ArrayMemoizable f, Ix a, Ix c, Ix e) => (a, a) -> (c, c) -> (e, e) -> ((a -> b) -> (c -> d) -> (e -> f) -> a -> b) -> ((a -> b) -> (c -> d) -> (e -> f) -> c -> d) -> ((a -> b) -> (c -> d) -> (e -> f) -> e -> f) -> a -> b #

Memoize a mutual fixed point for three functions (over sub domains of these functions).

uarrayMemoFixIO :: (Ix a, UArrayMemoizable b) => (a, a) -> ((a -> IO b) -> a -> IO b) -> a -> IO b #

Memoize a function over a finite (sub)domain, using an unboxed IO array. This requires the incoming function to return results in the IO monad, but should preferable be pure.

discreteMemo :: (ArrayMemoizable b, Discretize a) => (a, a) -> a -> (a -> b) -> Discrete a -> b #

Memoize and discretize a function over a finite (sub)domain, using an array. e.g. discretemMemo (0.0, 10.0) 2.0 f returns a discretized version of f (with the discrete type defined by Discrete) in the range 0.0 to 10.0 with step size 2.0 (i.e., the resulting discrete domain is of size 5).

discreteMemoFix :: (ArrayMemoizable b, Discretize a) => (a, a) -> a -> ((a -> b) -> a -> b) -> Discrete a -> b #

Memoize and discretize a fixed point of a function over a subdomain with discretization step

quantizedMemo :: (ArrayMemoizable b, Discretize a) => (a, a) -> a -> (a -> b) -> a -> b #

Memoize and quantize a function over a finite (sub)domain, using a boxed array, e.g, quantizedMemo (0.0, 10.0) 2.0 f memoizes f between 0.0 and 10.0 with step size 2.0 (i.e. the function is quantized into 5 parts, memoized into an array of size 5).

quantizedMemoFix :: (ArrayMemoizable b, Discretize a) => (a, a) -> a -> ((a -> b) -> a -> b) -> a -> b #

Memoize and quantize a fixed point of a function. Similar to fix, but using quantizedMemo to pass the fixed function a quantized memoized version of itself, therefore memoizing any recursive calls.

quantizedMemoFixMutual :: (ArrayMemoizable b, ArrayMemoizable d, Discretize a, Discretize c) => (a, a) -> a -> (c, c) -> c -> ((a -> b) -> (c -> d) -> a -> b) -> ((a -> b) -> (c -> d) -> c -> d) -> a -> b #

Memoize and quantize a mutually recursive fixed point of two functions.

quantizedMemoFixMutual3 :: (ArrayMemoizable b, ArrayMemoizable d, ArrayMemoizable f, Discretize a, Discretize c, Discretize e) => (a, a) -> a -> (c, c) -> c -> (e, e) -> e -> ((a -> b) -> (c -> d) -> (e -> f) -> a -> b) -> ((a -> b) -> (c -> d) -> (e -> f) -> c -> d) -> ((a -> b) -> (c -> d) -> (e -> f) -> e -> f) -> a -> b #

Memoize and quantize a mutually recursive fixed point of three functions.

class ArrayMemoizable a where #

ArrayMemoizable defines the subset of types for which we can do array memoization

Minimal complete definition

newArray_, writeArray

Methods

newArray_ :: Ix i => (i, i) -> ST s (STArray s i a) #

writeArray :: Ix i => STArray s i a -> i -> a -> ST s () #

Instances

ArrayMemoizable Bool #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Bool) # writeArray :: Ix i => STArray s i Bool -> i -> Bool -> ST s () #
ArrayMemoizable Char #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Char) # writeArray :: Ix i => STArray s i Char -> i -> Char -> ST s () #
ArrayMemoizable Double #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Double) # writeArray :: Ix i => STArray s i Double -> i -> Double -> ST s () #
ArrayMemoizable Float #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Float) # writeArray :: Ix i => STArray s i Float -> i -> Float -> ST s () #
ArrayMemoizable Int #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Int) # writeArray :: Ix i => STArray s i Int -> i -> Int -> ST s () #
ArrayMemoizable Integer #
Methods newArray_ :: Ix i => (i, i) -> ST s (STArray s i Integer) # writeArray :: Ix i => STArray s i Integer -> i -> Integer -> ST s () #

class IArray UArray a => UArrayMemoizable a where #

UArrayMemoizable defines the subset of types for which we can do unboxed IOUArray memoization

Minimal complete definition

newUArray_, writeUArray, readUArray

Methods

newUArray_ :: Ix i => (i, i) -> IO (IOUArray i a) #

writeUArray :: Ix i => IOUArray i a -> i -> a -> IO () #

readUArray :: Ix i => IOUArray i a -> i -> IO a #

Instances

UArrayMemoizable Char #
Methods newUArray_ :: Ix i => (i, i) -> IO (IOUArray i Char) # writeUArray :: Ix i => IOUArray i Char -> i -> Char -> IO () # readUArray :: Ix i => IOUArray i Char -> i -> IO Char #
UArrayMemoizable Double #
Methods newUArray_ :: Ix i => (i, i) -> IO (IOUArray i Double) # writeUArray :: Ix i => IOUArray i Double -> i -> Double -> IO () # readUArray :: Ix i => IOUArray i Double -> i -> IO Double #
UArrayMemoizable Float #
Methods newUArray_ :: Ix i => (i, i) -> IO (IOUArray i Float) # writeUArray :: Ix i => IOUArray i Float -> i -> Float -> IO () # readUArray :: Ix i => IOUArray i Float -> i -> IO Float #
UArrayMemoizable Int #
Methods newUArray_ :: Ix i => (i, i) -> IO (IOUArray i Int) # writeUArray :: Ix i => IOUArray i Int -> i -> Int -> IO () # readUArray :: Ix i => IOUArray i Int -> i -> IO Int #

class (Ix (Discrete t), Enum (Discrete t)) => Discretize t where #

Discretization of float/double values and tuples

Minimal complete definition

discretize, continuize

Associated Types

type Discrete t #

Methods

discretize :: t -> t -> Discrete t #

continuize :: t -> Discrete t -> t #

Instances

Discretize Double #
Associated Types type Discrete Double :: * # Methods discretize :: Double -> Double -> Discrete Double # continuize :: Double -> Discrete Double -> Double #
Discretize Float #
Associated Types type Discrete Float :: * # Methods discretize :: Float -> Float -> Discrete Float # continuize :: Float -> Discrete Float -> Float #
(Discretize a, Discretize b) => Discretize (a, b) #
Associated Types type Discrete (a, b) :: * # Methods discretize :: (a, b) -> (a, b) -> Discrete (a, b) # continuize :: (a, b) -> Discrete (a, b) -> (a, b) #
(Discretize a, Discretize b, Discretize c) => Discretize (a, b, c) #
Associated Types type Discrete (a, b, c) :: * # Methods discretize :: (a, b, c) -> (a, b, c) -> Discrete (a, b, c) # continuize :: (a, b, c) -> Discrete (a, b, c) -> (a, b, c) #

discrete :: Discretize a => (a -> b) -> a -> Discrete a -> b #

Discretized a function function. The second parameter is the discretisation step.

Orphan instances

(Enum a, Enum b) => Enum (a, b) #
Methods succ :: (a, b) -> (a, b) # pred :: (a, b) -> (a, b) # toEnum :: Int -> (a, b) # fromEnum :: (a, b) -> Int # enumFrom :: (a, b) -> [(a, b)] # enumFromThen :: (a, b) -> (a, b) -> [(a, b)] # enumFromTo :: (a, b) -> (a, b) -> [(a, b)] # enumFromThenTo :: (a, b) -> (a, b) -> (a, b) -> [(a, b)] #
(Num a, Num b) => Num (a, b) #
Methods (+) :: (a, b) -> (a, b) -> (a, b) # (-) :: (a, b) -> (a, b) -> (a, b) # (*) :: (a, b) -> (a, b) -> (a, b) # negate :: (a, b) -> (a, b) # abs :: (a, b) -> (a, b) # signum :: (a, b) -> (a, b) # fromInteger :: Integer -> (a, b) #
(Enum a, Enum b, Enum c) => Enum (a, b, c) #
Methods succ :: (a, b, c) -> (a, b, c) # pred :: (a, b, c) -> (a, b, c) # toEnum :: Int -> (a, b, c) # fromEnum :: (a, b, c) -> Int # enumFrom :: (a, b, c) -> [(a, b, c)] # enumFromThen :: (a, b, c) -> (a, b, c) -> [(a, b, c)] # enumFromTo :: (a, b, c) -> (a, b, c) -> [(a, b, c)] # enumFromThenTo :: (a, b, c) -> (a, b, c) -> (a, b, c) -> [(a, b, c)] #
(Num a, Num b, Num c) => Num (a, b, c) #
Methods (+) :: (a, b, c) -> (a, b, c) -> (a, b, c) # (-) :: (a, b, c) -> (a, b, c) -> (a, b, c) # (*) :: (a, b, c) -> (a, b, c) -> (a, b, c) # negate :: (a, b, c) -> (a, b, c) # abs :: (a, b, c) -> (a, b, c) # signum :: (a, b, c) -> (a, b, c) # fromInteger :: Integer -> (a, b, c) #