MatrixCategory(R, Row, Col)ΒΆ

matcat.spad line 63

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
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
from CoercibleTo 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: () -> %
from Aggregate
empty?: % -> Boolean
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
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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.
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
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: (NonNegativeInteger, NonNegativeInteger) -> %
zero(m, n) returns an m-by-n zero matrix.
zero?: % -> Boolean
zero?(m) returns true if m is a zero matrix and false otherwise.

Aggregate

BasicType

CoercibleTo OutputForm

Comparable if R has Comparable

Evalable R if R has Evalable R

finiteAggregate

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

SetCategory

shallowlyMutable

TwoDimensionalArrayCategory(R, Row, Col)