Algebra.Additive

Class

class C a where

Additive a encapsulates the notion of a commutative group, specified by the following laws:

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

Typical examples include integers, dollars, and vectors.

Minimal definition: +, zero, and (negate or '(-)')

Minimal complete definition

zero, (+), ((-) | negate)

Methods

zero :: a

zero element of the vector space

(+), (-) :: a -> a -> a infixl 6 +, -

add and subtract elements

negate :: a -> a

inverse with respect to +

Instances

C Double

Methods

zero :: Double

(+) :: Double -> Double -> Double

(-) :: Double -> Double -> Double

negate :: Double -> Double

C Float

Methods

zero :: Float

(+) :: Float -> Float -> Float

(-) :: Float -> Float -> Float

negate :: Float -> Float

C Int

Methods

zero :: Int

(+) :: Int -> Int -> Int

(-) :: Int -> Int -> Int

negate :: Int -> Int

C Int8

Methods

zero :: Int8

(+) :: Int8 -> Int8 -> Int8

(-) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

C Int16

Methods

zero :: Int16

(+) :: Int16 -> Int16 -> Int16

(-) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

C Int32

Methods

zero :: Int32

(+) :: Int32 -> Int32 -> Int32

(-) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

C Int64

Methods

zero :: Int64

(+) :: Int64 -> Int64 -> Int64

(-) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

C Integer

Methods

zero :: Integer

(+) :: Integer -> Integer -> Integer

(-) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

C Word

Methods

zero :: Word

(+) :: Word -> Word -> Word

(-) :: Word -> Word -> Word

negate :: Word -> Word

C Word8

Methods

zero :: Word8

(+) :: Word8 -> Word8 -> Word8

(-) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

C Word16

Methods

zero :: Word16

(+) :: Word16 -> Word16 -> Word16

(-) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

C Word32

Methods

zero :: Word32

(+) :: Word32 -> Word32 -> Word32

(-) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

C Word64

Methods

zero :: Word64

(+) :: Word64 -> Word64 -> Word64

(-) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

C T

Methods

zero :: T

(+) :: T -> T -> T

(-) :: T -> T -> T

negate :: T -> T

C T

Methods

zero :: T

(+) :: T -> T -> T

(-) :: T -> T -> T

negate :: T -> T

C T

Methods

zero :: T

(+) :: T -> T -> T

(-) :: T -> T -> T

negate :: T -> T

C T

Methods

zero :: T

(+) :: T -> T -> T

(-) :: T -> T -> T

negate :: T -> T

C v => C [v]

The Additive instantiations treat lists as prefixes of infinite lists with zero filled tail. This interpretation is not always appropriate. The end of a list may just mean: End of available data. In this case the shortening zip semantics would be more appropriate.

Methods

zero :: [v]

(+) :: [v] -> [v] -> [v]

(-) :: [v] -> [v] -> [v]

negate :: [v] -> [v]

Integral a => C (Ratio a)

Methods

zero :: Ratio a

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

(-) :: Ratio a -> Ratio a -> Ratio a

negate :: Ratio a -> Ratio a

RealFloat a => C (Complex a)

Methods

zero :: Complex a

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

(-) :: Complex a -> Complex a -> Complex a

negate :: Complex a -> Complex a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

Num a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

(Eq a, C a) => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

(Eq a, C a) => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

(C a, C a) => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

(C a, C a, C a) => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C a => C (T a)

Methods

zero :: T a

(+) :: T a -> T a -> T a

(-) :: T a -> T a -> T a

negate :: T a -> T a

C v => C (b -> v)

Methods

zero :: b -> v

(+) :: (b -> v) -> (b -> v) -> b -> v

(-) :: (b -> v) -> (b -> v) -> b -> v

negate :: (b -> v) -> b -> v

(C v0, C v1) => C (v0, v1)

Methods

zero :: (v0, v1)

(+) :: (v0, v1) -> (v0, v1) -> (v0, v1)

(-) :: (v0, v1) -> (v0, v1) -> (v0, v1)

negate :: (v0, v1) -> (v0, v1)

(Ord a, C b) => C (T a b)

Methods

zero :: T a b

(+) :: T a b -> T a b -> T a b

(-) :: T a b -> T a b -> T a b

negate :: T a b -> T a b

C v => C (T a v)

Methods

zero :: T a v

(+) :: T a v -> T a v -> T a v

(-) :: T a v -> T a v -> T a v

negate :: T a v -> T a v

(C u, C a) => C (T u a)

Methods

zero :: T u a

(+) :: T u a -> T u a -> T u a

(-) :: T u a -> T u a -> T u a

negate :: T u a -> T u a

(Ord i, C a) => C (T i a)

Methods

zero :: T i a

(+) :: T i a -> T i a -> T i a

(-) :: T i a -> T i a -> T i a

negate :: T i a -> T i a

C v => C (T a v)

Methods

zero :: T a v

(+) :: T a v -> T a v -> T a v

(-) :: T a v -> T a v -> T a v

negate :: T a v -> T a v

(C v0, C v1, C v2) => C (v0, v1, v2)

Methods

zero :: (v0, v1, v2)

(+) :: (v0, v1, v2) -> (v0, v1, v2) -> (v0, v1, v2)

(-) :: (v0, v1, v2) -> (v0, v1, v2) -> (v0, v1, v2)

negate :: (v0, v1, v2) -> (v0, v1, v2)

zero :: C a => a

zero element of the vector space

(+), (-) :: C a => a -> a -> a infixl 6 +, -

add and subtract elements

(+), (-) :: C a => a -> a -> a infixl 6 -, +

add and subtract elements

negate :: C a => a -> a

inverse with respect to +

subtract :: C a => a -> a -> a

subtract is (-) with swapped operand order. This is the operand order which will be needed in most cases of partial application.

Complex functions

sum :: C a => [a] -> a

Sum up all elements of a list. An empty list yields zero.

This function is inappropriate for number types like Peano. Maybe we should make sum a method of Additive. This would also make lengthLeft and lengthRight superfluous.

sum1 :: C a => [a] -> a

Sum up all elements of a non-empty list. This avoids including a zero which is useful for types where no universal zero is available. ToDo: Should have NonEmpty type.

sumNestedAssociative :: C a => [a] -> a

Sum the operands in an order, such that the dependencies are minimized. Does this have a measurably effect on speed?

Requires associativity.

sumNestedCommutative :: C a => [a] -> a

Instance definition helpers

elementAdd :: C x => (v -> x) -> T (v, v) x

Instead of baking the add operation into the element function, we could use higher rank types and pass a generic uncurry (+) to the run function. We do not do so in order to stay Haskell 98 at least for parts of NumericPrelude.

elementSub :: C x => (v -> x) -> T (v, v) x

elementNeg :: C x => (v -> x) -> T v x

(<*>.+) :: C x => T (v, v) (x -> a) -> (v -> x) -> T (v, v) a infixl 4

addPair :: (Additive.C a, Additive.C b) => (a,b) -> (a,b) -> (a,b)
addPair = Elem.run2 $ Elem.with (,) <*>.+  fst <*>.+  snd

(<*>.-) :: C x => T (v, v) (x -> a) -> (v -> x) -> T (v, v) a infixl 4

(<*>.-$) :: C x => T v (x -> a) -> (v -> x) -> T v a infixl 4

Instances for atomic types

propAssociative :: (Eq a, C a) => a -> a -> a -> Bool

propCommutative :: (Eq a, C a) => a -> a -> Bool

propIdentity :: (Eq a, C a) => a -> Bool

propInverse :: (Eq a, C a) => a -> Bool