Data.Semimodule.Transform

Types

type (**) f g = Compose f g infixr 2

type (++) f g = Product f g infixr 1

type Dim b c = forall a. Tran a b c

A dimensional (binary) relation between two bases.

Dim b c relations correspond to (compositions of) permutation, projection, and embedding transformations.

See also https://en.wikipedia.org/wiki/Logical_matrix.

type Endo a b = Tran a b b

An endomorphism over a free semimodule.

newtype Tran a b c

A morphism between free semimodules indexed with bases b and c.

Constructors

Tran

Fields

• runTran :: (c -> a) -> b -> a

Instances

Profunctor (Tran a)

Defined in Data.Semimodule.Transform

Methods

dimap :: (a0 -> b) -> (c -> d) -> Tran a b c -> Tran a a0 d

lmap :: (a0 -> b) -> Tran a b c -> Tran a a0 c

rmap :: (b -> c) -> Tran a a0 b -> Tran a a0 c

(#.) :: Coercible c b => q b c -> Tran a a0 b -> Tran a a0 c

(.#) :: Coercible b a0 => Tran a b c -> q a0 b -> Tran a a0 c

Category (Tran a :: Type -> Type -> Type)

Defined in Data.Semimodule.Transform

Methods

id :: Tran a a0 a0

(.) :: Tran a b c -> Tran a a0 b -> Tran a a0 c

Functor (Tran a b)

Defined in Data.Semimodule.Transform

Methods

fmap :: (a0 -> b0) -> Tran a b a0 -> Tran a b b0

(<$) :: a0 -> Tran a b b0 -> Tran a b a0

app :: Basis2 b c f g => Tran a b c -> g a -> f a

Apply a transformation to a vector.

arr :: (b -> c) -> Tran a b c

Lift a function on basis indices into a transformation.

 arr f = rmap f id

invmap :: (a1 -> a2) -> (a2 -> a1) -> Tran a1 b c -> Tran a2 b c

Tran a b c is an invariant functor on a.

See also http://comonad.com/reader/2008/rotten-bananas/.

Matrix combinators

rows :: Basis2 b c f g => g a -> (f ** g) a

Obtain a matrix by stacking rows.

>>> rows (V2 1 2) :: M22 Int
V2 (V2 1 2) (V2 1 2)

cols :: Basis2 b c f g => f a -> (f ** g) a

Obtain a matrix by stacking columns.

>>> cols (V2 1 2) :: M22 Int
V2 (V2 1 1) (V2 2 2)

projl :: Basis2 b c f g => (f ++ g) a -> f a

Project onto the left-hand component of a direct sum.

projr :: Basis2 b c f g => (f ++ g) a -> g a

Project onto the right-hand component of a direct sum.

compl :: Basis3 b c d f1 f2 g => Dim b c -> (f2 ** g) a -> (f1 ** g) a

Left (post) composition with a linear transformation.

compr :: Basis3 b c d f g1 g2 => Dim c d -> (f ** g2) a -> (f ** g1) a

Right (pre) composition with a linear transformation.

complr :: Basis2 b1 c1 f1 f2 => Basis2 b2 c2 g1 g2 => Dim b1 c1 -> Dim b2 c2 -> (f2 ** g2) a -> (f1 ** g1) a

Left and right composition with a linear transformation.

 complr f g = compl f >>> compr g

When f . g = id this induces a similarity transformation:

>>> perm1 = arr (+ E32)
>>> perm2 = arr (+ E33)
>>> m = m33 1 2 3 4 5 6 7 8 9 :: M33 Int
>>> complr perm1 perm2 m :: M33 Int
V3 (V3 5 6 4) (V3 8 9 7) (V3 2 3 1)

See also https://en.wikipedia.org/wiki/Matrix_similarity & https://en.wikipedia.org/wiki/Conjugacy_class.

transpose :: Basis2 b c f g => (f ** g) a -> (g ** f) a

Transpose a matrix.

>>> transpose (V3 (V2 1 2) (V2 3 4) (V2 5 6))
V2 (V3 1 3 5) (V3 2 4 6)

>>> transpose $ m23 1 2 3 4 5 6 :: M32 Int
V3 (V2 1 4) (V2 2 5) (V2 3 6)

Dimensional combinators

braid :: Dim (a, b) (b, a)

Swap components of a tensor product.

sbraid :: Dim (a + b) (b + a)

Swap components of a direct sum.

first :: Dim b c -> Dim (b, d) (c, d)

Lift a transform into a transform on tensor products.

second :: Dim b c -> Dim (d, b) (d, c)

Lift a transform into a transform on tensor products.

left :: Dim b c -> Dim (b + d) (c + d)

Lift a transform into a transform on direct sums.

right :: Dim b c -> Dim (d + b) (d + c)

Lift a transform into a transform on direct sums.

(***) :: Dim a1 b1 -> Dim a2 b2 -> Dim (a1, a2) (b1, b2) infixr 3

Create a transform on a tensor product of semimodules.

(+++) :: Dim a1 b1 -> Dim a2 b2 -> Dim (a1 + a2) (b1 + b2) infixr 2

Create a transform on a direct sum of semimodules.

(&&&) :: Dim a b1 -> Dim a b2 -> Dim a (b1, b2) infixr 3

(|||) :: Dim a1 b -> Dim a2 b -> Dim (a1 + a2) b infixr 2

($$$) :: Dim a (b -> c) -> Dim a b -> Dim a c infixr 0

adivide :: (a -> (a1, a2)) -> Dim a1 b -> Dim a2 b -> Dim a b

 adivide fork = id

adivide' :: Dim a1 b -> Dim a2 b -> Dim (a1, a2) b

aselect :: ((b1 + b2) -> b) -> Dim a b1 -> Dim a b2 -> Dim a b

 aselect join = id

aselect' :: Dim a b1 -> Dim a b2 -> Dim a (b1 + b2)