Safe Haskell	Safe
Language	Haskell98

Algebra.Additive

Contents

Class
Complex functions
Instance definition helpers
Instances for atomic types

Synopsis

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 #