Tower.Algebra

Algebra

general group structure

class Magma a where

A Magma is a tuple (T,⊕) consisting of

• a type a, and
• a function (⊕) :: T -> T -> T

The mathematical laws for a magma are:

• ⊕ is defined for all possible pairs of type T, and
• ⊕ is closed in the set of all possible values of type T

or, more tersly,

∀ a, b ∈ T: a ⊕ b ∈ T

These laws are true by construction in haskell: the type signature of magma and the above mathematical laws are synonyms.

Minimal complete definition

(⊕)

Methods

(⊕) :: a -> a -> a

class Magma a => Unital a where

A Unital Magma

unit ⊕ a = a
a ⊕ unit = a

Minimal complete definition

unit

Methods

unit :: a

class Magma a => Associative a

An Associative Magma

(a ⊕ b) ⊕ c = a ⊕ (b ⊕ c)

class Magma a => Commutative a

A Commutative Magma

a ⊕ b = b ⊕ a

class Magma a => Invertible a where

An Invertible Magma

∀ a ∈ T: inv a ∈ T

law is true by construction in Haskell

Minimal complete definition

inv

Methods

inv :: a -> a

class Magma a => Idempotent a

An Idempotent Magma

a ⊕ a = a

class (Magma a, Magma b) => Homomorphic a b where

A Homomorphic between two Magmas

∀ a ∈ A: hom a ∈ B

law is true by construction in Haskell

Minimal complete definition

hom

Methods

hom :: a -> b

Instances

Magma a => Homomorphic a a

Methods

hom :: a -> a

class (Associative a, Unital a) => Monoidal a

A Monoidal Magma is associative and unital.

class (Commutative a, Associative a, Unital a) => CMonoidal a

A CMonoidal Magma is commutative, associative and unital.

class (Unital a, Invertible a) => Loop a

A Loop is unital and invertible

class (Associative a, Unital a, Invertible a) => Group a

A Group is associative, unital and invertible

class (Associative a, Unital a, Invertible a, Commutative a) => Abelian a

An Abelian Group is associative, unital, invertible and commutative

Additive Structure

class AdditiveMagma a where

plus is used for the additive magma to distinguish from + which, by convention, implies commutativity

Minimal complete definition

plus

Methods

plus :: a -> a -> a

Instances

AdditiveMagma Double

Methods

plus :: Double -> Double -> Double

AdditiveMagma Float

Methods

plus :: Float -> Float -> Float

AdditiveMagma Int

Methods

plus :: Int -> Int -> Int

(Unbox a, AdditiveMagma a) => AdditiveMagma (VectorU n a)

Methods

plus :: VectorU n a -> VectorU n a -> VectorU n a

AdditiveMagma a => AdditiveMagma (VectorA n f a)

Methods

plus :: VectorA n f a -> VectorA n f a -> VectorA n f a

class AdditiveMagma a => AdditiveUnital a where

AdditiveUnital

zero `plus` a == a
a `plus` zero == a

Minimal complete definition

zero

Methods

zero :: a

Instances

AdditiveUnital Double

Methods

zero :: Double

AdditiveUnital Float

Methods

zero :: Float

AdditiveUnital Int

Methods

zero :: Int

(KnownNat n, Unbox a, AdditiveUnital a) => AdditiveUnital (VectorU n a)

Methods

zero :: VectorU n a

(AdditiveUnital a, KnownNat n) => AdditiveUnital (VectorA n [] a)

Methods

zero :: VectorA n [] a

class AdditiveMagma a => AdditiveAssociative a

AdditiveAssociative

(a `plus` b) `plus` c == a `plus` (b `plus` c)

Instances

AdditiveAssociative Double

AdditiveAssociative Float

AdditiveAssociative Int

(Unbox a, AdditiveAssociative a) => AdditiveAssociative (VectorU n a)

AdditiveAssociative a => AdditiveAssociative (VectorA n f a)

class AdditiveMagma a => AdditiveCommutative a

AdditiveCommutative

a `plus` b == b `plus` a

Instances

AdditiveCommutative Double

AdditiveCommutative Float

AdditiveCommutative Int

(Unbox a, AdditiveCommutative a) => AdditiveCommutative (VectorU n a)

AdditiveCommutative a => AdditiveCommutative (VectorA n f a)

class AdditiveMagma a => AdditiveInvertible a where

AdditiveInvertible

∀ a ∈ A: negate a ∈ A

law is true by construction in Haskell

Minimal complete definition

negate

Methods

negate :: a -> a

Instances

AdditiveInvertible Double

Methods

negate :: Double -> Double

AdditiveInvertible Float

Methods

negate :: Float -> Float

AdditiveInvertible Int

Methods

negate :: Int -> Int

(Unbox a, AdditiveInvertible a) => AdditiveInvertible (VectorU n a)

Methods

negate :: VectorU n a -> VectorU n a

AdditiveInvertible a => AdditiveInvertible (VectorA n f a)

Methods

negate :: VectorA n f a -> VectorA n f a

class (AdditiveMagma a, AdditiveMagma b) => AdditiveHomomorphic a b where

AdditiveHomomorphic

∀ a ∈ A: plushom a ∈ B

law is true by construction in Haskell

Minimal complete definition

plushom

Methods

plushom :: a -> b

Instances

AdditiveMagma a => AdditiveHomomorphic a a

Methods

plushom :: a -> a

(KnownNat n, Unbox a, AdditiveUnital a, AdditiveMagma a) => AdditiveHomomorphic a (VectorU n a)

Methods

plushom :: a -> VectorU n a

(AdditiveMagma a, KnownNat n) => AdditiveHomomorphic a (VectorA n [] a)

Methods

plushom :: a -> VectorA n [] a

class (AdditiveUnital a, AdditiveAssociative a) => AdditiveMonoidal a

AdditiveMonoidal

class (AdditiveCommutative a, AdditiveUnital a, AdditiveAssociative a) => Additive a where

Additive is commutative, unital and associative under addition

a + b = b + a

(a + b) + c = a + (b + c)

zero + a = a

a + zero = a

Methods

(+) :: a -> a -> a infixr 6

Instances

Additive Double

Methods

(+) :: Double -> Double -> Double

Additive Float

Methods

(+) :: Float -> Float -> Float

Additive Int

Methods

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

(KnownNat n, Unbox a, Additive a) => Additive (VectorU n a)

Methods

(+) :: VectorU n a -> VectorU n a -> VectorU n a

(Additive a, KnownNat n) => Additive (VectorA n [] a)

Methods

(+) :: VectorA n [] a -> VectorA n [] a -> VectorA n [] a

class (Additive a, AdditiveInvertible a) => AdditiveGroup a where

AdditiveGroup

a - a = zero

negate a = zero - a

negate a + a = zero

Methods

(-) :: a -> a -> a infixr 6

Instances

AdditiveGroup Double

Methods

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

AdditiveGroup Float

Methods

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

AdditiveGroup Int

Methods

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

(KnownNat n, Unbox a, AdditiveGroup a) => AdditiveGroup (VectorU n a)

Methods

(-) :: VectorU n a -> VectorU n a -> VectorU n a

(AdditiveGroup a, KnownNat n) => AdditiveGroup (VectorA n [] a)

Methods

(-) :: VectorA n [] a -> VectorA n [] a -> VectorA n [] a

Multiplicative Structure

class MultiplicativeMagma a where

times is used for the multiplicative magma to distinguish from * which, by convention, implies commutativity

Minimal complete definition

times

Methods

times :: a -> a -> a

Instances

MultiplicativeMagma Double

Methods

times :: Double -> Double -> Double

MultiplicativeMagma Float

Methods

times :: Float -> Float -> Float

MultiplicativeMagma Int

Methods

times :: Int -> Int -> Int

(Unbox a, MultiplicativeMagma a) => MultiplicativeMagma (VectorU n a)

Methods

times :: VectorU n a -> VectorU n a -> VectorU n a

MultiplicativeMagma a => MultiplicativeMagma (VectorA n f a)

Methods

times :: VectorA n f a -> VectorA n f a -> VectorA n f a

class MultiplicativeMagma a => MultiplicativeUnital a where

MultiplicativeUnital

one `times` a == a
a `times` one == a

Minimal complete definition

one

Methods

one :: a

Instances

MultiplicativeUnital Double

Methods

one :: Double

MultiplicativeUnital Float

Methods

one :: Float

MultiplicativeUnital Int

Methods

one :: Int

(KnownNat n, Unbox a, AdditiveUnital a, MultiplicativeUnital a) => MultiplicativeUnital (VectorU n a)

Methods

one :: VectorU n a

(MultiplicativeUnital a, KnownNat n) => MultiplicativeUnital (VectorA n [] a)

Methods

one :: VectorA n [] a

class MultiplicativeMagma a => MultiplicativeAssociative a

MultiplicativeAssociative

(a `times` b) `times` c == a `times` (b `times` c)

Instances

MultiplicativeAssociative Double

MultiplicativeAssociative Float

MultiplicativeAssociative Int

(Unbox a, MultiplicativeAssociative a) => MultiplicativeAssociative (VectorU n a)

MultiplicativeAssociative a => MultiplicativeAssociative (VectorA n f a)

class MultiplicativeMagma a => MultiplicativeCommutative a

MultiplicativeCommutative

a `times` b == b `times` a

Instances

MultiplicativeCommutative Double

MultiplicativeCommutative Float

MultiplicativeCommutative Int

(Unbox a, MultiplicativeCommutative a) => MultiplicativeCommutative (VectorU n a)

MultiplicativeCommutative a => MultiplicativeCommutative (VectorA n f a)

class MultiplicativeMagma a => MultiplicativeInvertible a where

MultiplicativeInvertible

∀ a ∈ A: recip a ∈ A

law is true by construction in Haskell

Minimal complete definition

recip

Methods

recip :: a -> a

Instances

MultiplicativeInvertible Double

Methods

recip :: Double -> Double

MultiplicativeInvertible Float

Methods

recip :: Float -> Float

(Unbox a, MultiplicativeInvertible a) => MultiplicativeInvertible (VectorU n a)

Methods

recip :: VectorU n a -> VectorU n a

MultiplicativeInvertible a => MultiplicativeInvertible (VectorA n f a)

Methods

recip :: VectorA n f a -> VectorA n f a

class (MultiplicativeMagma a, MultiplicativeMagma b) => MultiplicativeHomomorphic a b where

MultiplicativeHomomorphic

∀ a ∈ A: timeshom a ∈ B

law is true by construction in Haskell

Minimal complete definition

timeshom

Methods

timeshom :: a -> b

Instances

MultiplicativeMagma a => MultiplicativeHomomorphic a a

Methods

timeshom :: a -> a

(KnownNat n, Unbox a, AdditiveUnital a, MultiplicativeUnital a, MultiplicativeMagma a) => MultiplicativeHomomorphic a (VectorU n a)

Methods

timeshom :: a -> VectorU n a

MultiplicativeMagma a => MultiplicativeHomomorphic a (VectorA n f a)

Methods

timeshom :: a -> VectorA n f a

class (MultiplicativeUnital a, MultiplicativeAssociative a) => MultiplicativeMonoidal a

MultiplicativeMonoidal

class (MultiplicativeCommutative a, MultiplicativeUnital a, MultiplicativeAssociative a) => Multiplicative a where

Multiplicative is commutative, associative and unital under multiplication

a * b = b * a

(a * b) * c = a * (b * c)

one * a = a

a * one = a

Methods

(*) :: a -> a -> a infixr 7

Instances

Multiplicative Double

Methods

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

Multiplicative Float

Methods

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

Multiplicative Int

Methods

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

(KnownNat n, Unbox a, AdditiveUnital a, Multiplicative a) => Multiplicative (VectorU n a)

Methods

(*) :: VectorU n a -> VectorU n a -> VectorU n a

(Multiplicative a, KnownNat n) => Multiplicative (VectorA n [] a)

Methods

(*) :: VectorA n [] a -> VectorA n [] a -> VectorA n [] a

class (Multiplicative a, MultiplicativeInvertible a) => MultiplicativeGroup a where

MultiplicativeGroup

a / a = one

recip a = one / a

recip a * a = one

Methods

(/) :: a -> a -> a infixr 7

Instances

MultiplicativeGroup Double

Methods

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

MultiplicativeGroup Float

Methods

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

(KnownNat n, Unbox a, AdditiveUnital a, MultiplicativeGroup a) => MultiplicativeGroup (VectorU n a)

Methods

(/) :: VectorU n a -> VectorU n a -> VectorU n a

Distributive

class (Additive a, MultiplicativeMagma a) => Distributive a

Distributive

a . (b + c) == a . b + a . c

(a + b) . c == a . c + b . c

Instances

Distributive Double

Distributive Float

Distributive Int

(KnownNat n, Unbox a, Distributive a) => Distributive (VectorU n a)

(Distributive a, KnownNat n) => Distributive (VectorA n [] a)

Ring

class (Additive a, MultiplicativeAssociative a, MultiplicativeUnital a, Distributive a) => Semiring a

a semiring

Instances

Semiring Double

Semiring Float

Semiring Int

class (AdditiveGroup a, MultiplicativeAssociative a, MultiplicativeUnital a, Distributive a) => Ring a

Ring

Instances

Ring Double

Ring Float

(KnownNat n, Unbox a, Ring a) => Ring (VectorU n a)

class (AdditiveGroup a, MultiplicativeGroup a, Distributive a) => Field a

Field

Instances

Field Double

Field Float

Module

class (Additive a, AdditiveHomomorphic a a) => AdditiveBasis a where

AdditiveBasis element by element addition

Methods

(.+.) :: a -> a -> a infixr 7

class (AdditiveGroup a, AdditiveHomomorphic a a) => AdditiveGroupBasis a where

AdditiveGroupBasis element by element subtraction

Methods

(.-.) :: a -> a -> a infixr 7

class (Additive a, Additive s, AdditiveHomomorphic s a) => AdditiveModule s a where

AdditiveModule

Methods

(.+) :: AdditiveModule s a => s -> a -> a infixr 7

(+.) :: AdditiveModule s a => a -> s -> a infixr 7

Instances

(KnownNat n, Unbox a, Additive a) => AdditiveModule a (VectorU n a)

Methods

(.+) :: a -> VectorU n a -> VectorU n a

(+.) :: VectorU n a -> a -> VectorU n a

(Additive a, KnownNat n) => AdditiveModule a (VectorA n [] a)

Methods

(.+) :: a -> VectorA n [] a -> VectorA n [] a

(+.) :: VectorA n [] a -> a -> VectorA n [] a

class (AdditiveModule s a, AdditiveGroup a) => AdditiveGroupModule s a where

AdditiveGroupModule

Methods

(.-) :: AdditiveModule s a => s -> a -> a infixr 7

(-.) :: AdditiveModule s a => a -> s -> a infixr 7

class (Multiplicative a, MultiplicativeHomomorphic a a) => MultiplicativeBasis a where

MultiplicativeBasis element by element addition

Methods

(.*.) :: a -> a -> a infixr 7

class (MultiplicativeGroup a, MultiplicativeHomomorphic a a) => MultiplicativeGroupBasis a where

MultiplicativeGroupBasis element by element subtraction

Methods

(./.) :: a -> a -> a infixr 7

class (Multiplicative a, Multiplicative s, MultiplicativeHomomorphic s a) => MultiplicativeModule s a where

MultiplicativeModule

Methods

(.*) :: MultiplicativeModule s a => s -> a -> a infixr 7

(*.) :: MultiplicativeModule s a => a -> s -> a infixr 7

Instances

(KnownNat n, Unbox a, AdditiveUnital a, Multiplicative a) => MultiplicativeModule a (VectorU n a)

Methods

(.*) :: a -> VectorU n a -> VectorU n a

(*.) :: VectorU n a -> a -> VectorU n a

(Multiplicative a, KnownNat n) => MultiplicativeModule a (VectorA n [] a)

Methods

(.*) :: a -> VectorA n [] a -> VectorA n [] a

(*.) :: VectorA n [] a -> a -> VectorA n [] a

class (MultiplicativeModule s a, MultiplicativeGroup a) => MultiplicativeGroupModule s a where

MultiplicativeGroupModule

Methods

(./) :: MultiplicativeModule s a => s -> a -> a infixr 7

(/.) :: MultiplicativeModule s a => a -> s -> a infixr 7

Integral

class (Additive a, Multiplicative a) => Integral a where

Integral

b == zero || b * (a `div` b) + (a `mod` b) == a
b == zero || b * (a `quot` b) + (a `rem` b) == a

Minimal complete definition

toInteger, divMod

Methods

toInteger :: a -> Integer

div :: a -> a -> a infixl 7

truncates towards negative infinity

mod :: a -> a -> a infixl 7

divMod :: a -> a -> (a, a)

Instances

Integral Int

Methods

toInteger :: Int -> Integer

div :: Int -> Int -> Int

mod :: Int -> Int -> Int

divMod :: Int -> Int -> (Int, Int)

(KnownNat n, Unbox a, Integral a) => Integral (VectorU n a)

Methods

toInteger :: VectorU n a -> Integer

div :: VectorU n a -> VectorU n a -> VectorU n a

mod :: VectorU n a -> VectorU n a -> VectorU n a

divMod :: VectorU n a -> VectorU n a -> (VectorU n a, VectorU n a)

Metric

class Metric r m where

Metric

Minimal complete definition

d

Methods

d :: m -> m -> r

class Normed a where

Normed

Minimal complete definition

size

Methods

size :: a -> a

abs :: Normed a => a -> a

abs

class (MultiplicativeGroup a, MultiplicativeModule a a, MultiplicativeGroupModule a a, MultiplicativeInvertible a, Normed a) => Banach a where

Banach

Methods

normalize :: a -> a

class (Field a, Bounded a) => BoundedField a where

BoundedField

Methods

nan :: a

Instances

BoundedField Double

Methods

nan :: Double

BoundedField Float

Methods

nan :: Float

infinity :: BoundedField a => a

infinity

Exponential

class Ring a => ExpRing a where

ExpRing

Minimal complete definition

logBase

Methods

logBase :: a -> a -> a

(**) :: ExpRing a => a -> a -> a

(^) :: ExpRing a => a -> a -> a

(^)

class (Field a, ExpRing a) => ExpField a where

ExpField

Minimal complete definition

exp, log

Methods

sqrt :: a -> a

exp :: a -> a

log :: a -> a

Tensor Algebra

class (Banach a, TensorAlgebra a, ExpField r, AdditiveGroup a) => Hilbert a r where

Hilbert

Minimal complete definition

(<?>)

Methods

(<?>) :: a -> a -> r infix 8

class TensorAlgebra a where

TensorAlgebra

Minimal complete definition

(><), timesleft, timesright

Methods

(><) :: a -> a -> a >< a infixr 8

timesleft :: a -> (a >< a) -> a

timesright :: (a >< a) -> a -> a

squaredInnerProductNorm :: Hilbert v r => v -> r

squaredInnerProductNorm

innerProductNorm :: Hilbert v r => v -> r

innerProductNorm

innerProductDistance :: Hilbert v r => v -> v -> r

innerProductDistance

Orphan instances

Bounded Double

Methods

minBound :: Double

maxBound :: Double

Bounded Float

Methods

minBound :: Float

maxBound :: Float