# DirectProduct(dim, R)ΒΆ

vector.spad line 350 [edit on github]

dim: NonNegativeInteger

R: Type

This type represents the finite direct or cartesian product of an underlying component type. This contrasts with simple vectors in that the members can be viewed as having constant length. Thus many categorical properties can by lifted from the underlying component type. Component extraction operations are provided but no updating operations. Thus new direct product elements can either be created by converting vector elements using the directProduct function or by taking appropriate linear combinations of basis vectors provided by the `unitVector`

operation.

- 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
from DirectProductCategory(dim, 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 SemiRng or R has AbelianMonoid
from AbelianSemiGroup

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

- +: (%, %) -> % if R has SemiRng or R has AbelianMonoid
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

- <=: (%, %) -> 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 Ring or R has SetCategory and R has RetractableTo Integer
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 -> %
from DirectProductCategory(dim, R)

- dot: (%, %) -> R if R has AbelianMonoid and R has SemiRng
from DirectProductCategory(dim, R)

- 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

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

- hash: % -> SingleInteger if R has SetCategory
from SetCategory

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

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

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

- 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, %) -> %
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 AbelianMonoid or R has SemiRng and % has AbelianMonoid
from AbelianMonoid

- parts: % -> List R
from HomogeneousAggregate R

- qelt: (%, Integer) -> R
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

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

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

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

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

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

- unitVector: PositiveInteger -> % if R has Monoid and R has AbelianMonoid
from DirectProductCategory(dim, R)

- 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 SemiRng or R has AbelianMonoid

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 OrderedSet or R has Finite

ConvertibleTo InputForm if R has Finite

DifferentialExtension R if R has Ring

DifferentialRing if R has DifferentialRing and R has Ring

DirectProductCategory(dim, R)

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

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 R if R has SemiRng

SetCategory if R has SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown if R has unitsKnown