numhask-0.11.1.0: A numeric class hierarchy.
Safe HaskellSafe-Inferred
LanguageGHC2021

NumHask

Description

Numeric classes.

Synopsis

Usage

>>> :set -XRebindableSyntax
>>> import NumHask.Prelude
>>> 1+1
2

Overview

numhask is largely a set of classes that can replace the Num class and it's descendents. Principles that have guided design include:

  • balanced class density. The numeric hierarchy begins with addition and multiplication, choosing not to build from a Magma base. Whilst not being as principled as other approaches, this circumvents the instance explosion problems of Haskell whilst maintaining clarity of class purpose.
  • operator-first. In all cases, a class exists to define useful operators. Major class groupings, such as Distributive, Ring and Field are type synonyms.
  • lawful. All classes have laws associated with them that serve to relate class operators together in a meaningful way.
  • low-impact. The library attempts to fit in with the rest of the Haskell ecosystem. It provides instances for common numbers: Int, Integer, Double, Float, Natural, and the Word classes. It avoids name (or idea) clashes with other popular libraries and adopts conventions in the current prelude where they make sense.
  • proof-of-concept. The library may be below industrial-strength depending on a definition of this term. At the same time, correspondence around improving the library is most welcome.

The class heirarchy looks somewhat like this:

Prelude Mappings

Num is a very old part of haskell, and is virtually unchanged since its specification in haskell98.

A deconstruction of Num and mapping to numhask.

-- | Basic numeric class.
class  Num a  where
   {-# MINIMAL (+), (*), abs, signum, fromInteger, (negate | (-)) #-}

   (+), (-), (*)       :: a -> a -> a
   -- | Unary negation.
   negate              :: a -> a

(+) is an operator of the Additive class

(-) & negate are functions in the Subtractive class, and

(*) is an operator of the Multiplicative class.

zero and one are also introduced to the numeric hierarchy.

   -- | Absolute value.
   abs                 :: a -> a
   -- | Sign of a number.
   -- The functions 'abs' and 'signum' should satisfy the law:
   --
   -- > abs x * signum x == x
   --
   -- For real numbers, the 'signum' is either @-1@ (negative), @0@ (zero)
   -- or @1@ (positive).
   signum              :: a -> a

The concept of an absolute value and the sign of a number can include situations where the domain type is different to the absolute and sign codomain types.

A new class, Basis is supplied to handle these situations:

abs and signum are specialisations of these methods.

   -- | Conversion from an 'Integer'.
   -- An integer literal represents the application of the function
   -- 'fromInteger' to the appropriate value of type 'Integer',
   -- so such literals have type @('Num' a) => a@.
   fromInteger         :: Integer -> a

FromInteger becomes its own class and FromIntegral is introduced to polymorphise the covariant.

Mappings from other areas of prelude include:

In addition to base changes, alternatives to sum and product from Foldable are also supplied.

Extensions

RebindableSyntax is recommended for use with numhask.

As a replacement for the numerical classes, numhask clashes significantly with an unqualified import of the Prelude. Either numhask modules should be qualified, or prelude turned off with the NoImplicitPrelude extension, or with RebindableSyntax, which implies NoImplicitPrelude.

defaulting

Without RebindableSyntax, numeric literals default as follows:

>>> :set -XNoRebindableSyntax
>>> :t 1
1 :: Num a => a
>>> :t 1.0
1.0 :: Fractional a => a

With RebindableSyntax (which also switches NoImplicitPrelude on) literal numbers change to the numhask types, FromInteger and FromRational:

>>> :set -XRebindableSyntax
>>> :t 1
1 :: FromInteger a => a
>>> :t 1.0
1.0 :: FromRational a => a
>>> 1
1
>>> 1.0
1.0

RebindableSyntax is a tradeoff, however, and usage comes attached with other non-numeric changes that NumHask.Prelude attempts to counteract.

See haskell2010 Section 4.3.4 for the nuts and bolts to defaulting.

The effect of ExtendedDefaultRules in ghci or switched on as an extension also need to be understood. It can lead to unusual interactions with numerics and strange error messages at times because it adds () and [] to the start of the type defaulting list.

Additive

class Additive a where Source #

or Addition

For practical reasons, we begin the class tree with Additive. Starting with Associative and Unital, or using Semigroup and Monoid from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.

\a -> zero + a == a
\a -> a + zero == a
\a b c -> (a + b) + c == a + (b + c)
\a b -> a + b == b + a

By convention, (+) is regarded as commutative, but this is not universal, and the introduction of another symbol which means non-commutative addition seems a bit dogmatic.

>>> zero + 1
1
>>> 1 + 1
2

Methods

(+) :: a -> a -> a infixl 6 Source #

zero :: a Source #

Instances

Instances details
Additive Int16 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Int32 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Int64 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Int8 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: Int8 -> Int8 -> Int8 Source #

zero :: Int8 Source #

Additive Word16 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Word32 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Word64 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Word8 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Integer Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Natural Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Bool Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: Bool -> Bool -> Bool Source #

zero :: Bool Source #

Additive Double Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Float Source # 
Instance details

Defined in NumHask.Algebra.Additive

Additive Int Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: Int -> Int -> Int Source #

zero :: Int Source #

Additive Word Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: Word -> Word -> Word Source #

zero :: Word Source #

Additive a => Additive (Sum a) Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: Sum a -> Sum a -> Sum a Source #

zero :: Sum a Source #

Additive a => Additive (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Additive a => Additive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a Source #

zero :: Complex a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Additive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(+) :: Ratio a -> Ratio a -> Ratio a Source #

zero :: Ratio a Source #

Additive b => Additive (a -> b) Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

(+) :: (a -> b) -> (a -> b) -> a -> b Source #

zero :: a -> b Source #

sum :: (Additive a, Foldable f) => f a -> a Source #

Compute the sum of a Foldable.

>>> sum [0..10]
55

accsum :: (Additive a, Traversable f) => f a -> f a Source #

Compute the accumulating sum of a Traversable.

>>> accsum [0..10]
[0,1,3,6,10,15,21,28,36,45,55]

class Additive a => Subtractive a where Source #

or Subtraction

\a -> a - a == zero
\a -> negate a == zero - a
\a -> negate a + a == zero
\a -> a + negate a == zero
>>> negate 1
-1
>>> 1 - 2
-1

Minimal complete definition

(-) | negate

Methods

negate :: a -> a Source #

(-) :: a -> a -> a infixl 6 Source #

Instances

Instances details
Subtractive Int16 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Int32 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Int64 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Int8 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

negate :: Int8 -> Int8 Source #

(-) :: Int8 -> Int8 -> Int8 Source #

Subtractive Word16 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Word32 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Word64 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Word8 Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Integer Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Natural Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Double Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Float Source # 
Instance details

Defined in NumHask.Algebra.Additive

Subtractive Int Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

negate :: Int -> Int Source #

(-) :: Int -> Int -> Int Source #

Subtractive Word Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

negate :: Word -> Word Source #

(-) :: Word -> Word -> Word Source #

Subtractive a => Subtractive (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Subtractive a => Subtractive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

negate :: Complex a -> Complex a Source #

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

(Ord a, EndoBased a, Integral a, Ring a) => Subtractive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

negate :: Ratio a -> Ratio a Source #

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

Subtractive b => Subtractive (a -> b) Source # 
Instance details

Defined in NumHask.Algebra.Additive

Methods

negate :: (a -> b) -> a -> b Source #

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

Multiplicative

class Multiplicative a where Source #

or Multiplication

For practical reasons, we begin the class tree with Additive and Multiplicative. Starting with Associative and Unital, or using Semigroup and Monoid from base tends to confuse the interface once you start having to disinguish between (say) monoidal addition and monoidal multiplication.

\a -> one * a == a
\a -> a * one == a
\a b c -> (a * b) * c == a * (b * c)

By convention, (*) is regarded as not necessarily commutative, but this is not universal, and the introduction of another symbol which means commutative multiplication seems a bit dogmatic.

>>> one * 2
2
>>> 2 * 3
6

Methods

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

one :: a Source #

Instances

Instances details
Multiplicative Int16 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Int16 Source #

Multiplicative Int32 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Int32 Source #

Multiplicative Int64 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Int64 Source #

Multiplicative Int8 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Int8 Source #

Multiplicative Word16 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Word32 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Word64 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Word8 Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Word8 Source #

Multiplicative Integer Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Natural Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Bool Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Bool Source #

Multiplicative Double Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Multiplicative Float Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Float Source #

Multiplicative Int Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Int Source #

Multiplicative Word Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: Word Source #

Multiplicative a => Multiplicative (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

(Subtractive a, Multiplicative a) => Multiplicative (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

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

one :: Complex a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Multiplicative (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

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

one :: Ratio a Source #

Multiplicative b => Multiplicative (a -> b) Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

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

one :: a -> b Source #

product :: (Multiplicative a, Foldable f) => f a -> a Source #

Compute the product of a Foldable.

>>> product [1..5]
120

accproduct :: (Multiplicative a, Traversable f) => f a -> f a Source #

Compute the accumulating product of a Traversable.

>>> accproduct [1..5]
[1,2,6,24,120]

class Multiplicative a => Divisive a where Source #

or Division

Though unusual, the term Divisive usefully fits in with the grammer of other classes and avoids name clashes that occur with some popular libraries.

\(a :: Double) -> a / a ~= one || a == zero
\(a :: Double) -> recip a ~= one / a || a == zero
\(a :: Double) -> recip a * a ~= one || a == zero
\(a :: Double) -> a * recip a ~= one || a == zero
>>> recip 2.0
0.5
>>> 1 / 2
0.5

Minimal complete definition

(/) | recip

Methods

recip :: a -> a Source #

(/) :: a -> a -> a infixl 7 Source #

Instances

Instances details
Divisive Double Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Divisive Float Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

(Subtractive a, Divisive a) => Divisive (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

(Subtractive a, Divisive a) => Divisive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

recip :: Complex a -> Complex a Source #

(/) :: Complex a -> Complex a -> Complex a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Divisive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

recip :: Ratio a -> Ratio a Source #

(/) :: Ratio a -> Ratio a -> Ratio a Source #

Divisive b => Divisive (a -> b) Source # 
Instance details

Defined in NumHask.Algebra.Multiplicative

Methods

recip :: (a -> b) -> a -> b Source #

(/) :: (a -> b) -> (a -> b) -> a -> b Source #

Ring

type Distributive a = (Additive a, Multiplicative a) Source #

Distributive

\a b c -> a * (b + c) == a * b + a * c
\a b c -> (a + b) * c == a * c + b * c
\a -> zero * a == zero
\a -> a * zero == zero

The sneaking in of the Absorption laws here glosses over the possibility that the multiplicative zero element does not have to correspond with the additive unital zero.

type Ring a = (Distributive a, Subtractive a) Source #

A Ring is an abelian group under addition (Unital, Associative, Commutative, Invertible) and monoidal under multiplication (Unital, Associative), and where multiplication distributes over addition.

\a -> zero + a == a
\a -> a + zero == a
\a b c -> (a + b) + c == a + (b + c)
\a b -> a + b == b + a
\a -> a - a == zero
\a -> negate a == zero - a
\a -> negate a + a == zero
\a -> a + negate a == zero
\a -> one * a == a
\a -> a * one == a
\a b c -> (a * b) * c == a * (b * c)
\a b c -> a * (b + c) == a * b + a * c
\a b c -> (a + b) * c == a * c + b * c
\a -> zero * a == zero
\a -> a * zero == zero

class Distributive a => StarSemiring a where Source #

A StarSemiring is a semiring with an additional unary operator (star) satisfying:

\a -> star a == one + a * star a

Minimal complete definition

star | plus

Methods

star :: a -> a Source #

plus :: a -> a Source #

class (StarSemiring a, Idempotent a) => KleeneAlgebra a Source #

A Kleene Algebra is a Star Semiring with idempotent addition.

a * x + x = a ==> star a * x + x = x
x * a + x = a ==> x * star a + x = x

class Distributive a => InvolutiveRing a where Source #

Involutive Ring

adj (a + b) ==> adj a + adj b
adj (a * b) ==> adj a * adj b
adj one ==> one
adj (adj a) ==> a

Note: elements for which adj a == a are called "self-adjoint".

Minimal complete definition

Nothing

Methods

adj :: a -> a Source #

Instances

Instances details
InvolutiveRing Int16 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Int16 -> Int16 Source #

InvolutiveRing Int32 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Int32 -> Int32 Source #

InvolutiveRing Int64 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Int64 -> Int64 Source #

InvolutiveRing Int8 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Int8 -> Int8 Source #

InvolutiveRing Word16 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Word16 -> Word16 Source #

InvolutiveRing Word32 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Word32 -> Word32 Source #

InvolutiveRing Word64 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Word64 -> Word64 Source #

InvolutiveRing Word8 Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Word8 -> Word8 Source #

InvolutiveRing Integer Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Integer -> Integer Source #

InvolutiveRing Natural Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Natural -> Natural Source #

InvolutiveRing Double Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Double -> Double Source #

InvolutiveRing Float Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Float -> Float Source #

InvolutiveRing Int Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Int -> Int Source #

InvolutiveRing Word Source # 
Instance details

Defined in NumHask.Algebra.Ring

Methods

adj :: Word -> Word Source #

(Distributive a, Subtractive a) => InvolutiveRing (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

adj :: Complex a -> Complex a Source #

two :: (Multiplicative a, Additive a) => a Source #

Defining two requires adding the multiplicative unital to itself. In other words, the concept of two is a Ring one.

>>> two
2

Field

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

ExpField Float Source # 
Instance details

Defined in NumHask.Algebra.Field

(Ord a, TrigField a, ExpField a) => ExpField (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

(Ord a, TrigField a, ExpField a) => ExpField (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

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 #

QuotientField Float Source # 
Instance details

Defined in NumHask.Algebra.Field

Associated Types

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

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

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

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

TrigField Float Source # 
Instance details

Defined in NumHask.Algebra.Field

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 #

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

half :: Field a => a Source #

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

>>> half :: Double
0.5

Lattice

class Eq a => JoinSemiLattice a where Source #

A algebraic structure with element joins: See Semilattice

Associativity: x \/ (y \/ z) == (x \/ y) \/ z
Commutativity: x \/ y == y \/ x
Idempotency:   x \/ x == x

Methods

(\/) :: a -> a -> a infixr 5 Source #

Instances

Instances details
JoinSemiLattice Int16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Int16 -> Int16 -> Int16 Source #

JoinSemiLattice Int32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Int32 -> Int32 -> Int32 Source #

JoinSemiLattice Int64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Int64 -> Int64 -> Int64 Source #

JoinSemiLattice Int8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Int8 -> Int8 -> Int8 Source #

JoinSemiLattice Word16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Word16 -> Word16 -> Word16 Source #

JoinSemiLattice Word32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Word32 -> Word32 -> Word32 Source #

JoinSemiLattice Word64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Word64 -> Word64 -> Word64 Source #

JoinSemiLattice Word8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Word8 -> Word8 -> Word8 Source #

JoinSemiLattice Integer Source # 
Instance details

Defined in NumHask.Algebra.Lattice

JoinSemiLattice Natural Source # 
Instance details

Defined in NumHask.Algebra.Lattice

JoinSemiLattice Bool Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Bool -> Bool -> Bool Source #

JoinSemiLattice Double Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Double -> Double -> Double Source #

JoinSemiLattice Float Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Float -> Float -> Float Source #

JoinSemiLattice Int Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Int -> Int -> Int Source #

JoinSemiLattice Word Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(\/) :: Word -> Word -> Word Source #

JoinSemiLattice a => JoinSemiLattice (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

JoinSemiLattice a => JoinSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(\/) :: Complex a -> Complex a -> Complex a Source #

(Ord a, Integral a, EndoBased a, Subtractive a) => JoinSemiLattice (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(\/) :: Ratio a -> Ratio a -> Ratio a Source #

joinLeq :: JoinSemiLattice a => a -> a -> Bool Source #

The partial ordering induced by the join-semilattice structure

(<\) :: JoinSemiLattice a => a -> a -> Bool infixr 6 Source #

The partial ordering induced by the join-semilattice structure

class Eq a => MeetSemiLattice a where Source #

A algebraic structure with element meets: See Semilattice

Associativity: x /\ (y /\ z) == (x /\ y) /\ z
Commutativity: x /\ y == y /\ x
Idempotency:   x /\ x == x

Methods

(/\) :: a -> a -> a infixr 6 Source #

Instances

Instances details
MeetSemiLattice Int16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Int16 -> Int16 -> Int16 Source #

MeetSemiLattice Int32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Int32 -> Int32 -> Int32 Source #

MeetSemiLattice Int64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Int64 -> Int64 -> Int64 Source #

MeetSemiLattice Int8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Int8 -> Int8 -> Int8 Source #

MeetSemiLattice Word16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Word16 -> Word16 -> Word16 Source #

MeetSemiLattice Word32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Word32 -> Word32 -> Word32 Source #

MeetSemiLattice Word64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Word64 -> Word64 -> Word64 Source #

MeetSemiLattice Word8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Word8 -> Word8 -> Word8 Source #

MeetSemiLattice Integer Source # 
Instance details

Defined in NumHask.Algebra.Lattice

MeetSemiLattice Natural Source # 
Instance details

Defined in NumHask.Algebra.Lattice

MeetSemiLattice Bool Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Bool -> Bool -> Bool Source #

MeetSemiLattice Double Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Double -> Double -> Double Source #

MeetSemiLattice Float Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Float -> Float -> Float Source #

MeetSemiLattice Int Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Int -> Int -> Int Source #

MeetSemiLattice Word Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

(/\) :: Word -> Word -> Word Source #

MeetSemiLattice a => MeetSemiLattice (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

MeetSemiLattice a => MeetSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(/\) :: Complex a -> Complex a -> Complex a Source #

(Ord a, Integral a, EndoBased a, Subtractive a) => MeetSemiLattice (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(/\) :: Ratio a -> Ratio a -> Ratio a Source #

meetLeq :: MeetSemiLattice a => a -> a -> Bool Source #

The partial ordering induced by the meet-semilattice structure

(</) :: MeetSemiLattice a => a -> a -> Bool infixr 6 Source #

The partial ordering induced by the meet-semilattice structure

class JoinSemiLattice a => BoundedJoinSemiLattice a where Source #

A join-semilattice with an identity element bottom for \/.

Identity: x \/ bottom == x

Methods

bottom :: a Source #

Instances

Instances details
BoundedJoinSemiLattice Int16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Int16 Source #

BoundedJoinSemiLattice Int32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Int32 Source #

BoundedJoinSemiLattice Int64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Int64 Source #

BoundedJoinSemiLattice Int8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Int8 Source #

BoundedJoinSemiLattice Word16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Word16 Source #

BoundedJoinSemiLattice Word32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Word32 Source #

BoundedJoinSemiLattice Word64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Word64 Source #

BoundedJoinSemiLattice Word8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Word8 Source #

BoundedJoinSemiLattice Natural Source # 
Instance details

Defined in NumHask.Algebra.Lattice

BoundedJoinSemiLattice Bool Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Bool Source #

BoundedJoinSemiLattice Double Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Double Source #

BoundedJoinSemiLattice Float Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Float Source #

BoundedJoinSemiLattice Int Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Int Source #

BoundedJoinSemiLattice Word Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

bottom :: Word Source #

BoundedJoinSemiLattice a => BoundedJoinSemiLattice (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

BoundedJoinSemiLattice a => BoundedJoinSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

bottom :: Complex a Source #

class MeetSemiLattice a => BoundedMeetSemiLattice a where Source #

A meet-semilattice with an identity element top for /\.

Identity: x /\ top == x

Methods

top :: a Source #

Instances

Instances details
BoundedMeetSemiLattice Int16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Int16 Source #

BoundedMeetSemiLattice Int32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Int32 Source #

BoundedMeetSemiLattice Int64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Int64 Source #

BoundedMeetSemiLattice Int8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Int8 Source #

BoundedMeetSemiLattice Word16 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Word16 Source #

BoundedMeetSemiLattice Word32 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Word32 Source #

BoundedMeetSemiLattice Word64 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Word64 Source #

BoundedMeetSemiLattice Word8 Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Word8 Source #

BoundedMeetSemiLattice Bool Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Bool Source #

BoundedMeetSemiLattice Double Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Double Source #

BoundedMeetSemiLattice Float Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Float Source #

BoundedMeetSemiLattice Int Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Int Source #

BoundedMeetSemiLattice Word Source # 
Instance details

Defined in NumHask.Algebra.Lattice

Methods

top :: Word Source #

BoundedMeetSemiLattice a => BoundedMeetSemiLattice (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

top :: Complex a Source #

Action

class Additive (AdditiveScalar m) => AdditiveAction m where Source #

Additive Action

m |+ zero == m

Associated Types

type AdditiveScalar m :: Type Source #

Methods

(|+) :: m -> AdditiveScalar m -> m infixl 6 Source #

(+|) :: AdditiveAction m => AdditiveScalar m -> m -> m infixl 6 Source #

flipped additive action

(+|) == flip (|+)
zero +| m = m

class (AdditiveAction m, Subtractive (AdditiveScalar m)) => SubtractiveAction m where Source #

Subtractive Action

m |- zero = m

Methods

(|-) :: m -> AdditiveScalar m -> m infixl 6 Source #

(-|) :: (AdditiveAction m, Subtractive m) => AdditiveScalar m -> m -> m infixl 6 Source #

Subtraction with the scalar on the left

(-|) == (+|) . negate
zero -| m = negate m

class Multiplicative (Scalar m) => MultiplicativeAction m where Source #

Multiplicative Action

m |* one = m
m |* zero = zero

Associated Types

type Scalar m :: Type Source #

Methods

(|*) :: m -> Scalar m -> m infixl 7 Source #

Instances

Instances details
Multiplicative a => MultiplicativeAction (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Scalar (EuclideanPair a) Source #

(*|) :: MultiplicativeAction m => Scalar m -> m -> m infixl 7 Source #

flipped multiplicative action

(*|) == flip (|*)
one *| m = one
zero *| m = zero

class (Divisive (Scalar m), MultiplicativeAction m) => DivisiveAction m where Source #

Divisive Action

m |/ one = m

Methods

(|/) :: m -> Scalar m -> m infixl 7 Source #

Instances

Instances details
Divisive a => DivisiveAction (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

(/|) :: (MultiplicativeAction m, Divisive m) => Scalar m -> m -> m Source #

left scalar division

(/|) == (*|) . recip
one |/ m = recip m

type Module m = (Distributive (Scalar m), MultiplicativeAction m) Source #

A Module

a *| one == a
(a + b) *| c == (a *| c) + (b *| c)
c |* (a + b) == (c |* a) + (c |* b)
a *| zero == zero
a *| b == b |* a

Metric

class Distributive (Mag a) => Basis a where Source #

Basis encapsulates the notion of magnitude (intuitively the quotienting of a higher-kinded number to a scalar one) and the basis on which the magnitude quotienting was performed. An instance needs to satisfy these laws:

\a -> magnitude a >= zero
\a -> magnitude zero == zero
\a -> a == magnitude a *| basis a
\a -> magnitude (basis a) == one

The names chosen are meant to represent the spiritual idea of a basis rather than a specific mathematics. See https://en.wikipedia.org/wiki/Basis_(linear_algebra) & https://en.wikipedia.org/wiki/Norm_(mathematics) for some mathematical motivations.

>>> magnitude (-0.5 :: Double)
0.5
>>> basis (-0.5 :: Double)
-1.0

Associated Types

type Mag a :: Type Source #

type Base a :: Type Source #

Methods

magnitude :: a -> Mag a Source #

or length, or ||v||

basis :: a -> Base a Source #

or direction, or v-hat

Instances

Instances details
Basis Int16 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int16 Source #

type Base Int16 Source #

Basis Int32 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int32 Source #

type Base Int32 Source #

Basis Int64 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int64 Source #

type Base Int64 Source #

Basis Int8 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int8 Source #

type Base Int8 Source #

Basis Word16 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word16 Source #

type Base Word16 Source #

Basis Word32 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word32 Source #

type Base Word32 Source #

Basis Word64 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word64 Source #

type Base Word64 Source #

Basis Word8 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word8 Source #

type Base Word8 Source #

Basis Integer Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Integer Source #

type Base Integer Source #

Basis Natural Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Natural Source #

type Base Natural Source #

Basis Double Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Double Source #

type Base Double Source #

Basis Float Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Float Source #

type Base Float Source #

Basis Int Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Int Source #

type Base Int Source #

Basis Word Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag Word Source #

type Base Word Source #

(ExpField a, Eq a) => Basis (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (EuclideanPair a) Source #

type Base (EuclideanPair a) Source #

(Additive a, Multiplicative a) => Basis (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (Polar a) Source #

type Base (Polar a) Source #

Methods

magnitude :: Polar a -> Mag (Polar a) Source #

basis :: Polar a -> Base (Polar a) Source #

(ExpField a, Eq a) => Basis (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Associated Types

type Mag (Complex a) Source #

type Base (Complex a) Source #

(Ord a, EndoBased a, Integral a, Ring a) => Basis (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Associated Types

type Mag (Ratio a) Source #

type Base (Ratio a) Source #

Methods

magnitude :: Ratio a -> Mag (Ratio a) Source #

basis :: Ratio a -> Base (Ratio a) Source #

type Absolute a = (Basis a, Mag a ~ a) Source #

Basis where the domain and magnitude codomain are the same.

type Sign a = (Basis a, Base a ~ a) Source #

Basis where the domain and basis codomain are the same.

type EndoBased a = (Basis a, Mag a ~ a, Base a ~ a) Source #

Basis where the domain, magnitude codomain and basis codomain are the same.

abs :: Absolute a => a -> a Source #

The absolute value of a number.

\a -> abs a * signum a ~= a
>>> abs (-1)
1

signum :: Sign a => a -> a Source #

The sign of a number.

>>> signum (-1)
-1

abs zero == zero, so any value for signum zero is ok. We choose lawful neutral:

>>> signum zero == zero
True

distance :: (Basis a, Subtractive a) => a -> a -> Mag a Source #

Distance, which combines the Subtractive notion of difference, with Basis.

distance a b >= zero
distance a a == zero
distance a b *| basis (a - b) == a - b

class (Distributive coord, Distributive (Dir coord)) => Direction coord where Source #

Convert between a "co-ordinated" or "higher-kinded" number and a direction.

ray . angle == basis
magnitude (ray x) == one

Associated Types

type Dir coord :: Type Source #

Methods

angle :: coord -> Dir coord Source #

ray :: Dir coord -> coord Source #

Instances

Instances details
TrigField a => Direction (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Dir (EuclideanPair a) Source #

TrigField a => Direction (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Associated Types

type Dir (Complex a) Source #

Methods

angle :: Complex a -> Dir (Complex a) Source #

ray :: Dir (Complex a) -> Complex a Source #

data Polar a Source #

Something that has a magnitude and a direction, with both expressed as the same type.

See Polar coordinate system

Constructors

Polar 

Fields

Instances

Instances details
Generic (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Rep (Polar a) :: Type -> Type #

Methods

from :: Polar a -> Rep (Polar a) x #

to :: Rep (Polar a) x -> Polar a #

Show a => Show (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

showsPrec :: Int -> Polar a -> ShowS #

show :: Polar a -> String #

showList :: [Polar a] -> ShowS #

Eq a => Eq (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

(==) :: Polar a -> Polar a -> Bool #

(/=) :: Polar a -> Polar a -> Bool #

(Additive a, Multiplicative a) => Basis (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Associated Types

type Mag (Polar a) Source #

type Base (Polar a) Source #

Methods

magnitude :: Polar a -> Mag (Polar a) Source #

basis :: Polar a -> Base (Polar a) Source #

type Rep (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

type Rep (Polar a) = D1 ('MetaData "Polar" "NumHask.Algebra.Metric" "numhask-0.11.1.0-EApRBSOlfGg2K23zs0vJ5I" 'False) (C1 ('MetaCons "Polar" 'PrefixI 'True) (S1 ('MetaSel ('Just "radial") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a) :*: S1 ('MetaSel ('Just "azimuth") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 a)))
type Base (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

type Base (Polar a) = a
type Mag (Polar a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

type Mag (Polar a) = a

polar :: (Dir (Base a) ~ Mag a, Basis a, Direction (Base a)) => a -> Polar (Mag a) Source #

Convert a higher-kinded number that has direction, to a Polar

coord :: (Scalar m ~ Dir m, MultiplicativeAction m, Direction m) => Polar (Scalar m) -> m Source #

Convert a Polar to a (higher-kinded) number that has a direction.

class (Eq a, Additive a) => Epsilon a where Source #

A small number, especially useful for approximate equality.

Minimal complete definition

Nothing

Methods

epsilon :: a Source #

Instances

Instances details
Epsilon Int16 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Int16 Source #

Epsilon Int32 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Int32 Source #

Epsilon Int64 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Int64 Source #

Epsilon Int8 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Int8 Source #

Epsilon Word16 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Epsilon Word32 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Epsilon Word64 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Epsilon Word8 Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Word8 Source #

Epsilon Integer Source # 
Instance details

Defined in NumHask.Algebra.Metric

Epsilon Double Source #

1e-14

Instance details

Defined in NumHask.Algebra.Metric

Epsilon Float Source #

1e-6

Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Float Source #

Epsilon Int Source #

0

Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Int Source #

Epsilon Word Source # 
Instance details

Defined in NumHask.Algebra.Metric

Methods

epsilon :: Word Source #

Epsilon a => Epsilon (EuclideanPair a) Source # 
Instance details

Defined in NumHask.Algebra.Metric

Epsilon a => Epsilon (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

epsilon :: Complex a Source #

(Ord a, EndoBased a, Integral a, Ring a, MeetSemiLattice a) => Epsilon (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

epsilon :: Ratio a Source #

aboutEqual :: (Epsilon a, Lattice a, Subtractive a) => a -> a -> Bool Source #

Approximate equality

>>> aboutEqual zero (epsilon :: Double)
True

nearZero :: (Epsilon a, Lattice a, Subtractive a) => a -> Bool Source #

Note that the constraint is Lattice rather than Ord allowing broader usage.

>>> nearZero (epsilon :: Double)
True
>>> nearZero (epsilon :: EuclideanPair Double)
True

(~=) :: Epsilon a => (Lattice a, Subtractive a) => a -> a -> Bool infixl 4 Source #

About equal operator.

>>> (1.0 + epsilon) ~= (1.0 :: Double)
True

Complex

newtype Complex a Source #

The underlying representation is a newtype-wrapped tuple, compared with the base datatype. This was chosen to facilitate the use of DerivingVia.

Constructors

Complex 

Fields

Instances

Instances details
Functor Complex Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

fmap :: (a -> b) -> Complex a -> Complex b #

(<$) :: a -> Complex b -> Complex a #

Data a => Data (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Complex a -> c (Complex a) #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (Complex a) #

toConstr :: Complex a -> Constr #

dataTypeOf :: Complex a -> DataType #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (Complex a)) #

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (Complex a)) #

gmapT :: (forall b. Data b => b -> b) -> Complex a -> Complex a #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Complex a -> r #

gmapQ :: (forall d. Data d => d -> u) -> Complex a -> [u] #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Complex a -> u #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Complex a -> m (Complex a) #

Generic (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Associated Types

type Rep (Complex a) :: Type -> Type #

Methods

from :: Complex a -> Rep (Complex a) x #

to :: Rep (Complex a) x -> Complex a #

Read a => Read (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Show a => Show (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

showsPrec :: Int -> Complex a -> ShowS #

show :: Complex a -> String #

showList :: [Complex a] -> ShowS #

Eq a => Eq (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(==) :: Complex a -> Complex a -> Bool #

(/=) :: Complex a -> Complex a -> Bool #

Additive a => Additive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(+) :: Complex a -> Complex a -> Complex a Source #

zero :: Complex a Source #

Subtractive a => Subtractive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

negate :: Complex a -> Complex a Source #

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

(Ord a, TrigField a, ExpField a) => ExpField (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

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

BoundedJoinSemiLattice a => BoundedJoinSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

bottom :: Complex a Source #

BoundedMeetSemiLattice a => BoundedMeetSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

top :: Complex a Source #

JoinSemiLattice a => JoinSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(\/) :: Complex a -> Complex a -> Complex a Source #

MeetSemiLattice a => MeetSemiLattice (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

(/\) :: Complex a -> Complex a -> Complex a Source #

(ExpField a, Eq a) => Basis (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Associated Types

type Mag (Complex a) Source #

type Base (Complex a) Source #

TrigField a => Direction (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Associated Types

type Dir (Complex a) Source #

Methods

angle :: Complex a -> Dir (Complex a) Source #

ray :: Dir (Complex a) -> Complex a Source #

Epsilon a => Epsilon (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

epsilon :: Complex a Source #

(Subtractive a, Divisive a) => Divisive (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

recip :: Complex a -> Complex a Source #

(/) :: Complex a -> Complex a -> Complex a Source #

(Subtractive a, Multiplicative a) => Multiplicative (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

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

one :: Complex a Source #

(Distributive a, Subtractive a) => InvolutiveRing (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

adj :: Complex a -> Complex a Source #

(Additive a, FromIntegral a b) => FromIntegral (Complex a) b Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

fromIntegral :: b -> Complex a Source #

type Rep (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

type Rep (Complex a) = D1 ('MetaData "Complex" "NumHask.Data.Complex" "numhask-0.11.1.0-EApRBSOlfGg2K23zs0vJ5I" 'True) (C1 ('MetaCons "Complex" 'PrefixI 'True) (S1 ('MetaSel ('Just "complexPair") 'NoSourceUnpackedness 'NoSourceStrictness 'DecidedLazy) (Rec0 (a, a))))
type Whole (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

type Whole (Complex a) = Complex (Whole a)
type Base (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

type Dir (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

type Dir (Complex a) = Dir (EuclideanPair a)
type Mag (Complex a) Source # 
Instance details

Defined in NumHask.Data.Complex

type Mag (Complex a) = Mag (EuclideanPair a)

(+:) :: a -> a -> Complex a infixl 6 Source #

Complex number constructor.

realPart :: Complex a -> a Source #

Extracts the real part of a complex number.

imagPart :: Complex a -> a Source #

Extracts the imaginary part of a complex number.

Integral

class Distributive a => Integral a where Source #

An Integral is anything that satisfies the law:

\a b -> b == zero || b * (a `div` b) + (a `mod` b) == a
>>> 3 `divMod` 2
(1,1)
>>> (-3) `divMod` 2
(-2,1)
>>> (-3) `quotRem` 2
(-1,-1)

Minimal complete definition

divMod, quotRem

Methods

div :: a -> a -> a infixl 7 Source #

mod :: a -> a -> a infixl 7 Source #

divMod :: a -> a -> (a, a) Source #

quot :: a -> a -> a Source #

rem :: a -> a -> a Source #

quotRem :: a -> a -> (a, a) Source #

Instances

Instances details
Integral Int16 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Int32 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Int64 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Int8 Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

div :: Int8 -> Int8 -> Int8 Source #

mod :: Int8 -> Int8 -> Int8 Source #

divMod :: Int8 -> Int8 -> (Int8, Int8) Source #

quot :: Int8 -> Int8 -> Int8 Source #

rem :: Int8 -> Int8 -> Int8 Source #

quotRem :: Int8 -> Int8 -> (Int8, Int8) Source #

Integral Word16 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Word32 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Word64 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Word8 Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Integer Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Natural Source # 
Instance details

Defined in NumHask.Data.Integral

Integral Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

div :: Int -> Int -> Int Source #

mod :: Int -> Int -> Int Source #

divMod :: Int -> Int -> (Int, Int) Source #

quot :: Int -> Int -> Int Source #

rem :: Int -> Int -> Int Source #

quotRem :: Int -> Int -> (Int, Int) Source #

Integral Word Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

div :: Word -> Word -> Word Source #

mod :: Word -> Word -> Word Source #

divMod :: Word -> Word -> (Word, Word) Source #

quot :: Word -> Word -> Word Source #

rem :: Word -> Word -> Word Source #

quotRem :: Word -> Word -> (Word, Word) Source #

Integral b => Integral (a -> b) Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

div :: (a -> b) -> (a -> b) -> a -> b Source #

mod :: (a -> b) -> (a -> b) -> a -> b Source #

divMod :: (a -> b) -> (a -> b) -> (a -> b, a -> b) Source #

quot :: (a -> b) -> (a -> b) -> a -> b Source #

rem :: (a -> b) -> (a -> b) -> a -> b Source #

quotRem :: (a -> b) -> (a -> b) -> (a -> b, a -> b) Source #

class ToIntegral a b where Source #

toIntegral is kept separate from Integral to help with compatability issues.

toIntegral a == a

Methods

toIntegral :: a -> b Source #

Instances

Instances details
ToIntegral Int16 Int16 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int16 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int16 Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int16 -> Int Source #

ToIntegral Int32 Int32 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int32 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int32 Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int32 -> Int Source #

ToIntegral Int64 Int64 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int64 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int64 Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int64 -> Int Source #

ToIntegral Int8 Int8 Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int8 -> Int8 Source #

ToIntegral Int8 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int8 Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int8 -> Int Source #

ToIntegral Word16 Word16 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word16 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word16 Int Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word32 Word32 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word32 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word32 Int Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word64 Word64 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word64 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word64 Int Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word8 Word8 Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word8 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word8 Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Word8 -> Int Source #

ToIntegral Integer Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Integer Int Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Natural Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Natural Natural Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Natural Int Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Int Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Int -> Int Source #

ToIntegral Word Integer Source # 
Instance details

Defined in NumHask.Data.Integral

ToIntegral Word Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Word -> Int Source #

ToIntegral Word Word Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

toIntegral :: Word -> Word Source #

type ToInt a = ToIntegral a Int Source #

Convert to an Int

class FromIntegral a b where Source #

Polymorphic version of fromInteger

fromIntegral a == a

Methods

fromIntegral :: b -> a Source #

Instances

Instances details
FromIntegral Int16 Int16 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int16 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int16 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int32 Int32 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int32 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int32 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int64 Int64 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int64 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int64 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int8 Int8 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int8 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int8 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word16 Word16 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word16 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word16 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word32 Word32 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word32 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word32 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word64 Word64 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word64 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word64 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word8 Word8 Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word8 Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word8 Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Integer Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Integer Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Natural Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Natural Natural Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Natural Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Double Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Double Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Float Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Float Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Int Int Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

fromIntegral :: Int -> Int Source #

FromIntegral Word Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromIntegral Word Word Source # 
Instance details

Defined in NumHask.Data.Integral

(Additive a, FromIntegral a b) => FromIntegral (Complex a) b Source # 
Instance details

Defined in NumHask.Data.Complex

Methods

fromIntegral :: b -> Complex a Source #

(FromIntegral a b, Multiplicative a) => FromIntegral (Ratio a) b Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

fromIntegral :: b -> Ratio a Source #

FromIntegral a b => FromIntegral (c -> a) b Source # 
Instance details

Defined in NumHask.Data.Integral

Methods

fromIntegral :: b -> c -> a Source #

class FromInteger a where Source #

fromInteger is special in two ways:

  • numeric integral literals (like "42") are interpreted specifically as "fromInteger (42 :: GHC.Num.Integer)". The prelude version is used as default (or whatever fromInteger is in scope if RebindableSyntax is set).
  • The default rules in haskell2010 specify that constraints on fromInteger need to be in a form C v, where v is a Num or a subclass of Num.

So a type synonym such as type FromInteger a = FromIntegral a Integer doesn't work well with type defaulting; hence the need for a separate class.

Methods

fromInteger :: Integer -> a Source #

Instances

Instances details
FromInteger Int16 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Int32 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Int64 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Int8 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Word16 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Word32 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Word64 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Word8 Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Integer Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Natural Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Double Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Float Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Int Source # 
Instance details

Defined in NumHask.Data.Integral

FromInteger Word Source # 
Instance details

Defined in NumHask.Data.Integral

type FromInt a = FromIntegral a Int Source #

Convert from an Int

even :: (Eq a, Integral a) => a -> Bool Source #

>>> even 2
True

odd :: (Eq a, Integral a) => a -> Bool Source #

>>> odd 3
True

(^^) :: (Ord b, Divisive a, Subtractive b, Integral b) => a -> b -> a infixr 8 Source #

raise a number to an Integral power

>>> 2 ^^ 3
8.0
>>> 2 ^^ (-2)
0.25

(^) :: Divisive a => a -> Int -> a infixr 8 Source #

raise a number to an Int power

Note: This differs from (^) found in prelude which is a partial function (it errors on negative integrals). This is a monomorphic version of (^^) provided to help reduce ambiguous type noise in common usages.

>>> 2 ^ 3
8.0
>>> 2 ^ (-2)
0.25

Rational

data Ratio a Source #

A rational number

Constructors

!a :% !a 

Instances

Instances details
Show a => Show (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

showsPrec :: Int -> Ratio a -> ShowS #

show :: Ratio a -> String #

showList :: [Ratio a] -> ShowS #

(Eq a, Subtractive a, EndoBased a, Absolute a, Integral a) => Eq (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(==) :: Ratio a -> Ratio a -> Bool #

(/=) :: Ratio a -> Ratio a -> Bool #

(Ord a, Integral a, EndoBased a, Subtractive a) => Ord (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

compare :: Ratio a -> Ratio a -> Ordering #

(<) :: Ratio a -> Ratio a -> Bool #

(<=) :: Ratio a -> Ratio a -> Bool #

(>) :: Ratio a -> Ratio a -> Bool #

(>=) :: Ratio a -> Ratio a -> Bool #

max :: Ratio a -> Ratio a -> Ratio a #

min :: Ratio a -> Ratio a -> Ratio a #

(Ord a, EndoBased a, Integral a, Ring a) => Additive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(+) :: Ratio a -> Ratio a -> Ratio a Source #

zero :: Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Subtractive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

negate :: Ratio a -> Ratio a Source #

(-) :: Ratio a -> Ratio a -> Ratio 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 #

(Ord a, Integral a, EndoBased a, Subtractive a) => JoinSemiLattice (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(\/) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, Integral a, EndoBased a, Subtractive a) => MeetSemiLattice (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

(/\) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Basis (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Associated Types

type Mag (Ratio a) Source #

type Base (Ratio a) Source #

Methods

magnitude :: Ratio a -> Mag (Ratio a) Source #

basis :: Ratio a -> Base (Ratio a) Source #

(Ord a, EndoBased a, Integral a, Ring a, MeetSemiLattice a) => Epsilon (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

epsilon :: Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Divisive (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

recip :: Ratio a -> Ratio a Source #

(/) :: Ratio a -> Ratio a -> Ratio a Source #

(Ord a, EndoBased a, Integral a, Ring a) => Multiplicative (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

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

one :: Ratio a Source #

FromRational (Ratio Integer) Source # 
Instance details

Defined in NumHask.Data.Rational

(FromIntegral a b, Multiplicative a) => FromIntegral (Ratio a) b Source # 
Instance details

Defined in NumHask.Data.Rational

Methods

fromIntegral :: b -> Ratio a Source #

ToRatio (Ratio Integer) Integer Source # 
Instance details

Defined in NumHask.Data.Rational

type Whole (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

type Whole (Ratio a) = Int
type Base (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

type Base (Ratio a) = Ratio a
type Mag (Ratio a) Source # 
Instance details

Defined in NumHask.Data.Rational

type Mag (Ratio a) = Ratio a

type Rational = Ratio Integer #

Arbitrary-precision rational numbers, represented as a ratio of two Integer values. A rational number may be constructed using the % operator.

class ToRatio a b where Source #

toRatio is equivalent to Real in base, but is polymorphic in the Integral type.

>>> toRatio (3.1415927 :: Float) :: Ratio Integer
13176795 :% 4194304

Methods

toRatio :: a -> Ratio b Source #

Instances

Instances details
ToRatio Int16 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Int32 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Int64 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Int8 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Rational Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Word16 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Word32 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Word64 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Word8 Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Integer Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Natural Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Double Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Float Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Int Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio Word Integer Source # 
Instance details

Defined in NumHask.Data.Rational

ToRatio (Ratio Integer) Integer Source # 
Instance details

Defined in NumHask.Data.Rational

class FromRatio a b where Source #

Fractional in base splits into fromRatio and Field

>>> fromRatio (5 :% 2 :: Ratio Integer) :: Double
2.5

Methods

fromRatio :: Ratio b -> a Source #

Instances

Instances details
FromRatio Rational Integer Source # 
Instance details

Defined in NumHask.Data.Rational

FromRatio Double Integer Source # 
Instance details

Defined in NumHask.Data.Rational

FromRatio Float Integer Source # 
Instance details

Defined in NumHask.Data.Rational

class FromRational a where Source #

fromRational is special in two ways:

  • numeric decimal literals (like "53.66") are interpreted as exactly "fromRational (53.66 :: GHC.Real.Ratio Integer)". The prelude version, GHC.Real.fromRational is used as default (or whatever is in scope if RebindableSyntax is set).
  • The default rules in haskell2010 specify that contraints on fromRational need to be in a form C v, where v is a Num or a subclass of Num.

So a type synonym of `type FromRational a = FromRatio a Integer` doesn't work well with type defaulting; hence the need for a separate class.

Methods

fromRational :: Rational -> a Source #

Instances

Instances details
FromRational Double Source # 
Instance details

Defined in NumHask.Data.Rational

FromRational Float Source # 
Instance details

Defined in NumHask.Data.Rational

FromRational (Ratio Integer) Source # 
Instance details

Defined in NumHask.Data.Rational

reduce :: (Eq a, Subtractive a, EndoBased a, Integral a) => a -> a -> Ratio a Source #

reduce normalises a ratio by dividing both numerator and denominator by their greatest common divisor.

>>> reduce 72 60
6 :% 5
\a b -> reduce a b == a :% b || b == zero

gcd :: (Eq a, EndoBased a, Integral a) => a -> a -> a Source #

gcd x y is the non-negative factor of both x and y of which every common factor of x and y is also a factor; for example gcd 4 2 = 2, gcd (-4) 6 = 2, gcd 0 4 = 4. gcd 0 0 = 0. (That is, the common divisor that is "greatest" in the divisibility preordering.)

Note: Since for signed fixed-width integer types, abs minBound < 0, the result may be negative if one of the arguments is minBound (and necessarily is if the other is 0 or minBound) for such types.

>>> gcd 72 60
12

Exceptions

throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a #

Throw an exception. Exceptions may be thrown from purely functional code, but may only be caught within the IO monad.