Numeric.Algebra

Additive

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 idempotent semigroups

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

sinnumIdempotent :: (Integral n, Idempotent r, Monoidal r) => n -> r -> r

partitionable additive 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

additive monoids

class (LeftModule Natural m, RightModule Natural m) => Monoidal m where

An additive monoid

zero + a = a = a + zero

Minimal complete definition

zero

Methods

zero :: m

sinnum :: Natural -> m -> m

sumWith :: Foldable f => (a -> m) -> f a -> m

Instances

Monoidal Bool

Methods

zero :: Bool

sinnum :: Natural -> Bool -> Bool

sumWith :: Foldable f => (a -> Bool) -> f a -> Bool

Monoidal Int

Methods

zero :: Int

sinnum :: Natural -> Int -> Int

sumWith :: Foldable f => (a -> Int) -> f a -> Int

Monoidal Int8

Methods

zero :: Int8

sinnum :: Natural -> Int8 -> Int8

sumWith :: Foldable f => (a -> Int8) -> f a -> Int8

Monoidal Int16

Methods

zero :: Int16

sinnum :: Natural -> Int16 -> Int16

sumWith :: Foldable f => (a -> Int16) -> f a -> Int16

Monoidal Int32

Methods

zero :: Int32

sinnum :: Natural -> Int32 -> Int32

sumWith :: Foldable f => (a -> Int32) -> f a -> Int32

Monoidal Int64

Methods

zero :: Int64

sinnum :: Natural -> Int64 -> Int64

sumWith :: Foldable f => (a -> Int64) -> f a -> Int64

Monoidal Integer

Methods

zero :: Integer

sinnum :: Natural -> Integer -> Integer

sumWith :: Foldable f => (a -> Integer) -> f a -> Integer

Monoidal Natural

Methods

zero :: Natural

sinnum :: Natural -> Natural -> Natural

sumWith :: Foldable f => (a -> Natural) -> f a -> Natural

Monoidal Word

Methods

zero :: Word

sinnum :: Natural -> Word -> Word

sumWith :: Foldable f => (a -> Word) -> f a -> Word

Monoidal Word8

Methods

zero :: Word8

sinnum :: Natural -> Word8 -> Word8

sumWith :: Foldable f => (a -> Word8) -> f a -> Word8

Monoidal Word16

Methods

zero :: Word16

sinnum :: Natural -> Word16 -> Word16

sumWith :: Foldable f => (a -> Word16) -> f a -> Word16

Monoidal Word32

Methods

zero :: Word32

sinnum :: Natural -> Word32 -> Word32

sumWith :: Foldable f => (a -> Word32) -> f a -> Word32

Monoidal Word64

Methods

zero :: Word64

sinnum :: Natural -> Word64 -> Word64

sumWith :: Foldable f => (a -> Word64) -> f a -> Word64

Monoidal ()

Methods

zero :: ()

sinnum :: Natural -> () -> ()

sumWith :: Foldable f => (a -> ()) -> f a -> ()

Monoidal Euclidean

Methods

zero :: Euclidean

sinnum :: Natural -> Euclidean -> Euclidean

sumWith :: Foldable f => (a -> Euclidean) -> f a -> Euclidean

Monoidal r => Monoidal (ZeroRng r)

Methods

zero :: ZeroRng r

sinnum :: Natural -> ZeroRng r -> ZeroRng r

sumWith :: Foldable f => (a -> ZeroRng r) -> f a -> ZeroRng r

(Abelian r, Monoidal r) => Monoidal (RngRing r)

Methods

zero :: RngRing r

sinnum :: Natural -> RngRing r -> RngRing r

sumWith :: Foldable f => (a -> RngRing r) -> f a -> RngRing r

Monoidal r => Monoidal (Opposite r)

Methods

zero :: Opposite r

sinnum :: Natural -> Opposite r -> Opposite r

sumWith :: Foldable f => (a -> Opposite r) -> f a -> Opposite r

Monoidal r => Monoidal (End r)

Methods

zero :: End r

sinnum :: Natural -> End r -> End r

sumWith :: Foldable f => (a -> End r) -> f a -> End r

Unital r => Monoidal (Log r)

Methods

zero :: Log r

sinnum :: Natural -> Log r -> Log r

sumWith :: Foldable f => (a -> Log r) -> f a -> Log r

Monoidal r => Monoidal (Trig r)

Methods

zero :: Trig r

sinnum :: Natural -> Trig r -> Trig r

sumWith :: Foldable f => (a -> Trig r) -> f a -> Trig r

Monoidal r => Monoidal (Quaternion' r)

Methods

zero :: Quaternion' r

sinnum :: Natural -> Quaternion' r -> Quaternion' r

sumWith :: Foldable f => (a -> Quaternion' r) -> f a -> Quaternion' r

Monoidal r => Monoidal (Hyper r)

Methods

zero :: Hyper r

sinnum :: Natural -> Hyper r -> Hyper r

sumWith :: Foldable f => (a -> Hyper r) -> f a -> Hyper r

Monoidal (BasisCoblade m)

Methods

zero :: BasisCoblade m

sinnum :: Natural -> BasisCoblade m -> BasisCoblade m

sumWith :: Foldable f => (a -> BasisCoblade m) -> f a -> BasisCoblade m

Monoidal r => Monoidal (Dual' r)

Methods

zero :: Dual' r

sinnum :: Natural -> Dual' r -> Dual' r

sumWith :: Foldable f => (a -> Dual' r) -> f a -> Dual' r

Monoidal r => Monoidal (Quaternion r)

Methods

zero :: Quaternion r

sinnum :: Natural -> Quaternion r -> Quaternion r

sumWith :: Foldable f => (a -> Quaternion r) -> f a -> Quaternion r

Monoidal r => Monoidal (Hyper' r)

Methods

zero :: Hyper' r

sinnum :: Natural -> Hyper' r -> Hyper' r

sumWith :: Foldable f => (a -> Hyper' r) -> f a -> Hyper' r

Monoidal r => Monoidal (Dual r)

Methods

zero :: Dual r

sinnum :: Natural -> Dual r -> Dual r

sumWith :: Foldable f => (a -> Dual r) -> f a -> Dual r

Monoidal r => Monoidal (Complex r)

Methods

zero :: Complex r

sinnum :: Natural -> Complex r -> Complex r

sumWith :: Foldable f => (a -> Complex r) -> f a -> Complex r

GCDDomain d => Monoidal (Fraction d)

Methods

zero :: Fraction d

sinnum :: Natural -> Fraction d -> Fraction d

sumWith :: Foldable f => (a -> Fraction d) -> f a -> Fraction d

Monoidal r => Monoidal (e -> r)

Methods

zero :: e -> r

sinnum :: Natural -> (e -> r) -> e -> r

sumWith :: Foldable f => (a -> e -> r) -> f a -> e -> r

(Monoidal a, Monoidal b) => Monoidal (a, b)

Methods

zero :: (a, b)

sinnum :: Natural -> (a, b) -> (a, b)

sumWith :: Foldable f => (a -> (a, b)) -> f a -> (a, b)

Monoidal s => Monoidal (Covector s a)

Methods

zero :: Covector s a

sinnum :: Natural -> Covector s a -> Covector s a

sumWith :: Foldable f => (a -> Covector s a) -> f a -> Covector s a

(Monoidal a, Monoidal b, Monoidal c) => Monoidal (a, b, c)

Methods

zero :: (a, b, c)

sinnum :: Natural -> (a, b, c) -> (a, b, c)

sumWith :: Foldable f => (a -> (a, b, c)) -> f a -> (a, b, c)

Monoidal s => Monoidal (Map s b a)

Methods

zero :: Map s b a

sinnum :: Natural -> Map s b a -> Map s b a

sumWith :: Foldable f => (a -> Map s b a) -> f a -> Map s b a

(Monoidal a, Monoidal b, Monoidal c, Monoidal d) => Monoidal (a, b, c, d)

Methods

zero :: (a, b, c, d)

sinnum :: Natural -> (a, b, c, d) -> (a, b, c, d)

sumWith :: Foldable f => (a -> (a, b, c, d)) -> f a -> (a, b, c, d)

(Monoidal a, Monoidal b, Monoidal c, Monoidal d, Monoidal e) => Monoidal (a, b, c, d, e)

Methods

zero :: (a, b, c, d, e)

sinnum :: Natural -> (a, b, c, d, e) -> (a, b, c, d, e)

sumWith :: Foldable f => (a -> (a, b, c, d, e)) -> f a -> (a, b, c, d, e)

sum :: (Foldable f, Monoidal m) => f m -> m

additive groups

class (LeftModule Integer r, RightModule Integer r, Monoidal r) => Group r where

Methods

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

negate :: r -> r

subtract :: r -> r -> r

times :: Integral n => n -> r -> r infixl 7

Instances

Group Int

Methods

(-) :: Int -> Int -> Int

negate :: Int -> Int

subtract :: Int -> Int -> Int

times :: Integral n => n -> Int -> Int

Group Int8

Methods

(-) :: Int8 -> Int8 -> Int8

negate :: Int8 -> Int8

subtract :: Int8 -> Int8 -> Int8

times :: Integral n => n -> Int8 -> Int8

Group Int16

Methods

(-) :: Int16 -> Int16 -> Int16

negate :: Int16 -> Int16

subtract :: Int16 -> Int16 -> Int16

times :: Integral n => n -> Int16 -> Int16

Group Int32

Methods

(-) :: Int32 -> Int32 -> Int32

negate :: Int32 -> Int32

subtract :: Int32 -> Int32 -> Int32

times :: Integral n => n -> Int32 -> Int32

Group Int64

Methods

(-) :: Int64 -> Int64 -> Int64

negate :: Int64 -> Int64

subtract :: Int64 -> Int64 -> Int64

times :: Integral n => n -> Int64 -> Int64

Group Integer

Methods

(-) :: Integer -> Integer -> Integer

negate :: Integer -> Integer

subtract :: Integer -> Integer -> Integer

times :: Integral n => n -> Integer -> Integer

Group Word

Methods

(-) :: Word -> Word -> Word

negate :: Word -> Word

subtract :: Word -> Word -> Word

times :: Integral n => n -> Word -> Word

Group Word8

Methods

(-) :: Word8 -> Word8 -> Word8

negate :: Word8 -> Word8

subtract :: Word8 -> Word8 -> Word8

times :: Integral n => n -> Word8 -> Word8

Group Word16

Methods

(-) :: Word16 -> Word16 -> Word16

negate :: Word16 -> Word16

subtract :: Word16 -> Word16 -> Word16

times :: Integral n => n -> Word16 -> Word16

Group Word32

Methods

(-) :: Word32 -> Word32 -> Word32

negate :: Word32 -> Word32

subtract :: Word32 -> Word32 -> Word32

times :: Integral n => n -> Word32 -> Word32

Group Word64

Methods

(-) :: Word64 -> Word64 -> Word64

negate :: Word64 -> Word64

subtract :: Word64 -> Word64 -> Word64

times :: Integral n => n -> Word64 -> Word64

Group ()

Methods

(-) :: () -> () -> ()

negate :: () -> ()

subtract :: () -> () -> ()

times :: Integral n => n -> () -> ()

Group Euclidean

Methods

(-) :: Euclidean -> Euclidean -> Euclidean

negate :: Euclidean -> Euclidean

subtract :: Euclidean -> Euclidean -> Euclidean

times :: Integral n => n -> Euclidean -> Euclidean

Group r => Group (ZeroRng r)

Methods

(-) :: ZeroRng r -> ZeroRng r -> ZeroRng r

negate :: ZeroRng r -> ZeroRng r

subtract :: ZeroRng r -> ZeroRng r -> ZeroRng r

times :: Integral n => n -> ZeroRng r -> ZeroRng r

(Abelian r, Group r) => Group (RngRing r)

Methods

(-) :: RngRing r -> RngRing r -> RngRing r

negate :: RngRing r -> RngRing r

subtract :: RngRing r -> RngRing r -> RngRing r

times :: Integral n => n -> RngRing r -> RngRing r

Group r => Group (Opposite r)

Methods

(-) :: Opposite r -> Opposite r -> Opposite r

negate :: Opposite r -> Opposite r

subtract :: Opposite r -> Opposite r -> Opposite r

times :: Integral n => n -> Opposite r -> Opposite r

Group r => Group (End r)

Methods

(-) :: End r -> End r -> End r

negate :: End r -> End r

subtract :: End r -> End r -> End r

times :: Integral n => n -> End r -> End r

Division r => Group (Log r)

Methods

(-) :: Log r -> Log r -> Log r

negate :: Log r -> Log r

subtract :: Log r -> Log r -> Log r

times :: Integral n => n -> Log r -> Log r

Group r => Group (Trig r)

Methods

(-) :: Trig r -> Trig r -> Trig r

negate :: Trig r -> Trig r

subtract :: Trig r -> Trig r -> Trig r

times :: Integral n => n -> Trig r -> Trig r

Group r => Group (Quaternion' r)

Methods

(-) :: Quaternion' r -> Quaternion' r -> Quaternion' r

negate :: Quaternion' r -> Quaternion' r

subtract :: Quaternion' r -> Quaternion' r -> Quaternion' r

times :: Integral n => n -> Quaternion' r -> Quaternion' r

Group r => Group (Hyper r)

Methods

(-) :: Hyper r -> Hyper r -> Hyper r

negate :: Hyper r -> Hyper r

subtract :: Hyper r -> Hyper r -> Hyper r

times :: Integral n => n -> Hyper r -> Hyper r

Group r => Group (Dual' r)

Methods

(-) :: Dual' r -> Dual' r -> Dual' r

negate :: Dual' r -> Dual' r

subtract :: Dual' r -> Dual' r -> Dual' r

times :: Integral n => n -> Dual' r -> Dual' r

Group r => Group (Quaternion r)

Methods

(-) :: Quaternion r -> Quaternion r -> Quaternion r

negate :: Quaternion r -> Quaternion r

subtract :: Quaternion r -> Quaternion r -> Quaternion r

times :: Integral n => n -> Quaternion r -> Quaternion r

Group r => Group (Hyper' r)

Methods

(-) :: Hyper' r -> Hyper' r -> Hyper' r

negate :: Hyper' r -> Hyper' r

subtract :: Hyper' r -> Hyper' r -> Hyper' r

times :: Integral n => n -> Hyper' r -> Hyper' r

Group r => Group (Dual r)

Methods

(-) :: Dual r -> Dual r -> Dual r

negate :: Dual r -> Dual r

subtract :: Dual r -> Dual r -> Dual r

times :: Integral n => n -> Dual r -> Dual r

Group r => Group (Complex r)

Methods

(-) :: Complex r -> Complex r -> Complex r

negate :: Complex r -> Complex r

subtract :: Complex r -> Complex r -> Complex r

times :: Integral n => n -> Complex r -> Complex r

GCDDomain d => Group (Fraction d)

Methods

(-) :: Fraction d -> Fraction d -> Fraction d

negate :: Fraction d -> Fraction d

subtract :: Fraction d -> Fraction d -> Fraction d

times :: Integral n => n -> Fraction d -> Fraction d

Group r => Group (e -> r)

Methods

(-) :: (e -> r) -> (e -> r) -> e -> r

negate :: (e -> r) -> e -> r

subtract :: (e -> r) -> (e -> r) -> e -> r

times :: Integral n => n -> (e -> r) -> e -> r

(Group a, Group b) => Group (a, b)

Methods

(-) :: (a, b) -> (a, b) -> (a, b)

negate :: (a, b) -> (a, b)

subtract :: (a, b) -> (a, b) -> (a, b)

times :: Integral n => n -> (a, b) -> (a, b)

Group s => Group (Covector s a)

Methods

(-) :: Covector s a -> Covector s a -> Covector s a

negate :: Covector s a -> Covector s a

subtract :: Covector s a -> Covector s a -> Covector s a

times :: Integral n => n -> Covector s a -> Covector s a

(Group a, Group b, Group c) => Group (a, b, c)

Methods

(-) :: (a, b, c) -> (a, b, c) -> (a, b, c)

negate :: (a, b, c) -> (a, b, c)

subtract :: (a, b, c) -> (a, b, c) -> (a, b, c)

times :: Integral n => n -> (a, b, c) -> (a, b, c)

Group s => Group (Map s b a)

Methods

(-) :: Map s b a -> Map s b a -> Map s b a

negate :: Map s b a -> Map s b a

subtract :: Map s b a -> Map s b a -> Map s b a

times :: Integral n => n -> Map s b a -> Map s b a

(Group a, Group b, Group c, Group d) => Group (a, b, c, d)

Methods

(-) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

negate :: (a, b, c, d) -> (a, b, c, d)

subtract :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

times :: Integral n => n -> (a, b, c, d) -> (a, b, c, d)

(Group a, Group b, Group c, Group d, Group e) => Group (a, b, c, d, e)

Methods

(-) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

negate :: (a, b, c, d, e) -> (a, b, c, d, e)

subtract :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

times :: Integral n => n -> (a, b, c, d, e) -> (a, b, c, d, e)

Multiplicative

multiplicative semigroups

class Multiplicative r where

A multiplicative semigroup

Minimal complete definition

(*)

Methods

(*) :: r -> r -> r infixl 7

pow1p :: r -> Natural -> r infixr 8

productWith1 :: Foldable1 f => (a -> r) -> f a -> r

Instances

Multiplicative Bool

Methods

(*) :: Bool -> Bool -> Bool

pow1p :: Bool -> Natural -> Bool

productWith1 :: Foldable1 f => (a -> Bool) -> f a -> Bool

Multiplicative Int

Methods

(*) :: Int -> Int -> Int

pow1p :: Int -> Natural -> Int

productWith1 :: Foldable1 f => (a -> Int) -> f a -> Int

Multiplicative Int8

Methods

(*) :: Int8 -> Int8 -> Int8

pow1p :: Int8 -> Natural -> Int8

productWith1 :: Foldable1 f => (a -> Int8) -> f a -> Int8

Multiplicative Int16

Methods

(*) :: Int16 -> Int16 -> Int16

pow1p :: Int16 -> Natural -> Int16

productWith1 :: Foldable1 f => (a -> Int16) -> f a -> Int16

Multiplicative Int32

Methods

(*) :: Int32 -> Int32 -> Int32

pow1p :: Int32 -> Natural -> Int32

productWith1 :: Foldable1 f => (a -> Int32) -> f a -> Int32

Multiplicative Int64

Methods

(*) :: Int64 -> Int64 -> Int64

pow1p :: Int64 -> Natural -> Int64

productWith1 :: Foldable1 f => (a -> Int64) -> f a -> Int64

Multiplicative Integer

Methods

(*) :: Integer -> Integer -> Integer

pow1p :: Integer -> Natural -> Integer

productWith1 :: Foldable1 f => (a -> Integer) -> f a -> Integer

Multiplicative Natural

Methods

(*) :: Natural -> Natural -> Natural

pow1p :: Natural -> Natural -> Natural

productWith1 :: Foldable1 f => (a -> Natural) -> f a -> Natural

Multiplicative Word

Methods

(*) :: Word -> Word -> Word

pow1p :: Word -> Natural -> Word

productWith1 :: Foldable1 f => (a -> Word) -> f a -> Word

Multiplicative Word8

Methods

(*) :: Word8 -> Word8 -> Word8

pow1p :: Word8 -> Natural -> Word8

productWith1 :: Foldable1 f => (a -> Word8) -> f a -> Word8

Multiplicative Word16

Methods

(*) :: Word16 -> Word16 -> Word16

pow1p :: Word16 -> Natural -> Word16

productWith1 :: Foldable1 f => (a -> Word16) -> f a -> Word16

Multiplicative Word32

Methods

(*) :: Word32 -> Word32 -> Word32

pow1p :: Word32 -> Natural -> Word32

productWith1 :: Foldable1 f => (a -> Word32) -> f a -> Word32

Multiplicative Word64

Methods

(*) :: Word64 -> Word64 -> Word64

pow1p :: Word64 -> Natural -> Word64

productWith1 :: Foldable1 f => (a -> Word64) -> f a -> Word64

Multiplicative ()

Methods

(*) :: () -> () -> ()

pow1p :: () -> Natural -> ()

productWith1 :: Foldable1 f => (a -> ()) -> f a -> ()

Multiplicative Euclidean

Methods

(*) :: Euclidean -> Euclidean -> Euclidean

pow1p :: Euclidean -> Natural -> Euclidean

productWith1 :: Foldable1 f => (a -> Euclidean) -> f a -> Euclidean

Monoidal r => Multiplicative (ZeroRng r)

Methods

(*) :: ZeroRng r -> ZeroRng r -> ZeroRng r

pow1p :: ZeroRng r -> Natural -> ZeroRng r

productWith1 :: Foldable1 f => (a -> ZeroRng r) -> f a -> ZeroRng r

Rng r => Multiplicative (RngRing r)

Methods

(*) :: RngRing r -> RngRing r -> RngRing r

pow1p :: RngRing r -> Natural -> RngRing r

productWith1 :: Foldable1 f => (a -> RngRing r) -> f a -> RngRing r

Multiplicative r => Multiplicative (Opposite r)

Methods

(*) :: Opposite r -> Opposite r -> Opposite r

pow1p :: Opposite r -> Natural -> Opposite r

productWith1 :: Foldable1 f => (a -> Opposite r) -> f a -> Opposite r

Multiplicative (End r)

Methods

(*) :: End r -> End r -> End r

pow1p :: End r -> Natural -> End r

productWith1 :: Foldable1 f => (a -> End r) -> f a -> End r

Additive r => Multiplicative (Exp r)

Methods

(*) :: Exp r -> Exp r -> Exp r

pow1p :: Exp r -> Natural -> Exp r

productWith1 :: Foldable1 f => (a -> Exp r) -> f a -> Exp r

(Commutative k, Rng k) => Multiplicative (Trig k)

Methods

(*) :: Trig k -> Trig k -> Trig k

pow1p :: Trig k -> Natural -> Trig k

productWith1 :: Foldable1 f => (a -> Trig k) -> f a -> Trig k

(TriviallyInvolutive r, Semiring r) => Multiplicative (Quaternion' r)

Methods

(*) :: Quaternion' r -> Quaternion' r -> Quaternion' r

pow1p :: Quaternion' r -> Natural -> Quaternion' r

productWith1 :: Foldable1 f => (a -> Quaternion' r) -> f a -> Quaternion' r

(Commutative k, Semiring k) => Multiplicative (Hyper k)

Methods

(*) :: Hyper k -> Hyper k -> Hyper k

pow1p :: Hyper k -> Natural -> Hyper k

productWith1 :: Foldable1 f => (a -> Hyper k) -> f a -> Hyper k

Multiplicative (BasisCoblade m)

Methods

(*) :: BasisCoblade m -> BasisCoblade m -> BasisCoblade m

pow1p :: BasisCoblade m -> Natural -> BasisCoblade m

productWith1 :: Foldable1 f => (a -> BasisCoblade m) -> f a -> BasisCoblade m

(Commutative r, Rng r) => Multiplicative (Dual' r)

Methods

(*) :: Dual' r -> Dual' r -> Dual' r

pow1p :: Dual' r -> Natural -> Dual' r

productWith1 :: Foldable1 f => (a -> Dual' r) -> f a -> Dual' r

(TriviallyInvolutive r, Rng r) => Multiplicative (Quaternion r)

Methods

(*) :: Quaternion r -> Quaternion r -> Quaternion r

pow1p :: Quaternion r -> Natural -> Quaternion r

productWith1 :: Foldable1 f => (a -> Quaternion r) -> f a -> Quaternion r

(Commutative k, Semiring k) => Multiplicative (Hyper' k)

Methods

(*) :: Hyper' k -> Hyper' k -> Hyper' k

pow1p :: Hyper' k -> Natural -> Hyper' k

productWith1 :: Foldable1 f => (a -> Hyper' k) -> f a -> Hyper' k

(Commutative r, Rng r) => Multiplicative (Dual r)

Methods

(*) :: Dual r -> Dual r -> Dual r

pow1p :: Dual r -> Natural -> Dual r

productWith1 :: Foldable1 f => (a -> Dual r) -> f a -> Dual r

(Commutative r, Rng r) => Multiplicative (Complex r)

Methods

(*) :: Complex r -> Complex r -> Complex r

pow1p :: Complex r -> Natural -> Complex r

productWith1 :: Foldable1 f => (a -> Complex r) -> f a -> Complex r

GCDDomain d => Multiplicative (Fraction d)

Methods

(*) :: Fraction d -> Fraction d -> Fraction d

pow1p :: Fraction d -> Natural -> Fraction d

productWith1 :: Foldable1 f => (a -> Fraction d) -> f a -> Fraction d

Algebra r a => Multiplicative (a -> r)

Methods

(*) :: (a -> r) -> (a -> r) -> a -> r

pow1p :: (a -> r) -> Natural -> a -> r

productWith1 :: Foldable1 f => (a -> a -> r) -> f a -> a -> r

(Multiplicative a, Multiplicative b) => Multiplicative (a, b)

Methods

(*) :: (a, b) -> (a, b) -> (a, b)

pow1p :: (a, b) -> Natural -> (a, b)

productWith1 :: Foldable1 f => (a -> (a, b)) -> f a -> (a, b)

Multiplicative (Rect i j)

Methods

(*) :: Rect i j -> Rect i j -> Rect i j

pow1p :: Rect i j -> Natural -> Rect i j

productWith1 :: Foldable1 f => (a -> Rect i j) -> f a -> Rect i j

Coalgebra r m => Multiplicative (Covector r m)

Methods

(*) :: Covector r m -> Covector r m -> Covector r m

pow1p :: Covector r m -> Natural -> Covector r m

productWith1 :: Foldable1 f => (a -> Covector r m) -> f a -> Covector r m

(Multiplicative a, Multiplicative b, Multiplicative c) => Multiplicative (a, b, c)

Methods

(*) :: (a, b, c) -> (a, b, c) -> (a, b, c)

pow1p :: (a, b, c) -> Natural -> (a, b, c)

productWith1 :: Foldable1 f => (a -> (a, b, c)) -> f a -> (a, b, c)

Coalgebra r m => Multiplicative (Map r b m)

Methods

(*) :: Map r b m -> Map r b m -> Map r b m

pow1p :: Map r b m -> Natural -> Map r b m

productWith1 :: Foldable1 f => (a -> Map r b m) -> f a -> Map r b m

(Multiplicative a, Multiplicative b, Multiplicative c, Multiplicative d) => Multiplicative (a, b, c, d)

Methods

(*) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

pow1p :: (a, b, c, d) -> Natural -> (a, b, c, d)

productWith1 :: Foldable1 f => (a -> (a, b, c, d)) -> f a -> (a, b, c, d)

(Multiplicative a, Multiplicative b, Multiplicative c, Multiplicative d, Multiplicative e) => Multiplicative (a, b, c, d, e)

Methods

(*) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

pow1p :: (a, b, c, d, e) -> Natural -> (a, b, c, d, e)

productWith1 :: Foldable1 f => (a -> (a, b, c, d, e)) -> f a -> (a, b, c, d, e)

product1 :: (Foldable1 f, Multiplicative r) => f r -> r

commutative multiplicative semigroups

class Multiplicative r => Commutative r

A commutative multiplicative semigroup

Instances

Commutative Bool

Commutative Int

Commutative Int8

Commutative Int16

Commutative Int32

Commutative Int64

Commutative Integer

Commutative Natural

Commutative Word

Commutative Word8

Commutative Word16

Commutative Word32

Commutative Word64

Commutative ()

Commutative Euclidean

Monoidal r => Commutative (ZeroRng r)

(Commutative r, Rng r) => Commutative (RngRing r)

Commutative r => Commutative (Opposite r)

(Abelian r, Commutative r) => Commutative (End r)

Abelian r => Commutative (Exp r)

(Commutative k, Rng k) => Commutative (Trig k)

(Commutative k, Semiring k) => Commutative (Hyper k)

Commutative (BasisCoblade m)

(TriviallyInvolutive r, Rng r) => Commutative (Dual' r)

(Commutative k, Semiring k) => Commutative (Hyper' k)

(TriviallyInvolutive r, Rng r) => Commutative (Dual r)

(TriviallyInvolutive r, Rng r) => Commutative (Complex r)

GCDDomain d => Commutative (Fraction d)

CommutativeAlgebra r a => Commutative (a -> r)

(Commutative a, Commutative b) => Commutative (a, b)

(Commutative m, Coalgebra r m) => Commutative (Covector r m)

(Commutative a, Commutative b, Commutative c) => Commutative (a, b, c)

(Commutative m, Coalgebra r m) => Commutative (Map r b m)

(Commutative a, Commutative b, Commutative c, Commutative d) => Commutative (a, b, c, d)

(Commutative a, Commutative b, Commutative c, Commutative d, Commutative e) => Commutative (a, b, c, d, e)

multiplicative monoids

class Multiplicative r => Unital r where

Minimal complete definition

one

Methods

one :: r

pow :: r -> Natural -> r infixr 8

productWith :: Foldable f => (a -> r) -> f a -> r

Instances

Unital Bool

Methods

one :: Bool

pow :: Bool -> Natural -> Bool

productWith :: Foldable f => (a -> Bool) -> f a -> Bool

Unital Int

Methods

one :: Int

pow :: Int -> Natural -> Int

productWith :: Foldable f => (a -> Int) -> f a -> Int

Unital Int8

Methods

one :: Int8

pow :: Int8 -> Natural -> Int8

productWith :: Foldable f => (a -> Int8) -> f a -> Int8

Unital Int16

Methods

one :: Int16

pow :: Int16 -> Natural -> Int16

productWith :: Foldable f => (a -> Int16) -> f a -> Int16

Unital Int32

Methods

one :: Int32

pow :: Int32 -> Natural -> Int32

productWith :: Foldable f => (a -> Int32) -> f a -> Int32

Unital Int64

Methods

one :: Int64

pow :: Int64 -> Natural -> Int64

productWith :: Foldable f => (a -> Int64) -> f a -> Int64

Unital Integer

Methods

one :: Integer

pow :: Integer -> Natural -> Integer

productWith :: Foldable f => (a -> Integer) -> f a -> Integer

Unital Natural

Methods

one :: Natural

pow :: Natural -> Natural -> Natural

productWith :: Foldable f => (a -> Natural) -> f a -> Natural

Unital Word

Methods

one :: Word

pow :: Word -> Natural -> Word

productWith :: Foldable f => (a -> Word) -> f a -> Word

Unital Word8

Methods

one :: Word8

pow :: Word8 -> Natural -> Word8

productWith :: Foldable f => (a -> Word8) -> f a -> Word8

Unital Word16

Methods

one :: Word16

pow :: Word16 -> Natural -> Word16

productWith :: Foldable f => (a -> Word16) -> f a -> Word16

Unital Word32

Methods

one :: Word32

pow :: Word32 -> Natural -> Word32

productWith :: Foldable f => (a -> Word32) -> f a -> Word32

Unital Word64

Methods

one :: Word64

pow :: Word64 -> Natural -> Word64

productWith :: Foldable f => (a -> Word64) -> f a -> Word64

Unital ()

Methods

one :: ()

pow :: () -> Natural -> ()

productWith :: Foldable f => (a -> ()) -> f a -> ()

Unital Euclidean

Methods

one :: Euclidean

pow :: Euclidean -> Natural -> Euclidean

productWith :: Foldable f => (a -> Euclidean) -> f a -> Euclidean

Rng r => Unital (RngRing r)

Methods

one :: RngRing r

pow :: RngRing r -> Natural -> RngRing r

productWith :: Foldable f => (a -> RngRing r) -> f a -> RngRing r

Unital r => Unital (Opposite r)

Methods

one :: Opposite r

pow :: Opposite r -> Natural -> Opposite r

productWith :: Foldable f => (a -> Opposite r) -> f a -> Opposite r

Unital (End r)

Methods

one :: End r

pow :: End r -> Natural -> End r

productWith :: Foldable f => (a -> End r) -> f a -> End r

Monoidal r => Unital (Exp r)

Methods

one :: Exp r

pow :: Exp r -> Natural -> Exp r

productWith :: Foldable f => (a -> Exp r) -> f a -> Exp r

(Commutative k, Ring k) => Unital (Trig k)

Methods

one :: Trig k

pow :: Trig k -> Natural -> Trig k

productWith :: Foldable f => (a -> Trig k) -> f a -> Trig k

(TriviallyInvolutive r, Ring r) => Unital (Quaternion' r)

Methods

one :: Quaternion' r

pow :: Quaternion' r -> Natural -> Quaternion' r

productWith :: Foldable f => (a -> Quaternion' r) -> f a -> Quaternion' r

(Commutative k, Rig k) => Unital (Hyper k)

Methods

one :: Hyper k

pow :: Hyper k -> Natural -> Hyper k

productWith :: Foldable f => (a -> Hyper k) -> f a -> Hyper k

Unital (BasisCoblade m)

Methods

one :: BasisCoblade m

pow :: BasisCoblade m -> Natural -> BasisCoblade m

productWith :: Foldable f => (a -> BasisCoblade m) -> f a -> BasisCoblade m

(Commutative r, Ring r) => Unital (Dual' r)

Methods

one :: Dual' r

pow :: Dual' r -> Natural -> Dual' r

productWith :: Foldable f => (a -> Dual' r) -> f a -> Dual' r

(TriviallyInvolutive r, Ring r) => Unital (Quaternion r)

Methods

one :: Quaternion r

pow :: Quaternion r -> Natural -> Quaternion r

productWith :: Foldable f => (a -> Quaternion r) -> f a -> Quaternion r

(Commutative k, Rig k) => Unital (Hyper' k)

Methods

one :: Hyper' k

pow :: Hyper' k -> Natural -> Hyper' k

productWith :: Foldable f => (a -> Hyper' k) -> f a -> Hyper' k

(Commutative r, Ring r) => Unital (Dual r)

Methods

one :: Dual r

pow :: Dual r -> Natural -> Dual r

productWith :: Foldable f => (a -> Dual r) -> f a -> Dual r

(Commutative r, Ring r) => Unital (Complex r)

Methods

one :: Complex r

pow :: Complex r -> Natural -> Complex r

productWith :: Foldable f => (a -> Complex r) -> f a -> Complex r

GCDDomain d => Unital (Fraction d)

Methods

one :: Fraction d

pow :: Fraction d -> Natural -> Fraction d

productWith :: Foldable f => (a -> Fraction d) -> f a -> Fraction d

(Unital r, UnitalAlgebra r a) => Unital (a -> r)

Methods

one :: a -> r

pow :: (a -> r) -> Natural -> a -> r

productWith :: Foldable f => (a -> a -> r) -> f a -> a -> r

(Unital a, Unital b) => Unital (a, b)

Methods

one :: (a, b)

pow :: (a, b) -> Natural -> (a, b)

productWith :: Foldable f => (a -> (a, b)) -> f a -> (a, b)

CounitalCoalgebra r m => Unital (Covector r m)

Methods

one :: Covector r m

pow :: Covector r m -> Natural -> Covector r m

productWith :: Foldable f => (a -> Covector r m) -> f a -> Covector r m

(Unital a, Unital b, Unital c) => Unital (a, b, c)

Methods

one :: (a, b, c)

pow :: (a, b, c) -> Natural -> (a, b, c)

productWith :: Foldable f => (a -> (a, b, c)) -> f a -> (a, b, c)

CounitalCoalgebra r m => Unital (Map r b m)

Methods

one :: Map r b m

pow :: Map r b m -> Natural -> Map r b m

productWith :: Foldable f => (a -> Map r b m) -> f a -> Map r b m

(Unital a, Unital b, Unital c, Unital d) => Unital (a, b, c, d)

Methods

one :: (a, b, c, d)

pow :: (a, b, c, d) -> Natural -> (a, b, c, d)

productWith :: Foldable f => (a -> (a, b, c, d)) -> f a -> (a, b, c, d)

(Unital a, Unital b, Unital c, Unital d, Unital e) => Unital (a, b, c, d, e)

Methods

one :: (a, b, c, d, e)

pow :: (a, b, c, d, e) -> Natural -> (a, b, c, d, e)

productWith :: Foldable f => (a -> (a, b, c, d, e)) -> f a -> (a, b, c, d, e)

product :: (Foldable f, Unital r) => f r -> r

idempotent multiplicative semigroups

class Multiplicative r => Band r

An multiplicative semigroup with idempotent multiplication.

a * a = a

Instances

Band Bool

Band ()

Band r => Band (Opposite r)

Idempotent r => Band (Exp r)

(Band a, Band b) => Band (a, b)

Band (Rect i j)

(Idempotent r, IdempotentCoalgebra r a) => Band (Covector r a)

(Band a, Band b, Band c) => Band (a, b, c)

(Band a, Band b, Band c, Band d) => Band (a, b, c, d)

(Band a, Band b, Band c, Band d, Band e) => Band (a, b, c, d, e)

pow1pBand :: r -> Natural -> r

powBand :: Unital r => r -> Natural -> r

multiplicative groups

class Unital r => Division r where

Methods

recip :: r -> r

(/) :: r -> r -> r infixl 7

(\\) :: r -> r -> r infixl 7

(^) :: Integral n => r -> n -> r infixr 8

Instances

Division ()

Methods

recip :: () -> ()

(/) :: () -> () -> ()

(\\) :: () -> () -> ()

(^) :: Integral n => () -> n -> ()

(Rng r, Division r) => Division (RngRing r)

Methods

recip :: RngRing r -> RngRing r

(/) :: RngRing r -> RngRing r -> RngRing r

(\\) :: RngRing r -> RngRing r -> RngRing r

(^) :: Integral n => RngRing r -> n -> RngRing r

Division r => Division (Opposite r)

Methods

recip :: Opposite r -> Opposite r

(/) :: Opposite r -> Opposite r -> Opposite r

(\\) :: Opposite r -> Opposite r -> Opposite r

(^) :: Integral n => Opposite r -> n -> Opposite r

Group r => Division (Exp r)

Methods

recip :: Exp r -> Exp r

(/) :: Exp r -> Exp r -> Exp r

(\\) :: Exp r -> Exp r -> Exp r

(^) :: Integral n => Exp r -> n -> Exp r

(TriviallyInvolutive r, Ring r, Division r) => Division (Quaternion' r)

Methods

recip :: Quaternion' r -> Quaternion' r

(/) :: Quaternion' r -> Quaternion' r -> Quaternion' r

(\\) :: Quaternion' r -> Quaternion' r -> Quaternion' r

(^) :: Integral n => Quaternion' r -> n -> Quaternion' r

(Commutative r, InvolutiveSemiring r, DivisionRing r) => Division (Dual' r)

Methods

recip :: Dual' r -> Dual' r

(/) :: Dual' r -> Dual' r -> Dual' r

(\\) :: Dual' r -> Dual' r -> Dual' r

(^) :: Integral n => Dual' r -> n -> Dual' r

(TriviallyInvolutive r, Ring r, Division r) => Division (Quaternion r)

Methods

recip :: Quaternion r -> Quaternion r

(/) :: Quaternion r -> Quaternion r -> Quaternion r

(\\) :: Quaternion r -> Quaternion r -> Quaternion r

(^) :: Integral n => Quaternion r -> n -> Quaternion r

(Commutative r, InvolutiveSemiring r, DivisionRing r) => Division (Hyper' r)

Methods

recip :: Hyper' r -> Hyper' r

(/) :: Hyper' r -> Hyper' r -> Hyper' r

(\\) :: Hyper' r -> Hyper' r -> Hyper' r

(^) :: Integral n => Hyper' r -> n -> Hyper' r

(Commutative r, InvolutiveSemiring r, DivisionRing r) => Division (Dual r)

Methods

recip :: Dual r -> Dual r

(/) :: Dual r -> Dual r -> Dual r

(\\) :: Dual r -> Dual r -> Dual r

(^) :: Integral n => Dual r -> n -> Dual r

(Commutative r, InvolutiveSemiring r, DivisionRing r) => Division (Complex r)

Methods

recip :: Complex r -> Complex r

(/) :: Complex r -> Complex r -> Complex r

(\\) :: Complex r -> Complex r -> Complex r

(^) :: Integral n => Complex r -> n -> Complex r

GCDDomain d => Division (Fraction d)

Methods

recip :: Fraction d -> Fraction d

(/) :: Fraction d -> Fraction d -> Fraction d

(\\) :: Fraction d -> Fraction d -> Fraction d

(^) :: Integral n => Fraction d -> n -> Fraction d

(Unital r, DivisionAlgebra r a) => Division (a -> r)

Methods

recip :: (a -> r) -> a -> r

(/) :: (a -> r) -> (a -> r) -> a -> r

(\\) :: (a -> r) -> (a -> r) -> a -> r

(^) :: Integral n => (a -> r) -> n -> a -> r

(Division a, Division b) => Division (a, b)

Methods

recip :: (a, b) -> (a, b)

(/) :: (a, b) -> (a, b) -> (a, b)

(\\) :: (a, b) -> (a, b) -> (a, b)

(^) :: Integral n => (a, b) -> n -> (a, b)

(Division a, Division b, Division c) => Division (a, b, c)

Methods

recip :: (a, b, c) -> (a, b, c)

(/) :: (a, b, c) -> (a, b, c) -> (a, b, c)

(\\) :: (a, b, c) -> (a, b, c) -> (a, b, c)

(^) :: Integral n => (a, b, c) -> n -> (a, b, c)

(Division a, Division b, Division c, Division d) => Division (a, b, c, d)

Methods

recip :: (a, b, c, d) -> (a, b, c, d)

(/) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(\\) :: (a, b, c, d) -> (a, b, c, d) -> (a, b, c, d)

(^) :: Integral n => (a, b, c, d) -> n -> (a, b, c, d)

(Division a, Division b, Division c, Division d, Division e) => Division (a, b, c, d, e)

Methods

recip :: (a, b, c, d, e) -> (a, b, c, d, e)

(/) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

(\\) :: (a, b, c, d, e) -> (a, b, c, d, e) -> (a, b, c, d, e)

(^) :: Integral n => (a, b, c, d, e) -> n -> (a, b, c, d, e)

factorable multiplicative semigroups

class Multiplicative m => Factorable m where

`factorWith f c` returns a non-empty list containing `f a b` for all `a, b` such that `a * b = c`.

Results of factorWith f 0 are undefined and may result in either an error or an infinite list.

Minimal complete definition

factorWith

Methods

factorWith :: (m -> m -> r) -> m -> NonEmpty r

Instances

Factorable Bool

Methods

factorWith :: (Bool -> Bool -> r) -> Bool -> NonEmpty r

Factorable ()

Methods

factorWith :: (() -> () -> r) -> () -> NonEmpty r

Partitionable r => Factorable (Exp r)

Methods

factorWith :: (Exp r -> Exp r -> r) -> Exp r -> NonEmpty r

(Factorable a, Factorable b) => Factorable (a, b)

Methods

factorWith :: ((a, b) -> (a, b) -> r) -> (a, b) -> NonEmpty r

(Factorable a, Factorable b, Factorable c) => Factorable (a, b, c)

Methods

factorWith :: ((a, b, c) -> (a, b, c) -> r) -> (a, b, c) -> NonEmpty r

(Factorable a, Factorable b, Factorable c, Factorable d) => Factorable (a, b, c, d)

Methods

factorWith :: ((a, b, c, d) -> (a, b, c, d) -> r) -> (a, b, c, d) -> NonEmpty r

(Factorable a, Factorable b, Factorable c, Factorable d, Factorable e) => Factorable (a, b, c, d, e)

Methods

factorWith :: ((a, b, c, d, e) -> (a, b, c, d, e) -> r) -> (a, b, c, d, e) -> NonEmpty r

involutive multiplicative semigroups

class Multiplicative r => InvolutiveMultiplication r where

An semigroup with involution

adjoint a * adjoint b = adjoint (b * a)

Minimal complete definition

adjoint

Methods

adjoint :: r -> r

Instances

InvolutiveMultiplication Bool

Methods

adjoint :: Bool -> Bool

InvolutiveMultiplication Int

Methods

adjoint :: Int -> Int

InvolutiveMultiplication Int8

Methods

adjoint :: Int8 -> Int8

InvolutiveMultiplication Int16

Methods

adjoint :: Int16 -> Int16

InvolutiveMultiplication Int32

Methods

adjoint :: Int32 -> Int32

InvolutiveMultiplication Int64

Methods

adjoint :: Int64 -> Int64

InvolutiveMultiplication Integer

Methods

adjoint :: Integer -> Integer

InvolutiveMultiplication Natural

Methods

adjoint :: Natural -> Natural

InvolutiveMultiplication Word

Methods

adjoint :: Word -> Word

InvolutiveMultiplication Word8

Methods

adjoint :: Word8 -> Word8

InvolutiveMultiplication Word16

Methods

adjoint :: Word16 -> Word16

InvolutiveMultiplication Word32

Methods

adjoint :: Word32 -> Word32

InvolutiveMultiplication Word64

Methods

adjoint :: Word64 -> Word64

InvolutiveMultiplication ()

Methods

adjoint :: () -> ()

InvolutiveMultiplication Euclidean

Methods

adjoint :: Euclidean -> Euclidean

(Commutative r, Rng r, InvolutiveMultiplication r) => InvolutiveMultiplication (Trig r)

Methods

adjoint :: Trig r -> Trig r

(TriviallyInvolutive r, Rng r) => InvolutiveMultiplication (Quaternion' r)

Methods

adjoint :: Quaternion' r -> Quaternion' r

(Commutative r, Group r, InvolutiveSemiring r) => InvolutiveMultiplication (Hyper r)

Methods

adjoint :: Hyper r -> Hyper r

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveMultiplication (Dual' r)

Methods

adjoint :: Dual' r -> Dual' r

(TriviallyInvolutive r, Rng r) => InvolutiveMultiplication (Quaternion r)

Methods

adjoint :: Quaternion r -> Quaternion r

(Commutative r, InvolutiveSemiring r, Rng r) => InvolutiveMultiplication (Hyper' r)

Methods

adjoint :: Hyper' r -> Hyper' r

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveMultiplication (Dual r)

Methods

adjoint :: Dual r -> Dual r

(Commutative r, Rng r, InvolutiveMultiplication r) => InvolutiveMultiplication (Complex r)

Methods

adjoint :: Complex r -> Complex r

InvolutiveAlgebra r h => InvolutiveMultiplication (h -> r)

Methods

adjoint :: (h -> r) -> h -> r

(InvolutiveMultiplication a, InvolutiveMultiplication b) => InvolutiveMultiplication (a, b)

Methods

adjoint :: (a, b) -> (a, b)

(InvolutiveMultiplication a, InvolutiveMultiplication b, InvolutiveMultiplication c) => InvolutiveMultiplication (a, b, c)

Methods

adjoint :: (a, b, c) -> (a, b, c)

(InvolutiveMultiplication a, InvolutiveMultiplication b, InvolutiveMultiplication c, InvolutiveMultiplication d) => InvolutiveMultiplication (a, b, c, d)

Methods

adjoint :: (a, b, c, d) -> (a, b, c, d)

(InvolutiveMultiplication a, InvolutiveMultiplication b, InvolutiveMultiplication c, InvolutiveMultiplication d, InvolutiveMultiplication e) => InvolutiveMultiplication (a, b, c, d, e)

Methods

adjoint :: (a, b, c, d, e) -> (a, b, c, d, e)

class (Commutative r, InvolutiveMultiplication r) => TriviallyInvolutive r

adjoint = id

Instances

TriviallyInvolutive Bool

TriviallyInvolutive Int

TriviallyInvolutive Int8

TriviallyInvolutive Int16

TriviallyInvolutive Int32

TriviallyInvolutive Int64

TriviallyInvolutive Integer

TriviallyInvolutive Natural

TriviallyInvolutive Word

TriviallyInvolutive Word8

TriviallyInvolutive Word16

TriviallyInvolutive Word32

TriviallyInvolutive Word64

TriviallyInvolutive ()

TriviallyInvolutive Euclidean

(TriviallyInvolutive r, TriviallyInvolutiveAlgebra r a) => TriviallyInvolutive (a -> r)

(TriviallyInvolutive a, TriviallyInvolutive b) => TriviallyInvolutive (a, b)

(TriviallyInvolutive a, TriviallyInvolutive b, TriviallyInvolutive c) => TriviallyInvolutive (a, b, c)

(TriviallyInvolutive a, TriviallyInvolutive b, TriviallyInvolutive c, TriviallyInvolutive d) => TriviallyInvolutive (a, b, c, d)

(TriviallyInvolutive a, TriviallyInvolutive b, TriviallyInvolutive c, TriviallyInvolutive d, TriviallyInvolutive e) => TriviallyInvolutive (a, b, c, d, e)

Ring-Structures

Semirings

class (Additive r, Abelian r, Multiplicative r) => Semiring r

A pair of an additive abelian semigroup, and a multiplicative semigroup, with the distributive laws:

a(b + c) = ab + ac -- left distribution (we are a LeftNearSemiring)
(a + b)c = ac + bc -- right distribution (we are a [Right]NearSemiring)

Common notation includes the laws for additive and multiplicative identity in semiring.

If you want that, look at Rig instead.

Ideally we'd use the cyclic definition:

class (LeftModule r r, RightModule r r, Additive r, Abelian r, Multiplicative r) => Semiring r

to enforce that every semiring r is an r-module over itself, but Haskell doesn't like that.

Instances

Semiring Bool

Semiring Int

Semiring Int8

Semiring Int16

Semiring Int32

Semiring Int64

Semiring Integer

Semiring Natural

Semiring Word

Semiring Word8

Semiring Word16

Semiring Word32

Semiring Word64

Semiring ()

Semiring Euclidean

(Monoidal r, Abelian r) => Semiring (ZeroRng r)

Rng r => Semiring (RngRing r)

Semiring r => Semiring (Opposite r)

(Abelian r, Monoidal r) => Semiring (End r)

(Commutative k, Rng k) => Semiring (Trig k)

(TriviallyInvolutive r, Semiring r) => Semiring (Quaternion' r)

(Commutative k, Semiring k) => Semiring (Hyper k)

Semiring (BasisCoblade m)

(Commutative r, Rng r) => Semiring (Dual' r)

(TriviallyInvolutive r, Rng r) => Semiring (Quaternion r)

(Commutative k, Semiring k) => Semiring (Hyper' k)

(Commutative r, Rng r) => Semiring (Dual r)

(Commutative r, Rng r) => Semiring (Complex r)

GCDDomain d => Semiring (Fraction d)

Algebra r a => Semiring (a -> r)

(Semiring a, Semiring b) => Semiring (a, b)

Coalgebra r m => Semiring (Covector r m)

(Semiring a, Semiring b, Semiring c) => Semiring (a, b, c)

Coalgebra r m => Semiring (Map r b m)

(Semiring a, Semiring b, Semiring c, Semiring d) => Semiring (a, b, c, d)

(Semiring a, Semiring b, Semiring c, Semiring d, Semiring e) => Semiring (a, b, c, d, e)

class (Semiring r, InvolutiveMultiplication r) => InvolutiveSemiring r

adjoint (x + y) = adjoint x + adjoint y

Instances

InvolutiveSemiring Bool

InvolutiveSemiring Int

InvolutiveSemiring Int8

InvolutiveSemiring Int16

InvolutiveSemiring Int32

InvolutiveSemiring Int64

InvolutiveSemiring Integer

InvolutiveSemiring Natural

InvolutiveSemiring Word

InvolutiveSemiring Word8

InvolutiveSemiring Word16

InvolutiveSemiring Word32

InvolutiveSemiring Word64

InvolutiveSemiring ()

InvolutiveSemiring Euclidean

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveSemiring (Trig r)

(Commutative r, Group r, InvolutiveSemiring r) => InvolutiveSemiring (Hyper r)

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveSemiring (Dual' r)

(Commutative r, InvolutiveSemiring r, Rng r) => InvolutiveSemiring (Hyper' r)

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveSemiring (Dual r)

(Commutative r, Rng r, InvolutiveSemiring r) => InvolutiveSemiring (Complex r)

(InvolutiveSemiring a, InvolutiveSemiring b) => InvolutiveSemiring (a, b)

(InvolutiveSemiring a, InvolutiveSemiring b, InvolutiveSemiring c) => InvolutiveSemiring (a, b, c)

(InvolutiveSemiring a, InvolutiveSemiring b, InvolutiveSemiring c, InvolutiveSemiring d) => InvolutiveSemiring (a, b, c, d)

(InvolutiveSemiring a, InvolutiveSemiring b, InvolutiveSemiring c, InvolutiveSemiring d, InvolutiveSemiring e) => InvolutiveSemiring (a, b, c, d, e)

class (Semiring r, Idempotent r) => Dioid r

Instances

(Semiring r, Idempotent r) => Dioid r

Rngs

class (Group r, Semiring r) => Rng r

A Ring without an identity.

Instances

(Group r, Semiring r) => Rng r

(Group r, Abelian r) => Rng (ZeroRng r)

Rigs

class (Semiring r, Unital r, Monoidal r) => Rig r where

A Ring without (n)egation

Methods

fromNatural :: Natural -> r

Instances

Rig Bool

Methods

fromNatural :: Natural -> Bool

Rig Int

Methods

fromNatural :: Natural -> Int

Rig Int8

Methods

fromNatural :: Natural -> Int8

Rig Int16

Methods

fromNatural :: Natural -> Int16

Rig Int32

Methods

fromNatural :: Natural -> Int32

Rig Int64

Methods

fromNatural :: Natural -> Int64

Rig Integer

Methods

fromNatural :: Natural -> Integer

Rig Natural

Methods

fromNatural :: Natural -> Natural

Rig Word

Methods

fromNatural :: Natural -> Word

Rig Word8

Methods

fromNatural :: Natural -> Word8

Rig Word16

Methods

fromNatural :: Natural -> Word16

Rig Word32

Methods

fromNatural :: Natural -> Word32

Rig Word64

Methods

fromNatural :: Natural -> Word64

Rig ()

Methods

fromNatural :: Natural -> ()

Rig Euclidean

Methods

fromNatural :: Natural -> Euclidean

Rng r => Rig (RngRing r)

Methods

fromNatural :: Natural -> RngRing r

Rig r => Rig (Opposite r)

Methods

fromNatural :: Natural -> Opposite r

(Abelian r, Monoidal r) => Rig (End r)

Methods

fromNatural :: Natural -> End r

(Commutative r, Ring r) => Rig (Trig r)

Methods

fromNatural :: Natural -> Trig r

(TriviallyInvolutive r, Ring r) => Rig (Quaternion' r)

Methods

fromNatural :: Natural -> Quaternion' r

(Commutative r, Rig r) => Rig (Hyper r)

Methods

fromNatural :: Natural -> Hyper r

Rig (BasisCoblade m)

Methods

fromNatural :: Natural -> BasisCoblade m

(Commutative r, Ring r) => Rig (Dual' r)

Methods

fromNatural :: Natural -> Dual' r

(TriviallyInvolutive r, Ring r) => Rig (Quaternion r)

Methods

fromNatural :: Natural -> Quaternion r

(Commutative r, Rig r) => Rig (Hyper' r)

Methods

fromNatural :: Natural -> Hyper' r

(Commutative r, Ring r) => Rig (Dual r)

Methods

fromNatural :: Natural -> Dual r

(Commutative r, Ring r) => Rig (Complex r)

Methods

fromNatural :: Natural -> Complex r

GCDDomain d => Rig (Fraction d)

Methods

fromNatural :: Natural -> Fraction d

(Rig a, Rig b) => Rig (a, b)

Methods

fromNatural :: Natural -> (a, b)

(Rig r, CounitalCoalgebra r m) => Rig (Covector r m)

Methods

fromNatural :: Natural -> Covector r m

(Rig a, Rig b, Rig c) => Rig (a, b, c)

Methods

fromNatural :: Natural -> (a, b, c)

(Rig r, CounitalCoalgebra r m) => Rig (Map r b m)

Methods

fromNatural :: Natural -> Map r b m

(Rig a, Rig b, Rig c, Rig d) => Rig (a, b, c, d)

Methods

fromNatural :: Natural -> (a, b, c, d)

(Rig a, Rig b, Rig c, Rig d, Rig e) => Rig (a, b, c, d, e)

Methods

fromNatural :: Natural -> (a, b, c, d, e)

Rings

class (Rig r, Rng r) => Ring r where

Methods

fromInteger :: Integer -> r

Instances

Ring Int

Methods

fromInteger :: Integer -> Int

Ring Int8

Methods

fromInteger :: Integer -> Int8

Ring Int16

Methods

fromInteger :: Integer -> Int16

Ring Int32

Methods

fromInteger :: Integer -> Int32

Ring Int64

Methods

fromInteger :: Integer -> Int64

Ring Integer

Methods

fromInteger :: Integer -> Integer

Ring Word

Methods

fromInteger :: Integer -> Word

Ring Word8

Methods

fromInteger :: Integer -> Word8

Ring Word16

Methods

fromInteger :: Integer -> Word16

Ring Word32

Methods

fromInteger :: Integer -> Word32

Ring Word64

Methods

fromInteger :: Integer -> Word64

Ring ()

Methods

fromInteger :: Integer -> ()

Ring Euclidean

Methods

fromInteger :: Integer -> Euclidean

Rng r => Ring (RngRing r)

Methods

fromInteger :: Integer -> RngRing r

Ring r => Ring (Opposite r)

Methods

fromInteger :: Integer -> Opposite r

(Abelian r, Group r) => Ring (End r)

Methods

fromInteger :: Integer -> End r

(Commutative r, Ring r) => Ring (Trig r)

Methods

fromInteger :: Integer -> Trig r

(TriviallyInvolutive r, Ring r) => Ring (Quaternion' r)

Methods

fromInteger :: Integer -> Quaternion' r

(Commutative r, Ring r) => Ring (Hyper r)

Methods

fromInteger :: Integer -> Hyper r

(Commutative r, Ring r) => Ring (Dual' r)

Methods

fromInteger :: Integer -> Dual' r

(TriviallyInvolutive r, Ring r) => Ring (Quaternion r)

Methods

fromInteger :: Integer -> Quaternion r

(Commutative r, Ring r) => Ring (Hyper' r)

Methods

fromInteger :: Integer -> Hyper' r

(Commutative r, Ring r) => Ring (Dual r)

Methods

fromInteger :: Integer -> Dual r

(Commutative r, Ring r) => Ring (Complex r)

Methods

fromInteger :: Integer -> Complex r

GCDDomain d => Ring (Fraction d)

Methods

fromInteger :: Integer -> Fraction d

(Ring a, Ring b) => Ring (a, b)

Methods

fromInteger :: Integer -> (a, b)

(Ring r, CounitalCoalgebra r m) => Ring (Covector r m)

Methods

fromInteger :: Integer -> Covector r m

(Ring a, Ring b, Ring c) => Ring (a, b, c)

Methods

fromInteger :: Integer -> (a, b, c)

(Ring r, CounitalCoalgebra r m) => Ring (Map r a m)

Methods

fromInteger :: Integer -> Map r a m

(Ring a, Ring b, Ring c, Ring d) => Ring (a, b, c, d)

Methods

fromInteger :: Integer -> (a, b, c, d)

(Ring a, Ring b, Ring c, Ring d, Ring e) => Ring (a, b, c, d, e)

Methods

fromInteger :: Integer -> (a, b, c, d, e)

Division Rings

class Ring r => LocalRing r

class (Division r, Ring r) => DivisionRing r

Instances

(Division r, Ring r) => DivisionRing r

class (Euclidean d, Division d) => Field d

Instances

(Euclidean d, Division d) => Field d

Modules

class (Semiring r, Additive m) => LeftModule r m where

Minimal complete definition

(.*)

Methods

(.*) :: r -> m -> m infixl 7

Instances

LeftModule Integer Int

Methods

(.*) :: Integer -> Int -> Int

LeftModule Integer Int8

Methods

(.*) :: Integer -> Int8 -> Int8

LeftModule Integer Int16

Methods

(.*) :: Integer -> Int16 -> Int16

LeftModule Integer Int32

Methods

(.*) :: Integer -> Int32 -> Int32

LeftModule Integer Int64

Methods

(.*) :: Integer -> Int64 -> Int64

LeftModule Integer Integer

Methods

(.*) :: Integer -> Integer -> Integer

LeftModule Integer Word

Methods

(.*) :: Integer -> Word -> Word

LeftModule Integer Word8

Methods

(.*) :: Integer -> Word8 -> Word8

LeftModule Integer Word16

Methods

(.*) :: Integer -> Word16 -> Word16

LeftModule Integer Word32

Methods

(.*) :: Integer -> Word32 -> Word32

LeftModule Integer Word64

Methods

(.*) :: Integer -> Word64 -> Word64

LeftModule Integer Euclidean

Methods

(.*) :: Integer -> Euclidean -> Euclidean

LeftModule Natural Bool

Methods

(.*) :: Natural -> Bool -> Bool

LeftModule Natural Int

Methods

(.*) :: Natural -> Int -> Int

LeftModule Natural Int8

Methods

(.*) :: Natural -> Int8 -> Int8

LeftModule Natural Int16

Methods

(.*) :: Natural -> Int16 -> Int16

LeftModule Natural Int32

Methods

(.*) :: Natural -> Int32 -> Int32

LeftModule Natural Int64

Methods

(.*) :: Natural -> Int64 -> Int64

LeftModule Natural Integer

Methods

(.*) :: Natural -> Integer -> Integer

LeftModule Natural Natural

Methods

(.*) :: Natural -> Natural -> Natural

LeftModule Natural Word

Methods

(.*) :: Natural -> Word -> Word

LeftModule Natural Word8

Methods

(.*) :: Natural -> Word8 -> Word8

LeftModule Natural Word16

Methods

(.*) :: Natural -> Word16 -> Word16

LeftModule Natural Word32

Methods

(.*) :: Natural -> Word32 -> Word32

LeftModule Natural Word64

Methods

(.*) :: Natural -> Word64 -> Word64

LeftModule Natural Euclidean

Methods

(.*) :: Natural -> Euclidean -> Euclidean

Additive m => LeftModule () m

Methods

(.*) :: () -> m -> m

Semiring r => LeftModule r ()

Methods

(.*) :: r -> () -> ()

Group r => LeftModule Integer (ZeroRng r)

Methods

(.*) :: Integer -> ZeroRng r -> ZeroRng r

(Abelian r, Group r) => LeftModule Integer (RngRing r)

Methods

(.*) :: Integer -> RngRing r -> RngRing r

Division r => LeftModule Integer (Log r)

Methods

(.*) :: Integer -> Log r -> Log r

GCDDomain d => LeftModule Integer (Fraction d)

Methods

(.*) :: Integer -> Fraction d -> Fraction d

Monoidal r => LeftModule Natural (ZeroRng r)

Methods

(.*) :: Natural -> ZeroRng r -> ZeroRng r

(Abelian r, Monoidal r) => LeftModule Natural (RngRing r)

Methods

(.*) :: Natural -> RngRing r -> RngRing r

Unital r => LeftModule Natural (Log r)

Methods

(.*) :: Natural -> Log r -> Log r

LeftModule Natural (BasisCoblade m)

Methods

(.*) :: Natural -> BasisCoblade m -> BasisCoblade m

GCDDomain d => LeftModule Natural (Fraction d)

Methods

(.*) :: Natural -> Fraction d -> Fraction d

RightModule r s => LeftModule r (Opposite s)

Methods

(.*) :: r -> Opposite s -> Opposite s

LeftModule r m => LeftModule r (End m)

Methods

(.*) :: r -> End m -> End m

LeftModule r s => LeftModule r (Trig s)

Methods

(.*) :: r -> Trig s -> Trig s

LeftModule r s => LeftModule r (Quaternion' s)

Methods

(.*) :: r -> Quaternion' s -> Quaternion' s

LeftModule r s => LeftModule r (Hyper s)

Methods

(.*) :: r -> Hyper s -> Hyper s

LeftModule r s => LeftModule r (Dual' s)

Methods

(.*) :: r -> Dual' s -> Dual' s

LeftModule r s => LeftModule r (Quaternion s)

Methods

(.*) :: r -> Quaternion s -> Quaternion s

LeftModule r s => LeftModule r (Hyper' s)

Methods

(.*) :: r -> Hyper' s -> Hyper' s

LeftModule r s => LeftModule r (Dual s)

Methods

(.*) :: r -> Dual s -> Dual s

LeftModule r s => LeftModule r (Complex s)

Methods

(.*) :: r -> Complex s -> Complex s

(LeftModule r a, LeftModule r b) => LeftModule r (a, b)

Methods

(.*) :: r -> (a, b) -> (a, b)

LeftModule r m => LeftModule r (e -> m)

Methods

(.*) :: r -> (e -> m) -> e -> m

LeftModule r s => LeftModule r (Covector s m)

Methods

(.*) :: r -> Covector s m -> Covector s m

(LeftModule r a, LeftModule r b, LeftModule r c) => LeftModule r (a, b, c)

Methods

(.*) :: r -> (a, b, c) -> (a, b, c)

LeftModule r s => LeftModule r (Map s b m)

Methods

(.*) :: r -> Map s b m -> Map s b m

(LeftModule r a, LeftModule r b, LeftModule r c, LeftModule r d) => LeftModule r (a, b, c, d)

Methods

(.*) :: r -> (a, b, c, d) -> (a, b, c, d)

(LeftModule r a, LeftModule r b, LeftModule r c, LeftModule r d, LeftModule r e) => LeftModule r (a, b, c, d, e)

Methods

(.*) :: r -> (a, b, c, d, e) -> (a, b, c, d, e)

Rng s => LeftModule (RngRing s) (RngRing s)

Methods

(.*) :: RngRing s -> RngRing s -> RngRing s

Semiring r => LeftModule (Opposite r) (Opposite r)

Methods

(.*) :: Opposite r -> Opposite r -> Opposite r

(Monoidal m, Abelian m) => LeftModule (End m) (End m)

Methods

(.*) :: End m -> End m -> End m

(Commutative r, Rng r) => LeftModule (Trig r) (Trig r)

Methods

(.*) :: Trig r -> Trig r -> Trig r

(TriviallyInvolutive r, Rng r) => LeftModule (Quaternion' r) (Quaternion' r)

Methods

(.*) :: Quaternion' r -> Quaternion' r -> Quaternion' r

(Commutative r, Semiring r) => LeftModule (Hyper r) (Hyper r)

Methods

(.*) :: Hyper r -> Hyper r -> Hyper r

(Commutative r, Rng r) => LeftModule (Dual' r) (Dual' r)

Methods

(.*) :: Dual' r -> Dual' r -> Dual' r

(TriviallyInvolutive r, Rng r) => LeftModule (Quaternion r) (Quaternion r)

Methods

(.*) :: Quaternion r -> Quaternion r -> Quaternion r

(Commutative r, Semiring r) => LeftModule (Hyper' r) (Hyper' r)

Methods

(.*) :: Hyper' r -> Hyper' r -> Hyper' r

(Commutative r, Rng r) => LeftModule (Dual r) (Dual r)

Methods

(.*) :: Dual r -> Dual r -> Dual r

(Commutative r, Rng r) => LeftModule (Complex r) (Complex r)

Methods

(.*) :: Complex r -> Complex r -> Complex r

Coalgebra r m => LeftModule (Covector r m) (Covector r m)

Methods

(.*) :: Covector r m -> Covector r m -> Covector r m

Coalgebra r m => LeftModule (Map r b m) (Map r b m)

Methods

(.*) :: Map r b m -> Map r b m -> Map r b m

class (Semiring r, Additive m) => RightModule r m where

Minimal complete definition

(*.)

Methods

(*.) :: m -> r -> m infixl 7

Instances

RightModule Integer Int

Methods

(*.) :: Int -> Integer -> Int

RightModule Integer Int8

Methods

(*.) :: Int8 -> Integer -> Int8

RightModule Integer Int16

Methods

(*.) :: Int16 -> Integer -> Int16

RightModule Integer Int32

Methods

(*.) :: Int32 -> Integer -> Int32

RightModule Integer Int64

Methods

(*.) :: Int64 -> Integer -> Int64

RightModule Integer Integer

Methods

(*.) :: Integer -> Integer -> Integer

RightModule Integer Word

Methods

(*.) :: Word -> Integer -> Word

RightModule Integer Word8

Methods

(*.) :: Word8 -> Integer -> Word8

RightModule Integer Word16

Methods

(*.) :: Word16 -> Integer -> Word16

RightModule Integer Word32

Methods

(*.) :: Word32 -> Integer -> Word32

RightModule Integer Word64

Methods

(*.) :: Word64 -> Integer -> Word64

RightModule Integer Euclidean

Methods

(*.) :: Euclidean -> Integer -> Euclidean

RightModule Natural Bool

Methods

(*.) :: Bool -> Natural -> Bool

RightModule Natural Int

Methods

(*.) :: Int -> Natural -> Int

RightModule Natural Int8

Methods

(*.) :: Int8 -> Natural -> Int8

RightModule Natural Int16

Methods

(*.) :: Int16 -> Natural -> Int16

RightModule Natural Int32

Methods

(*.) :: Int32 -> Natural -> Int32

RightModule Natural Int64

Methods

(*.) :: Int64 -> Natural -> Int64

RightModule Natural Integer

Methods

(*.) :: Integer -> Natural -> Integer

RightModule Natural Natural

Methods

(*.) :: Natural -> Natural -> Natural

RightModule Natural Word

Methods

(*.) :: Word -> Natural -> Word

RightModule Natural Word8

Methods

(*.) :: Word8 -> Natural -> Word8

RightModule Natural Word16

Methods

(*.) :: Word16 -> Natural -> Word16

RightModule Natural Word32

Methods

(*.) :: Word32 -> Natural -> Word32

RightModule Natural Word64

Methods

(*.) :: Word64 -> Natural -> Word64

RightModule Natural Euclidean

Methods

(*.) :: Euclidean -> Natural -> Euclidean

Additive m => RightModule () m

Methods

(*.) :: m -> () -> m

Semiring r => RightModule r ()

Methods

(*.) :: () -> r -> ()

Group r => RightModule Integer (ZeroRng r)

Methods

(*.) :: ZeroRng r -> Integer -> ZeroRng r

(Abelian r, Group r) => RightModule Integer (RngRing r)

Methods

(*.) :: RngRing r -> Integer -> RngRing r

Division r => RightModule Integer (Log r)

Methods

(*.) :: Log r -> Integer -> Log r

GCDDomain d => RightModule Integer (Fraction d)

Methods

(*.) :: Fraction d -> Integer -> Fraction d

Monoidal r => RightModule Natural (ZeroRng r)

Methods

(*.) :: ZeroRng r -> Natural -> ZeroRng r

(Abelian r, Monoidal r) => RightModule Natural (RngRing r)

Methods

(*.) :: RngRing r -> Natural -> RngRing r

Unital r => RightModule Natural (Log r)

Methods

(*.) :: Log r -> Natural -> Log r

RightModule Natural (BasisCoblade m)

Methods

(*.) :: BasisCoblade m -> Natural -> BasisCoblade m

GCDDomain d => RightModule Natural (Fraction d)

Methods

(*.) :: Fraction d -> Natural -> Fraction d

LeftModule r s => RightModule r (Opposite s)

Methods

(*.) :: Opposite s -> r -> Opposite s

RightModule r m => RightModule r (End m)

Methods

(*.) :: End m -> r -> End m

RightModule r s => RightModule r (Trig s)

Methods

(*.) :: Trig s -> r -> Trig s

RightModule r s => RightModule r (Quaternion' s)

Methods

(*.) :: Quaternion' s -> r -> Quaternion' s

RightModule r s => RightModule r (Hyper s)

Methods

(*.) :: Hyper s -> r -> Hyper s

RightModule r s => RightModule r (Dual' s)

Methods

(*.) :: Dual' s -> r -> Dual' s

RightModule r s => RightModule r (Quaternion s)

Methods

(*.) :: Quaternion s -> r -> Quaternion s

RightModule r s => RightModule r (Hyper' s)

Methods

(*.) :: Hyper' s -> r -> Hyper' s

RightModule r s => RightModule r (Dual s)

Methods

(*.) :: Dual s -> r -> Dual s

RightModule r s => RightModule r (Complex s)

Methods

(*.) :: Complex s -> r -> Complex s

(RightModule r a, RightModule r b) => RightModule r (a, b)

Methods

(*.) :: (a, b) -> r -> (a, b)

RightModule r m => RightModule r (e -> m)

Methods

(*.) :: (e -> m) -> r -> e -> m

RightModule r s => RightModule r (Covector s m)

Methods

(*.) :: Covector s m -> r -> Covector s m

(RightModule r a, RightModule r b, RightModule r c) => RightModule r (a, b, c)

Methods

(*.) :: (a, b, c) -> r -> (a, b, c)

RightModule r s => RightModule r (Map s b m)

Methods

(*.) :: Map s b m -> r -> Map s b m

(RightModule r a, RightModule r b, RightModule r c, RightModule r d) => RightModule r (a, b, c, d)

Methods

(*.) :: (a, b, c, d) -> r -> (a, b, c, d)

(RightModule r a, RightModule r b, RightModule r c, RightModule r d, RightModule r e) => RightModule r (a, b, c, d, e)

Methods

(*.) :: (a, b, c, d, e) -> r -> (a, b, c, d, e)

Rng s => RightModule (RngRing s) (RngRing s)

Methods

(*.) :: RngRing s -> RngRing s -> RngRing s

Semiring r => RightModule (Opposite r) (Opposite r)

Methods

(*.) :: Opposite r -> Opposite r -> Opposite r

(Monoidal m, Abelian m) => RightModule (End m) (End m)

Methods

(*.) :: End m -> End m -> End m

(Commutative r, Rng r) => RightModule (Trig r) (Trig r)

Methods

(*.) :: Trig r -> Trig r -> Trig r

(TriviallyInvolutive r, Rng r) => RightModule (Quaternion' r) (Quaternion' r)

Methods

(*.) :: Quaternion' r -> Quaternion' r -> Quaternion' r

(Commutative r, Semiring r) => RightModule (Hyper r) (Hyper r)

Methods

(*.) :: Hyper r -> Hyper r -> Hyper r

(Commutative r, Rng r) => RightModule (Dual' r) (Dual' r)

Methods

(*.) :: Dual' r -> Dual' r -> Dual' r

(TriviallyInvolutive r, Rng r) => RightModule (Quaternion r) (Quaternion r)

Methods

(*.) :: Quaternion r -> Quaternion r -> Quaternion r

(Commutative r, Semiring r) => RightModule (Hyper' r) (Hyper' r)

Methods

(*.) :: Hyper' r -> Hyper' r -> Hyper' r

(Commutative r, Rng r) => RightModule (Dual r) (Dual r)

Methods

(*.) :: Dual r -> Dual r -> Dual r

(Commutative r, Rng r) => RightModule (Complex r) (Complex r)

Methods

(*.) :: Complex r -> Complex r -> Complex r

Coalgebra r m => RightModule (Covector r m) (Covector r m)

Methods

(*.) :: Covector r m -> Covector r m -> Covector r m

Coalgebra r m => RightModule (Map r b m) (Map r b m)

Methods

(*.) :: Map r b m -> Map r b m -> Map r b m

class (LeftModule r m, RightModule r m) => Module r m

Instances

(LeftModule r m, RightModule r m) => Module r m

Algebras

associative algebras over (non-commutative) semirings

class Semiring r => Algebra r a where

An associative algebra built with a free module over a semiring

Minimal complete definition

mult

Methods

mult :: (a -> a -> r) -> a -> r

Instances

Algebra () a

Methods

mult :: (a -> a -> ()) -> a -> ()

Semiring r => Algebra r IntSet

Methods

mult :: (IntSet -> IntSet -> r) -> IntSet -> r

Semiring r => Algebra r ()

Methods

mult :: (() -> () -> r) -> () -> r

(Commutative k, Rng k) => Algebra k TrigBasis

Methods

mult :: (TrigBasis -> TrigBasis -> k) -> TrigBasis -> k

(TriviallyInvolutive r, Semiring r) => Algebra r QuaternionBasis'

the trivial diagonal algebra

Methods

mult :: (QuaternionBasis' -> QuaternionBasis' -> r) -> QuaternionBasis' -> r

Semiring k => Algebra k HyperBasis

the trivial diagonal algebra

Methods

mult :: (HyperBasis -> HyperBasis -> k) -> HyperBasis -> k

Semiring k => Algebra k DualBasis'

Methods

mult :: (DualBasis' -> DualBasis' -> k) -> DualBasis' -> k

(TriviallyInvolutive r, Rng r) => Algebra r QuaternionBasis

the quaternion algebra

Methods

mult :: (QuaternionBasis -> QuaternionBasis -> r) -> QuaternionBasis -> r

(Commutative k, Semiring k) => Algebra k HyperBasis'

Methods

mult :: (HyperBasis' -> HyperBasis' -> k) -> HyperBasis' -> k

Rng k => Algebra k DualBasis

Methods

mult :: (DualBasis -> DualBasis -> k) -> DualBasis -> k

Rng k => Algebra k ComplexBasis

Methods

mult :: (ComplexBasis -> ComplexBasis -> k) -> ComplexBasis -> k

(Semiring r, Ord a) => Algebra r (Set a)

Methods

mult :: (Set a -> Set a -> r) -> Set a -> r

Semiring r => Algebra r (Seq a)

The tensor algebra

Methods

mult :: (Seq a -> Seq a -> r) -> Seq a -> r

Semiring r => Algebra r [a]

The tensor algebra

Methods

mult :: ([a] -> [a] -> r) -> [a] -> r

(Commutative r, Monoidal r, Semiring r, LocallyFiniteOrder a) => Algebra r (Interval a)

Methods

mult :: (Interval a -> Interval a -> r) -> Interval a -> r

(Algebra r a, Algebra r b) => Algebra r (a, b)

Methods

mult :: ((a, b) -> (a, b) -> r) -> (a, b) -> r

(Algebra r a, Algebra r b, Algebra r c) => Algebra r (a, b, c)

Methods

mult :: ((a, b, c) -> (a, b, c) -> r) -> (a, b, c) -> r

(Algebra r a, Algebra r b, Algebra r c, Algebra r d) => Algebra r (a, b, c, d)

Methods

mult :: ((a, b, c, d) -> (a, b, c, d) -> r) -> (a, b, c, d) -> r

(Algebra r a, Algebra r b, Algebra r c, Algebra r d, Algebra r e) => Algebra r (a, b, c, d, e)

Methods

mult :: ((a, b, c, d, e) -> (a, b, c, d, e) -> r) -> (a, b, c, d, e) -> r

class Semiring r => Coalgebra r c where

Minimal complete definition

comult

Methods

comult :: (c -> r) -> c -> c -> r

Instances

Semiring r => Coalgebra r IntSet

the free commutative band coalgebra over Int

Methods

comult :: (IntSet -> r) -> IntSet -> IntSet -> r

Semiring r => Coalgebra r ()

Methods

comult :: (() -> r) -> () -> () -> r

(Commutative k, Rng k) => Coalgebra k TrigBasis

Methods

comult :: (TrigBasis -> k) -> TrigBasis -> TrigBasis -> k

(TriviallyInvolutive r, Rng r) => Coalgebra r QuaternionBasis'

dual quaternion comultiplication

Methods

comult :: (QuaternionBasis' -> r) -> QuaternionBasis' -> QuaternionBasis' -> r

(Commutative k, Semiring k) => Coalgebra k HyperBasis

the hyperbolic trigonometric coalgebra

Methods

comult :: (HyperBasis -> k) -> HyperBasis -> HyperBasis -> k

Rng k => Coalgebra k DualBasis'

Methods

comult :: (DualBasis' -> k) -> DualBasis' -> DualBasis' -> k

(TriviallyInvolutive r, Rng r) => Coalgebra r QuaternionBasis

the trivial diagonal coalgebra

Methods

comult :: (QuaternionBasis -> r) -> QuaternionBasis -> QuaternionBasis -> r

(Commutative k, Monoidal k, Semiring k) => Coalgebra k HyperBasis'

Methods

comult :: (HyperBasis' -> k) -> HyperBasis' -> HyperBasis' -> k

Rng k => Coalgebra k DualBasis

Methods

comult :: (DualBasis -> k) -> DualBasis -> DualBasis -> k

Rng k => Coalgebra k ComplexBasis

Methods

comult :: (ComplexBasis -> k) -> ComplexBasis -> ComplexBasis -> k

(Semiring r, Additive b) => Coalgebra r (IntMap b)

the free commutative coalgebra over a set and Int

Methods

comult :: (IntMap b -> r) -> IntMap b -> IntMap b -> r

(Semiring r, Ord a) => Coalgebra r (Set a)

the free commutative band coalgebra

Methods

comult :: (Set a -> r) -> Set a -> Set a -> r

Semiring r => Coalgebra r (Seq a)

The tensor Hopf algebra

Methods

comult :: (Seq a -> r) -> Seq a -> Seq a -> r

Semiring r => Coalgebra r [a]

The tensor Hopf algebra

Methods

comult :: ([a] -> r) -> [a] -> [a] -> r

(Commutative r, Monoidal r, Semiring r, PartialSemigroup a) => Coalgebra r (Morphism a)

Methods

comult :: (Morphism a -> r) -> Morphism a -> Morphism a -> r

(Eq a, Commutative r, Monoidal r, Semiring r) => Coalgebra r (Interval' a)

Methods

comult :: (Interval' a -> r) -> Interval' a -> Interval' a -> r

Eigenmetric r m => Coalgebra r (BasisCoblade m)

Methods

comult :: (BasisCoblade m -> r) -> BasisCoblade m -> BasisCoblade m -> r

(Semiring r, Ord a, Additive b) => Coalgebra r (Map a b)

the free commutative coalgebra over a set and a given semigroup

Methods

comult :: (Map a b -> r) -> Map a b -> Map a b -> r

(Coalgebra r a, Coalgebra r b) => Coalgebra r (a, b)

Methods

comult :: ((a, b) -> r) -> (a, b) -> (a, b) -> r

Algebra r m => Coalgebra r (m -> r)

Every coalgebra gives rise to an algebra by vector space duality classically. Sadly, it requires vector space duality, which we cannot use constructively. The dual argument only relies in the fact that any constructive coalgebra can only inspect a finite number of coefficients, which we CAN exploit.

Methods

comult :: ((m -> r) -> r) -> (m -> r) -> (m -> r) -> r

(Coalgebra r a, Coalgebra r b, Coalgebra r c) => Coalgebra r (a, b, c)

Methods

comult :: ((a, b, c) -> r) -> (a, b, c) -> (a, b, c) -> r

(Coalgebra r a, Coalgebra r b, Coalgebra r c, Coalgebra r d) => Coalgebra r (a, b, c, d)

Methods

comult :: ((a, b, c, d) -> r) -> (a, b, c, d) -> (a, b, c, d) -> r

(Coalgebra r a, Coalgebra r b, Coalgebra r c, Coalgebra r d, Coalgebra r e) => Coalgebra r (a, b, c, d, e)

Methods

comult :: ((a, b, c, d, e) -> r) -> (a, b, c, d, e) -> (a, b, c, d, e) -> r

unital algebras

class Algebra r a => UnitalAlgebra r a where

An associative unital algebra over a semiring, built using a free module

Minimal complete definition

unit

Methods

unit :: r -> a -> r

Instances

Semiring r => UnitalAlgebra r ()

Methods

unit :: r -> () -> r

(Commutative k, Rng k) => UnitalAlgebra k TrigBasis

Methods

unit :: k -> TrigBasis -> k

(TriviallyInvolutive r, Semiring r) => UnitalAlgebra r QuaternionBasis'

Methods

unit :: r -> QuaternionBasis' -> r

Semiring k => UnitalAlgebra k HyperBasis

Methods

unit :: k -> HyperBasis -> k

Semiring k => UnitalAlgebra k DualBasis'

Methods

unit :: k -> DualBasis' -> k

(TriviallyInvolutive r, Rng r) => UnitalAlgebra r QuaternionBasis

Methods

unit :: r -> QuaternionBasis -> r

(Commutative k, Monoidal k, Semiring k) => UnitalAlgebra k HyperBasis'

Methods

unit :: k -> HyperBasis' -> k

Rng k => UnitalAlgebra k DualBasis

Methods

unit :: k -> DualBasis -> k

Rng k => UnitalAlgebra k ComplexBasis

Methods

unit :: k -> ComplexBasis -> k

(Monoidal r, Semiring r) => UnitalAlgebra r (Seq a)

Methods

unit :: r -> Seq a -> r

(Monoidal r, Semiring r) => UnitalAlgebra r [a]

Methods

unit :: r -> [a] -> r

(Commutative r, Monoidal r, Semiring r, LocallyFiniteOrder a) => UnitalAlgebra r (Interval a)

Methods

unit :: r -> Interval a -> r

(UnitalAlgebra r a, UnitalAlgebra r b) => UnitalAlgebra r (a, b)

Methods

unit :: r -> (a, b) -> r

(UnitalAlgebra r a, UnitalAlgebra r b, UnitalAlgebra r c) => UnitalAlgebra r (a, b, c)

Methods

unit :: r -> (a, b, c) -> r

(UnitalAlgebra r a, UnitalAlgebra r b, UnitalAlgebra r c, UnitalAlgebra r d) => UnitalAlgebra r (a, b, c, d)

Methods

unit :: r -> (a, b, c, d) -> r

(UnitalAlgebra r a, UnitalAlgebra r b, UnitalAlgebra r c, UnitalAlgebra r d, UnitalAlgebra r e) => UnitalAlgebra r (a, b, c, d, e)

Methods

unit :: r -> (a, b, c, d, e) -> r

class Coalgebra r c => CounitalCoalgebra r c where

Minimal complete definition

counit

Methods

counit :: (c -> r) -> r

Instances

Semiring r => CounitalCoalgebra r ()

Methods

counit :: (() -> r) -> r

(Commutative k, Rng k) => CounitalCoalgebra k TrigBasis

Methods

counit :: (TrigBasis -> k) -> k

(TriviallyInvolutive r, Rng r) => CounitalCoalgebra r QuaternionBasis'

Methods

counit :: (QuaternionBasis' -> r) -> r

(Commutative k, Semiring k) => CounitalCoalgebra k HyperBasis

Methods

counit :: (HyperBasis -> k) -> k

Rng k => CounitalCoalgebra k DualBasis'

Methods

counit :: (DualBasis' -> k) -> k

(TriviallyInvolutive r, Rng r) => CounitalCoalgebra r QuaternionBasis

Methods

counit :: (QuaternionBasis -> r) -> r

(Commutative k, Monoidal k, Semiring k) => CounitalCoalgebra k HyperBasis'

Methods

counit :: (HyperBasis' -> k) -> k

Rng k => CounitalCoalgebra k DualBasis

Methods

counit :: (DualBasis -> k) -> k

Rng k => CounitalCoalgebra k ComplexBasis

Methods

counit :: (ComplexBasis -> k) -> k

Semiring r => CounitalCoalgebra r (Seq a)

Methods

counit :: (Seq a -> r) -> r

Semiring r => CounitalCoalgebra r [a]

Methods

counit :: ([a] -> r) -> r

(Commutative r, Monoidal r, Semiring r, PartialMonoid a) => CounitalCoalgebra r (Morphism a)

Methods

counit :: (Morphism a -> r) -> r

(Eq a, Bounded a, Commutative r, Monoidal r, Semiring r) => CounitalCoalgebra r (Interval' a)

Methods

counit :: (Interval' a -> r) -> r

Eigenmetric r m => CounitalCoalgebra r (BasisCoblade m)

Methods

counit :: (BasisCoblade m -> r) -> r

(CounitalCoalgebra r a, CounitalCoalgebra r b) => CounitalCoalgebra r (a, b)

Methods

counit :: ((a, b) -> r) -> r

(Unital r, UnitalAlgebra r m) => CounitalCoalgebra r (m -> r)

Methods

counit :: ((m -> r) -> r) -> r

(CounitalCoalgebra r a, CounitalCoalgebra r b, CounitalCoalgebra r c) => CounitalCoalgebra r (a, b, c)

Methods

counit :: ((a, b, c) -> r) -> r

(CounitalCoalgebra r a, CounitalCoalgebra r b, CounitalCoalgebra r c, CounitalCoalgebra r d) => CounitalCoalgebra r (a, b, c, d)

Methods

counit :: ((a, b, c, d) -> r) -> r

(CounitalCoalgebra r a, CounitalCoalgebra r b, CounitalCoalgebra r c, CounitalCoalgebra r d, CounitalCoalgebra r e) => CounitalCoalgebra r (a, b, c, d, e)

Methods

counit :: ((a, b, c, d, e) -> r) -> r

class (UnitalAlgebra r a, CounitalCoalgebra r a) => Bialgebra r a

A bialgebra is both a unital algebra and counital coalgebra where the mult and unit are compatible in some sense with the comult and counit. That is to say that mult and unit are a coalgebra homomorphisms or (equivalently) that comult and counit are an algebra homomorphisms.

Instances

Semiring r => Bialgebra r ()

(Commutative k, Rng k) => Bialgebra k TrigBasis

(TriviallyInvolutive r, Rng r) => Bialgebra r QuaternionBasis'

(Commutative k, Semiring k) => Bialgebra k HyperBasis

Rng k => Bialgebra k DualBasis'

(TriviallyInvolutive r, Rng r) => Bialgebra r QuaternionBasis

(Commutative k, Monoidal k, Semiring k) => Bialgebra k HyperBasis'

Rng k => Bialgebra k DualBasis

Rng k => Bialgebra k ComplexBasis

(Monoidal r, Semiring r) => Bialgebra r (Seq a)

(Monoidal r, Semiring r) => Bialgebra r [a]

(Bialgebra r a, Bialgebra r b) => Bialgebra r (a, b)

(Bialgebra r a, Bialgebra r b, Bialgebra r c) => Bialgebra r (a, b, c)

(Bialgebra r a, Bialgebra r b, Bialgebra r c, Bialgebra r d) => Bialgebra r (a, b, c, d)

(Bialgebra r a, Bialgebra r b, Bialgebra r c, Bialgebra r d, Bialgebra r e) => Bialgebra r (a, b, c, d, e)

involutive algebras

class (InvolutiveSemiring r, Algebra r a) => InvolutiveAlgebra r a where

Minimal complete definition

inv

Methods

inv :: (a -> r) -> a -> r

Instances

InvolutiveSemiring r => InvolutiveAlgebra r ()

Methods

inv :: (() -> r) -> () -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveAlgebra k TrigBasis

Methods

inv :: (TrigBasis -> k) -> TrigBasis -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => InvolutiveAlgebra r QuaternionBasis'

Methods

inv :: (QuaternionBasis' -> r) -> QuaternionBasis' -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveAlgebra k HyperBasis

Methods

inv :: (HyperBasis -> k) -> HyperBasis -> k

(InvolutiveSemiring k, Rng k) => InvolutiveAlgebra k DualBasis'

Methods

inv :: (DualBasis' -> k) -> DualBasis' -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => InvolutiveAlgebra r QuaternionBasis

Methods

inv :: (QuaternionBasis -> r) -> QuaternionBasis -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveAlgebra k HyperBasis'

Methods

inv :: (HyperBasis' -> k) -> HyperBasis' -> k

(InvolutiveSemiring k, Rng k) => InvolutiveAlgebra k DualBasis

Methods

inv :: (DualBasis -> k) -> DualBasis -> k

(InvolutiveSemiring k, Rng k) => InvolutiveAlgebra k ComplexBasis

Methods

inv :: (ComplexBasis -> k) -> ComplexBasis -> k

(InvolutiveAlgebra r a, InvolutiveAlgebra r b) => InvolutiveAlgebra r (a, b)

Methods

inv :: ((a, b) -> r) -> (a, b) -> r

(InvolutiveAlgebra r a, InvolutiveAlgebra r b, InvolutiveAlgebra r c) => InvolutiveAlgebra r (a, b, c)

Methods

inv :: ((a, b, c) -> r) -> (a, b, c) -> r

(InvolutiveAlgebra r a, InvolutiveAlgebra r b, InvolutiveAlgebra r c, InvolutiveAlgebra r d) => InvolutiveAlgebra r (a, b, c, d)

Methods

inv :: ((a, b, c, d) -> r) -> (a, b, c, d) -> r

(InvolutiveAlgebra r a, InvolutiveAlgebra r b, InvolutiveAlgebra r c, InvolutiveAlgebra r d, InvolutiveAlgebra r e) => InvolutiveAlgebra r (a, b, c, d, e)

Methods

inv :: ((a, b, c, d, e) -> r) -> (a, b, c, d, e) -> r

class (InvolutiveSemiring r, Coalgebra r c) => InvolutiveCoalgebra r c where

Minimal complete definition

coinv

Methods

coinv :: (c -> r) -> c -> r

Instances

InvolutiveSemiring r => InvolutiveCoalgebra r ()

Methods

coinv :: (() -> r) -> () -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveCoalgebra k TrigBasis

Methods

coinv :: (TrigBasis -> k) -> TrigBasis -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => InvolutiveCoalgebra r QuaternionBasis'

Methods

coinv :: (QuaternionBasis' -> r) -> QuaternionBasis' -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveCoalgebra k HyperBasis

Methods

coinv :: (HyperBasis -> k) -> HyperBasis -> k

(InvolutiveSemiring k, Rng k) => InvolutiveCoalgebra k DualBasis'

Methods

coinv :: (DualBasis' -> k) -> DualBasis' -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => InvolutiveCoalgebra r QuaternionBasis

Methods

coinv :: (QuaternionBasis -> r) -> QuaternionBasis -> r

(Commutative k, Group k, InvolutiveSemiring k) => InvolutiveCoalgebra k HyperBasis'

Methods

coinv :: (HyperBasis' -> k) -> HyperBasis' -> k

(InvolutiveSemiring k, Rng k) => InvolutiveCoalgebra k DualBasis

Methods

coinv :: (DualBasis -> k) -> DualBasis -> k

(InvolutiveSemiring k, Rng k) => InvolutiveCoalgebra k ComplexBasis

Methods

coinv :: (ComplexBasis -> k) -> ComplexBasis -> k

(InvolutiveCoalgebra r a, InvolutiveCoalgebra r b) => InvolutiveCoalgebra r (a, b)

Methods

coinv :: ((a, b) -> r) -> (a, b) -> r

(InvolutiveCoalgebra r a, InvolutiveCoalgebra r b, InvolutiveCoalgebra r c) => InvolutiveCoalgebra r (a, b, c)

Methods

coinv :: ((a, b, c) -> r) -> (a, b, c) -> r

(InvolutiveCoalgebra r a, InvolutiveCoalgebra r b, InvolutiveCoalgebra r c, InvolutiveCoalgebra r d) => InvolutiveCoalgebra r (a, b, c, d)

Methods

coinv :: ((a, b, c, d) -> r) -> (a, b, c, d) -> r

(InvolutiveCoalgebra r a, InvolutiveCoalgebra r b, InvolutiveCoalgebra r c, InvolutiveCoalgebra r d, InvolutiveCoalgebra r e) => InvolutiveCoalgebra r (a, b, c, d, e)

Methods

coinv :: ((a, b, c, d, e) -> r) -> (a, b, c, d, e) -> r

class (Bialgebra r h, InvolutiveAlgebra r h, InvolutiveCoalgebra r h) => InvolutiveBialgebra r h

Instances

(Bialgebra r h, InvolutiveAlgebra r h, InvolutiveCoalgebra r h) => InvolutiveBialgebra r h

class (CommutativeAlgebra r a, TriviallyInvolutive r, InvolutiveAlgebra r a) => TriviallyInvolutiveAlgebra r a

Instances

(TriviallyInvolutive r, InvolutiveSemiring r) => TriviallyInvolutiveAlgebra r ()

(TriviallyInvolutiveAlgebra r a, TriviallyInvolutiveAlgebra r b) => TriviallyInvolutiveAlgebra r (a, b)

(TriviallyInvolutiveAlgebra r a, TriviallyInvolutiveAlgebra r b, TriviallyInvolutiveAlgebra r c) => TriviallyInvolutiveAlgebra r (a, b, c)

(TriviallyInvolutiveAlgebra r a, TriviallyInvolutiveAlgebra r b, TriviallyInvolutiveAlgebra r c, TriviallyInvolutiveAlgebra r d) => TriviallyInvolutiveAlgebra r (a, b, c, d)

(TriviallyInvolutiveAlgebra r a, TriviallyInvolutiveAlgebra r b, TriviallyInvolutiveAlgebra r c, TriviallyInvolutiveAlgebra r d, TriviallyInvolutiveAlgebra r e) => TriviallyInvolutiveAlgebra r (a, b, c, d, e)

class (CocommutativeCoalgebra r a, TriviallyInvolutive r, InvolutiveCoalgebra r a) => TriviallyInvolutiveCoalgebra r a

Instances

(TriviallyInvolutive r, InvolutiveSemiring r) => TriviallyInvolutiveCoalgebra r ()

(TriviallyInvolutiveCoalgebra r a, TriviallyInvolutiveCoalgebra r b) => TriviallyInvolutiveCoalgebra r (a, b)

(TriviallyInvolutiveCoalgebra r a, TriviallyInvolutiveCoalgebra r b, TriviallyInvolutiveCoalgebra r c) => TriviallyInvolutiveCoalgebra r (a, b, c)

(TriviallyInvolutiveCoalgebra r a, TriviallyInvolutiveCoalgebra r b, TriviallyInvolutiveCoalgebra r c, TriviallyInvolutiveCoalgebra r d) => TriviallyInvolutiveCoalgebra r (a, b, c, d)

(TriviallyInvolutiveCoalgebra r a, TriviallyInvolutiveCoalgebra r b, TriviallyInvolutiveCoalgebra r c, TriviallyInvolutiveCoalgebra r d, TriviallyInvolutiveCoalgebra r e) => TriviallyInvolutiveCoalgebra r (a, b, c, d, e)

class (InvolutiveBialgebra r h, TriviallyInvolutiveAlgebra r h, TriviallyInvolutiveCoalgebra r h) => TriviallyInvolutiveBialgebra r h

Instances

(InvolutiveBialgebra r h, TriviallyInvolutiveAlgebra r h, TriviallyInvolutiveCoalgebra r h) => TriviallyInvolutiveBialgebra r h

idempotent algebras

class Algebra r a => IdempotentAlgebra r a

Instances

(Semiring r, Band r) => IdempotentAlgebra r ()

(Semiring r, Band r) => IdempotentAlgebra r IntSet

(Semiring r, Band r, Ord a) => IdempotentAlgebra r (Set a)

(IdempotentAlgebra r a, IdempotentAlgebra r b) => IdempotentAlgebra r (a, b)

(IdempotentAlgebra r a, IdempotentAlgebra r b, IdempotentAlgebra r c) => IdempotentAlgebra r (a, b, c)

(IdempotentAlgebra r a, IdempotentAlgebra r b, IdempotentAlgebra r c, IdempotentAlgebra r d) => IdempotentAlgebra r (a, b, c, d)

(IdempotentAlgebra r a, IdempotentAlgebra r b, IdempotentAlgebra r c, IdempotentAlgebra r d, IdempotentAlgebra r e) => IdempotentAlgebra r (a, b, c, d, e)

class (Bialgebra r h, IdempotentAlgebra r h, IdempotentCoalgebra r h) => IdempotentBialgebra r h

Instances

(Bialgebra r h, IdempotentAlgebra r h, IdempotentCoalgebra r h) => IdempotentBialgebra r h

commutative algebras

class Algebra r a => CommutativeAlgebra r a

Instances

(Commutative r, Semiring r) => CommutativeAlgebra r IntSet

(Commutative r, Semiring r) => CommutativeAlgebra r ()

(Commutative r, Semiring r, Ord a) => CommutativeAlgebra r (Set a)

(CommutativeAlgebra r a, CommutativeAlgebra r b) => CommutativeAlgebra r (a, b)

(CommutativeAlgebra r a, CommutativeAlgebra r b, CommutativeAlgebra r c) => CommutativeAlgebra r (a, b, c)

(CommutativeAlgebra r a, CommutativeAlgebra r b, CommutativeAlgebra r c, CommutativeAlgebra r d) => CommutativeAlgebra r (a, b, c, d)

(CommutativeAlgebra r a, CommutativeAlgebra r b, CommutativeAlgebra r c, CommutativeAlgebra r d, CommutativeAlgebra r e) => CommutativeAlgebra r (a, b, c, d, e)

class (Bialgebra r h, CommutativeAlgebra r h, CocommutativeCoalgebra r h) => CommutativeBialgebra r h

Instances

(Bialgebra r h, CommutativeAlgebra r h, CocommutativeCoalgebra r h) => CommutativeBialgebra r h

class Coalgebra r c => CocommutativeCoalgebra r c

Instances

(Commutative r, Semiring r) => CocommutativeCoalgebra r IntSet

(Commutative r, Semiring r) => CocommutativeCoalgebra r ()

(Commutative r, Semiring r, Abelian b) => CocommutativeCoalgebra r (IntMap b)

(Commutative r, Semiring r, Ord a) => CocommutativeCoalgebra r (Set a)

(Commutative r, Semiring r, Ord a, Abelian b) => CocommutativeCoalgebra r (Map a b)

(CocommutativeCoalgebra r a, CocommutativeCoalgebra r b) => CocommutativeCoalgebra r (a, b)

CommutativeAlgebra r m => CocommutativeCoalgebra r (m -> r)

(CocommutativeCoalgebra r a, CocommutativeCoalgebra r b, CocommutativeCoalgebra r c) => CocommutativeCoalgebra r (a, b, c)

(CocommutativeCoalgebra r a, CocommutativeCoalgebra r b, CocommutativeCoalgebra r c, CocommutativeCoalgebra r d) => CocommutativeCoalgebra r (a, b, c, d)

(CocommutativeCoalgebra r a, CocommutativeCoalgebra r b, CocommutativeCoalgebra r c, CocommutativeCoalgebra r d, CocommutativeCoalgebra r e) => CocommutativeCoalgebra r (a, b, c, d, e)

division algebras

class UnitalAlgebra r a => DivisionAlgebra r a where

Minimal complete definition

recipriocal

Methods

recipriocal :: (a -> r) -> a -> r

Hopf alegebras

class Bialgebra r h => HopfAlgebra r h where

A HopfAlgebra algebra on a semiring, where the module is free.

When antipode . antipode = id and antipode is an antihomomorphism then we are an InvolutiveBialgebra with inv = antipode as well

Minimal complete definition

antipode

Methods

antipode :: (h -> r) -> h -> r

Instances

(Commutative k, Group k, InvolutiveSemiring k) => HopfAlgebra k TrigBasis

Methods

antipode :: (TrigBasis -> k) -> TrigBasis -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => HopfAlgebra r QuaternionBasis'

Methods

antipode :: (QuaternionBasis' -> r) -> QuaternionBasis' -> r

(Commutative k, Group k, InvolutiveSemiring k) => HopfAlgebra k HyperBasis

Methods

antipode :: (HyperBasis -> k) -> HyperBasis -> k

(InvolutiveSemiring k, Rng k) => HopfAlgebra k DualBasis'

Methods

antipode :: (DualBasis' -> k) -> DualBasis' -> k

(TriviallyInvolutive r, InvolutiveSemiring r, Rng r) => HopfAlgebra r QuaternionBasis

Methods

antipode :: (QuaternionBasis -> r) -> QuaternionBasis -> r

(Commutative k, Group k, InvolutiveSemiring k) => HopfAlgebra k HyperBasis'

Methods

antipode :: (HyperBasis' -> k) -> HyperBasis' -> k

(InvolutiveSemiring k, Rng k) => HopfAlgebra k DualBasis

Methods

antipode :: (DualBasis -> k) -> DualBasis -> k

(InvolutiveSemiring k, Rng k) => HopfAlgebra k ComplexBasis

Methods

antipode :: (ComplexBasis -> k) -> ComplexBasis -> k

(HopfAlgebra r a, HopfAlgebra r b) => HopfAlgebra r (a, b)

Methods

antipode :: ((a, b) -> r) -> (a, b) -> r

(HopfAlgebra r a, HopfAlgebra r b, HopfAlgebra r c) => HopfAlgebra r (a, b, c)

Methods

antipode :: ((a, b, c) -> r) -> (a, b, c) -> r

(HopfAlgebra r a, HopfAlgebra r b, HopfAlgebra r c, HopfAlgebra r d) => HopfAlgebra r (a, b, c, d)

Methods

antipode :: ((a, b, c, d) -> r) -> (a, b, c, d) -> r

(HopfAlgebra r a, HopfAlgebra r b, HopfAlgebra r c, HopfAlgebra r d, HopfAlgebra r e) => HopfAlgebra r (a, b, c, d, e)

Methods

antipode :: ((a, b, c, d, e) -> r) -> (a, b, c, d, e) -> r

Ring Properties

Characteristic

class Rig r => Characteristic r where

Minimal complete definition

char

Methods

char :: proxy r -> Natural

Instances

Characteristic Bool

NB: we're using the boolean semiring, not the boolean ring

Methods

char :: proxy Bool -> Natural

Characteristic Int

Methods

char :: proxy Int -> Natural

Characteristic Int8

Methods

char :: proxy Int8 -> Natural

Characteristic Int16

Methods

char :: proxy Int16 -> Natural

Characteristic Int32

Methods

char :: proxy Int32 -> Natural

Characteristic Int64

Methods

char :: proxy Int64 -> Natural

Characteristic Integer

Methods

char :: proxy Integer -> Natural

Characteristic Natural

Methods

char :: proxy Natural -> Natural

Characteristic Word

Methods

char :: proxy Word -> Natural

Characteristic Word8

Methods

char :: proxy Word8 -> Natural

Characteristic Word16

Methods

char :: proxy Word16 -> Natural

Characteristic Word32

Methods

char :: proxy Word32 -> Natural

Characteristic Word64

Methods

char :: proxy Word64 -> Natural

Characteristic ()

Methods

char :: proxy () -> Natural

(Characteristic d, GCDDomain d) => Characteristic (Fraction d)

Methods

char :: proxy (Fraction d) -> Natural

(Characteristic a, Characteristic b) => Characteristic (a, b)

Methods

char :: proxy (a, b) -> Natural

(Characteristic a, Characteristic b, Characteristic c) => Characteristic (a, b, c)

Methods

char :: proxy (a, b, c) -> Natural

(Characteristic a, Characteristic b, Characteristic c, Characteristic d) => Characteristic (a, b, c, d)

Methods

char :: proxy (a, b, c, d) -> Natural

(Characteristic a, Characteristic b, Characteristic c, Characteristic d, Characteristic e) => Characteristic (a, b, c, d, e)

Methods

char :: proxy (a, b, c, d, e) -> Natural

charInt :: (Integral s, Bounded s) => proxy s -> Natural

charWord :: (Integral s, Bounded s) => proxy s -> Natural

Order

class Order a where

Methods

(<~) :: a -> a -> Bool

(<) :: a -> a -> Bool

(>~) :: a -> a -> Bool

(>) :: a -> a -> Bool

(~~) :: a -> a -> Bool

(/~) :: a -> a -> Bool

order :: a -> a -> Maybe Ordering

comparable :: a -> a -> Bool

Instances

Order Bool

Methods

(<~) :: Bool -> Bool -> Bool

(<) :: Bool -> Bool -> Bool

(>~) :: Bool -> Bool -> Bool

(>) :: Bool -> Bool -> Bool

(~~) :: Bool -> Bool -> Bool

(/~) :: Bool -> Bool -> Bool

order :: Bool -> Bool -> Maybe Ordering

comparable :: Bool -> Bool -> Bool

Order Int

Methods

(<~) :: Int -> Int -> Bool

(<) :: Int -> Int -> Bool

(>~) :: Int -> Int -> Bool

(>) :: Int -> Int -> Bool

(~~) :: Int -> Int -> Bool

(/~) :: Int -> Int -> Bool

order :: Int -> Int -> Maybe Ordering

comparable :: Int -> Int -> Bool

Order Int8

Methods

(<~) :: Int8 -> Int8 -> Bool

(<) :: Int8 -> Int8 -> Bool

(>~) :: Int8 -> Int8 -> Bool

(>) :: Int8 -> Int8 -> Bool

(~~) :: Int8 -> Int8 -> Bool

(/~) :: Int8 -> Int8 -> Bool

order :: Int8 -> Int8 -> Maybe Ordering

comparable :: Int8 -> Int8 -> Bool

Order Int16

Methods

(<~) :: Int16 -> Int16 -> Bool

(<) :: Int16 -> Int16 -> Bool

(>~) :: Int16 -> Int16 -> Bool

(>) :: Int16 -> Int16 -> Bool

(~~) :: Int16 -> Int16 -> Bool

(/~) :: Int16 -> Int16 -> Bool

order :: Int16 -> Int16 -> Maybe Ordering

comparable :: Int16 -> Int16 -> Bool

Order Int32

Methods

(<~) :: Int32 -> Int32 -> Bool

(<) :: Int32 -> Int32 -> Bool

(>~) :: Int32 -> Int32 -> Bool

(>) :: Int32 -> Int32 -> Bool

(~~) :: Int32 -> Int32 -> Bool

(/~) :: Int32 -> Int32 -> Bool

order :: Int32 -> Int32 -> Maybe Ordering

comparable :: Int32 -> Int32 -> Bool

Order Int64

Methods

(<~) :: Int64 -> Int64 -> Bool

(<) :: Int64 -> Int64 -> Bool

(>~) :: Int64 -> Int64 -> Bool

(>) :: Int64 -> Int64 -> Bool

(~~) :: Int64 -> Int64 -> Bool

(/~) :: Int64 -> Int64 -> Bool

order :: Int64 -> Int64 -> Maybe Ordering

comparable :: Int64 -> Int64 -> Bool

Order Integer

Methods

(<~) :: Integer -> Integer -> Bool

(<) :: Integer -> Integer -> Bool

(>~) :: Integer -> Integer -> Bool

(>) :: Integer -> Integer -> Bool

(~~) :: Integer -> Integer -> Bool

(/~) :: Integer -> Integer -> Bool

order :: Integer -> Integer -> Maybe Ordering

comparable :: Integer -> Integer -> Bool

Order Natural

Methods

(<~) :: Natural -> Natural -> Bool

(<) :: Natural -> Natural -> Bool

(>~) :: Natural -> Natural -> Bool

(>) :: Natural -> Natural -> Bool

(~~) :: Natural -> Natural -> Bool

(/~) :: Natural -> Natural -> Bool

order :: Natural -> Natural -> Maybe Ordering

comparable :: Natural -> Natural -> Bool

Order Word

Methods

(<~) :: Word -> Word -> Bool

(<) :: Word -> Word -> Bool

(>~) :: Word -> Word -> Bool

(>) :: Word -> Word -> Bool

(~~) :: Word -> Word -> Bool

(/~) :: Word -> Word -> Bool

order :: Word -> Word -> Maybe Ordering

comparable :: Word -> Word -> Bool

Order Word8

Methods

(<~) :: Word8 -> Word8 -> Bool

(<) :: Word8 -> Word8 -> Bool

(>~) :: Word8 -> Word8 -> Bool

(>) :: Word8 -> Word8 -> Bool

(~~) :: Word8 -> Word8 -> Bool

(/~) :: Word8 -> Word8 -> Bool

order :: Word8 -> Word8 -> Maybe Ordering

comparable :: Word8 -> Word8 -> Bool

Order Word16

Methods

(<~) :: Word16 -> Word16 -> Bool

(<) :: Word16 -> Word16 -> Bool

(>~) :: Word16 -> Word16 -> Bool

(>) :: Word16 -> Word16 -> Bool

(~~) :: Word16 -> Word16 -> Bool

(/~) :: Word16 -> Word16 -> Bool

order :: Word16 -> Word16 -> Maybe Ordering

comparable :: Word16 -> Word16 -> Bool

Order Word32

Methods

(<~) :: Word32 -> Word32 -> Bool

(<) :: Word32 -> Word32 -> Bool

(>~) :: Word32 -> Word32 -> Bool

(>) :: Word32 -> Word32 -> Bool

(~~) :: Word32 -> Word32 -> Bool

(/~) :: Word32 -> Word32 -> Bool

order :: Word32 -> Word32 -> Maybe Ordering

comparable :: Word32 -> Word32 -> Bool

Order Word64

Methods

(<~) :: Word64 -> Word64 -> Bool

(<) :: Word64 -> Word64 -> Bool

(>~) :: Word64 -> Word64 -> Bool

(>) :: Word64 -> Word64 -> Bool

(~~) :: Word64 -> Word64 -> Bool

(/~) :: Word64 -> Word64 -> Bool

order :: Word64 -> Word64 -> Maybe Ordering

comparable :: Word64 -> Word64 -> Bool

Order ()

Methods

(<~) :: () -> () -> Bool

(<) :: () -> () -> Bool

(>~) :: () -> () -> Bool

(>) :: () -> () -> Bool

(~~) :: () -> () -> Bool

(/~) :: () -> () -> Bool

order :: () -> () -> Maybe Ordering

comparable :: () -> () -> Bool

Ord a => Order (Set a)

Methods

(<~) :: Set a -> Set a -> Bool

(<) :: Set a -> Set a -> Bool

(>~) :: Set a -> Set a -> Bool

(>) :: Set a -> Set a -> Bool

(~~) :: Set a -> Set a -> Bool

(/~) :: Set a -> Set a -> Bool

order :: Set a -> Set a -> Maybe Ordering

comparable :: Set a -> Set a -> Bool

(Order a, Order b) => Order (a, b)

Methods

(<~) :: (a, b) -> (a, b) -> Bool

(<) :: (a, b) -> (a, b) -> Bool

(>~) :: (a, b) -> (a, b) -> Bool

(>) :: (a, b) -> (a, b) -> Bool

(~~) :: (a, b) -> (a, b) -> Bool

(/~) :: (a, b) -> (a, b) -> Bool

order :: (a, b) -> (a, b) -> Maybe Ordering

comparable :: (a, b) -> (a, b) -> Bool

(Order a, Order b, Order c) => Order (a, b, c)

Methods

(<~) :: (a, b, c) -> (a, b, c) -> Bool

(<) :: (a, b, c) -> (a, b, c) -> Bool

(>~) :: (a, b, c) -> (a, b, c) -> Bool

(>) :: (a, b, c) -> (a, b, c) -> Bool

(~~) :: (a, b, c) -> (a, b, c) -> Bool

(/~) :: (a, b, c) -> (a, b, c) -> Bool

order :: (a, b, c) -> (a, b, c) -> Maybe Ordering

comparable :: (a, b, c) -> (a, b, c) -> Bool

(Order a, Order b, Order c, Order d) => Order (a, b, c, d)

Methods

(<~) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(<) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>~) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(>) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(~~) :: (a, b, c, d) -> (a, b, c, d) -> Bool

(/~) :: (a, b, c, d) -> (a, b, c, d) -> Bool

order :: (a, b, c, d) -> (a, b, c, d) -> Maybe Ordering

comparable :: (a, b, c, d) -> (a, b, c, d) -> Bool

(Order a, Order b, Order c, Order d, Order e) => Order (a, b, c, d, e)

Methods

(<~) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(<) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>~) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(>) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(~~) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

(/~) :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

order :: (a, b, c, d, e) -> (a, b, c, d, e) -> Maybe Ordering

comparable :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

class (AdditiveOrder r, Rig r) => OrderedRig r

Instances

OrderedRig Bool

OrderedRig Integer

OrderedRig Natural

OrderedRig ()

(OrderedRig a, OrderedRig b) => OrderedRig (a, b)

(OrderedRig a, OrderedRig b, OrderedRig c) => OrderedRig (a, b, c)

(OrderedRig a, OrderedRig b, OrderedRig c, OrderedRig d) => OrderedRig (a, b, c, d)

(OrderedRig a, OrderedRig b, OrderedRig c, OrderedRig d, OrderedRig e) => OrderedRig (a, b, c, d, e)

class (Additive r, Order r) => AdditiveOrder r

z + x <= z + y = x <= y = x + z <= y + z

Instances

AdditiveOrder Bool

AdditiveOrder Integer

AdditiveOrder Natural

AdditiveOrder ()

(AdditiveOrder a, AdditiveOrder b) => AdditiveOrder (a, b)

(AdditiveOrder a, AdditiveOrder b, AdditiveOrder c) => AdditiveOrder (a, b, c)

(AdditiveOrder a, AdditiveOrder b, AdditiveOrder c, AdditiveOrder d) => AdditiveOrder (a, b, c, d)

(AdditiveOrder a, AdditiveOrder b, AdditiveOrder c, AdditiveOrder d, AdditiveOrder e) => AdditiveOrder (a, b, c, d, e)

class Order a => LocallyFiniteOrder a

Minimal complete definition

range, rangeSize

Instances

LocallyFiniteOrder Bool

Methods

range :: Bool -> Bool -> [Bool]

rangeSize :: Bool -> Bool -> Natural

moebiusInversion :: Ring r => Bool -> Bool -> r

LocallyFiniteOrder Int

Methods

range :: Int -> Int -> [Int]

rangeSize :: Int -> Int -> Natural

moebiusInversion :: Ring r => Int -> Int -> r

LocallyFiniteOrder Int8

Methods

range :: Int8 -> Int8 -> [Int8]

rangeSize :: Int8 -> Int8 -> Natural

moebiusInversion :: Ring r => Int8 -> Int8 -> r

LocallyFiniteOrder Int16

Methods

range :: Int16 -> Int16 -> [Int16]

rangeSize :: Int16 -> Int16 -> Natural

moebiusInversion :: Ring r => Int16 -> Int16 -> r

LocallyFiniteOrder Int32

Methods

range :: Int32 -> Int32 -> [Int32]

rangeSize :: Int32 -> Int32 -> Natural

moebiusInversion :: Ring r => Int32 -> Int32 -> r

LocallyFiniteOrder Int64

Methods

range :: Int64 -> Int64 -> [Int64]

rangeSize :: Int64 -> Int64 -> Natural

moebiusInversion :: Ring r => Int64 -> Int64 -> r

LocallyFiniteOrder Integer

Methods

range :: Integer -> Integer -> [Integer]

rangeSize :: Integer -> Integer -> Natural

moebiusInversion :: Ring r => Integer -> Integer -> r

LocallyFiniteOrder Natural

Methods

range :: Natural -> Natural -> [Natural]

rangeSize :: Natural -> Natural -> Natural

moebiusInversion :: Ring r => Natural -> Natural -> r

LocallyFiniteOrder Word

Methods

range :: Word -> Word -> [Word]

rangeSize :: Word -> Word -> Natural

moebiusInversion :: Ring r => Word -> Word -> r

LocallyFiniteOrder Word8

Methods

range :: Word8 -> Word8 -> [Word8]

rangeSize :: Word8 -> Word8 -> Natural

moebiusInversion :: Ring r => Word8 -> Word8 -> r

LocallyFiniteOrder Word16

Methods

range :: Word16 -> Word16 -> [Word16]

rangeSize :: Word16 -> Word16 -> Natural

moebiusInversion :: Ring r => Word16 -> Word16 -> r

LocallyFiniteOrder Word32

Methods

range :: Word32 -> Word32 -> [Word32]

rangeSize :: Word32 -> Word32 -> Natural

moebiusInversion :: Ring r => Word32 -> Word32 -> r

LocallyFiniteOrder Word64

Methods

range :: Word64 -> Word64 -> [Word64]

rangeSize :: Word64 -> Word64 -> Natural

moebiusInversion :: Ring r => Word64 -> Word64 -> r

LocallyFiniteOrder ()

Methods

range :: () -> () -> [()]

rangeSize :: () -> () -> Natural

moebiusInversion :: Ring r => () -> () -> r

Ord a => LocallyFiniteOrder (Set a)

Methods

range :: Set a -> Set a -> [Set a]

rangeSize :: Set a -> Set a -> Natural

moebiusInversion :: Ring r => Set a -> Set a -> r

(LocallyFiniteOrder a, LocallyFiniteOrder b) => LocallyFiniteOrder (a, b)

Methods

range :: (a, b) -> (a, b) -> [(a, b)]

rangeSize :: (a, b) -> (a, b) -> Natural

moebiusInversion :: Ring r => (a, b) -> (a, b) -> r

(LocallyFiniteOrder a, LocallyFiniteOrder b, LocallyFiniteOrder c) => LocallyFiniteOrder (a, b, c)

Methods

range :: (a, b, c) -> (a, b, c) -> [(a, b, c)]

rangeSize :: (a, b, c) -> (a, b, c) -> Natural

moebiusInversion :: Ring r => (a, b, c) -> (a, b, c) -> r

(LocallyFiniteOrder a, LocallyFiniteOrder b, LocallyFiniteOrder c, LocallyFiniteOrder d) => LocallyFiniteOrder (a, b, c, d)

Methods

range :: (a, b, c, d) -> (a, b, c, d) -> [(a, b, c, d)]

rangeSize :: (a, b, c, d) -> (a, b, c, d) -> Natural

moebiusInversion :: Ring r => (a, b, c, d) -> (a, b, c, d) -> r

(LocallyFiniteOrder a, LocallyFiniteOrder b, LocallyFiniteOrder c, LocallyFiniteOrder d, LocallyFiniteOrder e) => LocallyFiniteOrder (a, b, c, d, e)

Methods

range :: (a, b, c, d, e) -> (a, b, c, d, e) -> [(a, b, c, d, e)]

rangeSize :: (a, b, c, d, e) -> (a, b, c, d, e) -> Natural

moebiusInversion :: Ring r => (a, b, c, d, e) -> (a, b, c, d, e) -> r

class Monoidal r => DecidableZero r

Minimal complete definition

isZero

Instances

DecidableZero Bool

Methods

isZero :: Bool -> Bool

DecidableZero Int

Methods

isZero :: Int -> Bool

DecidableZero Int8

Methods

isZero :: Int8 -> Bool

DecidableZero Int16

Methods

isZero :: Int16 -> Bool

DecidableZero Int32

Methods

isZero :: Int32 -> Bool

DecidableZero Int64

Methods

isZero :: Int64 -> Bool

DecidableZero Integer

Methods

isZero :: Integer -> Bool

DecidableZero Natural

Methods

isZero :: Natural -> Bool

DecidableZero Word

Methods

isZero :: Word -> Bool

DecidableZero Word8

Methods

isZero :: Word8 -> Bool

DecidableZero Word16

Methods

isZero :: Word16 -> Bool

DecidableZero Word32

Methods

isZero :: Word32 -> Bool

DecidableZero Word64

Methods

isZero :: Word64 -> Bool

DecidableZero ()

Methods

isZero :: () -> Bool

DecidableZero r => DecidableZero (Opposite r)

Methods

isZero :: Opposite r -> Bool

DecidableZero (BasisCoblade m)

Methods

isZero :: BasisCoblade m -> Bool

GCDDomain d => DecidableZero (Fraction d)

Methods

isZero :: Fraction d -> Bool

(DecidableZero a, DecidableZero b) => DecidableZero (a, b)

Methods

isZero :: (a, b) -> Bool

(DecidableZero a, DecidableZero b, DecidableZero c) => DecidableZero (a, b, c)

Methods

isZero :: (a, b, c) -> Bool

(DecidableZero a, DecidableZero b, DecidableZero c, DecidableZero d) => DecidableZero (a, b, c, d)

Methods

isZero :: (a, b, c, d) -> Bool

(DecidableZero a, DecidableZero b, DecidableZero c, DecidableZero d, DecidableZero e) => DecidableZero (a, b, c, d, e)

Methods

isZero :: (a, b, c, d, e) -> Bool

class Unital r => DecidableUnits r

Minimal complete definition

recipUnit

Instances

DecidableUnits Bool

Methods

recipUnit :: Bool -> Maybe Bool

isUnit :: Bool -> Bool

(^?) :: Integral n => Bool -> n -> Maybe Bool

DecidableUnits Int

Methods

recipUnit :: Int -> Maybe Int

isUnit :: Int -> Bool

(^?) :: Integral n => Int -> n -> Maybe Int

DecidableUnits Int8

Methods

recipUnit :: Int8 -> Maybe Int8

isUnit :: Int8 -> Bool

(^?) :: Integral n => Int8 -> n -> Maybe Int8

DecidableUnits Int16

Methods

recipUnit :: Int16 -> Maybe Int16

isUnit :: Int16 -> Bool

(^?) :: Integral n => Int16 -> n -> Maybe Int16

DecidableUnits Int32

Methods

recipUnit :: Int32 -> Maybe Int32

isUnit :: Int32 -> Bool

(^?) :: Integral n => Int32 -> n -> Maybe Int32

DecidableUnits Int64

Methods

recipUnit :: Int64 -> Maybe Int64

isUnit :: Int64 -> Bool

(^?) :: Integral n => Int64 -> n -> Maybe Int64

DecidableUnits Integer

Methods

recipUnit :: Integer -> Maybe Integer

isUnit :: Integer -> Bool

(^?) :: Integral n => Integer -> n -> Maybe Integer

DecidableUnits Natural

Methods

recipUnit :: Natural -> Maybe Natural

isUnit :: Natural -> Bool

(^?) :: Integral n => Natural -> n -> Maybe Natural

DecidableUnits Word

Methods

recipUnit :: Word -> Maybe Word

isUnit :: Word -> Bool

(^?) :: Integral n => Word -> n -> Maybe Word

DecidableUnits Word8

Methods

recipUnit :: Word8 -> Maybe Word8

isUnit :: Word8 -> Bool

(^?) :: Integral n => Word8 -> n -> Maybe Word8

DecidableUnits Word16

Methods

recipUnit :: Word16 -> Maybe Word16

isUnit :: Word16 -> Bool

(^?) :: Integral n => Word16 -> n -> Maybe Word16

DecidableUnits Word32

Methods

recipUnit :: Word32 -> Maybe Word32

isUnit :: Word32 -> Bool

(^?) :: Integral n => Word32 -> n -> Maybe Word32

DecidableUnits Word64

Methods

recipUnit :: Word64 -> Maybe Word64

isUnit :: Word64 -> Bool

(^?) :: Integral n => Word64 -> n -> Maybe Word64

DecidableUnits ()

Methods

recipUnit :: () -> Maybe ()

isUnit :: () -> Bool

(^?) :: Integral n => () -> n -> Maybe ()

DecidableUnits r => DecidableUnits (Opposite r)

Methods

recipUnit :: Opposite r -> Maybe (Opposite r)

isUnit :: Opposite r -> Bool

(^?) :: Integral n => Opposite r -> n -> Maybe (Opposite r)

DecidableUnits (BasisCoblade m)

Methods

recipUnit :: BasisCoblade m -> Maybe (BasisCoblade m)

isUnit :: BasisCoblade m -> Bool

(^?) :: Integral n => BasisCoblade m -> n -> Maybe (BasisCoblade m)

GCDDomain d => DecidableUnits (Fraction d)

Methods

recipUnit :: Fraction d -> Maybe (Fraction d)

isUnit :: Fraction d -> Bool

(^?) :: Integral n => Fraction d -> n -> Maybe (Fraction d)

(DecidableUnits a, DecidableUnits b) => DecidableUnits (a, b)

Methods

recipUnit :: (a, b) -> Maybe (a, b)

isUnit :: (a, b) -> Bool

(^?) :: Integral n => (a, b) -> n -> Maybe (a, b)

(DecidableUnits a, DecidableUnits b, DecidableUnits c) => DecidableUnits (a, b, c)

Methods

recipUnit :: (a, b, c) -> Maybe (a, b, c)

isUnit :: (a, b, c) -> Bool

(^?) :: Integral n => (a, b, c) -> n -> Maybe (a, b, c)

(DecidableUnits a, DecidableUnits b, DecidableUnits c, DecidableUnits d) => DecidableUnits (a, b, c, d)

Methods

recipUnit :: (a, b, c, d) -> Maybe (a, b, c, d)

isUnit :: (a, b, c, d) -> Bool

(^?) :: Integral n => (a, b, c, d) -> n -> Maybe (a, b, c, d)

(DecidableUnits a, DecidableUnits b, DecidableUnits c, DecidableUnits d, DecidableUnits e) => DecidableUnits (a, b, c, d, e)

Methods

recipUnit :: (a, b, c, d, e) -> Maybe (a, b, c, d, e)

isUnit :: (a, b, c, d, e) -> Bool

(^?) :: Integral n => (a, b, c, d, e) -> n -> Maybe (a, b, c, d, e)

class Unital r => DecidableAssociates r

Minimal complete definition

isAssociate

Instances

DecidableAssociates Bool

Methods

isAssociate :: Bool -> Bool -> Bool

DecidableAssociates Int

Methods

isAssociate :: Int -> Int -> Bool

DecidableAssociates Int8

Methods

isAssociate :: Int8 -> Int8 -> Bool

DecidableAssociates Int16

Methods

isAssociate :: Int16 -> Int16 -> Bool

DecidableAssociates Int32

Methods

isAssociate :: Int32 -> Int32 -> Bool

DecidableAssociates Int64

Methods

isAssociate :: Int64 -> Int64 -> Bool

DecidableAssociates Integer

Methods

isAssociate :: Integer -> Integer -> Bool

DecidableAssociates Natural

Methods

isAssociate :: Natural -> Natural -> Bool

DecidableAssociates Word

Methods

isAssociate :: Word -> Word -> Bool

DecidableAssociates Word8

Methods

isAssociate :: Word8 -> Word8 -> Bool

DecidableAssociates Word16

Methods

isAssociate :: Word16 -> Word16 -> Bool

DecidableAssociates Word32

Methods

isAssociate :: Word32 -> Word32 -> Bool

DecidableAssociates Word64

Methods

isAssociate :: Word64 -> Word64 -> Bool

DecidableAssociates ()

Methods

isAssociate :: () -> () -> Bool

DecidableAssociates r => DecidableAssociates (Opposite r)

Methods

isAssociate :: Opposite r -> Opposite r -> Bool

DecidableAssociates (BasisCoblade m)

Methods

isAssociate :: BasisCoblade m -> BasisCoblade m -> Bool

GCDDomain d => DecidableAssociates (Fraction d)

Methods

isAssociate :: Fraction d -> Fraction d -> Bool

(DecidableAssociates a, DecidableAssociates b) => DecidableAssociates (a, b)

Methods

isAssociate :: (a, b) -> (a, b) -> Bool

(DecidableAssociates a, DecidableAssociates b, DecidableAssociates c) => DecidableAssociates (a, b, c)

Methods

isAssociate :: (a, b, c) -> (a, b, c) -> Bool

(DecidableAssociates a, DecidableAssociates b, DecidableAssociates c, DecidableAssociates d) => DecidableAssociates (a, b, c, d)

Methods

isAssociate :: (a, b, c, d) -> (a, b, c, d) -> Bool

(DecidableAssociates a, DecidableAssociates b, DecidableAssociates c, DecidableAssociates d, DecidableAssociates e) => DecidableAssociates (a, b, c, d, e)

Methods

isAssociate :: (a, b, c, d, e) -> (a, b, c, d, e) -> Bool

Natural numbers

data Natural :: *

Type representing arbitrary-precision non-negative integers.

Operations whose result would be negative throw (Underflow :: ArithException).

Since: 4.8.0.0

Instances

Enum Natural

Since: 4.8.0.0

Methods

succ :: Natural -> Natural

pred :: Natural -> Natural

toEnum :: Int -> Natural

fromEnum :: Natural -> Int

enumFrom :: Natural -> [Natural]

enumFromThen :: Natural -> Natural -> [Natural]

enumFromTo :: Natural -> Natural -> [Natural]

enumFromThenTo :: Natural -> Natural -> Natural -> [Natural]

Eq Natural

Methods

(==) :: Natural -> Natural -> Bool

(/=) :: Natural -> Natural -> Bool

Integral Natural

Since: 4.8.0.0

Methods

quot :: Natural -> Natural -> Natural

rem :: Natural -> Natural -> Natural

div :: Natural -> Natural -> Natural

mod :: Natural -> Natural -> Natural

quotRem :: Natural -> Natural -> (Natural, Natural)

divMod :: Natural -> Natural -> (Natural, Natural)

toInteger :: Natural -> Integer

Data Natural

Since: 4.8.0.0

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Natural -> c Natural

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Natural

toConstr :: Natural -> Constr

dataTypeOf :: Natural -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c Natural)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Natural)

gmapT :: (forall b. Data b => b -> b) -> Natural -> Natural

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Natural -> r

gmapQ :: (forall d. Data d => d -> u) -> Natural -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> Natural -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Natural -> m Natural

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Natural -> m Natural

Num Natural

Since: 4.8.0.0

Methods

(+) :: Natural -> Natural -> Natural

(-) :: Natural -> Natural -> Natural

(*) :: Natural -> Natural -> Natural

negate :: Natural -> Natural

abs :: Natural -> Natural

signum :: Natural -> Natural

fromInteger :: Integer -> Natural

Ord Natural

Methods

compare :: Natural -> Natural -> Ordering

(<) :: Natural -> Natural -> Bool

(<=) :: Natural -> Natural -> Bool

(>) :: Natural -> Natural -> Bool

(>=) :: Natural -> Natural -> Bool

max :: Natural -> Natural -> Natural

min :: Natural -> Natural -> Natural

Read Natural

Since: 4.8.0.0

Methods

readsPrec :: Int -> ReadS Natural

readList :: ReadS [Natural]

readPrec :: ReadPrec Natural

readListPrec :: ReadPrec [Natural]

Real Natural

Since: 4.8.0.0

Methods

toRational :: Natural -> Rational

Show Natural

Since: 4.8.0.0

Methods

showsPrec :: Int -> Natural -> ShowS

show :: Natural -> String

showList :: [Natural] -> ShowS

Ix Natural

Since: 4.8.0.0

Methods

range :: (Natural, Natural) -> [Natural]

index :: (Natural, Natural) -> Natural -> Int

unsafeIndex :: (Natural, Natural) -> Natural -> Int

inRange :: (Natural, Natural) -> Natural -> Bool

rangeSize :: (Natural, Natural) -> Int

unsafeRangeSize :: (Natural, Natural) -> Int

Bits Natural

Since: 4.8.0.0

Methods

(.&.) :: Natural -> Natural -> Natural

(.|.) :: Natural -> Natural -> Natural

xor :: Natural -> Natural -> Natural

complement :: Natural -> Natural

shift :: Natural -> Int -> Natural

rotate :: Natural -> Int -> Natural

zeroBits :: Natural

bit :: Int -> Natural

setBit :: Natural -> Int -> Natural

clearBit :: Natural -> Int -> Natural

complementBit :: Natural -> Int -> Natural

testBit :: Natural -> Int -> Bool

bitSizeMaybe :: Natural -> Maybe Int

bitSize :: Natural -> Int

isSigned :: Natural -> Bool

shiftL :: Natural -> Int -> Natural

unsafeShiftL :: Natural -> Int -> Natural

shiftR :: Natural -> Int -> Natural

unsafeShiftR :: Natural -> Int -> Natural

rotateL :: Natural -> Int -> Natural

rotateR :: Natural -> Int -> Natural

popCount :: Natural -> Int

Hashable Natural

Methods

hashWithSalt :: Int -> Natural -> Int

hash :: Natural -> Int

Abelian Natural

Partitionable Natural

Methods

partitionWith :: (Natural -> Natural -> r) -> Natural -> NonEmpty r

Additive Natural

Methods

(+) :: Natural -> Natural -> Natural

sinnum1p :: Natural -> Natural -> Natural

sumWith1 :: Foldable1 f => (a -> Natural) -> f a -> Natural

Monoidal Natural

Methods

zero :: Natural

sinnum :: Natural -> Natural -> Natural

sumWith :: Foldable f => (a -> Natural) -> f a -> Natural

Semiring Natural

Multiplicative Natural

Methods

(*) :: Natural -> Natural -> Natural

pow1p :: Natural -> Natural -> Natural

productWith1 :: Foldable1 f => (a -> Natural) -> f a -> Natural

Unital Natural

Methods

one :: Natural

pow :: Natural -> Natural -> Natural

productWith :: Foldable f => (a -> Natural) -> f a -> Natural

Commutative Natural

TriviallyInvolutive Natural

InvolutiveSemiring Natural

InvolutiveMultiplication Natural

Methods

adjoint :: Natural -> Natural

DecidableAssociates Natural

Methods

isAssociate :: Natural -> Natural -> Bool

DecidableUnits Natural

Methods

recipUnit :: Natural -> Maybe Natural

isUnit :: Natural -> Bool

(^?) :: Integral n => Natural -> n -> Maybe Natural

DecidableZero Natural

Methods

isZero :: Natural -> Bool

Order Natural

Methods

(<~) :: Natural -> Natural -> Bool

(<) :: Natural -> Natural -> Bool

(>~) :: Natural -> Natural -> Bool

(>) :: Natural -> Natural -> Bool

(~~) :: Natural -> Natural -> Bool

(/~) :: Natural -> Natural -> Bool

order :: Natural -> Natural -> Maybe Ordering

comparable :: Natural -> Natural -> Bool

AdditiveOrder Natural

PartialSemigroup Natural

Methods

padd :: Natural -> Natural -> Maybe Natural

PartialMonoid Natural

Methods

pzero :: Natural

PartialGroup Natural

Methods

pnegate :: Natural -> Maybe Natural

pminus :: Natural -> Natural -> Maybe Natural

psubtract :: Natural -> Natural -> Maybe Natural

Rig Natural

Methods

fromNatural :: Natural -> Natural

Characteristic Natural

Methods

char :: proxy Natural -> Natural

OrderedRig Natural

LocallyFiniteOrder Natural

Methods

range :: Natural -> Natural -> [Natural]

rangeSize :: Natural -> Natural -> Natural

moebiusInversion :: Ring r => Natural -> Natural -> r

ZeroProductSemiring Natural

DecidableNilpotent Natural

Methods

isNilpotent :: Natural -> Bool

RightModule Natural Bool

Methods

(*.) :: Bool -> Natural -> Bool

RightModule Natural Int

Methods

(*.) :: Int -> Natural -> Int

RightModule Natural Int8

Methods

(*.) :: Int8 -> Natural -> Int8

RightModule Natural Int16

Methods

(*.) :: Int16 -> Natural -> Int16

RightModule Natural Int32

Methods

(*.) :: Int32 -> Natural -> Int32

RightModule Natural Int64

Methods

(*.) :: Int64 -> Natural -> Int64

RightModule Natural Integer

Methods

(*.) :: Integer -> Natural -> Integer

RightModule Natural Natural

Methods

(*.) :: Natural -> Natural -> Natural

RightModule Natural Word

Methods

(*.) :: Word -> Natural -> Word

RightModule Natural Word8

Methods

(*.) :: Word8 -> Natural -> Word8

RightModule Natural Word16

Methods

(*.) :: Word16 -> Natural -> Word16

RightModule Natural Word32

Methods

(*.) :: Word32 -> Natural -> Word32

RightModule Natural Word64

Methods

(*.) :: Word64 -> Natural -> Word64

RightModule Natural Euclidean

Methods

(*.) :: Euclidean -> Natural -> Euclidean

LeftModule Natural Bool

Methods

(.*) :: Natural -> Bool -> Bool

LeftModule Natural Int

Methods

(.*) :: Natural -> Int -> Int

LeftModule Natural Int8

Methods

(.*) :: Natural -> Int8 -> Int8

LeftModule Natural Int16

Methods

(.*) :: Natural -> Int16 -> Int16

LeftModule Natural Int32

Methods

(.*) :: Natural -> Int32 -> Int32

LeftModule Natural Int64

Methods

(.*) :: Natural -> Int64 -> Int64

LeftModule Natural Integer

Methods

(.*) :: Natural -> Integer -> Integer

LeftModule Natural Natural

Methods

(.*) :: Natural -> Natural -> Natural

LeftModule Natural Word

Methods

(.*) :: Natural -> Word -> Word

LeftModule Natural Word8

Methods

(.*) :: Natural -> Word8 -> Word8

LeftModule Natural Word16

Methods

(.*) :: Natural -> Word16 -> Word16

LeftModule Natural Word32

Methods

(.*) :: Natural -> Word32 -> Word32

LeftModule Natural Word64

Methods

(.*) :: Natural -> Word64 -> Word64

LeftModule Natural Euclidean

Methods

(.*) :: Natural -> Euclidean -> Euclidean

Rig r => Quadrance r Natural

Methods

quadrance :: Natural -> r

Monoidal r => RightModule Natural (ZeroRng r)

Methods

(*.) :: ZeroRng r -> Natural -> ZeroRng r

(Abelian r, Monoidal r) => RightModule Natural (RngRing r)

Methods

(*.) :: RngRing r -> Natural -> RngRing r

Unital r => RightModule Natural (Log r)

Methods

(*.) :: Log r -> Natural -> Log r

RightModule Natural (BasisCoblade m)

Methods

(*.) :: BasisCoblade m -> Natural -> BasisCoblade m

GCDDomain d => RightModule Natural (Fraction d)

Methods

(*.) :: Fraction d -> Natural -> Fraction d

Monoidal r => LeftModule Natural (ZeroRng r)

Methods

(.*) :: Natural -> ZeroRng r -> ZeroRng r

(Abelian r, Monoidal r) => LeftModule Natural (RngRing r)

Methods

(.*) :: Natural -> RngRing r -> RngRing r

Unital r => LeftModule Natural (Log r)

Methods

(.*) :: Natural -> Log r -> Log r

LeftModule Natural (BasisCoblade m)

Methods

(.*) :: Natural -> BasisCoblade m -> BasisCoblade m

GCDDomain d => LeftModule Natural (Fraction d)

Methods

(.*) :: Natural -> Fraction d -> Fraction d

Representable Additive

addRep :: (Applicative m, Additive r) => m r -> m r -> m r

`Additive.(+)` default definition

sinnum1pRep :: (Functor m, Additive r) => Natural -> m r -> m r

sinnum1p default definition

Representable Monoidal

zeroRep :: (Applicative m, Monoidal r) => m r

zero default definition

sinnumRep :: (Functor m, Monoidal r) => Natural -> m r -> m r

sinnum default definition

Representable Group

negateRep :: (Functor m, Group r) => m r -> m r

negate default definition

minusRep :: (Applicative m, Group r) => m r -> m r -> m r

`Group.(-)` default definition

subtractRep :: (Applicative m, Group r) => m r -> m r -> m r

subtract default definition

timesRep :: (Integral n, Functor m, Group r) => n -> m r -> m r

times default definition

Representable Multiplicative (via Algebra)

mulRep :: (Representable m, Algebra r (Rep m)) => m r -> m r -> m r

`Multiplicative.(*)` default definition

Representable Unital (via UnitalAlgebra)

oneRep :: (Representable m, Unital r, UnitalAlgebra r (Rep m)) => m r

one default definition

Representable Rig (via Algebra)

fromNaturalRep :: (UnitalAlgebra r (Rep m), Representable m, Rig r) => Natural -> m r

fromNatural default definition

Representable Ring (via Algebra)

fromIntegerRep :: (UnitalAlgebra r (Rep m), Representable m, Ring r) => Integer -> m r

fromInteger default definition

Norm

class Additive r => Quadrance r m where

Minimal complete definition

quadrance

Methods

quadrance :: m -> r

Instances

Quadrance () a

Methods

quadrance :: a -> ()

Rig r => Quadrance r Word64

Methods

quadrance :: Word64 -> r

Rig r => Quadrance r Word32

Methods

quadrance :: Word32 -> r

Rig r => Quadrance r Word16

Methods

quadrance :: Word16 -> r

Rig r => Quadrance r Word8

Methods

quadrance :: Word8 -> r

Rig r => Quadrance r Int64

Methods

quadrance :: Int64 -> r

Rig r => Quadrance r Int32

Methods

quadrance :: Int32 -> r

Rig r => Quadrance r Int16

Methods

quadrance :: Int16 -> r

Rig r => Quadrance r Int8

Methods

quadrance :: Int8 -> r

Rig r => Quadrance r Integer

Methods

quadrance :: Integer -> r

Rig r => Quadrance r Natural

Methods

quadrance :: Natural -> r

Rig r => Quadrance r Word

Methods

quadrance :: Word -> r

Rig r => Quadrance r Int

Methods

quadrance :: Int -> r

Rig r => Quadrance r Bool

Methods

quadrance :: Bool -> r

(Additive r, Monoidal r) => Quadrance r ()

Methods

quadrance :: () -> r

(TriviallyInvolutive r, Rng r) => Quadrance r (Quaternion' r)

Methods

quadrance :: Quaternion' r -> r

(Commutative r, Rng r, InvolutiveSemiring r) => Quadrance r (Dual' r)

Methods

quadrance :: Dual' r -> r

(TriviallyInvolutive r, Rng r) => Quadrance r (Quaternion r)

Methods

quadrance :: Quaternion r -> r

(Commutative r, InvolutiveSemiring r, Rng r) => Quadrance r (Hyper' r)

Methods

quadrance :: Hyper' r -> r

(Commutative r, Rng r, InvolutiveSemiring r) => Quadrance r (Dual r)

Methods

quadrance :: Dual r -> r

(Commutative r, Rng r, InvolutiveSemiring r) => Quadrance r (Complex r)

Methods

quadrance :: Complex r -> r

(Quadrance r a, Quadrance r b) => Quadrance r (a, b)

Methods

quadrance :: (a, b) -> r

(Quadrance r a, Quadrance r b, Quadrance r c) => Quadrance r (a, b, c)

Methods

quadrance :: (a, b, c) -> r

(Quadrance r a, Quadrance r b, Quadrance r c, Quadrance r d) => Quadrance r (a, b, c, d)

Methods

quadrance :: (a, b, c, d) -> r

(Quadrance r a, Quadrance r b, Quadrance r c, Quadrance r d, Quadrance r e) => Quadrance r (a, b, c, d, e)

Methods

quadrance :: (a, b, c, d, e) -> r

Covectors

newtype Covector r a

Linear functionals from elements of an (infinite) free module to a scalar

Constructors

Covector

Fields

• ($*) :: (a -> r) -> r

Instances

RightModule r s => RightModule r (Covector s m)

Methods

(*.) :: Covector s m -> r -> Covector s m

LeftModule r s => LeftModule r (Covector s m)

Methods

(.*) :: r -> Covector s m -> Covector s m

Monad (Covector r)

Methods

(>>=) :: Covector r a -> (a -> Covector r b) -> Covector r b

(>>) :: Covector r a -> Covector r b -> Covector r b

return :: a -> Covector r a

fail :: String -> Covector r a

Functor (Covector r)

Methods

fmap :: (a -> b) -> Covector r a -> Covector r b

(<$) :: a -> Covector r b -> Covector r a

Applicative (Covector r)

Methods

pure :: a -> Covector r a

(<*>) :: Covector r (a -> b) -> Covector r a -> Covector r b

liftA2 :: (a -> b -> c) -> Covector r a -> Covector r b -> Covector r c

(*>) :: Covector r a -> Covector r b -> Covector r b

(<*) :: Covector r a -> Covector r b -> Covector r a

Monoidal r => Alternative (Covector r)

Methods

empty :: Covector r a

(<|>) :: Covector r a -> Covector r a -> Covector r a

some :: Covector r a -> Covector r [a]

many :: Covector r a -> Covector r [a]

Monoidal r => MonadPlus (Covector r)

Methods

mzero :: Covector r a

mplus :: Covector r a -> Covector r a -> Covector r a

Monoidal r => Plus (Covector r)

Methods

zero :: Covector r a

Additive r => Alt (Covector r)

Methods

(<!>) :: Covector r a -> Covector r a -> Covector r a

some :: Applicative (Covector r) => Covector r a -> Covector r [a]

many :: Applicative (Covector r) => Covector r a -> Covector r [a]

Apply (Covector r)

Methods

(<.>) :: Covector r (a -> b) -> Covector r a -> Covector r b

(.>) :: Covector r a -> Covector r b -> Covector r b

(<.) :: Covector r a -> Covector r b -> Covector r a

Bind (Covector r)

Methods

(>>-) :: Covector r a -> (a -> Covector r b) -> Covector r b

join :: Covector r (Covector r a) -> Covector r a

Idempotent r => Idempotent (Covector r a)

Abelian s => Abelian (Covector s a)

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

Monoidal s => Monoidal (Covector s a)

Methods

zero :: Covector s a

sinnum :: Natural -> Covector s a -> Covector s a

sumWith :: Foldable f => (a -> Covector s a) -> f a -> Covector s a

Coalgebra r m => Semiring (Covector r m)

Coalgebra r m => Multiplicative (Covector r m)

Methods

(*) :: Covector r m -> Covector r m -> Covector r m

pow1p :: Covector r m -> Natural -> Covector r m

productWith1 :: Foldable1 f => (a -> Covector r m) -> f a -> Covector r m

Group s => Group (Covector s a)

Methods

(-) :: Covector s a -> Covector s a -> Covector s a

negate :: Covector s a -> Covector s a

subtract :: Covector s a -> Covector s a -> Covector s a

times :: Integral n => n -> Covector s a -> Covector s a

CounitalCoalgebra r m => Unital (Covector r m)

Methods

one :: Covector r m

pow :: Covector r m -> Natural -> Covector r m

productWith :: Foldable f => (a -> Covector r m) -> f a -> Covector r m

(Idempotent r, IdempotentCoalgebra r a) => Band (Covector r a)

(Commutative m, Coalgebra r m) => Commutative (Covector r m)

(Rig r, CounitalCoalgebra r m) => Rig (Covector r m)

Methods

fromNatural :: Natural -> Covector r m

(Ring r, CounitalCoalgebra r m) => Ring (Covector r m)

Methods

fromInteger :: Integer -> Covector r m

Trigonometric a => Trigonometric (Covector r a)

Methods

cos :: Covector r a

sin :: Covector r a

Hyperbolic a => Hyperbolic (Covector r a)

Methods

cosh :: Covector r a

sinh :: Covector r a

Distinguished a => Distinguished (Covector r a)

Methods

e :: Covector r a

Infinitesimal a => Infinitesimal (Covector r a)

Methods

d :: Covector r a

Complicated a => Complicated (Covector r a)

Methods

i :: Covector r a

Hamiltonian a => Hamiltonian (Covector r a)

Methods

j :: Covector r a

k :: Covector r a

Coalgebra r m => RightModule (Covector r m) (Covector r m)

Methods

(*.) :: Covector r m -> Covector r m -> Covector r m

Coalgebra r m => LeftModule (Covector r m) (Covector r m)

Methods

(.*) :: Covector r m -> Covector r m -> Covector r m

Covectors as linear functionals

counitM :: UnitalAlgebra r a => a -> Covector r ()

unitM :: CounitalCoalgebra r c => Covector r c

comultM :: Algebra r a => a -> Covector r (a, a)

multM :: Coalgebra r c => c -> c -> Covector r c

invM :: InvolutiveAlgebra r h => h -> Covector r h

coinvM :: InvolutiveCoalgebra r h => h -> Covector r h

antipodeM :: HopfAlgebra r h => h -> Covector r h

convolveM antipodeM return = convolveM return antipodeM = comultM >=> uncurry joinM

convolveM :: (Algebra r c, Coalgebra r a) => (c -> Covector r a) -> (c -> Covector r a) -> c -> Covector r a