Numeric.Additive.Class

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