RectangularMatrix(m, n, R)

matrix.spad line 230 [edit on github]

• m : NonNegativeInteger
• n : NonNegativeInteger
• R : Join(SemiRng, AbelianMonoid)

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

# : % -> NonNegativeInteger

from Aggregate

* : (%, R) -> %

from RightModule(R)

* : (R, %) -> %

from LeftModule(R)

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

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> % if R has AbelianGroup

from AbelianGroup

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

from AbelianGroup

/ : (%, R) -> % if R has Field

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

0 : () -> %

from AbelianMonoid

= : (%, %) -> Boolean

from BasicType

antisymmetric? : % -> Boolean

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

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

from HomogeneousAggregate(R)

count : (Mapping(Boolean, R), %) -> NonNegativeInteger

from HomogeneousAggregate(R)

diagonal? : % -> Boolean

from RectangularMatrixCategory(m, n, R, DirectProduct(n, R), DirectProduct(m, 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 : (%, 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(m, n, R, DirectProduct(n, R), DirectProduct(m, R))

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

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

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

map : (Mapping(R, 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))

max : % -> R if R has OrderedSet

from HomogeneousAggregate(R)

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

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

min : % -> R if R has OrderedSet

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))

nullSpace : % -> List(DirectProduct(m, R)) if R has IntegralDomain

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))

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 Aggregate

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

~= : (%, %) -> Boolean

from BasicType

Comparable

ConvertibleTo(InputForm)

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

Aggregate

BiModule(R, R)

BasicType

CancellationAbelianMonoid

RightModule(R)

LeftModule(R)

CoercibleTo(Matrix(R))

Finite

SetCategory

CoercibleTo(OutputForm)

AbelianGroup

AbelianSemiGroup

InnerEvalable(R, R)

finiteAggregate

Module(R)

Evalable(R)

AbelianMonoid

Hashable

HomogeneousAggregate(R)