NumHask.Algebra.Metric

Metric structure

Metric

class Field a => BoundedField a where

providing the concepts of infinity and NaN, thus moving away from error throwing

Minimal complete definition

isNaN

Methods

maxBound :: a

minBound :: a

nan :: a

isNaN :: a -> Bool

Instances

BoundedField Double

Methods

maxBound :: Double

minBound :: Double

nan :: Double

isNaN :: Double -> Bool

BoundedField Float

Methods

maxBound :: Float

minBound :: Float

nan :: Float

isNaN :: Float -> Bool

(Foldable r, Representable r, BoundedField a) => BoundedField (r a)

Methods

maxBound :: r a

minBound :: r a

nan :: r a

isNaN :: r a -> Bool

infinity :: BoundedField a => a

prints as Infinity

neginfinity :: BoundedField a => a

prints as `-Infinity`

class Metric a b where

distance between numbers

Minimal complete definition

distance

Methods

distance :: a -> a -> b

Instances

Metric Double Double

Methods

distance :: Double -> Double -> Double

Metric Float Float

Methods

distance :: Float -> Float -> Float

Metric Int Int

Methods

distance :: Int -> Int -> Int

Metric Integer Integer

Methods

distance :: Integer -> Integer -> Integer

(Foldable r, Representable r, ExpField a) => Metric (r a) a

Methods

distance :: r a -> r a -> a

class Normed a b where

Normed is a current wart on the NumHask api, causing all sorts of runaway constraint boiler-plate.

Minimal complete definition

size

Methods

size :: a -> b

Instances

Normed Double Double

Methods

size :: Double -> Double

Normed Float Float

Methods

size :: Float -> Float

Normed Int Int

Methods

size :: Int -> Int

Normed Integer Integer

Methods

size :: Integer -> Integer

(Foldable r, Representable r, ExpField a, ExpRing a) => Normed (r a) a

Methods

size :: r a -> a

class (AdditiveUnital a, AdditiveGroup a, Multiplicative a) => Signed a where

abs and signnum are also warts on the standard Num class, and are separated here to provide a cleaner structure.

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 Integer

Methods

sign :: Integer -> Integer

abs :: Integer -> Integer

(Representable r, Signed a) => Signed (r a)

Methods

sign :: r a -> r a

abs :: r a -> r a

class AdditiveGroup a => Epsilon a where

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

Minimal complete definition

nearZero, aboutEqual

Methods

nearZero :: a -> Bool

aboutEqual :: a -> a -> Bool

Instances

Epsilon Double

Methods

nearZero :: Double -> Bool

aboutEqual :: Double -> Double -> Bool

Epsilon Float

Methods

nearZero :: Float -> Bool

aboutEqual :: Float -> Float -> Bool

Epsilon Int

Methods

nearZero :: Int -> Bool

aboutEqual :: Int -> Int -> Bool

Epsilon Integer

Methods

nearZero :: Integer -> Bool

aboutEqual :: Integer -> Integer -> Bool

(Foldable r, Representable r, Epsilon a) => Epsilon (r a)

Methods

nearZero :: r a -> Bool

aboutEqual :: r a -> r a -> Bool

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

utf ???

class Ring a => QuotientField a where

quotient fields also explode constraints if they are polymorphed to emit general integrals

Minimal complete definition

round, ceiling, floor, (^^)

Methods

round :: a -> Integer

ceiling :: a -> Integer

floor :: a -> Integer

(^^) :: a -> Integer -> a

Instances

QuotientField Double

Methods

round :: Double -> Integer

ceiling :: Double -> Integer

floor :: Double -> Integer

(^^) :: Double -> Integer -> Double

QuotientField Float

Methods

round :: Float -> Integer

ceiling :: Float -> Integer

floor :: Float -> Integer

(^^) :: Float -> Integer -> Float