RectangularMatrix(m, n, R)ΒΆ

matrix.spad line 230

RectangularMatrix is a matrix domain where the number of rows and the number of columns are parameters of the domain.

0: %
from AbelianMonoid
#: % -> NonNegativeInteger
from Aggregate
*: (%, R) -> %
from RightModule R
*: (Integer, %) -> % if R has AbelianGroup
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
*: (R, %) -> %
from LeftModule R
+: (%, %) -> %
from AbelianSemiGroup
-: % -> % if R has AbelianGroup
from AbelianGroup
-: (%, %) -> % if R has AbelianGroup
from AbelianGroup
/: (%, R) -> % if R has Field
from VectorSpace R
=: (%, %) -> Boolean
from BasicType
~=: (%, %) -> Boolean
from BasicType
antisymmetric?: % -> Boolean
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
any?: (R -> Boolean, %) -> Boolean
from HomogeneousAggregate R
coerce: % -> Matrix R
coerce(m) converts a matrix of type RectangularMatrix to a matrix of type Matrix.
coerce: % -> OutputForm
from CoercibleTo OutputForm
column: (%, Integer) -> DirectProduct(m, R)
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
columnSpace: % -> List DirectProduct(m, R) if R has EuclideanDomain
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, 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
diagonal?: % -> Boolean
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
dimension: () -> CardinalNumber if R has Field
from VectorSpace R
elt: (%, Integer, Integer) -> R
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
elt: (%, Integer, Integer, R) -> R
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
empty: () -> %
from Aggregate
empty?: % -> Boolean
from Aggregate
enumerate: () -> List % if R has Finite
from Finite
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 RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
index: PositiveInteger -> % if R has Finite
from Finite
latex: % -> String
from SetCategory
less?: (%, NonNegativeInteger) -> Boolean
from Aggregate
listOfLists: % -> List List R
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
lookup: % -> PositiveInteger if R has Finite
from Finite
map: ((R, R) -> R, %, %) -> %
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
map: (R -> R, %) -> %
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
matrix: List List R -> %
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
maxColIndex: % -> Integer
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
maxRowIndex: % -> Integer
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
member?: (R, %) -> Boolean
from HomogeneousAggregate R
members: % -> List R
from HomogeneousAggregate R
minColIndex: % -> Integer
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
minRowIndex: % -> Integer
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
more?: (%, NonNegativeInteger) -> Boolean
from Aggregate
ncols: % -> NonNegativeInteger
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
nrows: % -> NonNegativeInteger
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
nullity: % -> NonNegativeInteger if R has IntegralDomain
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
nullSpace: % -> List DirectProduct(m, R) if R has IntegralDomain
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
opposite?: (%, %) -> Boolean
from AbelianMonoid
parts: % -> List R
from HomogeneousAggregate R
qelt: (%, Integer, Integer) -> R
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
random: () -> % if R has Finite
from Finite
rank: % -> NonNegativeInteger if R has IntegralDomain
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
rectangularMatrix: Matrix R -> %
rectangularMatrix(m) converts a matrix of type Matrix to a matrix of type RectangularMatrix.
row: (%, Integer) -> DirectProduct(n, R)
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
rowEchelon: % -> % if R has EuclideanDomain
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
sample: %
from AbelianMonoid
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(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
subtractIfCan: (%, %) -> Union(%, failed) if R has AbelianGroup
from CancellationAbelianMonoid
symmetric?: % -> Boolean
from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup if R has AbelianGroup

AbelianMonoid

AbelianSemiGroup

Aggregate

BasicType

BiModule(R, R)

CancellationAbelianMonoid if R has AbelianGroup

CoercibleTo Matrix R

CoercibleTo OutputForm

Comparable if R has Finite

ConvertibleTo InputForm if R has ConvertibleTo InputForm

Evalable R if R has Evalable R

Finite if R has Finite

finiteAggregate

HomogeneousAggregate R

InnerEvalable(R, R) if R has Evalable R

LeftModule R

Module R if R has CommutativeRing

RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, R))

RightModule R

SetCategory

VectorSpace R if R has Field