MatrixCategory(R, Row, Col)

matcat.spad line 63 [edit on github]

• R: AbelianMonoid

• Row: FiniteLinearAggregate R

• Col: FiniteLinearAggregate R

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

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?: % -> 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

CoercibleTo OutputForm

Comparable if R has Comparable

Evalable R if R has Evalable R

finiteAggregate

Hashable if R has Hashable

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

SetCategory

shallowlyMutable

TwoDimensionalArrayCategory(R, Row, Col)