Matrix R

matrix.spad line 69 [edit on github]

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

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)

max: % -> R if R has OrderedSet

from HomogeneousAggregate R

max: ((R, R) -> Boolean, %) -> R

from HomogeneousAggregate 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

min: % -> R if R has OrderedSet

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

from MatrixCategory(R, Vector R, Vector R)

zero: (NonNegativeInteger, NonNegativeInteger) -> %

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)