NumHask.Algebra.Field

Field classes

Documentation

type SemiField a = (Distributive a, Divisive a)

A Semifield is a field with no substraction.

Since: 0.12

type Field a = (Ring a, Divisive 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:

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

class Field a => ExpField a where

A hyperbolic field class

\(a::Double) -> a < zero || (sqrt . (**2)) a == a

\(a::Double) -> a < zero || (log . exp) a ~= a

\(a::Double) (b::Double) -> (b < zero) || a <= zero || a == 1 || abs (a ** logBase a b - b) < 10 * epsilon

Minimal complete definition

exp, log

Methods

exp :: a -> a

log :: a -> a

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

logBase :: a -> a -> a

log to the base of

>>> logBase 2 8
2.9999999999999996

sqrt :: a -> a

square root

>>> sqrt 4
2.0

Instances

ExpField Double

Defined in NumHask.Algebra.Field

Methods

exp :: Double -> Double

log :: Double -> Double

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

logBase :: Double -> Double -> Double

sqrt :: Double -> Double

ExpField Float

Defined in NumHask.Algebra.Field

Methods

exp :: Float -> Float

log :: Float -> Float

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

logBase :: Float -> Float -> Float

sqrt :: Float -> Float

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

Defined in NumHask.Algebra.Metric

Methods

exp :: EuclideanPair a -> EuclideanPair a

log :: EuclideanPair a -> EuclideanPair a

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

logBase :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a

sqrt :: EuclideanPair a -> EuclideanPair a

(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

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

sqrt :: Complex a -> Complex a

ExpField a => ExpField (Wrapped a)

Defined in NumHask.Data.Wrapped

Methods

exp :: Wrapped a -> Wrapped a

log :: Wrapped a -> Wrapped a

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

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

sqrt :: Wrapped a -> Wrapped 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 :: (a -> b) -> (a -> b) -> a -> b

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

class SemiField a => QuotientField a where

Quotienting of a Field into a Ring

See Field of fractions

\a -> a - one < floor a <= a <= ceiling a < a + one

Minimal complete definition

properFraction

Associated Types

type Whole a :: Type

Methods

properFraction :: a -> (Whole a, a)

round :: a -> Whole a

round to the nearest Int

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

>>> round (1.5 :: Double)
2

>>> round (2.5 :: Double)
2

default round :: (Subtractive a, Integral (Whole a), Eq (Whole a), Ord a, Subtractive (Whole a)) => a -> Whole a

ceiling :: a -> Whole a

supply the next upper whole component

>>> ceiling (1.001 :: Double)
2

default ceiling :: (Ord a, Distributive (Whole a)) => a -> Whole a

floor :: a -> Whole a

supply the previous lower whole component

>>> floor (1.001 :: Double)
1

default floor :: (Ord a, Subtractive (Whole a), Distributive (Whole a)) => a -> Whole a

truncate :: a -> Whole a

supply the whole component closest to zero

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

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

default truncate :: Ord a => a -> Whole a

Instances

QuotientField Double

Defined in NumHask.Algebra.Field

Associated Types

type Whole Double

Methods

properFraction :: Double -> (Whole Double, Double)

round :: Double -> Whole Double

ceiling :: Double -> Whole Double

floor :: Double -> Whole Double

truncate :: Double -> Whole Double

QuotientField Float

Defined in NumHask.Algebra.Field

Associated Types

type Whole Float

Methods

properFraction :: Float -> (Whole Float, Float)

round :: Float -> Whole Float

ceiling :: Float -> Whole Float

floor :: Float -> Whole Float

truncate :: Float -> Whole Float

(QuotientField a, Subtractive a) => QuotientField (EuclideanPair a)

Defined in NumHask.Algebra.Metric

Associated Types

type Whole (EuclideanPair a)

Methods

properFraction :: EuclideanPair a -> (Whole (EuclideanPair a), EuclideanPair a)

round :: EuclideanPair a -> Whole (EuclideanPair a)

ceiling :: EuclideanPair a -> Whole (EuclideanPair a)

floor :: EuclideanPair a -> Whole (EuclideanPair a)

truncate :: EuclideanPair a -> Whole (EuclideanPair a)

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

Defined in NumHask.Data.Complex

Associated Types

type Whole (Complex a)

Methods

properFraction :: Complex a -> (Whole (Complex a), Complex a)

round :: Complex a -> Whole (Complex a)

ceiling :: Complex a -> Whole (Complex a)

floor :: Complex a -> Whole (Complex a)

truncate :: Complex a -> Whole (Complex a)

QuotientField (Positive Double)

Defined in NumHask.Data.Positive

Associated Types

type Whole (Positive Double)

Methods

properFraction :: Positive Double -> (Whole (Positive Double), Positive Double)

round :: Positive Double -> Whole (Positive Double)

ceiling :: Positive Double -> Whole (Positive Double)

floor :: Positive Double -> Whole (Positive Double)

truncate :: Positive Double -> Whole (Positive Double)

(Ord a, EndoBased a, Absolute a, ToInt a, Integral a, Ring a) => QuotientField (Ratio a)

Defined in NumHask.Data.Rational

Associated Types

type Whole (Ratio a)

Methods

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

round :: Ratio a -> Whole (Ratio a)

ceiling :: Ratio a -> Whole (Ratio a)

floor :: Ratio a -> Whole (Ratio a)

truncate :: Ratio a -> Whole (Ratio a)

(Ord a, Eq (Whole a), Integral (Whole a), Subtractive (Whole a), Subtractive a, QuotientField a) => QuotientField (Wrapped a)

Defined in NumHask.Data.Wrapped

Associated Types

type Whole (Wrapped a)

Methods

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

round :: Wrapped a -> Whole (Wrapped a)

ceiling :: Wrapped a -> Whole (Wrapped a)

floor :: Wrapped a -> Whole (Wrapped a)

truncate :: Wrapped a -> Whole (Wrapped a)

infinity :: SemiField a => a

infinity is defined for any Field.

>>> one / zero + infinity
Infinity

>>> infinity + 1
Infinity

negInfinity :: Field a => a

negative infinity

>>> negInfinity + infinity
NaN

nan :: SemiField a => a

nan is defined as zero/zero

but note the (social) law:

>>> nan == zero / zero
False

class Field a => TrigField a where

Trigonometric Field

The list of laws is quite long: trigonometric identities

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 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

atan2 :: Wrapped a -> 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 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 :: (Additive a, Divisive a) => a

A half of one

>>> half :: Double
0.5