Safe Haskell	Safe-Inferred
Language	GHC2021

NumHask.Algebra.Field

Description

Field classes

Synopsis

type Field a = (Ring a, Divisive a)
class Field a => ExpField a where
- exp :: a -> a
- log :: a -> a
- (**) :: a -> a -> a
- logBase :: a -> a -> a
- sqrt :: a -> a
class Field a => QuotientField a where
- type Whole a :: Type
- properFraction :: a -> (Whole a, a)
- round :: (Eq (Whole a), Ring (Whole a)) => a -> Whole a
- ceiling :: Distributive (Whole a) => a -> Whole a
- floor :: Ring (Whole a) => a -> Whole a
- truncate :: Ring (Whole a) => a -> Whole a
infinity :: Field a => a
negInfinity :: Field a => a
nan :: Field a => a
class Field a => TrigField a where
- 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
half :: Field a => a

Documentation

type Field a = (Ring a, Divisive a) Source #

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

A hyperbolic field class

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

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

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

Minimal complete definition

exp, log

Methods

exp :: a -> a Source #

log :: a -> a Source #

(**) :: a -> a -> a Source #

logBase :: a -> a -> a Source #

log to the base of

>>> logBase 2 8
2.9999999999999996

sqrt :: a -> a Source #

square root

>>> sqrt 4
2.0

Instances

Instances details

ExpField Double Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: Double -> Double Source # log :: Double -> Double Source # (**) :: Double -> Double -> Double Source # logBase :: Double -> Double -> Double Source # sqrt :: Double -> Double Source #
ExpField Float Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: Float -> Float Source # log :: Float -> Float Source # (**) :: Float -> Float -> Float Source # logBase :: Float -> Float -> Float Source # sqrt :: Float -> Float Source #
(Ord a, TrigField a, ExpField a) => ExpField (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Methods exp :: EuclideanPair a -> EuclideanPair a Source # log :: EuclideanPair a -> EuclideanPair a Source # (**) :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # logBase :: EuclideanPair a -> EuclideanPair a -> EuclideanPair a Source # sqrt :: EuclideanPair a -> EuclideanPair a Source #
(Ord a, TrigField a, ExpField a) => ExpField (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Methods exp :: Complex a -> Complex a Source # log :: Complex a -> Complex a Source # (**) :: Complex a -> Complex a -> Complex a Source # logBase :: Complex a -> Complex a -> Complex a Source # sqrt :: Complex a -> Complex a Source #
ExpField b => ExpField (a -> b) Source #
Instance details Defined in NumHask.Algebra.Field Methods exp :: (a -> b) -> a -> b Source # log :: (a -> b) -> a -> b Source # (**) :: (a -> b) -> (a -> b) -> a -> b Source # logBase :: (a -> b) -> (a -> b) -> a -> b Source # sqrt :: (a -> b) -> a -> b Source #

class Field a => QuotientField a where Source #

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

Methods

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

round :: (Eq (Whole a), Ring (Whole a)) => a -> Whole a Source #

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 :: (Integral (Whole a), Eq (Whole a), Ord a, Ring (Whole a)) => a -> Whole a Source #

ceiling :: Distributive (Whole a) => a -> Whole a Source #

supply the next upper whole component

>>> ceiling (1.001 :: Double)
2

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

floor :: Ring (Whole a) => a -> Whole a Source #

supply the previous lower whole component

>>> floor (1.001 :: Double)
1

default floor :: (Ord a, Ring (Whole a)) => a -> Whole a Source #

truncate :: Ring (Whole a) => a -> Whole a Source #

supply the whole component closest to zero

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

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

default truncate :: (Ord a, Ring (Whole a)) => a -> Whole a Source #

Instances

Instances details

QuotientField Double Source #
Instance details Defined in NumHask.Algebra.Field Associated Types type Whole Double Source # Methods properFraction :: Double -> (Whole Double, Double) Source # round :: Double -> Whole Double Source # ceiling :: Double -> Whole Double Source # floor :: Double -> Whole Double Source # truncate :: Double -> Whole Double Source #
QuotientField Float Source #
Instance details Defined in NumHask.Algebra.Field Associated Types type Whole Float Source # Methods properFraction :: Float -> (Whole Float, Float) Source # round :: Float -> Whole Float Source # ceiling :: Float -> Whole Float Source # floor :: Float -> Whole Float Source # truncate :: Float -> Whole Float Source #
(Eq (Whole a), Ring (Whole a), QuotientField a) => QuotientField (EuclideanPair a) Source #
Instance details Defined in NumHask.Algebra.Metric Associated Types type Whole (EuclideanPair a) Source # Methods properFraction :: EuclideanPair a -> (Whole (EuclideanPair a), EuclideanPair a) Source # round :: EuclideanPair a -> Whole (EuclideanPair a) Source # ceiling :: EuclideanPair a -> Whole (EuclideanPair a) Source # floor :: EuclideanPair a -> Whole (EuclideanPair a) Source # truncate :: EuclideanPair a -> Whole (EuclideanPair a) Source #
(Eq (Whole a), Ring (Whole a), QuotientField a) => QuotientField (Complex a) Source #
Instance details Defined in NumHask.Data.Complex Associated Types type Whole (Complex a) Source # Methods properFraction :: Complex a -> (Whole (Complex a), Complex a) Source # round :: Complex a -> Whole (Complex a) Source # ceiling :: Complex a -> Whole (Complex a) Source # floor :: Complex a -> Whole (Complex a) Source # truncate :: Complex a -> Whole (Complex a) Source #
(Ord a, EndoBased a, Absolute a, ToInt a, Integral a, Ring a) => QuotientField (Ratio a) Source #
Instance details Defined in NumHask.Data.Rational Associated Types type Whole (Ratio a) Source # Methods properFraction :: Ratio a -> (Whole (Ratio a), Ratio a) Source # round :: Ratio a -> Whole (Ratio a) Source # ceiling :: Ratio a -> Whole (Ratio a) Source # floor :: Ratio a -> Whole (Ratio a) Source # truncate :: Ratio a -> Whole (Ratio a) Source #

infinity :: Field a => a Source #

infinity is defined for any Field.

>>> one / zero + infinity
Infinity

>>> infinity + 1
Infinity

negInfinity :: Field a => a Source #

negative infinity

>>> negInfinity + infinity
NaN

nan :: Field a => a Source #

nan is defined as zero/zero

but note the (social) law:

>>> nan == zero / zero
False

class Field a => TrigField a where Source #

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

sin :: a -> a Source #

cos :: a -> a Source #

tan :: a -> a Source #

asin :: a -> a Source #

acos :: a -> a Source #

atan :: a -> a Source #

atan2 :: a -> a -> a Source #

sinh :: a -> a Source #

cosh :: a -> a Source #

tanh :: a -> a Source #

asinh :: a -> a Source #

acosh :: a -> a Source #

atanh :: a -> a Source #

Instances

Instances details

TrigField Double Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: Double Source # sin :: Double -> Double Source # cos :: Double -> Double Source # tan :: Double -> Double Source # asin :: Double -> Double Source # acos :: Double -> Double Source # atan :: Double -> Double Source # atan2 :: Double -> Double -> Double Source # sinh :: Double -> Double Source # cosh :: Double -> Double Source # tanh :: Double -> Double Source # asinh :: Double -> Double Source # acosh :: Double -> Double Source # atanh :: Double -> Double Source #
TrigField Float Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: Float Source # sin :: Float -> Float Source # cos :: Float -> Float Source # tan :: Float -> Float Source # asin :: Float -> Float Source # acos :: Float -> Float Source # atan :: Float -> Float Source # atan2 :: Float -> Float -> Float Source # sinh :: Float -> Float Source # cosh :: Float -> Float Source # tanh :: Float -> Float Source # asinh :: Float -> Float Source # acosh :: Float -> Float Source # atanh :: Float -> Float Source #
TrigField b => TrigField (a -> b) Source #
Instance details Defined in NumHask.Algebra.Field Methods pi :: a -> b Source # sin :: (a -> b) -> a -> b Source # cos :: (a -> b) -> a -> b Source # tan :: (a -> b) -> a -> b Source # asin :: (a -> b) -> a -> b Source # acos :: (a -> b) -> a -> b Source # atan :: (a -> b) -> a -> b Source # atan2 :: (a -> b) -> (a -> b) -> a -> b Source # sinh :: (a -> b) -> a -> b Source # cosh :: (a -> b) -> a -> b Source # tanh :: (a -> b) -> a -> b Source # asinh :: (a -> b) -> a -> b Source # acosh :: (a -> b) -> a -> b Source # atanh :: (a -> b) -> a -> b Source #

half :: Field a => a Source #

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

>>> half :: Double
0.5