# RectangularMatrix(m, n, R)ΒΆ

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

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

from Aggregate

empty: () -> %

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

max: % -> R if R has OrderedSet

from HomogeneousAggregate R

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

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

from Aggregate

size: () -> NonNegativeInteger if R has Finite

from Finite

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

Comparable if R has Finite

Evalable R if R has Evalable R

Finite if R has Finite

finiteAggregate

Hashable if R has Finite

InnerEvalable(R, R) if R has Evalable R

Module R if R has CommutativeRing

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

SetCategory