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

matcat.spad line 706 [edit on github]

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.

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

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

copy: % -> %

from Aggregate

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 ith row and jth 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 ith row and jth column of the matrix m, if m has an ith row and a jth column, and returns r otherwise.

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

enumerate: () -> List % if R has Finite

from Finite

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.

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

listOfLists: % -> List List R

listOfLists(m) returns the rows of the matrix m as a list of lists.

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 ith row and jth column of the matrix m. Note: there is NO error check to determine if indices are in the proper ranges.

random: () -> % if R has Finite

from Finite

rank: % -> NonNegativeInteger if R has IntegralDomain

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

row: (%, Integer) -> Row

row(m, i) returns the ith 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

from CancellationAbelianMonoid

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

AbelianMonoid

AbelianSemiGroup

Aggregate

BasicType

BiModule(R, R)

CancellationAbelianMonoid if R has AbelianGroup

CoercibleTo OutputForm

Comparable if R has Finite

ConvertibleTo InputForm if R has Finite

Evalable R if R has Evalable R

Finite if R has Finite

finiteAggregate

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

LeftModule R

Module R if R has CommutativeRing

RightModule R

SetCategory