# DirectProductCategory(dim, R)ΒΆ

vector.spad line 244 [edit on github]

dim: NonNegativeInteger

R: Type

This category represents a finite cartesian product of a given type. Many categorical properties are preserved under this construction.

- 0: % if R has SemiRng and % has AbelianMonoid or R has AbelianMonoid
from AbelianMonoid

- 1: % if R has Monoid
from MagmaWithUnit

- #: % -> NonNegativeInteger
from Aggregate

- *: (%, %) -> % if R has SemiGroup
from Magma

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

- *: (%, R) -> % if R has SemiGroup
`y * r`

multiplies each component of the vector`y`

by the element`r`

.- *: (Integer, %) -> % if R has AbelianGroup or % has AbelianGroup and R has SemiRng
from AbelianGroup

- *: (NonNegativeInteger, %) -> % if R has SemiRng and % has AbelianMonoid or R has AbelianMonoid
from AbelianMonoid

- *: (PositiveInteger, %) -> % if R has AbelianMonoid or R has SemiRng
from AbelianSemiGroup

- *: (R, %) -> % if R has SemiGroup
`r * y`

multiplies the element`r`

times each component of the vector`y`

.

- +: (%, %) -> % if R has AbelianMonoid or R has SemiRng
from AbelianSemiGroup

- -: % -> % if R has AbelianGroup or % has AbelianGroup and R has SemiRng
from AbelianGroup

- -: (%, %) -> % if R has AbelianGroup or % has AbelianGroup and R has SemiRng
from AbelianGroup

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

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

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

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

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

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

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

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

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

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

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

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

- coerce: % -> OutputForm if R has CoercibleTo OutputForm
from CoercibleTo OutputForm

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

- coerce: Fraction Integer -> % if R has SetCategory and R has RetractableTo Fraction Integer
from CoercibleFrom Fraction Integer

- coerce: Integer -> % if R has SetCategory and R has RetractableTo Integer or R has Ring
from NonAssociativeRing

- coerce: R -> % if R has SetCategory
from CoercibleFrom R

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

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

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

- count: (R, %) -> NonNegativeInteger if R has BasicType
from HomogeneousAggregate R

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

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

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

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

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

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

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

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

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

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

- directProduct: Vector R -> %
`directProduct(v)`

converts the vector`v`

to a direct product. Error: if the length of`v`

is different from dim.

- dot: (%, %) -> R if R has AbelianMonoid and R has SemiRng
`dot(x, y)`

computes the inner product of the vectors`x`

and`y`

.

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

- entry?: (R, %) -> Boolean if R has BasicType
from IndexedAggregate(Integer, R)

- eval: (%, Equation R) -> % if R has SetCategory and R has Evalable R
from Evalable R

- eval: (%, List Equation R) -> % if R has SetCategory and R has Evalable R
from Evalable R

- eval: (%, List R, List R) -> % if R has SetCategory and R has Evalable R
from InnerEvalable(R, R)

- eval: (%, R, R) -> % if R has SetCategory and R has Evalable R
from InnerEvalable(R, R)

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

- fill!: (%, R) -> % if % has shallowlyMutable
from IndexedAggregate(Integer, R)

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

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

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

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

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

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

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

- latex: % -> String if R has SetCategory
from SetCategory

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

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

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

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

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

- map!: (R -> R, %) -> % if % has shallowlyMutable
from HomogeneousAggregate R

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

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

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

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

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

- member?: (R, %) -> Boolean if R has BasicType
from HomogeneousAggregate R

- members: % -> List R
from HomogeneousAggregate R

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

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

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

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

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

- opposite?: (%, %) -> Boolean if R has SemiRng and % has AbelianMonoid or R has AbelianMonoid
from AbelianMonoid

- parts: % -> List R
from HomogeneousAggregate R

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

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

- qsetelt!: (%, Integer, R) -> R if % has shallowlyMutable
from EltableAggregate(Integer, R)

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

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

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

- retract: % -> Fraction Integer if R has SetCategory and R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retract: % -> Integer if R has SetCategory and R has RetractableTo Integer
from RetractableTo Integer

- retract: % -> R if R has SetCategory
from RetractableTo R

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

- retractIfCan: % -> Union(Integer, failed) if R has SetCategory and R has RetractableTo Integer
from RetractableTo Integer

- retractIfCan: % -> Union(R, failed) if R has SetCategory
from RetractableTo R

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

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

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

- sample: %
from AbelianMonoid

- setelt!: (%, Integer, R) -> R if % has shallowlyMutable
from EltableAggregate(Integer, R)

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

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

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

- subtractIfCan: (%, %) -> Union(%, failed) if R has CancellationAbelianMonoid

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

- swap!: (%, Integer, Integer) -> Void if % has shallowlyMutable
from IndexedAggregate(Integer, R)

- unitVector: PositiveInteger -> % if R has Monoid and R has AbelianMonoid
`unitVector(n)`

produces a vector with 1 in position`n`

and zero elsewhere.

- zero?: % -> Boolean if R has SemiRng and % has AbelianMonoid or R has AbelianMonoid
from AbelianMonoid

AbelianGroup if R has AbelianGroup

AbelianMonoid if R has AbelianMonoid

AbelianSemiGroup if R has AbelianMonoid or R has SemiRng

Algebra % if R has CommutativeRing

Algebra R if R has CommutativeRing

BiModule(%, %) if R has SemiRng

BiModule(R, R) if R has SemiRng

CancellationAbelianMonoid if R has CancellationAbelianMonoid

CoercibleFrom Fraction Integer if R has SetCategory and R has RetractableTo Fraction Integer

CoercibleFrom Integer if R has SetCategory and R has RetractableTo Integer

CoercibleFrom R if R has SetCategory

CoercibleTo OutputForm if R has CoercibleTo OutputForm

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Finite or R has OrderedSet

ConvertibleTo InputForm if R has Finite

DifferentialExtension R if R has Ring

DifferentialRing if R has DifferentialRing and R has Ring

Evalable R if R has SetCategory and R has Evalable R

FullyLinearlyExplicitOver R if R has Ring

FullyRetractableTo R if R has SetCategory

InnerEvalable(R, R) if R has SetCategory and R has Evalable R

LeftModule % if R has SemiRng

LeftModule R if R has SemiRng

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer and R has Ring

LinearlyExplicitOver R if R has Ring

MagmaWithUnit if R has Monoid

Module % if R has CommutativeRing

Module R if R has CommutativeRing

NonAssociativeAlgebra % if R has CommutativeRing

NonAssociativeAlgebra R if R has CommutativeRing

NonAssociativeRing if R has Ring

NonAssociativeRng if R has Ring

NonAssociativeSemiRing if R has Ring

NonAssociativeSemiRng if R has SemiRng

OrderedAbelianMonoid if R has OrderedAbelianMonoid

OrderedAbelianMonoidSup if R has OrderedAbelianMonoidSup

OrderedAbelianSemiGroup if R has OrderedAbelianMonoid

OrderedCancellationAbelianMonoid if R has OrderedAbelianMonoidSup

OrderedSet if R has OrderedSet

PartialDifferentialRing Symbol if R has PartialDifferentialRing Symbol and R has Ring

PartialOrder if R has OrderedSet

RetractableTo Fraction Integer if R has SetCategory and R has RetractableTo Fraction Integer

RetractableTo Integer if R has SetCategory and R has RetractableTo Integer

RetractableTo R if R has SetCategory

RightModule % if R has SemiRng

RightModule Integer if R has LinearlyExplicitOver Integer and R has Ring

RightModule R if R has SemiRng

SetCategory if R has SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown if R has unitsKnown