Data.AdditiveGroup

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

Documentation

class AdditiveGroup v where

Additive group v.

Methods

zeroV :: v

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

zeroV :: (Generic v, AdditiveGroup (VRep v)) => v

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

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

Add vectors

(^+^) :: (Generic v, AdditiveGroup (VRep v)) => v -> v -> v infixl 6

Add vectors

negateV :: v -> v

Additive inverse

negateV :: (Generic v, AdditiveGroup (VRep v)) => 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 a => AdditiveGroup (Rec0 a s)

Methods

zeroV :: Rec0 a s

(^+^) :: Rec0 a s -> Rec0 a s -> Rec0 a s

negateV :: Rec0 a s -> Rec0 a s

(^-^) :: Rec0 a s -> Rec0 a s -> Rec0 a s

(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 (f p), AdditiveGroup (g p)) => AdditiveGroup ((:*:) f g p)

Methods

zeroV :: (f :*: g) p

(^+^) :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

negateV :: (f :*: g) p -> (f :*: g) p

(^-^) :: (f :*: g) p -> (f :*: g) p -> (f :*: g) p

(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 (f p) => AdditiveGroup (M1 i c f p)

Methods

zeroV :: M1 i c f p

(^+^) :: M1 i c f p -> M1 i c f p -> M1 i c f p

negateV :: M1 i c f p -> M1 i c f p

(^-^) :: M1 i c f p -> M1 i c f p -> M1 i c f p

(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