License | BSD-style |
---|---|
Maintainer | Vincent Hanquez <vincent@snarc.org> |
Stability | experimental |
Portability | portable |
Safe Haskell | None |
Language | Haskell2010 |
Foundation.Numerical
Description
Compared to the Haskell hierarchy of number classes this provide a more flexible approach that is closer to the mathematical foundation (group, field, etc)
This try to only provide one feature per class, at the expense of the number of classes.
- class (Enum a, Eq a, Ord a, Integral a) => IsIntegral a where
- class (Enum a, Eq a, Ord a, Integral a, IsIntegral a) => IsNatural a where
- class Signed a where
- class Additive a where
- class Subtractive a where
- type Difference a
- (-) :: a -> a -> Difference a
- class Multiplicative a where
- midentity :: a
- (*) :: a -> a -> a
- (^) :: (IsNatural n, IDivisible n) => a -> n -> a
- class (Additive a, Multiplicative a) => IDivisible a where
- class Multiplicative a => Divisible a where
- (/) :: a -> a -> a
- data Sign
- recip :: Divisible a => a -> a
- class IntegralRounding a where
- roundUp :: Integral n => a -> n
- roundDown :: Integral n => a -> n
- roundTruncate :: Integral n => a -> n
- roundNearest :: Integral n => a -> n
- class FloatingPoint a where
- floatRadix :: Proxy a -> Integer
- floatDigits :: Proxy a -> Int
- floatRange :: Proxy a -> (Int, Int)
- floatDecode :: a -> (Integer, Int)
- floatEncode :: Integer -> Int -> a
Documentation
class (Enum a, Eq a, Ord a, Integral a) => IsIntegral a where
Number literals, convertible through the generic Integer type.
all number are Enum'erable, meaning that you can move to next element
class (Enum a, Eq a, Ord a, Integral a, IsIntegral a) => IsNatural a where
Non Negative Number literals, convertible through the generic Natural type
class Signed a where
types that have sign and can be made absolute
class Additive a where
Represent class of things that can be added together, contains a neutral element and is commutative.
x + azero = x azero + x = x x + y = y + x
Instances
class Subtractive a where
Represent class of things that can be subtracted.
Note that the result is not necessary of the same type as the operand depending on the actual type.
For example:
(-) :: Int -> Int -> Int (-) :: DateTime -> DateTime -> Seconds (-) :: Ptr a -> Ptr a -> PtrDiff (-) :: Natural -> Natural -> Maybe Natural
Associated Types
type Difference a
Methods
(-) :: a -> a -> Difference a infixl 6
Instances
class Multiplicative a where
Represent class of things that can be multiplied together
x * midentity = x midentity * x = x
Methods
midentity :: a
Identity element over multiplication
(*) :: a -> a -> a infixl 7
Multiplication of 2 elements that result in another element
(^) :: (IsNatural n, IDivisible n) => a -> n -> a infixr 8
Raise to power, repeated multiplication e.g. > a ^ 2 = a * a > a ^ 10 = (a ^ 5) * (a ^ 5) .. (^) :: (IsNatural n) => a -> n -> a
Instances
class (Additive a, Multiplicative a) => IDivisible a where
Represent types that supports an euclidian division
(x ‘div‘ y) * y + (x ‘mod‘ y) == x
class Multiplicative a => Divisible a where
Support for division between same types
This is likely to change to represent specific mathematic divisions
Methods
(/) :: a -> a -> a infixl 7
class IntegralRounding a where
Methods
roundUp :: Integral n => a -> n
Round up, to the next integral.
Also known as ceiling
roundDown :: Integral n => a -> n
Round down, to the previous integral
Also known as floor
roundTruncate :: Integral n => a -> n
Truncate to the closest integral to the fractional number closer to 0.
This is equivalent to roundUp for negative Number and roundDown for positive Number
roundNearest :: Integral n => a -> n
Round to the nearest integral
roundNearest 3.6
4 > roundNearest 3.4 3
class FloatingPoint a where
IEEE754 Floating Point
Methods
floatRadix :: Proxy a -> Integer
floatDigits :: Proxy a -> Int
floatRange :: Proxy a -> (Int, Int)
floatDecode :: a -> (Integer, Int)
floatEncode :: Integer -> Int -> a
Instances