numhask-0.2.3.1: numeric classes

Safe HaskellNone
LanguageHaskell2010

NumHask.Algebra.Additive

Description

A magma heirarchy for addition. The basic magma structure is repeated and prefixed with 'Additive-'.

Synopsis

Documentation

class AdditiveMagma a where Source #

plus is used as the operator for the additive magma to distinguish from + which, by convention, implies commutativity

∀ a,b ∈ A: a `plus` b ∈ A

law is true by construction in Haskell

Minimal complete definition

plus

Methods

plus :: a -> a -> a Source #

Instances

AdditiveMagma Bool Source # 

Methods

plus :: Bool -> Bool -> Bool Source #

AdditiveMagma Double Source # 

Methods

plus :: Double -> Double -> Double Source #

AdditiveMagma Float Source # 

Methods

plus :: Float -> Float -> Float Source #

AdditiveMagma Int Source # 

Methods

plus :: Int -> Int -> Int Source #

AdditiveMagma Int8 Source # 

Methods

plus :: Int8 -> Int8 -> Int8 Source #

AdditiveMagma Int16 Source # 

Methods

plus :: Int16 -> Int16 -> Int16 Source #

AdditiveMagma Int32 Source # 

Methods

plus :: Int32 -> Int32 -> Int32 Source #

AdditiveMagma Int64 Source # 

Methods

plus :: Int64 -> Int64 -> Int64 Source #

AdditiveMagma Integer Source # 
AdditiveMagma Natural Source # 
AdditiveMagma Word Source # 

Methods

plus :: Word -> Word -> Word Source #

AdditiveMagma Word8 Source # 

Methods

plus :: Word8 -> Word8 -> Word8 Source #

AdditiveMagma Word16 Source # 

Methods

plus :: Word16 -> Word16 -> Word16 Source #

AdditiveMagma Word32 Source # 

Methods

plus :: Word32 -> Word32 -> Word32 Source #

AdditiveMagma Word64 Source # 

Methods

plus :: Word64 -> Word64 -> Word64 Source #

AdditiveMagma a => AdditiveMagma (Complex a) Source # 

Methods

plus :: Complex a -> Complex a -> Complex a Source #

(Ord a, Integral a, Signed a, AdditiveInvertible a) => AdditiveMagma (Ratio a) Source # 

Methods

plus :: Ratio a -> Ratio a -> Ratio a Source #

AdditiveMagma a => AdditiveMagma (Complex a) Source # 

Methods

plus :: Complex a -> Complex a -> Complex a Source #

AdditiveMagma a => AdditiveMagma (Sum a) Source # 

Methods

plus :: Sum a -> Sum a -> Sum a Source #

(ExpField a, LowerBoundedField a, Ord a) => AdditiveMagma (LogField a) Source # 

Methods

plus :: LogField a -> LogField a -> LogField a Source #

class AdditiveMagma a => AdditiveUnital a where Source #

Unital magma for addition.

zero `plus` a == a
a `plus` zero == a

Minimal complete definition

zero

Methods

zero :: a Source #

class AdditiveMagma a => AdditiveInvertible a where Source #

Invertible magma for addition.

∀ a ∈ A: negate a ∈ A

law is true by construction in Haskell

Minimal complete definition

negate

Methods

negate :: a -> a Source #

Instances

AdditiveInvertible Bool Source # 

Methods

negate :: Bool -> Bool Source #

AdditiveInvertible Double Source # 

Methods

negate :: Double -> Double Source #

AdditiveInvertible Float Source # 

Methods

negate :: Float -> Float Source #

AdditiveInvertible Int Source # 

Methods

negate :: Int -> Int Source #

AdditiveInvertible Int8 Source # 

Methods

negate :: Int8 -> Int8 Source #

AdditiveInvertible Int16 Source # 

Methods

negate :: Int16 -> Int16 Source #

AdditiveInvertible Int32 Source # 

Methods

negate :: Int32 -> Int32 Source #

AdditiveInvertible Int64 Source # 

Methods

negate :: Int64 -> Int64 Source #

AdditiveInvertible Integer Source # 
AdditiveInvertible Word Source # 

Methods

negate :: Word -> Word Source #

AdditiveInvertible Word8 Source # 

Methods

negate :: Word8 -> Word8 Source #

AdditiveInvertible Word16 Source # 

Methods

negate :: Word16 -> Word16 Source #

AdditiveInvertible Word32 Source # 

Methods

negate :: Word32 -> Word32 Source #

AdditiveInvertible Word64 Source # 

Methods

negate :: Word64 -> Word64 Source #

AdditiveInvertible a => AdditiveInvertible (Complex a) Source # 

Methods

negate :: Complex a -> Complex a Source #

(Ord a, Signed a, Integral a, AdditiveInvertible a) => AdditiveInvertible (Ratio a) Source # 

Methods

negate :: Ratio a -> Ratio a Source #

AdditiveInvertible a => AdditiveInvertible (Complex a) Source # 

Methods

negate :: Complex a -> Complex a Source #

AdditiveInvertible a => AdditiveInvertible (Sum a) Source # 

Methods

negate :: Sum a -> Sum a Source #

class AdditiveMagma a => AdditiveIdempotent a Source #

Idempotent magma for addition.

a `plus` a == a

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

sum definition avoiding a clash with the Sum monoid in base fixme: fit in with the Sum monoid

class (AdditiveCommutative a, AdditiveUnital a, AdditiveAssociative a) => Additive a where Source #

Additive is commutative, unital and associative under addition

zero + a == a
a + zero == a
(a + b) + c == a + (b + c)
a + b == b + a

Methods

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

Instances

Additive Bool Source # 

Methods

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

Additive Double Source # 

Methods

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

Additive Float Source # 

Methods

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

Additive Int Source # 

Methods

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

Additive Int8 Source # 

Methods

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

Additive Int16 Source # 

Methods

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

Additive Int32 Source # 

Methods

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

Additive Int64 Source # 

Methods

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

Additive Integer Source # 

Methods

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

Additive Natural Source # 

Methods

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

Additive Word Source # 

Methods

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

Additive Word8 Source # 

Methods

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

Additive Word16 Source # 

Methods

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

Additive Word32 Source # 

Methods

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

Additive Word64 Source # 

Methods

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

Additive a => Additive (Complex a) Source # 

Methods

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

(Ord a, Signed a, Integral a, AdditiveInvertible a) => Additive (Ratio a) Source # 

Methods

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

Additive a => Additive (Complex a) Source # 

Methods

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

(AdditiveUnital a, AdditiveMagma a) => Additive (Sum a) Source # 

Methods

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

(LowerBoundedField a, ExpField a, Ord a) => Additive (LogField a) Source # 

Methods

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

class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveRightCancellative a where Source #

Non-commutative right minus

a `plus` negate a = zero

Methods

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

class (AdditiveUnital a, AdditiveAssociative a, AdditiveInvertible a) => AdditiveLeftCancellative a where Source #

Non-commutative left minus

negate a `plus` a = zero

Methods

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

class (Additive a, AdditiveInvertible a) => AdditiveGroup a where Source #

Minus (-) is reserved for where both the left and right cancellative laws hold. This then implies that the AdditiveGroup is also Abelian.

Syntactic unary negation - substituting "negate a" for "-a" in code - is hard-coded in the language to assume a Num instance. So, for example, using ''-a = zero - a' for the second rule below doesn't work.

a - a = zero
negate a = zero - a
negate a + a = zero
a + negate a = zero

Methods

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

Instances

subtract :: AdditiveGroup a => a -> a -> a Source #