DirectProduct(dim, R)

vector.spad line 350 [edit on github]

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.

# : % -> NonNegativeInteger
from Aggregate
* : (%, %) -> % if R has SemiGroup
from Magma
* : (%, R) -> % if R has SemiGroup
from DirectProductCategory(dim, R)
* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer) and R has Ring
from RightModule(Integer)
* : (R, %) -> % if R has SemiGroup
from DirectProductCategory(dim, R)
* : (Integer, %) -> % if R has SemiRng and % has AbelianGroup or R has AbelianGroup
from AbelianGroup
* : (NonNegativeInteger, %) -> % if R has AbelianMonoid or % has AbelianMonoid and R has SemiRng
from AbelianMonoid
* : (PositiveInteger, %) -> % if R has AbelianMonoid or R has SemiRng
from AbelianSemiGroup
+ : (%, %) -> % if R has AbelianMonoid or R has SemiRng
from AbelianSemiGroup
- : % -> % if R has SemiRng and % has AbelianGroup or R has AbelianGroup
from AbelianGroup
- : (%, %) -> % if R has SemiRng and % has AbelianGroup or R has AbelianGroup
from AbelianGroup
0 : () -> % if R has AbelianMonoid or % has AbelianMonoid and R has SemiRng
from AbelianMonoid
1 : () -> % if R has Monoid
from MagmaWithUnit
< : (%, %) -> 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
D : % -> % if R has DifferentialRing and R has Ring
from DifferentialRing
D : (%, List(Symbol)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, Mapping(R, R)) -> % if R has Ring
from DifferentialExtension(R)
D : (%, Mapping(R, R), NonNegativeInteger) -> % if R has Ring
from DifferentialExtension(R)
D : (%, NonNegativeInteger) -> % if R has DifferentialRing and R has Ring
from DifferentialRing
D : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
D : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
^ : (%, 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
from NonAssociativeSemiRng
any? : (Mapping(Boolean, R), %) -> 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 : R -> % if R has SetCategory
from Algebra(R)
coerce : Fraction(Integer) -> % if R has RetractableTo(Fraction(Integer)) and R has SetCategory
from CoercibleFrom(Fraction(Integer))
coerce : Integer -> % if R has RetractableTo(Integer) and R has SetCategory or R has Ring
from NonAssociativeRing
coerce : % -> OutputForm if R has CoercibleTo(OutputForm)
from CoercibleTo(OutputForm)
coerce : % -> Vector(R)
from CoercibleTo(Vector(R))
commutator : (%, %) -> % if R has Ring
from NonAssociativeRng
convert : % -> InputForm if R has Finite
from ConvertibleTo(InputForm)
copy : % -> %
from Aggregate
count : (R, %) -> NonNegativeInteger if R has BasicType
from HomogeneousAggregate(R)
count : (Mapping(Boolean, R), %) -> NonNegativeInteger
from HomogeneousAggregate(R)
differentiate : % -> % if R has DifferentialRing and R has Ring
from DifferentialRing
differentiate : (%, List(Symbol)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, Mapping(R, R)) -> % if R has Ring
from DifferentialExtension(R)
differentiate : (%, Mapping(R, R), NonNegativeInteger) -> % if R has Ring
from DifferentialExtension(R)
differentiate : (%, NonNegativeInteger) -> % if R has DifferentialRing and R has Ring
from DifferentialRing
differentiate : (%, Symbol) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
differentiate : (%, Symbol, NonNegativeInteger) -> % if R has PartialDifferentialRing(Symbol) and R has Ring
from PartialDifferentialRing(Symbol)
directProduct : Vector(R) -> %
from DirectProductCategory(dim, R)
dot : (%, %) -> R if R has AbelianMonoid and R has SemiRng
from DirectProductCategory(dim, R)
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 : (%, R, R) -> % if R has Evalable(R) and R has SetCategory
from InnerEvalable(R, R)
eval : (%, Equation(R)) -> % if R has Evalable(R) and R has SetCategory
from Evalable(R)
eval : (%, List(R), List(R)) -> % if R has Evalable(R) and R has SetCategory
from InnerEvalable(R, R)
eval : (%, List(Equation(R))) -> % if R has Evalable(R) and R has SetCategory
from Evalable(R)
every? : (Mapping(Boolean, R), %) -> Boolean
from HomogeneousAggregate(R)
first : % -> R
from IndexedAggregate(Integer, R)
hash : % -> SingleInteger if R has Hashable
from Hashable
hashUpdate! : (HashState, %) -> HashState if R has Hashable
from Hashable
index : PositiveInteger -> % if R has Finite
from Finite
index? : (Integer, %) -> Boolean
from IndexedAggregate(Integer, R)
indices : % -> List(Integer)
from IndexedAggregate(Integer, R)
inf : (%, %) -> % if R has OrderedAbelianMonoidSup
from 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 : (Mapping(R, R), %) -> %
from HomogeneousAggregate(R)
max : (%, %) -> % if R has OrderedSet
from OrderedSet
max : % -> R if R has OrderedSet
from HomogeneousAggregate(R)
max : (Mapping(Boolean, R, R), %) -> 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 : (%, %) -> % if R has OrderedSet
from OrderedSet
min : % -> R if R has OrderedSet
from HomogeneousAggregate(R)
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 % has AbelianMonoid and R has SemiRng
from AbelianMonoid
parts : % -> List(R)
from HomogeneousAggregate(R)
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing
from NonAssociativeAlgebra(R)
qelt : (%, Integer) -> R
from EltableAggregate(Integer, R)
random : () -> % if R has Finite
from Finite
recip : % -> Union(%, "failed") if R has Monoid
from MagmaWithUnit
reducedSystem : Matrix(%) -> Matrix(R) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R)) if R has Ring
from LinearlyExplicitOver(R)
reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(Integer), vec : Vector(Integer)) if R has LinearlyExplicitOver(Integer) and R has Ring
from LinearlyExplicitOver(Integer)
retract : % -> R if R has SetCategory
from RetractableTo(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)
retractIfCan : % -> Union(R, "failed") 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)
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 MagmaWithUnit
size : () -> NonNegativeInteger if R has Finite
from Finite
size? : (%, NonNegativeInteger) -> Boolean
from Aggregate
smaller? : (%, %) -> Boolean if R has Finite or R has OrderedSet
from Comparable
subtractIfCan : (%, %) -> Union(%, "failed") if R has CancellationAbelianMonoid
from CancellationAbelianMonoid
sup : (%, %) -> % if R has OrderedAbelianMonoidSup
from OrderedAbelianMonoidSup
unitVector : PositiveInteger -> % if R has AbelianMonoid and R has Monoid
from DirectProductCategory(dim, R)
zero? : % -> Boolean if R has AbelianMonoid or % has AbelianMonoid and R has SemiRng
from AbelianMonoid
~= : (%, %) -> Boolean if R has BasicType
from BasicType

PartialOrder

NonAssociativeSemiRing

LeftModule(R)

Evalable(R)

ConvertibleTo(InputForm)

Rng

BiModule(R, R)

IndexedAggregate(Integer, R)

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

CoercibleTo(Vector(R))

unitsKnown

FullyLinearlyExplicitOver(R)

NonAssociativeRng

LinearlyExplicitOver(Integer)

RetractableTo(Fraction(Integer))

OrderedSet

Magma

SemiGroup

RightModule(R)

LeftModule(%)

NonAssociativeRing

finiteAggregate

PartialDifferentialRing(Symbol)

EltableAggregate(Integer, R)

Module(R)

BiModule(%, %)

CommutativeRing

Algebra(%)

DifferentialRing

Algebra(R)

DirectProductCategory(dim, R)

InnerEvalable(R, R)

CancellationAbelianMonoid

Comparable

RetractableTo(Integer)

OrderedCancellationAbelianMonoid

SetCategory

OrderedAbelianMonoid

LinearlyExplicitOver(R)

AbelianMonoid

MagmaWithUnit

RightModule(%)

AbelianProductCategory(R)

Hashable

CommutativeStar

HomogeneousAggregate(R)

OrderedAbelianSemiGroup

Module(%)

CoercibleTo(OutputForm)

DifferentialExtension(R)

Ring

SemiRng

Monoid

NonAssociativeAlgebra(%)

Finite

Aggregate

BasicType

RightModule(Integer)

OrderedAbelianMonoidSup

AbelianSemiGroup

CoercibleFrom(Fraction(Integer))

NonAssociativeSemiRng

CoercibleFrom(R)

RetractableTo(R)

Eltable(Integer, R)

AbelianGroup

NonAssociativeAlgebra(R)