# DirectProductMatrixModule(n, R, M, S)ΒΆ

vector.spad line 564 [edit on github]

R: Ring

M: SquareMatrixCategory(n, R, DirectProduct(n, R), DirectProduct(n, R))

S: LeftModule R

This constructor provides a direct product type with a left matrix-module view.

- 0: %
from AbelianMonoid

- 1: % if S has Monoid
from MagmaWithUnit

- #: % -> NonNegativeInteger
from Aggregate

- *: (%, %) -> % if S has SemiGroup
from LeftModule %

- *: (%, Integer) -> % if S has Ring and S has LinearlyExplicitOver Integer
from RightModule Integer

- *: (%, S) -> % if S has SemiGroup
from DirectProductCategory(n, S)

- *: (Integer, %) -> %
from AbelianGroup

- *: (M, %) -> %
from LeftModule M

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> %
from LeftModule R

- *: (S, %) -> % if S has SemiGroup
from DirectProductCategory(n, S)

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- <=: (%, %) -> Boolean if S has OrderedSet
from PartialOrder

- <: (%, %) -> Boolean if S has OrderedSet
from PartialOrder

- >=: (%, %) -> Boolean if S has OrderedSet
from PartialOrder

- >: (%, %) -> Boolean if S has OrderedSet
from PartialOrder

- ^: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- ^: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- annihilate?: (%, %) -> Boolean if S has Ring
from Rng

- antiCommutator: (%, %) -> % if S has SemiRng

- any?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S

- associator: (%, %, %) -> % if S has Ring
from NonAssociativeRng

- characteristic: () -> NonNegativeInteger if S has Ring
from NonAssociativeRing

- coerce: % -> % if S has CommutativeRing
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: % -> Vector S
from CoercibleTo Vector S

- coerce: Fraction Integer -> % if S has RetractableTo Fraction Integer
from CoercibleFrom Fraction Integer

- coerce: Integer -> % if S has RetractableTo Integer or S has Ring
from NonAssociativeRing

- coerce: S -> %
from Algebra S

- commutator: (%, %) -> % if S has Ring
from NonAssociativeRng

- convert: % -> InputForm if S has Finite
from ConvertibleTo InputForm

- count: (S -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate S

- count: (S, %) -> NonNegativeInteger
from HomogeneousAggregate S

- D: % -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring
- D: (%, NonNegativeInteger) -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- D: (%, S -> S) -> % if S has Ring
from DifferentialExtension S

- D: (%, S -> S, NonNegativeInteger) -> % if S has Ring
from DifferentialExtension S

- D: (%, Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- D: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring

- differentiate: % -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, NonNegativeInteger) -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- differentiate: (%, S -> S) -> % if S has Ring
from DifferentialExtension S

- differentiate: (%, S -> S, NonNegativeInteger) -> % if S has Ring
from DifferentialExtension S

- differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring

- directProduct: Vector S -> %
from DirectProductCategory(n, S)

- dot: (%, %) -> S if S has SemiRng
from DirectProductCategory(n, S)

- entries: % -> List S
from IndexedAggregate(Integer, S)

- entry?: (S, %) -> Boolean
from IndexedAggregate(Integer, S)

- eval: (%, Equation S) -> % if S has Evalable S
from Evalable S

- eval: (%, List Equation S) -> % if S has Evalable S
from Evalable S

- eval: (%, List S, List S) -> % if S has Evalable S
from InnerEvalable(S, S)

- eval: (%, S, S) -> % if S has Evalable S
from InnerEvalable(S, S)

- every?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S

- first: % -> S
from IndexedAggregate(Integer, S)

- hash: % -> SingleInteger if S has Finite
from Hashable

- hashUpdate!: (HashState, %) -> HashState if S has Finite
from Hashable

- index?: (Integer, %) -> Boolean
from IndexedAggregate(Integer, S)

- index: PositiveInteger -> % if S has Finite
from Finite

- indices: % -> List Integer
from IndexedAggregate(Integer, S)

- inf: (%, %) -> % if S has OrderedAbelianMonoidSup

- latex: % -> String
from SetCategory

- leftPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- leftRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

- less?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- lookup: % -> PositiveInteger if S has Finite
from Finite

- map: (S -> S, %) -> %
from HomogeneousAggregate S

- max: % -> S if S has OrderedSet
from HomogeneousAggregate S

- max: (%, %) -> % if S has OrderedSet
from OrderedSet

- max: ((S, S) -> Boolean, %) -> S
from HomogeneousAggregate S

- maxIndex: % -> Integer
from IndexedAggregate(Integer, S)

- member?: (S, %) -> Boolean
from HomogeneousAggregate S

- members: % -> List S
from HomogeneousAggregate S

- min: % -> S if S has OrderedSet
from HomogeneousAggregate S

- min: (%, %) -> % if S has OrderedSet
from OrderedSet

- minIndex: % -> Integer
from IndexedAggregate(Integer, S)

- more?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- one?: % -> Boolean if S has Monoid
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- parts: % -> List S
from HomogeneousAggregate S

- plenaryPower: (%, PositiveInteger) -> % if S has CommutativeRing
from NonAssociativeAlgebra S

- qelt: (%, Integer) -> S
from EltableAggregate(Integer, S)

- recip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if S has Ring and S has LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix S, vec: Vector S) if S has Ring
from LinearlyExplicitOver S

- reducedSystem: Matrix % -> Matrix Integer if S has Ring and S has LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix S if S has Ring
from LinearlyExplicitOver S

- retract: % -> Fraction Integer if S has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retract: % -> Integer if S has RetractableTo Integer
from RetractableTo Integer

- retract: % -> S
from RetractableTo S

- retractIfCan: % -> Union(Fraction Integer, failed) if S has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retractIfCan: % -> Union(Integer, failed) if S has RetractableTo Integer
from RetractableTo Integer

- retractIfCan: % -> Union(S, failed)
from RetractableTo S

- rightPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- rightRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

- sample: %
from AbelianMonoid

- size?: (%, NonNegativeInteger) -> Boolean
from Aggregate

- size: () -> NonNegativeInteger if S has Finite
from Finite

- smaller?: (%, %) -> Boolean if S has OrderedSet or S has Finite
from Comparable

- subtractIfCan: (%, %) -> Union(%, failed)

- sup: (%, %) -> % if S has OrderedAbelianMonoidSup

- unitVector: PositiveInteger -> % if S has Monoid
from DirectProductCategory(n, S)

- zero?: % -> Boolean
from AbelianMonoid

Algebra % if S has CommutativeRing

Algebra S if S has CommutativeRing

BiModule(%, %) if S has SemiRng

BiModule(S, S) if S has SemiRng

CoercibleFrom Fraction Integer if S has RetractableTo Fraction Integer

CoercibleFrom Integer if S has RetractableTo Integer

CommutativeRing if S has CommutativeRing

CommutativeStar if S has CommutativeRing

Comparable if S has OrderedSet or S has Finite

ConvertibleTo InputForm if S has Finite

DifferentialExtension S if S has Ring

DifferentialRing if S has DifferentialRing and S has Ring

DirectProductCategory(n, S)

Evalable S if S has Evalable S

FullyLinearlyExplicitOver S if S has Ring

InnerEvalable(S, S) if S has Evalable S

LeftModule % if S has SemiRng

LeftModule S if S has SemiRng

LinearlyExplicitOver Integer if S has Ring and S has LinearlyExplicitOver Integer

LinearlyExplicitOver S if S has Ring

MagmaWithUnit if S has Monoid

Module % if S has CommutativeRing

Module S if S has CommutativeRing

NonAssociativeAlgebra % if S has CommutativeRing

NonAssociativeAlgebra S if S has CommutativeRing

NonAssociativeRing if S has Ring

NonAssociativeRng if S has Ring

NonAssociativeSemiRing if S has Ring

NonAssociativeSemiRng if S has SemiRng

OrderedAbelianMonoid if S has OrderedAbelianMonoid

OrderedAbelianMonoidSup if S has OrderedAbelianMonoidSup

OrderedAbelianSemiGroup if S has OrderedAbelianMonoid

OrderedCancellationAbelianMonoid if S has OrderedAbelianMonoidSup

OrderedSet if S has OrderedSet

PartialDifferentialRing Symbol if S has PartialDifferentialRing Symbol and S has Ring

PartialOrder if S has OrderedSet

RetractableTo Fraction Integer if S has RetractableTo Fraction Integer

RetractableTo Integer if S has RetractableTo Integer

RightModule % if S has SemiRng

RightModule Integer if S has Ring and S has LinearlyExplicitOver Integer

RightModule S if S has SemiRng

TwoSidedRecip if S has CommutativeRing

unitsKnown if S has unitsKnown