NumHask.Algebra.Abstract.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 thus inherited from super-classes of Field

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 * b == b * a
a / a = one
recip a = one / a
recip a * a = one
a * recip a = one

Instances

Field Double

Defined in NumHask.Algebra.Abstract.Field

Field Float

Defined in NumHask.Algebra.Abstract.Field

(Field a, Subtractive a) => Field (Complex a)

Defined in NumHask.Data.Complex

GCDConstraints a => Field (Ratio a)

Defined in NumHask.Data.Rational

Field a => Field (Pair a)

Defined in NumHask.Data.Pair

(Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) => Field (LogField a)

Defined in NumHask.Data.LogField

(Subtractive a, Divisive a) => Field (Wrapped a)

Defined in NumHask.Data.Wrapped

(Ord a, Subtractive a, Divisive a) => Field (Positive a)

Defined in NumHask.Data.Positive

Field b => Field (a -> b)

Defined in NumHask.Algebra.Abstract.Field

class Field a => ExpField a where

A hyperbolic field class

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

Minimal complete definition

exp, log

Methods

exp :: a -> a

log :: a -> a

logBase :: a -> a -> a

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

sqrt :: a -> a

Instances

ExpField Double

Defined in NumHask.Algebra.Abstract.Field

Methods

exp :: Double -> Double

log :: Double -> Double

logBase :: Double -> Double -> Double

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

sqrt :: Double -> Double

ExpField Float

Defined in NumHask.Algebra.Abstract.Field

Methods

exp :: Float -> Float

log :: Float -> Float

logBase :: Float -> Float -> Float

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

sqrt :: Float -> Float

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

Defined in NumHask.Data.Complex

Methods

exp :: Complex a -> Complex a

log :: Complex a -> Complex a

logBase :: Complex a -> Complex a -> Complex a

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

sqrt :: Complex a -> Complex a

ExpField a => ExpField (Pair a)

Defined in NumHask.Data.Pair

Methods

exp :: Pair a -> Pair a

log :: Pair a -> Pair a

logBase :: Pair a -> Pair a -> Pair a

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

sqrt :: Pair a -> Pair a

(Field (LogField a), ExpField a, LowerBoundedField a, Ord a) => ExpField (LogField a)

Defined in NumHask.Data.LogField

Methods

exp :: LogField a -> LogField a

log :: LogField a -> LogField a

logBase :: LogField a -> LogField a -> LogField a

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

sqrt :: LogField a -> LogField a

ExpField a => ExpField (Wrapped a)

Defined in NumHask.Data.Wrapped

Methods

exp :: Wrapped a -> Wrapped a

log :: Wrapped a -> Wrapped a

logBase :: Wrapped a -> Wrapped a -> Wrapped a

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

sqrt :: Wrapped a -> Wrapped a

(ExpField a, Ord a) => ExpField (Positive a)

Defined in NumHask.Data.Positive

Methods

exp :: Positive a -> Positive a

log :: Positive a -> Positive a

logBase :: Positive a -> Positive a -> Positive a

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

sqrt :: Positive a -> Positive a

ExpField b => ExpField (a -> b)

Defined in NumHask.Algebra.Abstract.Field

Methods

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

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

logBase :: (a -> b) -> (a -> b) -> a -> b

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

sqrt :: (a -> b) -> a -> b

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

Minimal complete definition

properFraction

Methods

properFraction :: a -> (b, a)

round :: a -> b

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

ceiling :: a -> b

ceiling :: Ord a => a -> b

floor :: a -> b

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

truncate :: a -> b

truncate :: Ord a => a -> b

Instances

QuotientField Double Integer

Defined in NumHask.Algebra.Abstract.Field

Methods

properFraction :: Double -> (Integer, Double)

round :: Double -> Integer

ceiling :: Double -> Integer

floor :: Double -> Integer

truncate :: Double -> Integer

QuotientField Float Integer

Defined in NumHask.Algebra.Abstract.Field

Methods

properFraction :: Float -> (Integer, Float)

round :: Float -> Integer

ceiling :: Float -> Integer

floor :: Float -> Integer

truncate :: Float -> Integer

(GCDConstraints a, GCDConstraints b, ToInteger a, Field a, FromIntegral b a) => QuotientField (Ratio a) b

Defined in NumHask.Data.Rational

Methods

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

round :: Ratio a -> b

ceiling :: Ratio a -> b

floor :: Ratio a -> b

truncate :: Ratio a -> b

(Ord a, QuotientField a Integer) => QuotientField (Wrapped a) (Wrapped Integer)

Defined in NumHask.Data.Wrapped

Methods

properFraction :: Wrapped a -> (Wrapped Integer, Wrapped a)

round :: Wrapped a -> Wrapped Integer

ceiling :: Wrapped a -> Wrapped Integer

floor :: Wrapped a -> Wrapped Integer

truncate :: Wrapped a -> Wrapped Integer

(Ord a, QuotientField a Integer) => QuotientField (Positive a) (Positive Integer)

Defined in NumHask.Data.Positive

Methods

properFraction :: Positive a -> (Positive Integer, Positive a)

round :: Positive a -> Positive Integer

ceiling :: Positive a -> Positive Integer

floor :: Positive a -> Positive Integer

truncate :: Positive a -> Positive Integer

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

Defined in NumHask.Algebra.Abstract.Field

Methods

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

round :: (a -> b) -> a -> c

ceiling :: (a -> b) -> a -> c

floor :: (a -> b) -> a -> c

truncate :: (a -> b) -> a -> c

class Field a => UpperBoundedField a where

A bounded field includes the concepts of infinity and NaN, thus moving away from error throwing.

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.

Minimal complete definition

Nothing

Methods

infinity :: a

nan :: a

Instances

UpperBoundedField Double

Defined in NumHask.Algebra.Abstract.Field

Methods

infinity :: Double

nan :: Double

UpperBoundedField Float

Defined in NumHask.Algebra.Abstract.Field

Methods

infinity :: Float

nan :: Float

(UpperBoundedField a, IntegralDomain a, Subtractive a) => UpperBoundedField (Complex a)

Defined in NumHask.Data.Complex

Methods

infinity :: Complex a

nan :: Complex a

(GCDConstraints a, Distributive a, IntegralDomain a) => UpperBoundedField (Ratio a)

Defined in NumHask.Data.Rational

Methods

infinity :: Ratio a

nan :: Ratio a

UpperBoundedField a => UpperBoundedField (Pair a)

Defined in NumHask.Data.Pair

Methods

infinity :: Pair a

nan :: Pair a

(Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) => UpperBoundedField (LogField a)

Defined in NumHask.Data.LogField

Methods

infinity :: LogField a

nan :: LogField a

UpperBoundedField a => UpperBoundedField (Wrapped a)

Defined in NumHask.Data.Wrapped

Methods

infinity :: Wrapped a

nan :: Wrapped a

(Ord a, UpperBoundedField a) => UpperBoundedField (Positive a)

Defined in NumHask.Data.Positive

Methods

infinity :: Positive a

nan :: Positive a

UpperBoundedField b => UpperBoundedField (a -> b)

Defined in NumHask.Algebra.Abstract.Field

Methods

infinity :: a -> b

nan :: a -> b

class (Subtractive a, Field a) => LowerBoundedField a where

Minimal complete definition

Nothing

Methods

negInfinity :: a

Instances

LowerBoundedField Double

Defined in NumHask.Algebra.Abstract.Field

Methods

negInfinity :: Double

LowerBoundedField Float

Defined in NumHask.Algebra.Abstract.Field

Methods

negInfinity :: Float

LowerBoundedField a => LowerBoundedField (Complex a)

Defined in NumHask.Data.Complex

Methods

negInfinity :: Complex a

(GCDConstraints a, Field a) => LowerBoundedField (Ratio a)

Defined in NumHask.Data.Rational

Methods

negInfinity :: Ratio a

LowerBoundedField a => LowerBoundedField (Pair a)

Defined in NumHask.Data.Pair

Methods

negInfinity :: Pair a

(Ord a, ExpField a, LowerBoundedField a, UpperBoundedField a) => LowerBoundedField (LogField a)

Defined in NumHask.Data.LogField

Methods

negInfinity :: LogField a

LowerBoundedField a => LowerBoundedField (Wrapped a)

Defined in NumHask.Data.Wrapped

Methods

negInfinity :: Wrapped a

LowerBoundedField b => LowerBoundedField (a -> b)

Defined in NumHask.Algebra.Abstract.Field

Methods

negInfinity :: a -> b

class Field a => TrigField a where

Trigonometric Field

Minimal complete definition

pi, sin, cos, asin, acos, atan, 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

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.Abstract.Field

Methods

pi :: Double

sin :: Double -> Double

cos :: Double -> Double

tan :: Double -> Double

asin :: Double -> Double

acos :: Double -> Double

atan :: 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.Abstract.Field

Methods

pi :: Float

sin :: Float -> Float

cos :: Float -> Float

tan :: Float -> Float

asin :: Float -> Float

acos :: Float -> Float

atan :: Float -> Float

sinh :: Float -> Float

cosh :: Float -> Float

tanh :: Float -> Float

asinh :: Float -> Float

acosh :: Float -> Float

atanh :: Float -> Float

TrigField a => TrigField (Wrapped a)

Defined in NumHask.Data.Wrapped

Methods

pi :: Wrapped a

sin :: Wrapped a -> Wrapped a

cos :: Wrapped a -> Wrapped a

tan :: Wrapped a -> Wrapped a

asin :: Wrapped a -> Wrapped a

acos :: Wrapped a -> Wrapped a

atan :: Wrapped a -> Wrapped a

sinh :: Wrapped a -> Wrapped a

cosh :: Wrapped a -> Wrapped a

tanh :: Wrapped a -> Wrapped a

asinh :: Wrapped a -> Wrapped a

acosh :: Wrapped a -> Wrapped a

atanh :: Wrapped a -> Wrapped a

(TrigField a, Ord a) => TrigField (Positive a)

Defined in NumHask.Data.Positive

Methods

pi :: Positive a

sin :: Positive a -> Positive a

cos :: Positive a -> Positive a

tan :: Positive a -> Positive a

asin :: Positive a -> Positive a

acos :: Positive a -> Positive a

atan :: Positive a -> Positive a

sinh :: Positive a -> Positive a

cosh :: Positive a -> Positive a

tanh :: Positive a -> Positive a

asinh :: Positive a -> Positive a

acosh :: Positive a -> Positive a

atanh :: Positive a -> Positive a

TrigField b => TrigField (a -> b)

Defined in NumHask.Algebra.Abstract.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

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 to be computed.