# RectangularMatrixCategory(m, n, R, Row, Col)¶

matcat.spad line 706 [edit on github]

R: Join(SemiRng, AbelianMonoid)

Row: DirectProductCategory(n, R)

Col: DirectProductCategory(m, R)

RectangularMatrixCategory is a category of matrices of fixed dimensions. The dimensions of the matrix will be parameters of the domain. Domains in this category will be `R`

-modules and will be non-mutable.

- 0: %
from AbelianMonoid

- #: % -> NonNegativeInteger
from Aggregate

- *: (%, R) -> %
from RightModule R

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

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> % if R has AbelianGroup
from AbelianGroup

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

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

divides the elements of`m`

by`r`

. Error: if`r = 0`

.

- antisymmetric?: % -> Boolean
`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

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- column: (%, Integer) -> Col
`column(m, j)`

returns the`j`

th column of the matrix`m`

. Error: if the index outside the proper range.

- 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.

- convert: % -> InputForm if R has Finite
from ConvertibleTo InputForm

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

- count: (R, %) -> NonNegativeInteger
from HomogeneousAggregate R

- 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.

- elt: (%, Integer, Integer) -> R
`elt(m, i, j)`

returns the element in the`i`

th row and`j`

th column of the matrix`m`

. Error: if indices are outside the proper ranges.

- elt: (%, Integer, Integer, R) -> R
`elt(m, i, j, r)`

returns the element in the`i`

th row and`j`

th column of the matrix`m`

, if`m`

has an`i`

th row and a`j`

th column, and returns`r`

otherwise.

- 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.

- hash: % -> SingleInteger
from SetCategory

- hashUpdate!: (HashState, %) -> HashState
from SetCategory

- index: PositiveInteger -> % if R has Finite
from Finite

- latex: % -> String
from SetCategory

- less?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- lookup: % -> PositiveInteger if R has Finite
from Finite

- map!: (R -> R, %) -> % if % has shallowlyMutable
from HomogeneousAggregate R

- map: ((R, R) -> R, %, %) -> %
`map(f, a, b)`

returns`c`

, where`c`

is such that`c(i, j) = f(a(i, j), b(i, j))`

for all`i`

,`j`

.

- map: (R -> R, %) -> %
`map(f, a)`

returns`b`

, where`b(i, j) = a(i, j)`

for all`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
`maxColIndex(m)`

returns the index of the ‘last’ column of the matrix`m`

.

- maxRowIndex: % -> Integer
`maxRowIndex(m)`

returns the index of the ‘last’ row of the matrix`m`

.

- member?: (R, %) -> Boolean
from HomogeneousAggregate R

- members: % -> List R
from HomogeneousAggregate R

- min: % -> R if R has OrderedSet
from HomogeneousAggregate R

- minColIndex: % -> Integer
`minColIndex(m)`

returns the index of the ‘first’ column of the matrix`m`

.

- minRowIndex: % -> Integer
`minRowIndex(m)`

returns the index of the ‘first’ row of the matrix`m`

.

- more?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- ncols: % -> NonNegativeInteger
`ncols(m)`

returns the number of columns in the matrix`m`

.

- nrows: % -> NonNegativeInteger
`nrows(m)`

returns the number of rows in the matrix`m`

.

- 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`

.

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- parts: % -> List R
from HomogeneousAggregate R

- qelt: (%, Integer, Integer) -> R
`qelt(m, i, j)`

returns the element in the`i`

th row and`j`

th column of the matrix`m`

. Note: there is NO error check to determine if indices are in the proper ranges.

- rank: % -> NonNegativeInteger if R has IntegralDomain
`rank(m)`

returns the rank of the matrix`m`

.

- row: (%, Integer) -> Row
`row(m, i)`

returns the`i`

th row of the matrix`m`

. Error: if the index is outside the proper range.

- rowEchelon: % -> % if R has EuclideanDomain
`rowEchelon(m)`

returns the row echelon form of the matrix`m`

.

- sample: %
from AbelianMonoid

- size?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- size: () -> NonNegativeInteger if R has Finite
from Finite

- smaller?: (%, %) -> Boolean if R has Finite
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.

- subtractIfCan: (%, %) -> Union(%, failed) if R has AbelianGroup

- 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.

- zero?: % -> Boolean
from AbelianMonoid

AbelianGroup if R has AbelianGroup

BiModule(R, R)

CancellationAbelianMonoid if R has AbelianGroup

Comparable if R has Finite

ConvertibleTo InputForm if R has Finite

Evalable R if R has Evalable R

InnerEvalable(R, R) if R has Evalable R

Module R if R has CommutativeRing