SplitHomogeneousDirectProduct(dimtot, dim1, S)

gdirprod.spad line 130 [edit on github]

• dimtot : NonNegativeInteger
• dim1 : NonNegativeInteger
• S : OrderedAbelianMonoid

This type represents the finite direct or cartesian product of an underlying ordered component type. The vectors are ordered as if they were split into two blocks. The dim1 parameter specifies the length of the first block. The ordering is lexicographic between the blocks but acts like HomogeneousDirectProduct within each block. This type is a suitable third argument for GeneralDistributedMultivariatePolynomial.

# : % -> NonNegativeInteger

from Aggregate

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

from Magma

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

from DirectProductCategory(dimtot, S)

* : (%, Integer) -> % if S has LinearlyExplicitOver(Integer) and S has Ring

from RightModule(Integer)

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

from DirectProductCategory(dimtot, S)

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

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

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

from AbelianGroup

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

from AbelianGroup

0 : () -> %

from AbelianMonoid

1 : () -> % if S has Monoid

from MagmaWithUnit

< : (%, %) -> Boolean

from PartialOrder

<= : (%, %) -> Boolean

from PartialOrder

= : (%, %) -> Boolean

from BasicType

> : (%, %) -> Boolean

from PartialOrder

>= : (%, %) -> Boolean

from PartialOrder

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(S)

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

from DifferentialExtension(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from NonAssociativeSemiRng

any? : (Mapping(Boolean, S), %) -> 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 : S -> %

from Algebra(S)

coerce : Fraction(Integer) -> % if S has RetractableTo(Fraction(Integer))

from CoercibleFrom(Fraction(Integer))

coerce : Integer -> % if S has Ring or S has RetractableTo(Integer)

from NonAssociativeRing

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

coerce : % -> Vector(S)

from CoercibleTo(Vector(S))

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

from NonAssociativeRng

convert : % -> InputForm if S has Finite

from ConvertibleTo(InputForm)

copy : % -> %

from Aggregate

count : (S, %) -> NonNegativeInteger

from HomogeneousAggregate(S)

count : (Mapping(Boolean, S), %) -> NonNegativeInteger

from HomogeneousAggregate(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

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

from DifferentialExtension(S)

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

from DifferentialExtension(S)

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

from DifferentialRing

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

from PartialDifferentialRing(Symbol)

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

from PartialDifferentialRing(Symbol)

directProduct : Vector(S) -> %

from DirectProductCategory(dimtot, S)

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

from DirectProductCategory(dimtot, S)

elt : (%, Integer) -> S

from Eltable(Integer, S)

elt : (%, Integer, S) -> S

from EltableAggregate(Integer, S)

empty : () -> %

from Aggregate

empty? : % -> Boolean

from Aggregate

entries : % -> List(S)

from IndexedAggregate(Integer, S)

entry? : (S, %) -> Boolean

from IndexedAggregate(Integer, S)

enumerate : () -> List(%) if S has Finite

from Finite

eq? : (%, %) -> Boolean

from Aggregate

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

from InnerEvalable(S, S)

eval : (%, 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 : (%, List(Equation(S))) -> % if S has Evalable(S)

from Evalable(S)

every? : (Mapping(Boolean, S), %) -> Boolean

from HomogeneousAggregate(S)

first : % -> S

from IndexedAggregate(Integer, S)

hash : % -> SingleInteger if S has Finite

from Hashable

hashUpdate! : (HashState, %) -> HashState if S has Finite

from Hashable

index : PositiveInteger -> % if S has Finite

from Finite

index? : (Integer, %) -> Boolean

from IndexedAggregate(Integer, S)

indices : % -> List(Integer)

from IndexedAggregate(Integer, S)

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

from OrderedAbelianMonoidSup

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

from HomogeneousAggregate(S)

max : (%, %) -> %

from OrderedSet

max : % -> S

from HomogeneousAggregate(S)

max : (Mapping(Boolean, S, S), %) -> S

from HomogeneousAggregate(S)

maxIndex : % -> Integer

from IndexedAggregate(Integer, S)

member? : (S, %) -> Boolean

from HomogeneousAggregate(S)

members : % -> List(S)

from HomogeneousAggregate(S)

min : (%, %) -> %

from OrderedSet

min : % -> S

from HomogeneousAggregate(S)

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)

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

from NonAssociativeAlgebra(S)

qelt : (%, Integer) -> S

from EltableAggregate(Integer, S)

random : () -> % if S has Finite

from Finite

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

from MagmaWithUnit

reducedSystem : Matrix(%) -> Matrix(S) if S has Ring

from LinearlyExplicitOver(S)

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

from LinearlyExplicitOver(Integer)

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

from LinearlyExplicitOver(S)

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

from LinearlyExplicitOver(Integer)

retract : % -> S

from RetractableTo(S)

retract : % -> Fraction(Integer) if S has RetractableTo(Fraction(Integer))

from RetractableTo(Fraction(Integer))

retract : % -> Integer if S has RetractableTo(Integer)

from RetractableTo(Integer)

retractIfCan : % -> Union(S, "failed")

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)

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 if S has Finite

from Finite

size? : (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller? : (%, %) -> Boolean

from Comparable

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

from CancellationAbelianMonoid

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

from OrderedAbelianMonoidSup

unitVector : PositiveInteger -> % if S has Monoid

from DirectProductCategory(dimtot, S)

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

LinearlyExplicitOver(S)

PartialOrder

NonAssociativeSemiRing

BiModule(%, %)

HomogeneousAggregate(S)

ConvertibleTo(InputForm)

DirectProductCategory(dimtot, S)

Rng

CoercibleFrom(Integer)

TwoSidedRecip

SemiRing

Aggregate

DifferentialExtension(S)

unitsKnown

CoercibleTo(Vector(S))

NonAssociativeAlgebra(S)

FullyRetractableTo(S)

LinearlyExplicitOver(Integer)

RetractableTo(Fraction(Integer))

EltableAggregate(Integer, S)

OrderedSet

Magma

SemiGroup

LeftModule(%)

NonAssociativeRing

finiteAggregate

PartialDifferentialRing(Symbol)

RightModule(S)

CoercibleFrom(Fraction(Integer))

Algebra(%)

DifferentialRing

CommutativeRing

Evalable(S)

NonAssociativeSemiRng

CancellationAbelianMonoid

Module(S)

Comparable

RetractableTo(Integer)

OrderedCancellationAbelianMonoid

OrderedAbelianMonoid

SetCategory

InnerEvalable(S, S)

AbelianMonoid

MagmaWithUnit

RightModule(%)

Hashable

CoercibleFrom(S)

CommutativeStar

RetractableTo(S)

LeftModule(S)

OrderedAbelianSemiGroup

Module(%)

CoercibleTo(OutputForm)

Ring

Eltable(Integer, S)

SemiRng

IndexedAggregate(Integer, S)

Monoid

NonAssociativeAlgebra(%)

Finite

Algebra(S)

BiModule(S, S)

BasicType

RightModule(Integer)

OrderedAbelianMonoidSup

AbelianSemiGroup

FullyLinearlyExplicitOver(S)

NonAssociativeRng

AbelianGroup

AbelianProductCategory(S)