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.

# : % -> 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 R has LinearlyExplicitOver(Integer) and R has Ring

from RightModule(Integer)

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

r * y multiplies the element r times each component of the vector y.

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

from AbelianGroup

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

from AbelianMonoid

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

from AbelianSemiGroup

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

from AbelianSemiGroup

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

from AbelianGroup

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

from AbelianGroup

0 : () -> % if % has AbelianMonoid and R has SemiRng or R has AbelianMonoid

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 Ring or R has RetractableTo(Integer) and R has SetCategory

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) -> %

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.

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)

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 : 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)

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

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

from AbelianMonoid

parts : % -> List(R)

from HomogeneousAggregate(R)

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

from NonAssociativeAlgebra(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(%) -> 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

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 AbelianMonoid and R has Monoid

unitVector(n) produces a vector with 1 in position n and zero elsewhere.

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

from AbelianMonoid

~= : (%, %) -> Boolean if R has BasicType

from BasicType

NonAssociativeSemiRing

LeftModule(R)

Evalable(R)

DifferentialRing

ConvertibleTo(InputForm)

Rng

IndexedAggregate(Integer, R)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

CoercibleTo(Vector(R))

unitsKnown

FullyLinearlyExplicitOver(R)

MagmaWithUnit

RetractableTo(Fraction(Integer))

OrderedSet

SemiGroup

Magma

RightModule(R)

LeftModule(%)

NonAssociativeRing

finiteAggregate

PartialDifferentialRing(Symbol)

EltableAggregate(Integer, R)

Module(R)

BiModule(%, %)

CoercibleFrom(Fraction(Integer))

Algebra(%)

BiModule(R, R)

Algebra(R)

CommutativeRing

PartialOrder

InnerEvalable(R, R)

NonAssociativeSemiRng

Aggregate

CoercibleFrom(Integer)

CancellationAbelianMonoid

Comparable

RetractableTo(Integer)

OrderedCancellationAbelianMonoid

OrderedAbelianMonoid

AbelianMonoid

RightModule(%)

AbelianProductCategory(R)

Hashable

CommutativeStar

HomogeneousAggregate(R)

OrderedAbelianSemiGroup

Module(%)

CoercibleTo(OutputForm)

LinearlyExplicitOver(Integer)

DifferentialExtension(R)

SemiRng

Monoid

NonAssociativeAlgebra(%)

Finite

BasicType

Ring

RightModule(Integer)

OrderedAbelianMonoidSup

AbelianSemiGroup

SetCategory

LinearlyExplicitOver(R)

NonAssociativeRng

CoercibleFrom(R)

RetractableTo(R)

Eltable(Integer, R)

AbelianGroup

NonAssociativeAlgebra(R)