| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
NumHask
Description
Numeric classes.
Synopsis
- class Additive a => Subtractive a where
- class Additive a where
- sum :: (Additive a, Foldable f) => f a -> a
- class Multiplicative a => Divisive a where
- class Multiplicative a where
- product :: (Multiplicative a, Foldable f) => f a -> a
- class Distributive a => InvolutiveRing a where
- adj :: a -> a
- class (StarSemiring a, Idempotent a) => KleeneAlgebra a
- class Distributive a => StarSemiring a where
- class (Distributive a, Subtractive a) => Ring a
- class (Additive a, Multiplicative a) => Distributive a
- two :: (Multiplicative a, Additive a) => a
- class Field a => TrigField a where
- class (Subtractive a, Field a) => LowerBoundedField a where
- negInfinity :: a
- class Field a => UpperBoundedField a where
- class (Field a, Multiplicative b, Additive b) => QuotientField a b where
- properFraction :: a -> (b, a)
- round :: a -> b
- ceiling :: a -> b
- floor :: a -> b
- truncate :: a -> b
- class Field a => ExpField a where
- class (Distributive a, Subtractive a, Divisive a) => Field a
- half :: Field a => a
- class MeetSemiLattice a => BoundedMeetSemiLattice a where
- top :: a
- class JoinSemiLattice a => BoundedJoinSemiLattice a where
- bottom :: a
- class Eq a => MeetSemiLattice a where
- (/\) :: a -> a -> a
- class Eq a => JoinSemiLattice a where
- (\/) :: a -> a -> a
- joinLeq :: JoinSemiLattice a => a -> a -> Bool
- meetLeq :: MeetSemiLattice a => a -> a -> Bool
- class (Distributive a, MultiplicativeAction m a) => Module m a
- class Divisive a => DivisiveAction m a | m -> a where
- class Multiplicative a => MultiplicativeAction m a | m -> a where
- class Subtractive a => SubtractiveAction m a | m -> a where
- class Additive a => AdditiveAction m a | m -> a where
- class (Eq a, Additive a, Subtractive a, MeetSemiLattice a) => Epsilon a where
- epsilon :: a
- nearZero :: a -> Bool
- aboutEqual :: a -> a -> Bool
- data Polar mag dir = Polar {}
- class (Additive coord, Multiplicative coord, Additive dir, Multiplicative dir) => Direction coord dir | coord -> dir where
- class (Additive a, Multiplicative b, Additive b) => Norm a b | a -> b where
- class (Additive a, Multiplicative a) => Signed a where
- distance :: (Norm a b, Subtractive a) => a -> a -> b
- polar :: (Norm coord mag, Direction coord dir) => coord -> Polar mag dir
- coord :: (MultiplicativeAction coord mag, Direction coord dir) => Polar mag dir -> coord
- (~=) :: Epsilon a => a -> a -> Bool
- class (Associative a, Unital a, Invertible a, Commutative a) => AbelianGroup a
- class Magma a => Idempotent a
- class Magma a => Absorbing a where
- absorb :: a
- class (Associative a, Unital a, Invertible a) => Group a
- class Magma a => Invertible a where
- inv :: a -> a
- class Magma a => Commutative a
- class Magma a => Associative a
- class Magma a => Unital a where
- unit :: a
- class Magma a where
- (⊕) :: a -> a -> a
- data Complex a = !a :+ !a
- realPart :: Complex a -> a
- imagPart :: Complex a -> a
- class FromInteger a where
- fromInteger :: Integer -> a
- class FromIntegral a b where
- fromIntegral :: b -> a
- class ToIntegral a b where
- toIntegral :: a -> b
- class Distributive a => Integral a where
- even :: (Eq a, Integral a) => a -> Bool
- odd :: (Eq a, Integral a) => a -> Bool
- (^^) :: (Ord b, Divisive a, Subtractive b, Integral b) => a -> b -> a
- (^) :: Divisive a => a -> Int -> a
- type Rational = Ratio Integer
- class FromRational a where
- fromRational :: Rational -> a
- class FromRatio a b where
- class ToRatio a b where
- data Ratio a = !a :% !a
- reduce :: (Eq a, Subtractive a, Signed a, Integral a) => a -> a -> Ratio a
- gcd :: (Eq a, Signed a, Integral a) => a -> a -> a
- throw :: forall (r :: RuntimeRep) (a :: TYPE r) e. Exception e => e -> a
- newtype NumHaskException = NumHaskException {}
Usage
>>>:set -XRebindableSyntax>>>import NumHask.Prelude>>>1+12
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 heirarchy begins with addition and multiplication,
choosing not to build from a
Magmabase. 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 most cases, a class exists to define useful operators.
The exceptions are
Distributive,RingandField, which are collections of operators representing major teleological fault lines. - lawful. Most 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,Floatand 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:
If the base started with magma, and the library tolerated clashing with Semigroup
and Monoid in base, it would look like:
These first two levels, contained in Group are moral super-classes.
Prelude Mappings
Num is a very old part of haskell, and is virtually unchanged since it's 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 heirarchy.
-- | 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
abs is a function in the Signed class.
The concept of an absolute value can also include situations where the domain and codomain
are different, and norm as a function in the Norm class is supplied
for these cases.
sign replaces signum, because signum is simply a naming crime.
basis can also be seen as a generalisation of sign.
-- | 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 -> aFromInteger becomes its own class and FromIntegral is introduced to polymorphise the covariant.
Mappings from other areas of prelude include:\
Integral becomes Integral and a polymorphic ToIntegral is introduced.
Fractional is roughly synonymous to Field together with a polymorphic FromRatio.
RealFrac becomes the polymorphic QuotientField
Floating is split into ExpField and TrigField
RealFloat is not attempted. Life is too short.
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 11 :: Num a => a
>>>:t 1.01.0 :: Fractional a => a
With RebindableSyntax (which also switches NoImplicitPrelude on) literal numbers change to the numhask types, FromInteger and FromRational:
>>>:set -XRebindableSyntax>>>:t 11 :: FromInteger a => a
>>>:t 1.01.0 :: FromRational a => a
>>>11
>>>1.01.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.
Exports
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
Instances
| Subtractive Bool Source # | |
| Subtractive Double Source # | |
| Subtractive Float Source # | |
| Subtractive Int Source # | |
| Subtractive Int8 Source # | |
| Subtractive Int16 Source # | |
| Subtractive Int32 Source # | |
| Subtractive Int64 Source # | |
| Subtractive Integer Source # | |
| Subtractive Natural Source # | |
| Subtractive Word Source # | |
| Subtractive Word8 Source # | |
| Subtractive Word16 Source # | |
| Subtractive Word32 Source # | |
| Subtractive Word64 Source # | |
| Subtractive a => Subtractive (Complex a) Source # | |
| (Ord a, Signed a, Integral a, Ring a) => Subtractive (Ratio a) Source # | |
| Subtractive b => Subtractive (a -> b) Source # | |
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 + 11
>>>1 + 12
Instances
| Additive Bool Source # | |
| Additive Double Source # | |
| Additive Float Source # | |
| Additive Int Source # | |
| Additive Int8 Source # | |
| Additive Int16 Source # | |
| Additive Int32 Source # | |
| Additive Int64 Source # | |
| Additive Integer Source # | |
| Additive Natural Source # | |
| Additive Word Source # | |
| Additive Word8 Source # | |
| Additive Word16 Source # | |
| Additive Word32 Source # | |
| Additive Word64 Source # | |
| Additive a => Additive (Complex a) Source # | |
| (Ord a, Signed a, Integral a, Ring a) => Additive (Ratio a) Source # | |
| Additive b => Additive (a -> b) Source # | |
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.00.5
>>>1 / 20.5
Minimal complete definition
class Multiplicative a where Source #
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 * 22
>>>2 * 36
Instances
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
Instances
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
Instances
| KleeneAlgebra b => KleeneAlgebra (a -> b) Source # | |
Defined in NumHask.Algebra.Ring | |
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
Nothing
Instances
| StarSemiring b => StarSemiring (a -> b) Source # | |
class (Distributive a, Subtractive a) => Ring 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
Instances
| (Distributive a, Subtractive a) => Ring a Source # | |
Defined in NumHask.Algebra.Ring | |
class (Additive a, Multiplicative a) => Distributive a Source #
\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.
Instances
two :: (Multiplicative a, Additive a) => a Source #
class Field a => TrigField a where Source #
Trigonometric Field
Methods
Instances
class (Subtractive a, Field a) => LowerBoundedField a where Source #
Negative infinity.
Minimal complete definition
Nothing
Methods
negInfinity :: a Source #
Instances
| LowerBoundedField Double Source # | |
Defined in NumHask.Algebra.Field Methods negInfinity :: Double Source # | |
| LowerBoundedField Float Source # | |
Defined in NumHask.Algebra.Field Methods negInfinity :: Float Source # | |
| LowerBoundedField a => LowerBoundedField (Complex a) Source # | |
Defined in NumHask.Data.Complex Methods negInfinity :: Complex a Source # | |
| (Ord a, Signed a, Integral a, Field a) => LowerBoundedField (Ratio a) Source # | |
Defined in NumHask.Data.Rational Methods negInfinity :: Ratio a Source # | |
| LowerBoundedField b => LowerBoundedField (a -> b) Source # | |
Defined in NumHask.Algebra.Field Methods negInfinity :: a -> b Source # | |
class Field a => UpperBoundedField a where Source #
A bounded field introduces the concepts of infinity and NaN.
one / zero + infinity == infinity infinity + a == infinity zero / zero != nan
Note the tricky law that, although nan is assigned to zero/zero, they are never-the-less not equal. A committee decided this.
Minimal complete definition
Nothing
Instances
| UpperBoundedField Double Source # | |
| UpperBoundedField Float Source # | |
| (UpperBoundedField a, Subtractive a) => UpperBoundedField (Complex a) Source # | |
| (Ord a, Signed a, Integral a, Ring a, Distributive a) => UpperBoundedField (Ratio a) Source # | |
| UpperBoundedField b => UpperBoundedField (a -> b) Source # | |
class (Field a, Multiplicative b, Additive b) => QuotientField a b where Source #
Conversion from a Field to a Ring
a - one < floor a <= a <= ceiling a < a + one round a == floor (a + half)
Minimal complete definition
Methods
properFraction :: a -> (b, a) Source #
default floor :: (Ord a, Subtractive b) => a -> b Source #
Instances
| QuotientField Double Int Source # | |
| QuotientField Double Integer Source # | |
| QuotientField Float Int Source # | |
| QuotientField Float Integer Source # | |
| (Ord a, Signed a, Integral a, Ring a, Ord b, Signed b, Integral b, Ring b, Field a, FromIntegral b a) => QuotientField (Ratio a) b Source # | |
| QuotientField b c => QuotientField (a -> b) (a -> c) Source # | |
class Field a => ExpField a where Source #
A hyperbolic field class
sqrt . (**2) == id log . exp == id for +ive b, a != 0,1: a ** logBase a b ≈ b
class (Distributive a, Subtractive a, Divisive a) => Field 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. Floating point computation is a terrible, messy business and, in practice, only rough approximation can be achieve for association and distribution.
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
Instances
| Field Double Source # | |
Defined in NumHask.Algebra.Field | |
| Field Float Source # | |
Defined in NumHask.Algebra.Field | |
| Field a => Field (Complex a) Source # | |
Defined in NumHask.Data.Complex | |
| (Ord a, Signed a, Integral a, Ring a) => Field (Ratio a) Source # | |
Defined in NumHask.Data.Rational | |
| Field b => Field (a -> b) Source # | |
Defined in NumHask.Algebra.Field | |
class MeetSemiLattice a => BoundedMeetSemiLattice a where Source #
Instances
class JoinSemiLattice a => BoundedJoinSemiLattice a where Source #
Instances
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
Instances
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
Instances
joinLeq :: JoinSemiLattice a => a -> a -> Bool Source #
The partial ordering induced by the join-semilattice structure
meetLeq :: MeetSemiLattice a => a -> a -> Bool Source #
The partial ordering induced by the meet-semilattice structure
class (Distributive a, MultiplicativeAction m a) => Module m a 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
class Divisive a => DivisiveAction m a | m -> a where Source #
Divisive Action
class Multiplicative a => MultiplicativeAction m a | m -> a where Source #
Multiplicative Action
class Subtractive a => SubtractiveAction m a | m -> a where Source #
Subtractive Action
class Additive a => AdditiveAction m a | m -> a where Source #
Additive Action
class (Eq a, Additive a, Subtractive a, MeetSemiLattice a) => Epsilon a where Source #
A small number, especially useful for approximate equality.
Minimal complete definition
Nothing
Instances
| Epsilon Double Source # | 1e-14 |
| Epsilon Float Source # | 1e-6 |
| Epsilon Int Source # | 0 |
| Epsilon Int8 Source # | |
| Epsilon Int16 Source # | |
| Epsilon Int32 Source # | |
| Epsilon Int64 Source # | |
| Epsilon Integer Source # | |
| Epsilon Word Source # | |
| Epsilon Word8 Source # | |
| Epsilon Word16 Source # | |
| Epsilon Word32 Source # | |
| Epsilon Word64 Source # | |
| (Ord a, Signed a, Subtractive a, Epsilon a) => Epsilon (Complex a) Source # | |
| (Ord a, Signed a, Integral a, Ring a, MeetSemiLattice a) => Epsilon (Ratio a) Source # | |
Something that has a magnitude and a direction.
Instances
| (Eq mag, Eq dir) => Eq (Polar mag dir) Source # | |
| (Show mag, Show dir) => Show (Polar mag dir) Source # | |
| Generic (Polar mag dir) Source # | |
| type Rep (Polar mag dir) Source # | |
Defined in NumHask.Algebra.Metric type Rep (Polar mag dir) = D1 ('MetaData "Polar" "NumHask.Algebra.Metric" "numhask-0.8.1.0-6vtGETGPv6z5KBqA0pprnK" 'False) (C1 ('MetaCons "Polar" 'PrefixI 'True) (S1 ('MetaSel ('Just "magnitude") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 mag) :*: S1 ('MetaSel ('Just "direction") 'NoSourceUnpackedness 'SourceStrict 'DecidedStrict) (Rec0 dir))) | |
class (Additive coord, Multiplicative coord, Additive dir, Multiplicative dir) => Direction coord dir | coord -> dir where Source #
Convert between a "co-ordinated" or "higher-kinded" number and representations of an angle. Typically thought of as polar co-ordinate conversion.
ray . angle == basis norm (ray x) == one
class (Additive a, Multiplicative b, Additive b) => Norm a b | a -> b where Source #
Norm is a slight generalisation of Signed. The class has the same shape but allows the codomain to be different to the domain.
norm a >= zero norm zero == zero a == norm a .* basis a norm (basis a) == one
Instances
| Norm Double Double Source # | |
| Norm Float Float Source # | |
| Norm Int Int Source # | |
| Norm Int8 Int8 Source # | |
| Norm Int16 Int16 Source # | |
| Norm Int32 Int32 Source # | |
| Norm Int64 Int64 Source # | |
| Norm Integer Integer Source # | |
| Norm Natural Natural Source # | |
| Norm Word Word Source # | |
| Norm Word8 Word8 Source # | |
| Norm Word16 Word16 Source # | |
| Norm Word32 Word32 Source # | |
| Norm Word64 Word64 Source # | |
| ExpField a => Norm (Complex a) a Source # | A euclidean-style norm is strong convention for Complex. |
| (Ord a, Signed a, Integral a, Ring a) => Norm (Ratio a) (Ratio a) Source # | |
class (Additive a, Multiplicative a) => Signed a where Source #
signum from base is not an operator name in numhask and is replaced by sign. Compare with Norm where there is a change in codomain.
abs a * sign a == a
abs zero == zero, so any value for sign zero is ok. We choose lawful neutral:
sign zero == zero
Instances
| Signed Double Source # | |
| Signed Float Source # | |
| Signed Int Source # | |
| Signed Int8 Source # | |
| Signed Int16 Source # | |
| Signed Int32 Source # | |
| Signed Int64 Source # | |
| Signed Integer Source # | |
| Signed Natural Source # | |
| Signed Word Source # | |
| Signed Word8 Source # | |
| Signed Word16 Source # | |
| Signed Word32 Source # | |
| Signed Word64 Source # | |
| (Ord a, Signed a, Integral a, Ring a) => Signed (Ratio a) Source # | |
distance :: (Norm a b, Subtractive a) => a -> a -> b Source #
Distance, which combines the Subtractive notion of difference, with Norm.
distance a b >= zero distance a a == zero distance a b .* basis (a - b) == a - b
polar :: (Norm coord mag, Direction coord dir) => coord -> Polar mag dir Source #
Convert from a number to a Polar.
coord :: (MultiplicativeAction coord mag, Direction coord dir) => Polar mag dir -> coord Source #
Convert from a Polar to a (coordinated aka higher-kinded) number.
class (Associative a, Unital a, Invertible a, Commutative a) => AbelianGroup a Source #
An Abelian Group is an Associative, Unital, Invertible and Commutative Magma . In other words, it is a Commutative Group
Instances
| (Associative a, Unital a, Invertible a, Commutative a) => AbelianGroup a Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Idempotent a Source #
An Idempotent Magma is a magma where every element is Idempotent.
a ⊕ a = a
Instances
| Idempotent b => Idempotent (a -> b) Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Absorbing a where Source #
An Absorbing is a Magma with an Absorbing Element
a ⊕ absorb = absorb
class (Associative a, Unital a, Invertible a) => Group a Source #
A Group is a Associative, Unital and Invertible Magma.
Instances
| (Associative a, Unital a, Invertible a) => Group a Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Invertible a where Source #
An Invertible Magma
∀ a,b ∈ T: inv a ⊕ (a ⊕ b) = b = (b ⊕ a) ⊕ inv a
Instances
| Invertible b => Invertible (a -> b) Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Commutative a Source #
A Commutative Magma is a Magma where the binary operation is commutative.
a ⊕ b = b ⊕ a
Instances
| Commutative b => Commutative (a -> b) Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Associative a Source #
An Associative Magma
(a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)
Instances
| Associative b => Associative (a -> b) Source # | |
Defined in NumHask.Algebra.Group | |
class Magma a => Unital a where Source #
A Unital Magma is a magma with an identity element (the unit).
unit ⊕ a = a a ⊕ unit = a
A Magma is a tuple (T,magma) consisting of
- a type a, and
- a function (magma) :: T -> T -> T
The mathematical laws for a magma are:
- magma is defined for all possible pairs of type T, and
- magma is closed in the set of all possible values of type T
or, more tersly,
∀ a, b ∈ T: a ⊕ b ∈ T
These laws are true by construction in haskell: the type signature of ⊕ and the above mathematical laws are synonyms.
Complex numbers have real and imaginary parts.
The Foldable and Traversable instances traverse the real part first.
Constructors
| !a :+ !a infix 6 | forms a complex number from its real and imaginary rectangular components. |
Instances
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
fromIntegerneed to be in a formC v, where v is a Num or a subclass of Num.
So a type synonym of `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
class FromIntegral a b where Source #
Polymorphic version of fromInteger
fromIntegral a == a
Minimal complete definition
Instances
class ToIntegral a b where Source #
toIntegral is kept separate from Integral to help with compatability issues.
toIntegral a == a
Minimal complete definition
Instances
class Distributive a => Integral a where Source #
An Integral is anything that satisfies the law:
b == zero || b * (a `div` b) + (a `mod` b) == a
Methods
div :: a -> a -> a infixl 7 Source #
mod :: a -> a -> a infixl 7 Source #
Instances
(^^) :: (Ord b, Divisive a, Subtractive b, Integral b) => a -> b -> a infixr 8 Source #
raise a number to an Integral power
(^) :: 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 monomorphic version is provided to help reduce ambiguous type noise in common usages of this sign.
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
fromRationalneed to be in a formC 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
| FromRational Double Source # | |
Defined in NumHask.Data.Rational Methods fromRational :: Rational -> Double Source # | |
| FromRational Float Source # | |
Defined in NumHask.Data.Rational Methods fromRational :: Rational -> Float Source # | |
| FromRational (Ratio Integer) Source # | |
Defined in NumHask.Data.Rational | |
class FromRatio a b where Source #
Fractional in base splits into fromRatio and Field
>>>fromRatio (5 :% 2 :: Ratio Integer) :: Double2.5
Minimal complete definition
Nothing
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
Minimal complete definition
Nothing
Methods
Instances
A rational number
Constructors
| !a :% !a |
Instances
reduce :: (Eq a, Subtractive a, Signed a, Integral a) => a -> a -> Ratio a Source #
reduce normalises a ratio by dividing both numerator and denominator by
their greatest common divisor.
gcd :: (Eq a, Signed a, Integral a) => a -> a -> a Source #
gcd x yx and y of which
every common factor of x and y is also a factor; for example
gcd 4 2 = 2gcd (-4) 6 = 2gcd 0 44. gcd 0 00.
(That is, the common divisor that is "greatest" in the divisibility
preordering.)
Note: Since for signed fixed-width integer types, abs minBound < 0minBound0 or minBound
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.
newtype NumHaskException Source #
A numhask exception.
Constructors
| NumHaskException | |
Fields | |
Instances
| Show NumHaskException Source # | |
Defined in NumHask.Exception Methods showsPrec :: Int -> NumHaskException -> ShowS # show :: NumHaskException -> String # showList :: [NumHaskException] -> ShowS # | |
| Exception NumHaskException Source # | |
Defined in NumHask.Exception Methods toException :: NumHaskException -> SomeException # | |