# DirectProductCategory(dim, R)ΒΆ

- 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 AbelianMonoid or R has SemiRng and % has AbelianMonoid
- from AbelianMonoid
- 1: % if R has Monoid
- from MagmaWithUnit
- #: % -> NonNegativeInteger
- from Aggregate
- *: (%, %) -> % if R has SemiGroup
- from Magma

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

multiplies each component of the vector`y`

by the element`r`

.- *: (Integer, %) -> % if % has AbelianGroup and R has SemiRng or R has AbelianGroup
- from AbelianGroup
- *: (NonNegativeInteger, %) -> % if R has AbelianMonoid or R has SemiRng and % 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 % has AbelianGroup and R has SemiRng or R has AbelianGroup
- from AbelianGroup
- -: (%, %) -> % if % has AbelianGroup and R has SemiRng or R has AbelianGroup
- from AbelianGroup
- /: (%, R) -> % if R has Field
- from VectorSpace R
- <: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- <=: (%, %) -> Boolean if R has OrderedSet
- from PartialOrder
- =: (%, %) -> Boolean if R has BasicType
- from BasicType
- >: (%, %) -> 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
- ~=: (%, %) -> Boolean if R has BasicType
- from BasicType
- annihilate?: (%, %) -> Boolean if R has Ring
- from Rng
- antiCommutator: (%, %) -> % if R has SemiRng
- from NonAssociativeSemiRng
- 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 RetractableTo Fraction Integer and R has SetCategory
- from RetractableTo Fraction Integer
- coerce: Integer -> % if R has RetractableTo Integer and R has SetCategory or R has Ring
- from NonAssociativeRing
- coerce: R -> % if R has SetCategory
- from RetractableTo R
- commutator: (%, %) -> % if R has Ring
- from NonAssociativeRng
- convert: % -> InputForm if R has Finite
- from ConvertibleTo InputForm
- copy: % -> %
- from Aggregate
- count: (R -> Boolean, %) -> NonNegativeInteger
- from HomogeneousAggregate R
- count: (R, %) -> NonNegativeInteger if R has BasicType
- from HomogeneousAggregate R
- D: % -> % if R has Ring and R has DifferentialRing
- from DifferentialRing
- D: (%, List Symbol) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, List Symbol, List NonNegativeInteger) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, NonNegativeInteger) -> % if R has Ring and R has DifferentialRing
- 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 Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- D: (%, Symbol, NonNegativeInteger) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: % -> % if R has Ring and R has DifferentialRing
- from DifferentialRing
- differentiate: (%, List Symbol) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, NonNegativeInteger) -> % if R has Ring and R has DifferentialRing
- 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 Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- differentiate: (%, Symbol, NonNegativeInteger) -> % if R has Ring and R has PartialDifferentialRing Symbol
- from PartialDifferentialRing Symbol
- dimension: () -> CardinalNumber if R has Field
- from VectorSpace R

- 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 SemiRng and R has AbelianMonoid
`dot(x, y)`

computes the inner product of the vectors`x`

and`y`

.- elt: (%, Integer) -> R
- from Eltable(Integer, R)
- elt: (%, Integer, R) -> R
- from EltableAggregate(Integer, R)
- empty: () -> %
- from Aggregate
- empty?: % -> Boolean
- from Aggregate
- entries: % -> List R
- from IndexedAggregate(Integer, R)
- entry?: (R, %) -> Boolean if R has BasicType
- from IndexedAggregate(Integer, R)
- enumerate: () -> List % if R has Finite
- from Finite
- eq?: (%, %) -> Boolean
- from Aggregate
- 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 SetCategory
- from SetCategory
- hashUpdate!: (HashState, %) -> HashState if R has SetCategory
- from SetCategory
- index: PositiveInteger -> % if R has Finite
- from Finite
- index?: (Integer, %) -> Boolean
- from IndexedAggregate(Integer, R)
- indices: % -> List Integer
- from IndexedAggregate(Integer, R)
- 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: (%, %) -> % if R has OrderedSet
- from OrderedSet
- maxIndex: % -> Integer
- from IndexedAggregate(Integer, R)
- member?: (R, %) -> Boolean if R has BasicType
- from HomogeneousAggregate R
- members: % -> List R
- 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 AbelianMonoid or R has SemiRng and % has AbelianMonoid
- from AbelianMonoid
- parts: % -> List R
- from HomogeneousAggregate R
- qelt: (%, Integer) -> R
- from EltableAggregate(Integer, R)
- qsetelt!: (%, Integer, R) -> R if % has shallowlyMutable
- from EltableAggregate(Integer, R)
- random: () -> % if R has Finite
- from Finite
- recip: % -> Union(%, failed) if R has Monoid
- from MagmaWithUnit
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has Ring and R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R) if R has Ring
- from LinearlyExplicitOver R
- reducedSystem: Matrix % -> Matrix Integer if R has Ring and R has LinearlyExplicitOver Integer
- from LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix R if R has Ring
- from LinearlyExplicitOver R
- retract: % -> Fraction Integer if R has RetractableTo Fraction Integer and R has SetCategory
- from RetractableTo Fraction Integer
- retract: % -> Integer if R has RetractableTo Integer and R has SetCategory
- from RetractableTo Integer
- retract: % -> R if R has SetCategory
- from RetractableTo R
- retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer and R has SetCategory
- from RetractableTo Fraction Integer
- retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer and R has SetCategory
- 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 if R has Finite
- from Finite
- size?: (%, NonNegativeInteger) -> Boolean
- from Aggregate
- smaller?: (%, %) -> Boolean if R has OrderedSet or R has Finite
- from Comparable
- subtractIfCan: (%, %) -> Union(%, failed) if R has CancellationAbelianMonoid
- from CancellationAbelianMonoid
- sup: (%, %) -> % if R has OrderedAbelianMonoidSup
- from 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 AbelianMonoid or R has SemiRng and % 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

CoercibleTo OutputForm if R has CoercibleTo OutputForm

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has OrderedSet or R has Finite

ConvertibleTo InputForm if R has Finite

DifferentialExtension R if R has Ring

DifferentialRing if R has Ring and R has DifferentialRing

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 Ring and R has LinearlyExplicitOver Integer

LinearlyExplicitOver R if R has Ring

MagmaWithUnit if R has Monoid

Module % if R has CommutativeRing

Module 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 OrderedAbelianMonoidSup

OrderedAbelianMonoidSup if R has OrderedAbelianMonoidSup

OrderedAbelianSemiGroup if R has OrderedAbelianMonoidSup

OrderedCancellationAbelianMonoid if R has OrderedAbelianMonoidSup

OrderedSet if R has OrderedSet

PartialDifferentialRing Symbol if R has Ring and R has PartialDifferentialRing Symbol

PartialOrder if R has OrderedSet

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

RetractableTo Integer if R has RetractableTo Integer and R has SetCategory

RetractableTo R if R has SetCategory

RightModule % if R has SemiRng

RightModule R if R has SemiRng

SetCategory if R has SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown if R has unitsKnown

VectorSpace R if R has Field