DirectProductMatrixModule(n, R, M, S)

vector.spad line 564 [edit on github]

• n : PositiveInteger
• 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.

# : % -> NonNegativeInteger

from Aggregate

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

from Magma

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

from DirectProductCategory(n, S)

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

from RightModule(Integer)

* : (M, %) -> %

from LeftModule(M)

* : (R, %) -> %

from LeftModule(R)

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

from DirectProductCategory(n, S)

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

0 : () -> %

from AbelianMonoid

1 : () -> % if S has Monoid

from MagmaWithUnit

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

from PartialOrder

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

from PartialOrder

= : (%, %) -> Boolean

from BasicType

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

from PartialOrder

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

from PartialOrder

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(S)

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

from DifferentialExtension(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

^ : (%, 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

from NonAssociativeSemiRng

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

from Algebra(S)

coerce : Fraction(Integer) -> % if S has RetractableTo(Fraction(Integer))

from CoercibleFrom(Fraction(Integer))

coerce : Integer -> % if S has Ring or S has RetractableTo(Integer)

from NonAssociativeRing

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

coerce : % -> Vector(S)

from CoercibleTo(Vector(S))

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

from NonAssociativeRng

convert : % -> InputForm if S has Finite

from ConvertibleTo(InputForm)

copy : % -> %

from Aggregate

count : (S, %) -> NonNegativeInteger

from HomogeneousAggregate(S)

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

from HomogeneousAggregate(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(S)

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

from DifferentialExtension(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

directProduct : Vector(S) -> %

from DirectProductCategory(n, S)

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

from DirectProductCategory(n, S)

elt : (%, Integer) -> S

from Eltable(Integer, S)

elt : (%, Integer, S) -> S

from EltableAggregate(Integer, S)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(S)

from IndexedAggregate(Integer, S)

entry? : (S, %) -> Boolean

from IndexedAggregate(Integer, S)

enumerate : () -> List(%) if S has Finite

from Finite

eq? : (%, %) -> Boolean

from Aggregate

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

from InnerEvalable(S, S)

eval : (%, 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 : (%, List(Equation(S))) -> % if S has Evalable(S)

from Evalable(S)

every? : (Mapping(Boolean, S), %) -> 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 : PositiveInteger -> % if S has Finite

from Finite

index? : (Integer, %) -> Boolean

from IndexedAggregate(Integer, S)

indices : % -> List(Integer)

from IndexedAggregate(Integer, S)

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

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

from HomogeneousAggregate(S)

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

from OrderedSet

max : % -> S if S has OrderedSet

from HomogeneousAggregate(S)

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

from HomogeneousAggregate(S)

maxIndex : % -> Integer

from IndexedAggregate(Integer, S)

member? : (S, %) -> Boolean

from HomogeneousAggregate(S)

members : % -> List(S)

from HomogeneousAggregate(S)

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

from OrderedSet

min : % -> S if S has OrderedSet

from HomogeneousAggregate(S)

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)

random : () -> % if S has Finite

from Finite

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

from MagmaWithUnit

reducedSystem : Matrix(%) -> Matrix(S) if S has Ring

from LinearlyExplicitOver(S)

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

from LinearlyExplicitOver(Integer)

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

from LinearlyExplicitOver(S)

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

from LinearlyExplicitOver(Integer)

retract : % -> S

from RetractableTo(S)

retract : % -> Fraction(Integer) if S has RetractableTo(Fraction(Integer))

from RetractableTo(Fraction(Integer))

retract : % -> Integer if S has RetractableTo(Integer)

from RetractableTo(Integer)

retractIfCan : % -> Union(S, "failed")

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)

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 if S has Finite

from Finite

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from Comparable

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

from CancellationAbelianMonoid

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

from OrderedAbelianMonoidSup

unitVector : PositiveInteger -> % if S has Monoid

from DirectProductCategory(n, S)

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

LeftModule(M)

LinearlyExplicitOver(S)

PartialOrder

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

HomogeneousAggregate(S)

ConvertibleTo(InputForm)

Rng

CoercibleFrom(Integer)

TwoSidedRecip

SemiRing

DifferentialExtension(S)

unitsKnown

CoercibleTo(Vector(S))

NonAssociativeAlgebra(S)

FullyRetractableTo(S)

LinearlyExplicitOver(Integer)

RetractableTo(Fraction(Integer))

EltableAggregate(Integer, S)

OrderedSet

Magma

SemiGroup

LeftModule(%)

NonAssociativeRing

finiteAggregate

PartialDifferentialRing(Symbol)

RightModule(S)

Algebra(%)

DirectProductCategory(n, S)

CoercibleFrom(Fraction(Integer))

DifferentialRing

CommutativeRing

Evalable(S)

NonAssociativeSemiRng

CancellationAbelianMonoid

Module(S)

Comparable

RetractableTo(Integer)

OrderedCancellationAbelianMonoid

OrderedAbelianMonoid

InnerEvalable(S, S)

AbelianMonoid

MagmaWithUnit

RightModule(%)

Hashable

CoercibleFrom(S)

CommutativeStar

RetractableTo(S)

LeftModule(S)

OrderedAbelianSemiGroup

Module(%)

CoercibleTo(OutputForm)

Ring

Eltable(Integer, S)

SemiRng

IndexedAggregate(Integer, S)

Monoid

NonAssociativeAlgebra(%)

Finite

Aggregate

BiModule(S, S)

BasicType

RightModule(Integer)

OrderedAbelianMonoidSup

AbelianSemiGroup

SetCategory

FullyLinearlyExplicitOver(S)

NonAssociativeRng

Algebra(S)

AbelianGroup

AbelianProductCategory(S)