DirectProductCategory(dim, R)ΒΆ

vector.spad line 244 [edit on github]

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

0: % if % has AbelianMonoid and R has SemiRng 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 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

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

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

+: (%, %) -> % 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

<=: (%, %) -> 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 CoercibleFrom Fraction Integer

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

from NonAssociativeRing

coerce: R -> % if R has SetCategory

from Algebra 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 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: (%, 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

from PartialDifferentialRing Symbol

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

from PartialDifferentialRing Symbol

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: (%, 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

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?: % -> Boolean

from Aggregate

empty: () -> %

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 Evalable R and R has SetCategory

from Evalable R

eval: (%, List 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: (%, R, R) -> % if R has Evalable R and R has SetCategory

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

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!: (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 % 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 %, Vector %) -> Record(mat: Matrix Integer, vec: Vector 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 % -> Matrix Integer if R has LinearlyExplicitOver Integer and R has Ring

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 MagmaWithUnit

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

AbelianGroup if R has AbelianGroup

AbelianMonoid if R has AbelianMonoid

AbelianProductCategory R

AbelianSemiGroup if R has SemiRng or R has AbelianMonoid

Aggregate

Algebra % if R has CommutativeRing

Algebra R if R has CommutativeRing

BasicType if R has BasicType

BiModule(%, %) if R has SemiRng

BiModule(R, R) if R has SemiRng

CancellationAbelianMonoid if R has CancellationAbelianMonoid

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

CoercibleFrom Integer if R has RetractableTo Integer and R has SetCategory

CoercibleFrom R if R has SetCategory

CoercibleTo OutputForm if R has CoercibleTo OutputForm

CoercibleTo Vector R

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

Eltable(Integer, R)

EltableAggregate(Integer, R)

Evalable R if R has Evalable R and R has SetCategory

Finite if R has Finite

finiteAggregate

FullyLinearlyExplicitOver R if R has Ring

FullyRetractableTo R if R has SetCategory

Hashable if R has Finite

HomogeneousAggregate R

IndexedAggregate(Integer, R)

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

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

Magma if R has SemiGroup

MagmaWithUnit if R has Monoid

Module % if R has CommutativeRing

Module R if R has CommutativeRing

Monoid if R has Monoid

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

RightModule R if R has SemiRng

Ring if R has Ring

Rng if R has Ring

SemiGroup if R has SemiGroup

SemiRing if R has Ring

SemiRng if R has SemiRng

SetCategory if R has SetCategory

TwoSidedRecip if R has CommutativeRing

unitsKnown if R has unitsKnown