# MatrixCategory(R, Row, Col)¶

MatrixCategory is a general matrix category which allows different representations and indexing schemes. Rows and columns may be extracted with rows returned as objects of type Row and colums returned as objects of type Col. A domain belonging to this category will be shallowly mutable. The index of the ‘first’ row may be obtained by calling the function minRowIndex. The index of the ‘first’ column may be obtained by calling the function minColIndex. The index of the first element of a Row is the same as the index of the first column in a matrix and vice versa.

#: % -> NonNegativeInteger

from Aggregate

*: (%, %) -> % if R has SemiRng

`x * y` is the product of the matrices `x` and `y`. Error: if the dimensions are incompatible.

*: (%, Col) -> Col if R has SemiRng

`x * c` is the product of the matrix `x` and the column vector `c`. Error: if the dimensions are incompatible.

*: (%, R) -> % if R has SemiRng

`x * r` is the right scalar multiple of the scalar `r` and the matrix `x`.

*: (Integer, %) -> % if R has AbelianGroup

`n * x` is an integer multiple.

*: (R, %) -> % if R has SemiRng

`r*x` is the left scalar multiple of the scalar `r` and the matrix `x`.

*: (Row, %) -> Row if R has SemiRng

`r * x` is the product of the row vector `r` and the matrix `x`. Error: if the dimensions are incompatible.

+: (%, %) -> %

`x + y` is the sum of the matrices `x` and `y`. Error: if the dimensions are incompatible.

-: % -> % if R has AbelianGroup

`-x` returns the negative of the matrix `x`.

-: (%, %) -> % if R has AbelianGroup

`x - y` is the difference of the matrices `x` and `y`. Error: if the dimensions are incompatible.

/: (%, R) -> % if R has Field

`m/r` divides the elements of `m` by `r`. Error: if `r = 0`.

=: (%, %) -> Boolean

from BasicType

^: (%, Integer) -> % if R has Field

`m^n` computes an integral power of the matrix `m`. Error: if matrix is not square or if the matrix is square but not invertible.

^: (%, NonNegativeInteger) -> % if R has Monoid and R has SemiRng

`x ^ n` computes a non-negative integral power of the matrix `x`. Error: if the matrix is not square.

~=: (%, %) -> Boolean

from BasicType

antisymmetric?: % -> Boolean if R has AbelianGroup

`antisymmetric?(m)` returns `true` if the matrix `m` is square and antisymmetric (i.e. `m[i, j] = -m[j, i]` for all `i` and `j`) and `false` otherwise.

any?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

array2: List List R -> %

from TwoDimensionalArrayCategory(R, Row, Col)

blockConcat: List List % -> %

from TwoDimensionalArrayCategory(R, Row, Col)

blockSplit: (%, List NonNegativeInteger, List NonNegativeInteger) -> List List %

from TwoDimensionalArrayCategory(R, Row, Col)

blockSplit: (%, PositiveInteger, PositiveInteger) -> List List %

from TwoDimensionalArrayCategory(R, Row, Col)

coerce: % -> OutputForm
coerce: Col -> %

`coerce(col)` converts the column `col` to a column matrix.

colSlice: % -> Segment Integer

from TwoDimensionalArrayCategory(R, Row, Col)

column: (%, Integer) -> Col

from TwoDimensionalArrayCategory(R, Row, Col)

columnSpace: % -> List Col if R has EuclideanDomain

`columnSpace(m)` returns a sublist of columns of the matrix `m` forming a basis of its column space

copy: % -> %

from Aggregate

count: (R -> Boolean, %) -> NonNegativeInteger

from HomogeneousAggregate R

count: (R, %) -> NonNegativeInteger

from HomogeneousAggregate R

determinant: % -> R if R has CommutativeRing

`determinant(m)` returns the determinant of the matrix `m`. Error: if the matrix is not square.

diagonal?: % -> Boolean

`diagonal?(m)` returns `true` if the matrix `m` is square and diagonal (i.e. all entries of `m` not on the diagonal are zero) and `false` otherwise.

diagonalMatrix: List % -> %

`diagonalMatrix([m1, ..., mk])` creates a block diagonal matrix `M` with block matrices m1, …, mk down the diagonal, with 0 block matrices elsewhere. More precisly: if `ri := nrows mi`, `ci := ncols mi`, then `m` is an (`r1+`..`+rk`) by (`c1+`..`+ck`) - matrix with entries `m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))`, if `(r1+..+r(l-1)) < i <= r1+..+rl` and `(c1+..+c(l-1)) < i <= c1+..+cl`, `m.i.j` = 0 otherwise.

diagonalMatrix: List R -> %

`diagonalMatrix(l)` returns a diagonal matrix with the elements of `l` on the diagonal.

elt: (%, Integer, Integer) -> R

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Segment Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Segment Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, List Segment Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Segment Integer, List Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Segment Integer, List Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

elt: (%, Segment Integer, Segment Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

eq?: (%, %) -> Boolean

from Aggregate

eval: (%, Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List R, List R) -> % if R has Evalable R

from InnerEvalable(R, R)

eval: (%, R, R) -> % if R has Evalable R

from InnerEvalable(R, R)

every?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

exquo: (%, R) -> Union(%, failed) if R has IntegralDomain

`exquo(m, r)` computes the exact quotient of the elements of `m` by `r`, returning `"failed"` if this is not possible.

fill!: (%, R) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

hash: % -> SingleInteger if R has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if R has Hashable

from Hashable

horizConcat: (%, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

horizConcat: List % -> %

from TwoDimensionalArrayCategory(R, Row, Col)

horizSplit: (%, List NonNegativeInteger) -> List %

from TwoDimensionalArrayCategory(R, Row, Col)

horizSplit: (%, PositiveInteger) -> List %

from TwoDimensionalArrayCategory(R, Row, Col)

inverse: % -> Union(%, failed) if R has Field

`inverse(m)` returns the inverse of the matrix `m`. If the matrix is not invertible, “failed” is returned. Error: if the matrix is not square.

kronecker_prod1: (%, Integer, List List NonNegativeInteger, List %, NonNegativeInteger, NonNegativeInteger, Union(R, one)) -> Void

Should be local but conditional.

kroneckerProduct: (%, %) -> % if R has SemiRng

`kroneckerProduct(a, b)` calculates the Kronecker product of the matrices a and `b`. This corresponds to tensor product of corresponding operators.

kroneckerProduct: List % -> % if R has SemiRng

`kroneckerProduct([a1, a2, ..., an])` calculates the Kronecker product of the matrices `a1`, `a2`, …, an. This corresponds to tensor product of corresponding operators.

kroneckerSum: (%, %) -> %

`kroneckerSum(a, b)` calculates the Kronecker sum of the matrices a and `b`.

kroneckerSum: List % -> %

`kroneckerSum([a1, a2, ..., an])` calculates the Kronecker sum of the matrices `a1`, `a2`, …, an.

latex: % -> String

from SetCategory

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

listOfLists: % -> List List R

from TwoDimensionalArrayCategory(R, Row, Col)

map!: (R -> R, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

map: ((R, R) -> R, %, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

map: ((R, R) -> R, %, %, R) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

map: (R -> R, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

matrix: (NonNegativeInteger, NonNegativeInteger, (Integer, Integer) -> R) -> %

`matrix(n,m,f)` constructs an `n * m` matrix with the `(i,j)` entry equal to `f(i,j)`.

matrix: List List R -> %

`matrix(l)` converts the list of lists `l` to a matrix, where the list of lists is viewed as a list of the rows of the matrix.

max: % -> R if R has OrderedSet

from HomogeneousAggregate R

max: ((R, R) -> Boolean, %) -> R

from HomogeneousAggregate R

maxColIndex: % -> Integer

from TwoDimensionalArrayCategory(R, Row, Col)

maxRowIndex: % -> Integer

from TwoDimensionalArrayCategory(R, Row, Col)

member?: (R, %) -> Boolean

from HomogeneousAggregate R

members: % -> List R

from HomogeneousAggregate R

min: % -> R if R has OrderedSet

from HomogeneousAggregate R

minColIndex: % -> Integer

from TwoDimensionalArrayCategory(R, Row, Col)

minordet: % -> R if R has CommutativeRing

`minordet(m)` computes the determinant of the matrix `m` using minors. Error: if the matrix is not square.

minRowIndex: % -> Integer

from TwoDimensionalArrayCategory(R, Row, Col)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

ncols: % -> NonNegativeInteger

from TwoDimensionalArrayCategory(R, Row, Col)

new: (NonNegativeInteger, NonNegativeInteger, R) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

nrows: % -> NonNegativeInteger

from TwoDimensionalArrayCategory(R, Row, Col)

nullity: % -> NonNegativeInteger if R has IntegralDomain

`nullity(m)` returns the nullity of the matrix `m`. This is the dimension of the null space of the matrix `m`.

nullSpace: % -> List Col if R has IntegralDomain

`nullSpace(m)` returns a basis for the null space of the matrix `m`.

parts: % -> List R

from TwoDimensionalArrayCategory(R, Row, Col)

Pfaffian: % -> R if R has CommutativeRing

`Pfaffian(m)` returns the Pfaffian of the matrix `m`. Error: if the matrix is not antisymmetric.

positivePower: (%, Integer) -> % if R has SemiRng

`positivePower(x, n)` computes a positive integral power of the matrix `x`. Error: if the matrix is not square.

qelt: (%, Integer, Integer) -> R

from TwoDimensionalArrayCategory(R, Row, Col)

qnew: (NonNegativeInteger, NonNegativeInteger) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

qsetelt!: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, Row, Col)

rank: % -> NonNegativeInteger if R has IntegralDomain

`rank(m)` returns the rank of the matrix `m`.

row: (%, Integer) -> Row

from TwoDimensionalArrayCategory(R, Row, Col)

rowEchelon: % -> % if R has EuclideanDomain

`rowEchelon(m)` returns the row echelon form of the matrix `m`.

rowSlice: % -> Segment Integer

from TwoDimensionalArrayCategory(R, Row, Col)

sample: %

from Aggregate

scalarMatrix: (NonNegativeInteger, R) -> %

`scalarMatrix(n, r)` returns an `n`-by-`n` matrix with `r``'s` on the diagonal and zeroes elsewhere.

setColumn!: (%, Integer, Col) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Integer, Integer, R) -> R

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Segment Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Segment Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, List Segment Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Segment Integer, List Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Segment Integer, List Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setelt!: (%, Segment Integer, Segment Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setRow!: (%, Integer, Row) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

setsubMatrix!: (%, Integer, Integer, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean if R has Comparable

from Comparable

square?: % -> Boolean

`square?(m)` returns `true` if `m` is a square matrix (i.e. if `m` has the same number of rows as columns) and `false` otherwise.

squareTop: % -> %

from TwoDimensionalArrayCategory(R, Row, Col)

subMatrix: (%, Integer, Integer, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

swapColumns!: (%, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

swapRows!: (%, Integer, Integer) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

symmetric?: % -> Boolean

`symmetric?(m)` returns `true` if the matrix `m` is square and symmetric (i.e. `m[i, j] = m[j, i]` for all `i` and `j`) and `false` otherwise.

transpose: % -> %

from TwoDimensionalArrayCategory(R, Row, Col)

transpose: Row -> %

`transpose(r)` converts the row `r` to a row matrix.

vertConcat: (%, %) -> %

from TwoDimensionalArrayCategory(R, Row, Col)

vertConcat: List % -> %

from TwoDimensionalArrayCategory(R, Row, Col)

vertSplit: (%, List NonNegativeInteger) -> List %

from TwoDimensionalArrayCategory(R, Row, Col)

vertSplit: (%, PositiveInteger) -> List %

from TwoDimensionalArrayCategory(R, Row, Col)

zero?: % -> Boolean

`zero?(m)` returns `true` if `m` is a zero matrix and `false` otherwise.

zero: (NonNegativeInteger, NonNegativeInteger) -> %

`zero(m, n)` returns an `m`-by-`n` zero matrix.

Aggregate

BasicType

Comparable if R has Comparable

Evalable R if R has Evalable R

finiteAggregate

Hashable if R has Hashable

InnerEvalable(R, R) if R has Evalable R

SetCategory

shallowlyMutable

TwoDimensionalArrayCategory(R, Row, Col)