# OrderedDirectProduct(dim, S, f)ΒΆ

gdirprod.spad line 69 [edit on github]

dim: NonNegativeInteger

This type represents the finite direct or cartesian product of an underlying ordered component type. The ordering on the type is determined by its third argument which represents the less than function on vectors. This type is a suitable third argument for GeneralDistributedMultivariatePolynomial.

- 0: %
from AbelianMonoid

- 1: % if S has Monoid
from MagmaWithUnit

- #: % -> NonNegativeInteger
from Aggregate

- *: (%, %) -> % if S has SemiGroup
from LeftModule %

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

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

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

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

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> % if S has AbelianGroup or % has AbelianGroup and S has SemiRng
from AbelianGroup

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

- <=: (%, %) -> Boolean
from PartialOrder

- <: (%, %) -> Boolean
from PartialOrder

- >=: (%, %) -> Boolean
from PartialOrder

- >: (%, %) -> Boolean
from PartialOrder

- ^: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- ^: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- annihilate?: (%, %) -> Boolean if S has Ring
from Rng

- antiCommutator: (%, %) -> % if S has SemiRng

- any?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S

- associator: (%, %, %) -> % if S has Ring
from NonAssociativeRng

- characteristic: () -> NonNegativeInteger if S has Ring
from NonAssociativeRing

- coerce: % -> % if S has CommutativeRing
from Algebra %

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: % -> Vector S
from CoercibleTo Vector S

- coerce: Fraction Integer -> % if S has RetractableTo Fraction Integer
from CoercibleFrom Fraction Integer

- coerce: Integer -> % if S has RetractableTo Integer or S has Ring
from NonAssociativeRing

- coerce: S -> %
from Algebra S

- commutator: (%, %) -> % if S has Ring
from NonAssociativeRng

- convert: % -> InputForm if S has Finite
from ConvertibleTo InputForm

- count: (S -> Boolean, %) -> NonNegativeInteger
from HomogeneousAggregate S

- count: (S, %) -> NonNegativeInteger
from HomogeneousAggregate S

- D: % -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- D: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- D: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring
- D: (%, NonNegativeInteger) -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- D: (%, S -> S) -> % if S has Ring
from DifferentialExtension S

- D: (%, S -> S, NonNegativeInteger) -> % if S has Ring
from DifferentialExtension S

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

- differentiate: % -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- differentiate: (%, List Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, List Symbol, List NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, NonNegativeInteger) -> % if S has DifferentialRing and S has Ring
from DifferentialRing

- differentiate: (%, S -> S) -> % if S has Ring
from DifferentialExtension S

- differentiate: (%, S -> S, NonNegativeInteger) -> % if S has Ring
from DifferentialExtension S

- differentiate: (%, Symbol) -> % if S has PartialDifferentialRing Symbol and S has Ring
- differentiate: (%, Symbol, NonNegativeInteger) -> % if S has PartialDifferentialRing Symbol and S has Ring

- directProduct: Vector S -> %
from DirectProductCategory(dim, S)

- dot: (%, %) -> S if S has SemiRng
from DirectProductCategory(dim, S)

- entries: % -> List S
from IndexedAggregate(Integer, S)

- entry?: (S, %) -> Boolean
from IndexedAggregate(Integer, S)

- eval: (%, Equation S) -> % if S has Evalable S
from Evalable S

- eval: (%, List Equation S) -> % if S has Evalable S
from Evalable S

- eval: (%, List S, List S) -> % if S has Evalable S
from InnerEvalable(S, S)

- eval: (%, S, S) -> % if S has Evalable S
from InnerEvalable(S, S)

- every?: (S -> Boolean, %) -> Boolean
from HomogeneousAggregate S

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

- hash: % -> SingleInteger
from SetCategory

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

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

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

- indices: % -> List Integer
from IndexedAggregate(Integer, S)

- latex: % -> String
from SetCategory

- leftPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- leftRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

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

- lookup: % -> PositiveInteger if S has Finite
from Finite

- map: (S -> S, %) -> %
from HomogeneousAggregate S

- max: % -> S
from HomogeneousAggregate S

- max: (%, %) -> %
from OrderedSet

- max: ((S, S) -> Boolean, %) -> S
from HomogeneousAggregate S

- maxIndex: % -> Integer
from IndexedAggregate(Integer, S)

- member?: (S, %) -> Boolean
from HomogeneousAggregate S

- members: % -> List S
from HomogeneousAggregate S

- min: % -> S
from HomogeneousAggregate S

- min: (%, %) -> %
from OrderedSet

- minIndex: % -> Integer
from IndexedAggregate(Integer, S)

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

- one?: % -> Boolean if S has Monoid
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- parts: % -> List S
from HomogeneousAggregate S

- qelt: (%, Integer) -> S
from EltableAggregate(Integer, S)

- recip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if S has Ring and S has LinearlyExplicitOver Integer
- reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix S, vec: Vector S) if S has Ring
from LinearlyExplicitOver S

- reducedSystem: Matrix % -> Matrix Integer if S has Ring and S has LinearlyExplicitOver Integer
- reducedSystem: Matrix % -> Matrix S if S has Ring
from LinearlyExplicitOver S

- retract: % -> Fraction Integer if S has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retract: % -> Integer if S has RetractableTo Integer
from RetractableTo Integer

- retract: % -> S
from RetractableTo S

- retractIfCan: % -> Union(Fraction Integer, failed) if S has RetractableTo Fraction Integer
from RetractableTo Fraction Integer

- retractIfCan: % -> Union(Integer, failed) if S has RetractableTo Integer
from RetractableTo Integer

- retractIfCan: % -> Union(S, failed)
from RetractableTo S

- rightPower: (%, NonNegativeInteger) -> % if S has Monoid
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> % if S has SemiGroup
from Magma

- rightRecip: % -> Union(%, failed) if S has Monoid
from MagmaWithUnit

- sample: %
from AbelianMonoid

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

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

- smaller?: (%, %) -> Boolean
from Comparable

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

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

- unitVector: PositiveInteger -> % if S has Monoid
from DirectProductCategory(dim, S)

- zero?: % -> Boolean
from AbelianMonoid

AbelianGroup if S has AbelianGroup

Algebra % if S has CommutativeRing

Algebra S if S has CommutativeRing

BiModule(%, %) if S has SemiRng

BiModule(S, S) if S has SemiRng

CancellationAbelianMonoid if S has CancellationAbelianMonoid

CoercibleFrom Fraction Integer if S has RetractableTo Fraction Integer

CoercibleFrom Integer if S has RetractableTo Integer

CommutativeRing if S has CommutativeRing

CommutativeStar if S has CommutativeRing

ConvertibleTo InputForm if S has Finite

DifferentialExtension S if S has Ring

DifferentialRing if S has DifferentialRing and S has Ring

DirectProductCategory(dim, S)

Evalable S if S has Evalable S

FullyLinearlyExplicitOver S if S has Ring

InnerEvalable(S, S) if S has Evalable S

LeftModule % if S has SemiRng

LeftModule S if S has SemiRng

LinearlyExplicitOver Integer if S has Ring and S has LinearlyExplicitOver Integer

LinearlyExplicitOver S if S has Ring

MagmaWithUnit if S has Monoid

Module % if S has CommutativeRing

Module S if S has CommutativeRing

NonAssociativeRing if S has Ring

NonAssociativeRng if S has Ring

NonAssociativeSemiRing if S has Ring

NonAssociativeSemiRng if S has SemiRng

OrderedAbelianMonoidSup if S has OrderedAbelianMonoidSup

OrderedCancellationAbelianMonoid if S has OrderedAbelianMonoidSup

PartialDifferentialRing Symbol if S has PartialDifferentialRing Symbol and S has Ring

RetractableTo Fraction Integer if S has RetractableTo Fraction Integer

RetractableTo Integer if S has RetractableTo Integer

RightModule % if S has SemiRng

RightModule S if S has SemiRng

TwoSidedRecip if S has CommutativeRing

unitsKnown if S has unitsKnown