numeric-prelude-0.0.2: An experimental alternative hierarchy of numeric type classesSource codeContentsIndex
Algebra.Additive
Contents
Class
Complex functions
Instances for atomic types
Synopsis
class C a where
zero :: a
(+) :: a -> a -> a
(-) :: a -> a -> a
negate :: a -> a
subtract :: C a => a -> a -> a
sum :: C a => [a] -> a
sum1 :: C a => [a] -> a
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
Class
class C a whereSource

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 '(-)')

Methods
zero :: aSource
zero element of the vector space
(+) :: a -> a -> aSource
add and subtract elements
(-) :: a -> a -> aSource
negate :: a -> aSource
inverse with respect to +
show/hide Instances
C Double
C Float
C Int
C Integer
C T
C T
C T
C v => C [v]
Integral a => C (Ratio a)
(Ord a, C a) => C (T a)
C a => C (T a)
C a => C (T a)
C a => C (T a)
C a => C (T a)
C a => C (T a)
C a => C (T a)
(C a, C a, C a) => C (T a)
C a => C (T a)
C a => C (T a)
(C a, C a) => C (T a)
C a => C (T a)
C a => C (T a)
(Eq a, C a) => C (T a)
(Eq a, C a) => C (T a)
C a => C (T a)
C v => C (b -> v)
(C v0, C v1) => C (v0, v1)
(Ord i, Eq v, C v) => C (Map i v)
(Ord a, C b) => C (T a b)
(C u, C a) => C (T u a)
C v => C (T a v)
(Ord i, C a) => C (T i a)
C v => C (T a v)
(C v0, C v1, C v2) => C (v0, v1, v2)
subtract :: C a => a -> a -> aSource
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] -> aSource
Sum up all elements of a list. An empty list yields zero.
sum1 :: C a => [a] -> aSource
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.
Instances for atomic types
propAssociative :: (Eq a, C a) => a -> a -> a -> BoolSource
propCommutative :: (Eq a, C a) => a -> a -> BoolSource
propIdentity :: (Eq a, C a) => a -> BoolSource
propInverse :: (Eq a, C a) => a -> BoolSource
Produced by Haddock version 2.6.0