SquareMatrixCategory(ndim, R, Row, Col)

matcat.spad line 908 [edit on github]

SquareMatrixCategory is a general square 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.

# : % -> NonNegativeInteger
from Aggregate
* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer) and R has Ring
from RightModule(Integer)
* : (R, %) -> %
from LeftModule(R)
* : (Integer, %) -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
* : (%, Col) -> Col

x * c is the product of the matrix x and the column vector c. Error: if the dimensions are incompatible.

* : (Row, %) -> Row

r * x is the product of the row vector r and the matrix x. Error: if the dimensions are incompatible.

+ : (%, %) -> %
from AbelianSemiGroup
- : % -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
- : (%, %) -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
/ : (%, R) -> % if R has Field
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
0 : () -> %
from AbelianMonoid
1 : () -> % if R has SemiRing
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
D : % -> % if R has DifferentialRing and R has Ring
from DifferentialRing
D : (%, List(Symbol)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, Mapping(R, R)) -> % if R has Ring
from DifferentialExtension(R)
D : (%, Mapping(R, R), NonNegativeInteger) -> % if R has Ring
from DifferentialExtension(R)
D : (%, NonNegativeInteger) -> % if R has DifferentialRing and R has Ring
from DifferentialRing
D : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
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 the matrix is not invertible.

^ : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
annihilate? : (%, %) -> Boolean if R has Ring
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
antisymmetric? : % -> Boolean
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
any? : (Mapping(Boolean, R), %) -> Boolean
from HomogeneousAggregate(R)
associator : (%, %, %) -> % if R has Ring
from NonAssociativeRng
characteristic : () -> NonNegativeInteger if R has Ring
from NonAssociativeRing
coerce : R -> %
from Algebra(R)
coerce : Fraction(Integer) -> % if R has RetractableTo(Fraction(Integer))
from CoercibleFrom(Fraction(Integer))
coerce : Integer -> % if R has Ring or R has RetractableTo(Integer)
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
column : (%, Integer) -> Col
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
columnSpace : % -> List(Col) if R has EuclideanDomain
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
commutator : (%, %) -> % if R has Ring
from NonAssociativeRng
convert : % -> InputForm if R has Finite
from ConvertibleTo(InputForm)
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.

diagonal : % -> Row

diagonal(m) returns a row consisting of the elements on the diagonal of the matrix m.

diagonal? : % -> Boolean
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
diagonalMatrix : List(R) -> %

diagonalMatrix(l) returns a diagonal matrix with the elements of l on the diagonal.

diagonalProduct : % -> R

diagonalProduct(m) returns the product of the elements on the diagonal of the matrix m.

differentiate : % -> % if R has DifferentialRing and R has Ring
from DifferentialRing
differentiate : (%, List(Symbol)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, Mapping(R, R)) -> % if R has Ring
from DifferentialExtension(R)
differentiate : (%, Mapping(R, R), NonNegativeInteger) -> % if R has Ring
from DifferentialExtension(R)
differentiate : (%, NonNegativeInteger) -> % if R has DifferentialRing and R has Ring
from DifferentialRing
differentiate : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
elt : (%, Integer, Integer) -> R
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
elt : (%, Integer, Integer, R) -> R
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
empty : () -> %
from Aggregate
empty? : % -> Boolean
from Aggregate
enumerate : () -> List(%) if R has Finite
from Finite
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
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
hash : % -> SingleInteger if R has Finite
from Hashable
hashUpdate! : (HashState, %) -> HashState if R has Finite
from Hashable
index : PositiveInteger -> % if R has Finite
from Finite
inverse : % -> Union(%, "failed") if R has Field

inverse(m) returns the inverse of the matrix m, if that matrix is invertible and returns "failed" otherwise.

latex : % -> String
from SetCategory
leftPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
less? : (%, NonNegativeInteger) -> Boolean
from Aggregate
listOfLists : % -> List(List(R))
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
lookup : % -> PositiveInteger if R has Finite
from Finite
map : (Mapping(R, R), %) -> %
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
map : (Mapping(R, R, R), %, %) -> %
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
map! : (Mapping(R, R), %) -> % if % has shallowlyMutable
from HomogeneousAggregate(R)
matrix : List(List(R)) -> %
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
max : % -> R if R has OrderedSet
from HomogeneousAggregate(R)
max : (Mapping(Boolean, R, R), %) -> R
from HomogeneousAggregate(R)
maxColIndex : % -> Integer
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
maxRowIndex : % -> Integer
from RectangularMatrixCategory(ndim, ndim, 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 RectangularMatrixCategory(ndim, ndim, R, Row, Col)
minRowIndex : % -> Integer
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
minordet : % -> R if R has CommutativeRing

minordet(m) computes the determinant of the matrix m using minors.

more? : (%, NonNegativeInteger) -> Boolean
from Aggregate
ncols : % -> NonNegativeInteger
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
nrows : % -> NonNegativeInteger
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
nullSpace : % -> List(Col) if R has IntegralDomain
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
nullity : % -> NonNegativeInteger if R has IntegralDomain
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
one? : % -> Boolean if R has SemiRing
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
parts : % -> List(R)
from HomogeneousAggregate(R)
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing
from NonAssociativeAlgebra(R)
qelt : (%, Integer, Integer) -> R
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
random : () -> % if R has Finite
from Finite
rank : % -> NonNegativeInteger if R has IntegralDomain
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
recip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
reducedSystem : Matrix(%) -> Matrix(R) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R)) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
retract : % -> R
from RetractableTo(R)
retract : % -> Fraction(Integer) if R has RetractableTo(Fraction(Integer))
from RetractableTo(Fraction(Integer))
retract : % -> Integer if R has RetractableTo(Integer)
from RetractableTo(Integer)
retractIfCan : % -> Union(R, "failed")
from RetractableTo(R)
retractIfCan : % -> Union(Fraction(Integer), "failed") if R has RetractableTo(Fraction(Integer))
from RetractableTo(Fraction(Integer))
retractIfCan : % -> Union(Integer, "failed") if R has RetractableTo(Integer)
from RetractableTo(Integer)
rightPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
row : (%, Integer) -> Row
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
rowEchelon : % -> % if R has EuclideanDomain
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
sample : () -> %
from AbelianMonoid
scalarMatrix : R -> %

scalarMatrix(r) returns an n-by-n matrix with r's on the diagonal and zeroes elsewhere.

size : () -> NonNegativeInteger if R has Finite
from Finite
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
smaller? : (%, %) -> Boolean if R has Finite
from Comparable
square? : % -> Boolean
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
subtractIfCan : (%, %) -> Union(%, "failed") if % has AbelianGroup or R has AbelianGroup
from CancellationAbelianMonoid
symmetric? : % -> Boolean
from RectangularMatrixCategory(ndim, ndim, R, Row, Col)
trace : % -> R

trace(m) returns the trace of the matrix m. this is the sum of the elements on the diagonal of the matrix m.

zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

NonAssociativeSemiRing

LeftModule(R)

LinearlyExplicitOver(R)

Evalable(R)

ConvertibleTo(InputForm)

Rng

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

unitsKnown

FullyLinearlyExplicitOver(R)

MagmaWithUnit

LinearlyExplicitOver(Integer)

Magma

SemiGroup

LeftModule(%)

NonAssociativeRing

finiteAggregate

PartialDifferentialRing(Symbol)

Module(R)

BiModule(%, %)

CoercibleFrom(Fraction(Integer))

DifferentialRing

BiModule(R, R)

Algebra(R)

RightModule(R)

InnerEvalable(R, R)

NonAssociativeSemiRng

Aggregate

CancellationAbelianMonoid

RetractableTo(Integer)

RectangularMatrixCategory(ndim, ndim, R, Row, Col)

AbelianMonoid

RetractableTo(Fraction(Integer))

Comparable

RightModule(%)

Hashable

HomogeneousAggregate(R)

CoercibleTo(OutputForm)

DifferentialExtension(R)

SemiRng

Monoid

Finite

BasicType

Ring

RightModule(Integer)

AbelianSemiGroup

SetCategory

NonAssociativeRng

CoercibleFrom(R)

RetractableTo(R)

AbelianGroup

NonAssociativeAlgebra(R)