Safe Haskell	Safe
Language	Haskell98

Numeric.Additive.Class

Contents

Additive Semigroups
Additive Abelian semigroups
Additive Monoids
Partitionable semigroups

Synopsis

Additive Semigroups

class Additive r where #

(a + b) + c = a + (b + c)
sinnum 1 a = a
sinnum (2 * n) a = sinnum n a + sinnum n a
sinnum (2 * n + 1) a = sinnum n a + sinnum n a + a

Minimal complete definition

(+)

Methods

(+) :: r -> r -> r infixl 6 #

sinnum1p :: Natural -> r -> r #

sinnum1p n r = sinnum (1 + n) r

sumWith1 :: Foldable1 f => (a -> r) -> f a -> r #

Instances

Additive Bool #
Methods (+) :: Bool -> Bool -> Bool # sinnum1p :: Natural -> Bool -> Bool # sumWith1 :: Foldable1 f => (a -> Bool) -> f a -> Bool #
Additive Int #
Methods (+) :: Int -> Int -> Int # sinnum1p :: Natural -> Int -> Int # sumWith1 :: Foldable1 f => (a -> Int) -> f a -> Int #
Additive Int8 #
Methods (+) :: Int8 -> Int8 -> Int8 # sinnum1p :: Natural -> Int8 -> Int8 # sumWith1 :: Foldable1 f => (a -> Int8) -> f a -> Int8 #
Additive Int16 #
Methods (+) :: Int16 -> Int16 -> Int16 # sinnum1p :: Natural -> Int16 -> Int16 # sumWith1 :: Foldable1 f => (a -> Int16) -> f a -> Int16 #
Additive Int32 #
Methods (+) :: Int32 -> Int32 -> Int32 # sinnum1p :: Natural -> Int32 -> Int32 # sumWith1 :: Foldable1 f => (a -> Int32) -> f a -> Int32 #
Additive Int64 #
Methods (+) :: Int64 -> Int64 -> Int64 # sinnum1p :: Natural -> Int64 -> Int64 # sumWith1 :: Foldable1 f => (a -> Int64) -> f a -> Int64 #
Additive Integer #
Methods (+) :: Integer -> Integer -> Integer # sinnum1p :: Natural -> Integer -> Integer # sumWith1 :: Foldable1 f => (a -> Integer) -> f a -> Integer #
Additive Natural #
Methods (+) :: Natural -> Natural -> Natural # sinnum1p :: Natural -> Natural -> Natural # sumWith1 :: Foldable1 f => (a -> Natural) -> f a -> Natural #
Additive Word #
Methods (+) :: Word -> Word -> Word # sinnum1p :: Natural -> Word -> Word # sumWith1 :: Foldable1 f => (a -> Word) -> f a -> Word #
Additive Word8 #
Methods (+) :: Word8 -> Word8 -> Word8 # sinnum1p :: Natural -> Word8 -> Word8 # sumWith1 :: Foldable1 f => (a -> Word8) -> f a -> Word8 #
Additive Word16 #
Methods (+) :: Word16 -> Word16 -> Word16 # sinnum1p :: Natural -> Word16 -> Word16 # sumWith1 :: Foldable1 f => (a -> Word16) -> f a -> Word16 #
Additive Word32 #
Methods (+) :: Word32 -> Word32 -> Word32 # sinnum1p :: Natural -> Word32 -> Word32 # sumWith1 :: Foldable1 f => (a -> Word32) -> f a -> Word32 #
Additive Word64 #
Methods (+) :: Word64 -> Word64 -> Word64 # sinnum1p :: Natural -> Word64 -> Word64 # sumWith1 :: Foldable1 f => (a -> Word64) -> f a -> Word64 #
Additive () #
Methods (+) :: () -> () -> () # sinnum1p :: Natural -> () -> () # sumWith1 :: Foldable1 f => (a -> ()) -> f a -> () #
Additive Euclidean #
Methods (+) :: Euclidean -> Euclidean -> Euclidean # sinnum1p :: Natural -> Euclidean -> Euclidean # sumWith1 :: Foldable1 f => (a -> Euclidean) -> f a -> Euclidean #
Additive r => Additive (ZeroRng r) #
Methods (+) :: ZeroRng r -> ZeroRng r -> ZeroRng r # sinnum1p :: Natural -> ZeroRng r -> ZeroRng r # sumWith1 :: Foldable1 f => (a -> ZeroRng r) -> f a -> ZeroRng r #
Abelian r => Additive (RngRing r) #
Methods (+) :: RngRing r -> RngRing r -> RngRing r # sinnum1p :: Natural -> RngRing r -> RngRing r # sumWith1 :: Foldable1 f => (a -> RngRing r) -> f a -> RngRing r #
Additive r => Additive (Opposite r) #
Methods (+) :: Opposite r -> Opposite r -> Opposite r # sinnum1p :: Natural -> Opposite r -> Opposite r # sumWith1 :: Foldable1 f => (a -> Opposite r) -> f a -> Opposite r #
Additive r => Additive (End r) #
Methods (+) :: End r -> End r -> End r # sinnum1p :: Natural -> End r -> End r # sumWith1 :: Foldable1 f => (a -> End r) -> f a -> End r #
Multiplicative r => Additive (Log r) #
Methods (+) :: Log r -> Log r -> Log r # sinnum1p :: Natural -> Log r -> Log r # sumWith1 :: Foldable1 f => (a -> Log r) -> f a -> Log r #
Additive r => Additive (Trig r) #
Methods (+) :: Trig r -> Trig r -> Trig r # sinnum1p :: Natural -> Trig r -> Trig r # sumWith1 :: Foldable1 f => (a -> Trig r) -> f a -> Trig r #
Additive r => Additive (Quaternion' r) #
Methods (+) :: Quaternion' r -> Quaternion' r -> Quaternion' r # sinnum1p :: Natural -> Quaternion' r -> Quaternion' r # sumWith1 :: Foldable1 f => (a -> Quaternion' r) -> f a -> Quaternion' r #
Additive r => Additive (Hyper r) #
Methods (+) :: Hyper r -> Hyper r -> Hyper r # sinnum1p :: Natural -> Hyper r -> Hyper r # sumWith1 :: Foldable1 f => (a -> Hyper r) -> f a -> Hyper r #
Additive (BasisCoblade m) #
Methods (+) :: BasisCoblade m -> BasisCoblade m -> BasisCoblade m # sinnum1p :: Natural -> BasisCoblade m -> BasisCoblade m # sumWith1 :: Foldable1 f => (a -> BasisCoblade m) -> f a -> BasisCoblade m #
Additive r => Additive (Dual' r) #
Methods (+) :: Dual' r -> Dual' r -> Dual' r # sinnum1p :: Natural -> Dual' r -> Dual' r # sumWith1 :: Foldable1 f => (a -> Dual' r) -> f a -> Dual' r #
Additive r => Additive (Quaternion r) #
Methods (+) :: Quaternion r -> Quaternion r -> Quaternion r # sinnum1p :: Natural -> Quaternion r -> Quaternion r # sumWith1 :: Foldable1 f => (a -> Quaternion r) -> f a -> Quaternion r #
Additive r => Additive (Hyper' r) #
Methods (+) :: Hyper' r -> Hyper' r -> Hyper' r # sinnum1p :: Natural -> Hyper' r -> Hyper' r # sumWith1 :: Foldable1 f => (a -> Hyper' r) -> f a -> Hyper' r #
Additive r => Additive (Dual r) #
Methods (+) :: Dual r -> Dual r -> Dual r # sinnum1p :: Natural -> Dual r -> Dual r # sumWith1 :: Foldable1 f => (a -> Dual r) -> f a -> Dual r #
Additive r => Additive (Complex r) #
Methods (+) :: Complex r -> Complex r -> Complex r # sinnum1p :: Natural -> Complex r -> Complex r # sumWith1 :: Foldable1 f => (a -> Complex r) -> f a -> Complex r #
GCDDomain d => Additive (Fraction d) #
Methods (+) :: Fraction d -> Fraction d -> Fraction d # sinnum1p :: Natural -> Fraction d -> Fraction d # sumWith1 :: Foldable1 f => (a -> Fraction d) -> f a -> Fraction d #
Additive r => Additive (b -> r) #
Methods (+) :: (b -> r) -> (b -> r) -> b -> r # sinnum1p :: Natural -> (b -> r) -> b -> r # sumWith1 :: Foldable1 f => (a -> b -> r) -> f a -> b -> r #
(Additive a, Additive b) => Additive (a, b) #
Methods (+) :: (a, b) -> (a, b) -> (a, b) # sinnum1p :: Natural -> (a, b) -> (a, b) # sumWith1 :: Foldable1 f => (a -> (a, b)) -> f a -> (a, b) #
Additive r => Additive (Covector r a) #
Methods (+) :: Covector r a -> Covector r a -> Covector r a # sinnum1p :: Natural -> Covector r a -> Covector r a # sumWith1 :: Foldable1 f => (a -> Covector r a) -> f a -> Covector r a #
(Additive a, Additive b, Additive c) => Additive (a, b, c) #
Methods (+) :: (a, b, c) -> (a, b, c) -> (a, b, c) # sinnum1p :: Natural -> (a, b, c) -> (a, b, c) # sumWith1 :: Foldable1 f => (a -> (a, b, c)) -> f a -> (a, b, c) #
Additive r => Additive (Map r b a) #
Methods (+) :: Map r b a -> Map r b a -> Map r b a # sinnum1p :: Natural -> Map r b a -> Map r b a # sumWith1 :: Foldable1 f => (a -> Map r b a) -> f a -> Map r b a #
(Additive a, Additive b, Additive c, Additive d) => Additive (a, b, c, d) #
Methods (+) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d) # sinnum1p :: Natural -> (a, b, c, d) -> (a, b, c, d) # sumWith1 :: Foldable1 f => (a -> (a, b, c, d)) -> f a -> (a, b, c, d) #
(Additive a, Additive b, Additive c, Additive d, Additive e) => Additive (a, b, c, d, e) #
Methods (+) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e) # sinnum1p :: Natural -> (a, b, c, d, e) -> (a, b, c, d, e) # sumWith1 :: Foldable1 f => (a -> (a, b, c, d, e)) -> f a -> (a, b, c, d, e) #

sum1 :: (Foldable1 f, Additive r) => f r -> r #

Additive Abelian semigroups

class Additive r => Abelian r #

an additive abelian semigroup

a + b = b + a

Instances

Abelian Bool #

Abelian Int #

Abelian Int8 #

Abelian Int16 #

Abelian Int32 #

Abelian Int64 #

Abelian Integer #

Abelian Natural #

Abelian Word #

Abelian Word8 #

Abelian Word16 #

Abelian Word32 #

Abelian Word64 #

Abelian () #

Abelian Euclidean #

Abelian r => Abelian (ZeroRng r) #

Abelian r => Abelian (RngRing r) #

Abelian r => Abelian (Opposite r) #

Abelian r => Abelian (End r) #

Commutative r => Abelian (Log r) #

Abelian r => Abelian (Trig r) #

Abelian r => Abelian (Quaternion' r) #

Abelian r => Abelian (Hyper r) #

Abelian (BasisCoblade m) #

Abelian r => Abelian (Dual' r) #

Abelian r => Abelian (Quaternion r) #

Abelian r => Abelian (Hyper' r) #

Abelian r => Abelian (Dual r) #

Abelian r => Abelian (Complex r) #

GCDDomain d => Abelian (Fraction d) #

Abelian r => Abelian (e -> r) #

(Abelian a, Abelian b) => Abelian (a, b) #

Abelian s => Abelian (Covector s a) #

(Abelian a, Abelian b, Abelian c) => Abelian (a, b, c) #

Abelian s => Abelian (Map s b a) #

(Abelian a, Abelian b, Abelian c, Abelian d) => Abelian (a, b, c, d) #

(Abelian a, Abelian b, Abelian c, Abelian d, Abelian e) => Abelian (a, b, c, d, e) #

Additive Monoids

class Additive r => Idempotent r #

An additive semigroup with idempotent addition.

a + a = a

Instances

Idempotent Bool #

Idempotent () #

Idempotent r => Idempotent (ZeroRng r) #

Idempotent r => Idempotent (Opposite r) #

Band r => Idempotent (Log r) #

Idempotent r => Idempotent (Trig r) #

Idempotent r => Idempotent (Quaternion' r) #

Idempotent r => Idempotent (Hyper r) #

Idempotent r => Idempotent (Dual' r) #

Idempotent r => Idempotent (Quaternion r) #

Idempotent r => Idempotent (Hyper' r) #

Idempotent r => Idempotent (Dual r) #

Idempotent r => Idempotent (Complex r) #

Idempotent r => Idempotent (e -> r) #

(Idempotent a, Idempotent b) => Idempotent (a, b) #

Idempotent r => Idempotent (Covector r a) #

(Idempotent a, Idempotent b, Idempotent c) => Idempotent (a, b, c) #

(Idempotent a, Idempotent b, Idempotent c, Idempotent d) => Idempotent (a, b, c, d) #

(Idempotent a, Idempotent b, Idempotent c, Idempotent d, Idempotent e) => Idempotent (a, b, c, d, e) #

sinnum1pIdempotent :: Natural -> r -> r #

Partitionable semigroups

class Additive m => Partitionable m where #

Minimal complete definition

partitionWith

Methods

partitionWith :: (m -> m -> r) -> m -> NonEmpty r #

partitionWith f c returns a list containing f a b for each a b such that a + b = c,

Instances

Partitionable Bool #
Methods partitionWith :: (Bool -> Bool -> r) -> Bool -> NonEmpty r #
Partitionable Natural #
Methods partitionWith :: (Natural -> Natural -> r) -> Natural -> NonEmpty r #
Partitionable () #
Methods partitionWith :: (() -> () -> r) -> () -> NonEmpty r #
Factorable r => Partitionable (Log r) #
Methods partitionWith :: (Log r -> Log r -> r) -> Log r -> NonEmpty r #
Partitionable r => Partitionable (Trig r) #
Methods partitionWith :: (Trig r -> Trig r -> r) -> Trig r -> NonEmpty r #
Partitionable r => Partitionable (Quaternion' r) #
Methods partitionWith :: (Quaternion' r -> Quaternion' r -> r) -> Quaternion' r -> NonEmpty r #
Partitionable r => Partitionable (Hyper r) #
Methods partitionWith :: (Hyper r -> Hyper r -> r) -> Hyper r -> NonEmpty r #
Partitionable r => Partitionable (Dual' r) #
Methods partitionWith :: (Dual' r -> Dual' r -> r) -> Dual' r -> NonEmpty r #
Partitionable r => Partitionable (Quaternion r) #
Methods partitionWith :: (Quaternion r -> Quaternion r -> r) -> Quaternion r -> NonEmpty r #
Partitionable r => Partitionable (Hyper' r) #
Methods partitionWith :: (Hyper' r -> Hyper' r -> r) -> Hyper' r -> NonEmpty r #
Partitionable r => Partitionable (Dual r) #
Methods partitionWith :: (Dual r -> Dual r -> r) -> Dual r -> NonEmpty r #
Partitionable r => Partitionable (Complex r) #
Methods partitionWith :: (Complex r -> Complex r -> r) -> Complex r -> NonEmpty r #
(Partitionable a, Partitionable b) => Partitionable (a, b) #
Methods partitionWith :: ((a, b) -> (a, b) -> r) -> (a, b) -> NonEmpty r #
(Partitionable a, Partitionable b, Partitionable c) => Partitionable (a, b, c) #
Methods partitionWith :: ((a, b, c) -> (a, b, c) -> r) -> (a, b, c) -> NonEmpty r #
(Partitionable a, Partitionable b, Partitionable c, Partitionable d) => Partitionable (a, b, c, d) #
Methods partitionWith :: ((a, b, c, d) -> (a, b, c, d) -> r) -> (a, b, c, d) -> NonEmpty r #
(Partitionable a, Partitionable b, Partitionable c, Partitionable d, Partitionable e) => Partitionable (a, b, c, d, e) #
Methods partitionWith :: ((a, b, c, d, e) -> (a, b, c, d, e) -> r) -> (a, b, c, d, e) -> NonEmpty r #