Portability | portable |
---|---|

Stability | experimental |

Maintainer | amy@nualeargais.ie |

Safe Haskell | Safe-Inferred |

Tools for identifying patterns in data.

- class Pattern p where
- type Metric p
- difference :: p -> p -> Metric p
- makeSimilar :: p -> Metric p -> p -> p

- adjustNum :: (Num a, Ord a, Eq a) => a -> a -> a -> a
- absDifference :: Num a => a -> a -> a
- adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]
- euclideanDistanceSquared :: Num a => [a] -> [a] -> a
- magnitudeSquared :: Num a => [a] -> a
- data NormalisedVector a
- normalise :: Floating a => [a] -> NormalisedVector a
- data ScaledVector a
- scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector a
- scaleAll :: (Fractional a, Ord a) => [[a]] -> [ScaledVector a]

# Patterns

A pattern to be learned or classified.

difference :: p -> p -> Metric pSource

Compares two patterns and returns a *non-negative* number
representing how different the patterns are. A result of `0`

indicates that the patterns are identical.

makeSimilar :: p -> Metric p -> p -> pSource

returns a modified copy of
`makeSimilar`

target amount pattern`pattern`

that is more similar to `target`

than `pattern`

is. The
magnitude of the adjustment is controlled by the `amount`

parameter, which should be a number between 0 and 1. Larger
values for `amount`

permit greater adjustments. If `amount`

=1,
the result should be identical to the `target`

. If `amount`

=0,
the result should be the unmodified `pattern`

.

(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a) | |

(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a) |

# Numbers as patterns

If you wish to use, say, a `Double`

as a pattern, one option is to
use `no-warn-orphans`

and add the following to your code:

instance Double => Pattern Double where type Metric Double = Double difference = absDifference makeSimilar = adjustNum

absDifference :: Num a => a -> a -> aSource

# Numeric vectors as patterns

## Raw vectors

If you wish to use raw numeric vectors as a pattern, one option is to
use `no-warn-orphans`

and add the following to your code:

instance (Floating a, Fractional a, Ord a, Eq a) => Pattern [a] where type Metric [a] = a difference = euclideanDistanceSquared makeSimilar = adjustVector

adjustVector :: (Num a, Ord a, Eq a) => [a] -> a -> [a] -> [a]Source

adjusts `adjustVector`

target amount vector`vector`

to move it
closer to `target`

. The amount of adjustment is controlled by the
learning rate `r`

, which is a number between 0 and 1. Larger values
of `r`

permit more adjustment. If `r`

=1, the result will be
identical to the `target`

. If `amount`

=0, the result will be the
unmodified `pattern`

.

euclideanDistanceSquared :: Num a => [a] -> [a] -> aSource

Calculates the square of the Euclidean distance between two vectors.

magnitudeSquared :: Num a => [a] -> aSource

## Normalised vectors

data NormalisedVector a Source

A vector that has been normalised, i.e., the magnitude of the vector = 1.

Show a => Show (NormalisedVector a) | |

(Floating a, Fractional a, Ord a, Eq a) => Pattern (NormalisedVector a) |

normalise :: Floating a => [a] -> NormalisedVector aSource

Normalises a vector

## Scaled vectors

data ScaledVector a Source

A vector that has been scaled so that all elements in the vector
are between zero and one. To scale a set of vectors, use

. Alternatively, if you can identify a maximum and
minimum value for each element in a vector, you can scale
individual vectors using `scaleAll`

.
`scale`

Show a => Show (ScaledVector a) | |

(Fractional a, Ord a, Eq a) => Pattern (ScaledVector a) |

scale :: Fractional a => [(a, a)] -> [a] -> ScaledVector aSource

Given a vector `qs`

of pairs of numbers, where each pair represents
the maximum and minimum value to be expected at each index in
`xs`

,

scales the vector `scale`

qs xs`xs`

element by element,
mapping the maximum value expected at that index to one, and the
minimum value to zero.

scaleAll :: (Fractional a, Ord a) => [[a]] -> [ScaledVector a]Source

Scales a set of vectors by determining the maximum and minimum values at each index in the vector, and mapping the maximum value to one, and the minimum value to zero.