NumHask.Algebra.Field

Field classes

Documentation

class (Distributive a, Subtractive a, Divisive a) => Field a

A Field is a set on which addition, subtraction, multiplication, and division are defined. It is also assumed that multiplication is distributive over addition.

A summary of the rules inherited from super-classes of Field. Floating point computation is a terrible, messy business and, in practice, only rough approximation can be achieve for association and distribution.

zero + a == a
a + zero == a
((a + b) + c) (a + (b + c))
a + b == b + a
a - a == zero
negate a == zero - a
negate a + a == zero
a + negate a == zero
one * a == a
a * one == a
((a * b) * c) == (a * (b * c))
(a * (b + c)) == (a * b + a * c)
((a + b) * c) == (a * c + b * c)
a * zero == zero
zero * a == zero
a / a == one || a == zero
recip a == one / a || a == zero
recip a * a == one || a == zero
a * recip a == one || a == zero

Instances

Field Double

Defined in NumHask.Algebra.Field

Field Float

Defined in NumHask.Algebra.Field

Field a => Field (Complex a)

Defined in NumHask.Data.Complex

(Ord a, Signed a, Integral a, Ring a) => Field (Ratio a)

Defined in NumHask.Data.Rational

Field b => Field (a -> b)

Defined in NumHask.Algebra.Field

class Field a => ExpField a where

A hyperbolic field class

sqrt . (**2) == id
log . exp == id
for +ive b, a != 0,1: a ** logBase a b ≈ b

Minimal complete definition

exp, log

Methods

exp :: a -> a

log :: a -> a

(**) :: a -> a -> a

Instances

ExpField Double

Defined in NumHask.Algebra.Field

Methods

exp :: Double -> Double

log :: Double -> Double

(**) :: Double -> Double -> Double

ExpField Float

Defined in NumHask.Algebra.Field

Methods

exp :: Float -> Float

log :: Float -> Float

(**) :: Float -> Float -> Float

(Ord a, TrigField a, ExpField a) => ExpField (Complex a)

Defined in NumHask.Data.Complex

Methods

exp :: Complex a -> Complex a

log :: Complex a -> Complex a

(**) :: Complex a -> Complex a -> Complex a

ExpField b => ExpField (a -> b)

Defined in NumHask.Algebra.Field

Methods

exp :: (a -> b) -> a -> b

log :: (a -> b) -> a -> b

(**) :: (a -> b) -> (a -> b) -> a -> b

logBase :: ExpField a => a -> a -> a

log to the base of

>>> logBase 2 8
2.9999999999999996

sqrt :: ExpField a => a -> a

square root

>>> sqrt 4
2.0

class (Field a, Multiplicative b, Additive b) => QuotientField a b where

Conversion from a Field to a Ring

See Field of fractions

a - one < floor a <= a <= ceiling a < a + one
round a == floor (a + half)

Methods

properFraction :: a -> (b, a)

Instances

QuotientField Double Int

Defined in NumHask.Algebra.Field

Methods

properFraction :: Double -> (Int, Double)

QuotientField Double Integer

Defined in NumHask.Algebra.Field

Methods

properFraction :: Double -> (Integer, Double)

QuotientField Float Int

Defined in NumHask.Algebra.Field

Methods

properFraction :: Float -> (Int, Float)

QuotientField Float Integer

Defined in NumHask.Algebra.Field

Methods

properFraction :: Float -> (Integer, Float)

(Ord a, Signed a, Integral a, Ring a, Signed b, FromIntegral b a) => QuotientField (Ratio a) b

Defined in NumHask.Data.Rational

Methods

properFraction :: Ratio a -> (b, Ratio a)

QuotientField b c => QuotientField (a -> b) (a -> c)

Defined in NumHask.Algebra.Field

Methods

properFraction :: (a -> b) -> (a -> c, a -> b)

round :: (Ord a, Ord b, QuotientField a b, Subtractive b, Integral b) => a -> b

round to the nearest integral

Exact ties are managed by rounding down ties if the whole component is even.

>>> round (1.5 :: Double) :: Int
2

>>> round (2.5 :: Double) :: Int
2

ceiling :: (Ord a, QuotientField a b) => a -> b

supply the next upper whole component

>>> ceiling (1.001 :: Double) :: Int
2

floor :: (Ord a, QuotientField a b, Subtractive b) => a -> b

supply the previous lower whole component

>>> floor (1.001 :: Double) :: Int
1

truncate :: (Ord a, QuotientField a b, Subtractive b) => a -> b

supply the whole component closest to zero

>>> floor (-1.001 :: Double) :: Int
-2

>>> truncate (-1.001 :: Double) :: Int
-1

infinity :: Field a => a

A field introduces the concept of infinity.

one / zero + infinity == infinity
infinity + a == infinity
zero / zero != nan

Note the tricky law that, although nan is assigned to zero/zero, they are never-the-less not equal. A committee decided this.

negInfinity :: Field a => a

negative infinity

nan :: Field a => a

Note the law: -- > zero / zero != nan

class Field a => TrigField a where

Trigonometric Field

Minimal complete definition

pi, sin, cos, asin, acos, atan, atan2, sinh, cosh, asinh, acosh, atanh

Methods

pi :: a

sin :: a -> a

cos :: a -> a

tan :: a -> a

asin :: a -> a

acos :: a -> a

atan :: a -> a

atan2 :: a -> a -> a

sinh :: a -> a

cosh :: a -> a

tanh :: a -> a

asinh :: a -> a

acosh :: a -> a

atanh :: a -> a

Instances

TrigField Double

Defined in NumHask.Algebra.Field

Methods

pi :: Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: Double -> Double

atan2 :: Double -> Double -> Double

sinh :: Double -> Double

cosh :: Double -> Double

tanh :: Double -> Double

asinh :: Double -> Double

acosh :: Double -> Double

atanh :: Double -> Double

TrigField Float

Defined in NumHask.Algebra.Field

Methods

pi :: Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

atan2 :: Float -> Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

TrigField b => TrigField (a -> b)

Defined in NumHask.Algebra.Field

Methods

pi :: a -> b

sin :: (a -> b) -> a -> b

cos :: (a -> b) -> a -> b

tan :: (a -> b) -> a -> b

asin :: (a -> b) -> a -> b

acos :: (a -> b) -> a -> b

atan :: (a -> b) -> a -> b

atan2 :: (a -> b) -> (a -> b) -> a -> b

sinh :: (a -> b) -> a -> b

cosh :: (a -> b) -> a -> b

tanh :: (a -> b) -> a -> b

asinh :: (a -> b) -> a -> b

acosh :: (a -> b) -> a -> b

atanh :: (a -> b) -> a -> b

half :: Field a => a

A half is a Field because it requires addition, multiplication and division.