Copyright	(c) Conal Elliott and Andy J Gill 2008
License	BSD3
Maintainer	conal@conal.net, andygill@ku.edu
Stability	experimental
Safe Haskell	Safe
Language	Haskell98

Data.AdditiveGroup

Description

Groups: zero, addition, and negation (additive inverse)

Synopsis

Documentation

class AdditiveGroup v where #

Additive group v.

Minimal complete definition

zeroV, (^+^), negateV

Methods

zeroV :: v #

The zero element: identity for '(^+^)'

(^+^) :: v -> v -> v infixl 6 #

Add vectors

negateV :: v -> v #

Additive inverse

(^-^) :: v -> v -> v infixl 6 #

Group subtraction

Instances

AdditiveGroup Double #
Methods zeroV :: Double # (^+^) :: Double -> Double -> Double # negateV :: Double -> Double # (^-^) :: Double -> Double -> Double #
AdditiveGroup Float #
Methods zeroV :: Float # (^+^) :: Float -> Float -> Float # negateV :: Float -> Float # (^-^) :: Float -> Float -> Float #
AdditiveGroup Int #
Methods zeroV :: Int # (^+^) :: Int -> Int -> Int # negateV :: Int -> Int # (^-^) :: Int -> Int -> Int #
AdditiveGroup Integer #
Methods zeroV :: Integer # (^+^) :: Integer -> Integer -> Integer # negateV :: Integer -> Integer # (^-^) :: Integer -> Integer -> Integer #
AdditiveGroup () #
Methods zeroV :: () # (^+^) :: () -> () -> () # negateV :: () -> () # (^-^) :: () -> () -> () #
AdditiveGroup CSChar #
Methods zeroV :: CSChar # (^+^) :: CSChar -> CSChar -> CSChar # negateV :: CSChar -> CSChar # (^-^) :: CSChar -> CSChar -> CSChar #
AdditiveGroup CShort #
Methods zeroV :: CShort # (^+^) :: CShort -> CShort -> CShort # negateV :: CShort -> CShort # (^-^) :: CShort -> CShort -> CShort #
AdditiveGroup CInt #
Methods zeroV :: CInt # (^+^) :: CInt -> CInt -> CInt # negateV :: CInt -> CInt # (^-^) :: CInt -> CInt -> CInt #
AdditiveGroup CLong #
Methods zeroV :: CLong # (^+^) :: CLong -> CLong -> CLong # negateV :: CLong -> CLong # (^-^) :: CLong -> CLong -> CLong #
AdditiveGroup CLLong #
Methods zeroV :: CLLong # (^+^) :: CLLong -> CLLong -> CLLong # negateV :: CLLong -> CLLong # (^-^) :: CLLong -> CLLong -> CLLong #
AdditiveGroup CFloat #
Methods zeroV :: CFloat # (^+^) :: CFloat -> CFloat -> CFloat # negateV :: CFloat -> CFloat # (^-^) :: CFloat -> CFloat -> CFloat #
AdditiveGroup CDouble #
Methods zeroV :: CDouble # (^+^) :: CDouble -> CDouble -> CDouble # negateV :: CDouble -> CDouble # (^-^) :: CDouble -> CDouble -> CDouble #
AdditiveGroup CIntMax #
Methods zeroV :: CIntMax # (^+^) :: CIntMax -> CIntMax -> CIntMax # negateV :: CIntMax -> CIntMax # (^-^) :: CIntMax -> CIntMax -> CIntMax #
AdditiveGroup a => AdditiveGroup (Maybe a) #
Methods zeroV :: Maybe a # (^+^) :: Maybe a -> Maybe a -> Maybe a # negateV :: Maybe a -> Maybe a # (^-^) :: Maybe a -> Maybe a -> Maybe a #
Integral a => AdditiveGroup (Ratio a) #
Methods zeroV :: Ratio a # (^+^) :: Ratio a -> Ratio a -> Ratio a # negateV :: Ratio a -> Ratio a # (^-^) :: Ratio a -> Ratio a -> Ratio a #
(RealFloat v, AdditiveGroup v) => AdditiveGroup (Complex v) #
Methods zeroV :: Complex v # (^+^) :: Complex v -> Complex v -> Complex v # negateV :: Complex v -> Complex v # (^-^) :: Complex v -> Complex v -> Complex v #
AdditiveGroup a => AdditiveGroup (Sum a) #
Methods zeroV :: Sum a # (^+^) :: Sum a -> Sum a -> Sum a # negateV :: Sum a -> Sum a # (^-^) :: Sum a -> Sum a -> Sum a #
AdditiveGroup v => AdditiveGroup (a -> v) #
Methods zeroV :: a -> v # (^+^) :: (a -> v) -> (a -> v) -> a -> v # negateV :: (a -> v) -> a -> v # (^-^) :: (a -> v) -> (a -> v) -> a -> v #
(AdditiveGroup u, AdditiveGroup v) => AdditiveGroup (u, v) #
Methods zeroV :: (u, v) # (^+^) :: (u, v) -> (u, v) -> (u, v) # negateV :: (u, v) -> (u, v) # (^-^) :: (u, v) -> (u, v) -> (u, v) #
(HasTrie u, AdditiveGroup v) => AdditiveGroup ((:->:) u v) #
Methods zeroV :: u :->: v # (^+^) :: (u :->: v) -> (u :->: v) -> u :->: v # negateV :: (u :->: v) -> u :->: v # (^-^) :: (u :->: v) -> (u :->: v) -> u :->: v #
(HasTrie (Basis u), AdditiveGroup v) => AdditiveGroup ((:-*) u v) #
Methods zeroV :: u :-* v # (^+^) :: (u :-* v) -> (u :-* v) -> u :-* v # negateV :: (u :-* v) -> u :-* v # (^-^) :: (u :-* v) -> (u :-* v) -> u :-* v #
(HasBasis a, HasTrie (Basis a), AdditiveGroup u) => AdditiveGroup ((:>) a u) #
Methods zeroV :: a :> u # (^+^) :: (a :> u) -> (a :> u) -> a :> u # negateV :: (a :> u) -> a :> u # (^-^) :: (a :> u) -> (a :> u) -> a :> u #
(AdditiveGroup u, AdditiveGroup v, AdditiveGroup w) => AdditiveGroup (u, v, w) #
Methods zeroV :: (u, v, w) # (^+^) :: (u, v, w) -> (u, v, w) -> (u, v, w) # negateV :: (u, v, w) -> (u, v, w) # (^-^) :: (u, v, w) -> (u, v, w) -> (u, v, w) #
(AdditiveGroup u, AdditiveGroup v, AdditiveGroup w, AdditiveGroup x) => AdditiveGroup (u, v, w, x) #
Methods zeroV :: (u, v, w, x) # (^+^) :: (u, v, w, x) -> (u, v, w, x) -> (u, v, w, x) # negateV :: (u, v, w, x) -> (u, v, w, x) # (^-^) :: (u, v, w, x) -> (u, v, w, x) -> (u, v, w, x) #

sumV :: (Foldable f, AdditiveGroup v) => f v -> v #

Sum over several vectors

newtype Sum a #

Monoid under group addition. Alternative to the Sum in Data.Monoid, which uses Num instead of AdditiveGroup.

Constructors

Sum
Fields getSum :: a

Instances

Functor Sum #
Methods fmap :: (a -> b) -> Sum a -> Sum b # (<$) :: a -> Sum b -> Sum a #
Applicative Sum #
Methods pure :: a -> Sum a # (<>) :: Sum (a -> b) -> Sum a -> Sum b # (>) :: Sum a -> Sum b -> Sum b # (<*) :: Sum a -> Sum b -> Sum a #
Bounded a => Bounded (Sum a) #
Methods minBound :: Sum a # maxBound :: Sum a #
Eq a => Eq (Sum a) #
Methods (==) :: Sum a -> Sum a -> Bool # (/=) :: Sum a -> Sum a -> Bool #
Ord a => Ord (Sum a) #
Methods compare :: Sum a -> Sum a -> Ordering # (<) :: Sum a -> Sum a -> Bool # (<=) :: Sum a -> Sum a -> Bool # (>) :: Sum a -> Sum a -> Bool # (>=) :: Sum a -> Sum a -> Bool # max :: Sum a -> Sum a -> Sum a # min :: Sum a -> Sum a -> Sum a #
Read a => Read (Sum a) #
Methods readsPrec :: Int -> ReadS (Sum a) # readList :: ReadS [Sum a] # readPrec :: ReadPrec (Sum a) # readListPrec :: ReadPrec [Sum a] #
Show a => Show (Sum a) #
Methods showsPrec :: Int -> Sum a -> ShowS # show :: Sum a -> String # showList :: [Sum a] -> ShowS #
AdditiveGroup a => Monoid (Sum a) #
Methods mempty :: Sum a # mappend :: Sum a -> Sum a -> Sum a # mconcat :: [Sum a] -> Sum a #
AdditiveGroup a => AdditiveGroup (Sum a) #
Methods zeroV :: Sum a # (^+^) :: Sum a -> Sum a -> Sum a # negateV :: Sum a -> Sum a # (^-^) :: Sum a -> Sum a -> Sum a #

inSum :: (a -> b) -> Sum a -> Sum b #

Application a unary function inside a Sum

inSum2 :: (a -> b -> c) -> Sum a -> Sum b -> Sum c #

Application a binary function inside a Sum