NumHask.Algebra.Metric

Metric classes

Documentation

class MultiplicativeUnital a => Signed a where

signum from base is not an operator replicated in numhask, being such a very silly name, and preferred is the much more obvious sign. Compare with Norm and Banach where there is a change in codomain

abs a * sign a == a

Generalising this class tends towards size and direction (abs is the size on the one-dim number line of a vector with its tail at zero, and sign is the direction, right?).

Minimal complete definition

sign, abs

Methods

sign :: a -> a

abs :: a -> a

Instances

Signed Double

Methods

sign :: Double -> Double

abs :: Double -> Double

Signed Float

Methods

sign :: Float -> Float

abs :: Float -> Float

Signed Int

Methods

sign :: Int -> Int

abs :: Int -> Int

Signed Int8

Methods

sign :: Int8 -> Int8

abs :: Int8 -> Int8

Signed Int16

Methods

sign :: Int16 -> Int16

abs :: Int16 -> Int16

Signed Int32

Methods

sign :: Int32 -> Int32

abs :: Int32 -> Int32

Signed Int64

Methods

sign :: Int64 -> Int64

abs :: Int64 -> Int64

Signed Integer

Methods

sign :: Integer -> Integer

abs :: Integer -> Integer

Signed Natural

Methods

sign :: Natural -> Natural

abs :: Natural -> Natural

Signed Word

Methods

sign :: Word -> Word

abs :: Word -> Word

Signed Word8

Methods

sign :: Word8 -> Word8

abs :: Word8 -> Word8

Signed Word16

Methods

sign :: Word16 -> Word16

abs :: Word16 -> Word16

Signed Word32

Methods

sign :: Word32 -> Word32

abs :: Word32 -> Word32

Signed Word64

Methods

sign :: Word64 -> Word64

abs :: Word64 -> Word64

(Ord a, Signed a, Integral a, AdditiveInvertible a) => Signed (Ratio a)

Methods

sign :: Ratio a -> Ratio a

abs :: Ratio a -> Ratio a

class Normed a b where

L1 and L2 norms are provided for potential speedups, as well as the generalized p-norm.

for p >= 1

normLp p a >= zero
normLp p zero == zero

Note that the Normed codomain can be different to the domain.

Minimal complete definition

normL1, normL2, normLp

Methods

normL1 :: a -> b

normL2 :: a -> b

normLp :: b -> a -> b

Instances

Normed Double Double

Methods

normL1 :: Double -> Double

normL2 :: Double -> Double

normLp :: Double -> Double -> Double

Normed Float Float

Methods

normL1 :: Float -> Float

normL2 :: Float -> Float

normLp :: Float -> Float -> Float

Normed Int Int

Methods

normL1 :: Int -> Int

normL2 :: Int -> Int

normLp :: Int -> Int -> Int

Normed Int8 Int8

Methods

normL1 :: Int8 -> Int8

normL2 :: Int8 -> Int8

normLp :: Int8 -> Int8 -> Int8

Normed Int16 Int16

Methods

normL1 :: Int16 -> Int16

normL2 :: Int16 -> Int16

normLp :: Int16 -> Int16 -> Int16

Normed Int32 Int32

Methods

normL1 :: Int32 -> Int32

normL2 :: Int32 -> Int32

normLp :: Int32 -> Int32 -> Int32

Normed Int64 Int64

Methods

normL1 :: Int64 -> Int64

normL2 :: Int64 -> Int64

normLp :: Int64 -> Int64 -> Int64

Normed Integer Integer

Methods

normL1 :: Integer -> Integer

normL2 :: Integer -> Integer

normLp :: Integer -> Integer -> Integer

Normed Natural Natural

Methods

normL1 :: Natural -> Natural

normL2 :: Natural -> Natural

normLp :: Natural -> Natural -> Natural

Normed Word Word

Methods

normL1 :: Word -> Word

normL2 :: Word -> Word

normLp :: Word -> Word -> Word

Normed Word8 Word8

Methods

normL1 :: Word8 -> Word8

normL2 :: Word8 -> Word8

normLp :: Word8 -> Word8 -> Word8

Normed Word16 Word16

Methods

normL1 :: Word16 -> Word16

normL2 :: Word16 -> Word16

normLp :: Word16 -> Word16 -> Word16

Normed Word32 Word32

Methods

normL1 :: Word32 -> Word32

normL2 :: Word32 -> Word32

normLp :: Word32 -> Word32 -> Word32

Normed Word64 Word64

Methods

normL1 :: Word64 -> Word64

normL2 :: Word64 -> Word64

normLp :: Word64 -> Word64 -> Word64

(Multiplicative a, ExpField a, Normed a a) => Normed (Complex a) a

Methods

normL1 :: Complex a -> a

normL2 :: Complex a -> a

normLp :: a -> Complex a -> a

(Ord a, Integral a, Signed a, AdditiveInvertible a) => Normed (Ratio a) (Ratio a)

Methods

normL1 :: Ratio a -> Ratio a

normL2 :: Ratio a -> Ratio a

normLp :: Ratio a -> Ratio a -> Ratio a

class Metric a b where

distance between numbers using L1, L2 or Lp-norms

distanceL2 a b >= zero
distanceL2 a a == zero
\a b c -> distanceL2 a c + distanceL2 b c - distanceL2 a b >= zero &&
          distanceL2 a b + distanceL2 b c - distanceL2 a c >= zero &&
          distanceL2 a b + distanceL2 a c - distanceL2 b c >= zero &&

Minimal complete definition

distanceL1, distanceL2, distanceLp

Methods

distanceL1 :: a -> a -> b

distanceL2 :: a -> a -> b

distanceLp :: b -> a -> a -> b

Instances

Metric Double Double

Methods

distanceL1 :: Double -> Double -> Double

distanceL2 :: Double -> Double -> Double

distanceLp :: Double -> Double -> Double -> Double

Metric Float Float

Methods

distanceL1 :: Float -> Float -> Float

distanceL2 :: Float -> Float -> Float

distanceLp :: Float -> Float -> Float -> Float

Metric Int Int

Methods

distanceL1 :: Int -> Int -> Int

distanceL2 :: Int -> Int -> Int

distanceLp :: Int -> Int -> Int -> Int

Metric Int8 Int8

Methods

distanceL1 :: Int8 -> Int8 -> Int8

distanceL2 :: Int8 -> Int8 -> Int8

distanceLp :: Int8 -> Int8 -> Int8 -> Int8

Metric Int16 Int16

Methods

distanceL1 :: Int16 -> Int16 -> Int16

distanceL2 :: Int16 -> Int16 -> Int16

distanceLp :: Int16 -> Int16 -> Int16 -> Int16

Metric Int32 Int32

Methods

distanceL1 :: Int32 -> Int32 -> Int32

distanceL2 :: Int32 -> Int32 -> Int32

distanceLp :: Int32 -> Int32 -> Int32 -> Int32

Metric Int64 Int64

Methods

distanceL1 :: Int64 -> Int64 -> Int64

distanceL2 :: Int64 -> Int64 -> Int64

distanceLp :: Int64 -> Int64 -> Int64 -> Int64

Metric Integer Integer

Methods

distanceL1 :: Integer -> Integer -> Integer

distanceL2 :: Integer -> Integer -> Integer

distanceLp :: Integer -> Integer -> Integer -> Integer

Metric Natural Natural

Methods

distanceL1 :: Natural -> Natural -> Natural

distanceL2 :: Natural -> Natural -> Natural

distanceLp :: Natural -> Natural -> Natural -> Natural

Metric Word Word

Methods

distanceL1 :: Word -> Word -> Word

distanceL2 :: Word -> Word -> Word

distanceLp :: Word -> Word -> Word -> Word

Metric Word8 Word8

Methods

distanceL1 :: Word8 -> Word8 -> Word8

distanceL2 :: Word8 -> Word8 -> Word8

distanceLp :: Word8 -> Word8 -> Word8 -> Word8

Metric Word16 Word16

Methods

distanceL1 :: Word16 -> Word16 -> Word16

distanceL2 :: Word16 -> Word16 -> Word16

distanceLp :: Word16 -> Word16 -> Word16 -> Word16

Metric Word32 Word32

Methods

distanceL1 :: Word32 -> Word32 -> Word32

distanceL2 :: Word32 -> Word32 -> Word32

distanceLp :: Word32 -> Word32 -> Word32 -> Word32

Metric Word64 Word64

Methods

distanceL1 :: Word64 -> Word64 -> Word64

distanceL2 :: Word64 -> Word64 -> Word64

distanceLp :: Word64 -> Word64 -> Word64 -> Word64

(Multiplicative a, ExpField a, Normed a a) => Metric (Complex a) a

Methods

distanceL1 :: Complex a -> Complex a -> a

distanceL2 :: Complex a -> Complex a -> a

distanceLp :: a -> Complex a -> Complex a -> a

(Ord a, Integral a, Signed a, AdditiveGroup a) => Metric (Ratio a) (Ratio a)

Methods

distanceL1 :: Ratio a -> Ratio a -> Ratio a

distanceL2 :: Ratio a -> Ratio a -> Ratio a

distanceLp :: Ratio a -> Ratio a -> Ratio a -> Ratio a

class (Eq a, AdditiveGroup a) => Epsilon a where

todo: This should probably be split off into some sort of alternative Equality logic, but to what end?

Methods

nearZero :: a -> Bool

aboutEqual :: a -> a -> Bool

positive :: Signed a => a -> Bool

veryPositive :: Signed a => a -> Bool

veryNegative :: Signed a => a -> Bool

Instances

Epsilon Double

Methods

nearZero :: Double -> Bool

aboutEqual :: Double -> Double -> Bool

positive :: Double -> Bool

veryPositive :: Double -> Bool

veryNegative :: Double -> Bool

Epsilon Float

Methods

nearZero :: Float -> Bool

aboutEqual :: Float -> Float -> Bool

positive :: Float -> Bool

veryPositive :: Float -> Bool

veryNegative :: Float -> Bool

Epsilon Int

Methods

nearZero :: Int -> Bool

aboutEqual :: Int -> Int -> Bool

positive :: Int -> Bool

veryPositive :: Int -> Bool

veryNegative :: Int -> Bool

Epsilon Int8

Methods

nearZero :: Int8 -> Bool

aboutEqual :: Int8 -> Int8 -> Bool

positive :: Int8 -> Bool

veryPositive :: Int8 -> Bool

veryNegative :: Int8 -> Bool

Epsilon Int16

Methods

nearZero :: Int16 -> Bool

aboutEqual :: Int16 -> Int16 -> Bool

positive :: Int16 -> Bool

veryPositive :: Int16 -> Bool

veryNegative :: Int16 -> Bool

Epsilon Int32

Methods

nearZero :: Int32 -> Bool

aboutEqual :: Int32 -> Int32 -> Bool

positive :: Int32 -> Bool

veryPositive :: Int32 -> Bool

veryNegative :: Int32 -> Bool

Epsilon Int64

Methods

nearZero :: Int64 -> Bool

aboutEqual :: Int64 -> Int64 -> Bool

positive :: Int64 -> Bool

veryPositive :: Int64 -> Bool

veryNegative :: Int64 -> Bool

Epsilon Integer

Methods

nearZero :: Integer -> Bool

aboutEqual :: Integer -> Integer -> Bool

positive :: Integer -> Bool

veryPositive :: Integer -> Bool

veryNegative :: Integer -> Bool

Epsilon Word

Methods

nearZero :: Word -> Bool

aboutEqual :: Word -> Word -> Bool

positive :: Word -> Bool

veryPositive :: Word -> Bool

veryNegative :: Word -> Bool

Epsilon Word8

Methods

nearZero :: Word8 -> Bool

aboutEqual :: Word8 -> Word8 -> Bool

positive :: Word8 -> Bool

veryPositive :: Word8 -> Bool

veryNegative :: Word8 -> Bool

Epsilon Word16

Methods

nearZero :: Word16 -> Bool

aboutEqual :: Word16 -> Word16 -> Bool

positive :: Word16 -> Bool

veryPositive :: Word16 -> Bool

veryNegative :: Word16 -> Bool

Epsilon Word32

Methods

nearZero :: Word32 -> Bool

aboutEqual :: Word32 -> Word32 -> Bool

positive :: Word32 -> Bool

veryPositive :: Word32 -> Bool

veryNegative :: Word32 -> Bool

Epsilon Word64

Methods

nearZero :: Word64 -> Bool

aboutEqual :: Word64 -> Word64 -> Bool

positive :: Word64 -> Bool

veryPositive :: Word64 -> Bool

veryNegative :: Word64 -> Bool

Epsilon a => Epsilon (Complex a)

Methods

nearZero :: Complex a -> Bool

aboutEqual :: Complex a -> Complex a -> Bool

positive :: Complex a -> Bool

veryPositive :: Complex a -> Bool

veryNegative :: Complex a -> Bool

(Ord a, Signed a, Integral a, AdditiveGroup a) => Epsilon (Ratio a)

Methods

nearZero :: Ratio a -> Bool

aboutEqual :: Ratio a -> Ratio a -> Bool

positive :: Ratio a -> Bool

veryPositive :: Ratio a -> Bool

veryNegative :: Ratio a -> Bool

(≈) :: Epsilon a => a -> a -> Bool infixl 4

todo: is utf perfectly acceptable these days?