Matrix RΒΆ

matrix.spad line 69

Matrix is a matrix domain where 1-based indexing is used for both rows and columns.

#: % -> NonNegativeInteger
from Aggregate
*: (%, %) -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
*: (%, R) -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
*: (%, Vector R) -> Vector R if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
*: (Integer, %) -> % if R has AbelianGroup
from MatrixCategory(R, Vector R, Vector R)
*: (R, %) -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
*: (Vector R, %) -> Vector R if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
+: (%, %) -> %
from MatrixCategory(R, Vector R, Vector R)
-: % -> % if R has AbelianGroup
from MatrixCategory(R, Vector R, Vector R)
-: (%, %) -> % if R has AbelianGroup
from MatrixCategory(R, Vector R, Vector R)
/: (%, R) -> % if R has Field
from MatrixCategory(R, Vector R, Vector R)
=: (%, %) -> Boolean
from BasicType
^: (%, Integer) -> % if R has Field
from MatrixCategory(R, Vector R, Vector R)
^: (%, NonNegativeInteger) -> % if R has Monoid and R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
~=: (%, %) -> Boolean
from BasicType
antisymmetric?: % -> Boolean if R has AbelianGroup
from MatrixCategory(R, Vector R, Vector R)
any?: (R -> Boolean, %) -> Boolean
from HomogeneousAggregate R
blockConcat: List List % -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
blockSplit: (%, List NonNegativeInteger, List NonNegativeInteger) -> List List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
blockSplit: (%, PositiveInteger, PositiveInteger) -> List List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Vector R -> %
from MatrixCategory(R, Vector R, Vector R)
colSlice: % -> Segment Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
column: (%, Integer) -> Vector R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
columnSpace: % -> List Vector R if R has EuclideanDomain
from MatrixCategory(R, Vector R, Vector R)
convert: % -> InputForm if R has ConvertibleTo InputForm
from ConvertibleTo InputForm
copy: % -> %
from Aggregate
count: (R -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate R
count: (R, %) -> NonNegativeInteger
from HomogeneousAggregate R
determinant: % -> R if R has CommutativeRing
from MatrixCategory(R, Vector R, Vector R)
diagonal?: % -> Boolean
from MatrixCategory(R, Vector R, Vector R)
diagonalMatrix: List % -> %
from MatrixCategory(R, Vector R, Vector R)
diagonalMatrix: List R -> %
from MatrixCategory(R, Vector R, Vector R)
diagonalMatrix: Vector R -> %
diagonalMatrix(v) returns a diagonal matrix where the elements of v appear on the diagonal.
elt: (%, Integer, Integer) -> R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Integer, Integer, R) -> R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Integer, List Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Integer, List Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Integer, Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Integer, List Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Integer, Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Segment Integer, Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Segment Integer, List Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, List Segment Integer, Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Segment Integer, List Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Segment Integer, List Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
elt: (%, Segment Integer, Segment Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
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
from MatrixCategory(R, Vector R, Vector R)
fill!: (%, R) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
horizConcat: (%, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
horizConcat: List % -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
horizSplit: (%, List NonNegativeInteger) -> List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
horizSplit: (%, PositiveInteger) -> List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
inverse: % -> Union(%, failed) if R has Field
from MatrixCategory(R, Vector R, Vector R)
invertIfCan: % -> Union(%, failed) if R has IntegralDomain
invertIfCan(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
from MatrixCategory(R, Vector R, Vector R)
kroneckerProduct: (%, %) -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
kroneckerProduct: List % -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
kroneckerSum: (%, %) -> %
from MatrixCategory(R, Vector R, Vector R)
kroneckerSum: List % -> %
from MatrixCategory(R, Vector R, Vector R)
latex: % -> String
from SetCategory
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
listOfLists: % -> List List R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
map!: (R -> R, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
map: ((R, R) -> R, %, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
map: ((R, R) -> R, %, %, R) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
map: (R -> R, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
matrix: (NonNegativeInteger, NonNegativeInteger, (Integer, Integer) -> R) -> %
from MatrixCategory(R, Vector R, Vector R)
matrix: List List R -> %
from MatrixCategory(R, Vector R, Vector R)
maxColIndex: % -> Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
maxRowIndex: % -> Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
member?: (R, %) -> Boolean
from HomogeneousAggregate R
members: % -> List R
from HomogeneousAggregate R
minColIndex: % -> Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
minordet: % -> R if R has CommutativeRing
from MatrixCategory(R, Vector R, Vector R)
minRowIndex: % -> Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
ncols: % -> NonNegativeInteger
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
new: (NonNegativeInteger, NonNegativeInteger, R) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
nrows: % -> NonNegativeInteger
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
nullity: % -> NonNegativeInteger if R has IntegralDomain
from MatrixCategory(R, Vector R, Vector R)
nullSpace: % -> List Vector R if R has IntegralDomain
from MatrixCategory(R, Vector R, Vector R)
parts: % -> List R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
Pfaffian: % -> R if R has CommutativeRing
from MatrixCategory(R, Vector R, Vector R)
positivePower: (%, Integer) -> % if R has SemiRng
from MatrixCategory(R, Vector R, Vector R)
qelt: (%, Integer, Integer) -> R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
qnew: (NonNegativeInteger, NonNegativeInteger) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
qsetelt!: (%, Integer, Integer, R) -> R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
rank: % -> NonNegativeInteger if R has IntegralDomain
from MatrixCategory(R, Vector R, Vector R)
row: (%, Integer) -> Vector R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
rowEchelon: % -> % if R has EuclideanDomain
from MatrixCategory(R, Vector R, Vector R)
rowSlice: % -> Segment Integer
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
sample: %
from Aggregate
scalarMatrix: (NonNegativeInteger, R) -> %
from MatrixCategory(R, Vector R, Vector R)
setColumn!: (%, Integer, Vector R) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Integer, Integer, R) -> R
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Integer, List Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Integer, List Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Integer, Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Integer, List Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Integer, Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Segment Integer, Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Segment Integer, List Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, List Segment Integer, Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Segment Integer, List Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Segment Integer, List Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setelt!: (%, Segment Integer, Segment Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setRow!: (%, Integer, Vector R) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
setsubMatrix!: (%, Integer, Integer, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
size?: (%, NonNegativeInteger) -> Boolean
from Aggregate
smaller?: (%, %) -> Boolean if R has Comparable
from Comparable
square?: % -> Boolean
from MatrixCategory(R, Vector R, Vector R)
squareTop: % -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
subMatrix: (%, Integer, Integer, Integer, Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
swapColumns!: (%, Integer, Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
swapRows!: (%, Integer, Integer) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
symmetric?: % -> Boolean
from MatrixCategory(R, Vector R, Vector R)
transpose: % -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
transpose: Vector R -> %
from MatrixCategory(R, Vector R, Vector R)
vertConcat: (%, %) -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
vertConcat: List % -> %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
vertSplit: (%, List NonNegativeInteger) -> List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
vertSplit: (%, PositiveInteger) -> List %
from TwoDimensionalArrayCategory(R, Vector R, Vector R)
zero: (NonNegativeInteger, NonNegativeInteger) -> %
from MatrixCategory(R, Vector R, Vector R)
zero?: % -> Boolean
from MatrixCategory(R, Vector R, Vector R)

Aggregate

BasicType

CoercibleTo OutputForm

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Evalable R if R has Evalable R

finiteAggregate

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

MatrixCategory(R, Vector R, Vector R)

SetCategory

shallowlyMutable

TwoDimensionalArrayCategory(R, Vector R, Vector R)