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

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

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

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

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

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

n * x is an integer multiple.

* : (%, 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.

* : (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

Pfaffian : % -> R if R has CommutativeRing

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

^ : (%, 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.

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? : (Mapping(Boolean, R), %) -> 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 : Col -> %

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

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

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, %) -> NonNegativeInteger

from HomogeneousAggregate(R)

count : (Mapping(Boolean, 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 precisely: 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, 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)

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

from TwoDimensionalArrayCategory(R, Row, Col)

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

from TwoDimensionalArrayCategory(R, Row, Col)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

eq? : (%, %) -> Boolean

from Aggregate

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

from InnerEvalable(R, R)

eval : (%, 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 : (%, List(Equation(R))) -> % if R has Evalable(R)

from Evalable(R)

every? : (Mapping(Boolean, R), %) -> 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.

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.

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

Should be local but conditional.

latex : % -> String

from SetCategory

less? : (%, NonNegativeInteger) -> Boolean

from Aggregate

listOfLists : % -> List(List(R))

from TwoDimensionalArrayCategory(R, Row, Col)

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

from TwoDimensionalArrayCategory(R, Row, Col)

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

from TwoDimensionalArrayCategory(R, Row, Col)

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

from TwoDimensionalArrayCategory(R, Row, Col)

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

from TwoDimensionalArrayCategory(R, Row, Col)

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.

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

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

max : % -> R if R has OrderedSet

from HomogeneousAggregate(R)

max : (Mapping(Boolean, R, R), %) -> 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)

minRowIndex : % -> 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.

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)

nullSpace : % -> List(Col) if R has IntegralDomain

nullSpace(m) returns a basis for the null space of 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.

parts : % -> List(R)

from TwoDimensionalArrayCategory(R, Row, Col)

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)

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

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)

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

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.

~= : (%, %) -> Boolean

from BasicType

Comparable

Aggregate

shallowlyMutable

SetCategory

InnerEvalable(R, R)

CoercibleTo(OutputForm)

Hashable

finiteAggregate

TwoDimensionalArrayCategory(R, Row, Col)

Evalable(R)

HomogeneousAggregate(R)

BasicType