GeneralDistributedMultivariatePolynomial(vl, R, E)ΒΆ

gdpoly.spad line 1

This type supports distributed multivariate polynomials whose variables are from a user specified list of symbols. The coefficient ring may be non commutative, but the variables are assumed to commute. The term ordering is specified by its third parameter. Suggested types which define term orderings include: DirectProduct, HomogeneousDirectProduct, SplitHomogeneousDirectProduct and finally OrderedDirectProduct which accepts an arbitrary user function to define a term ordering.

0: %
from AbelianMonoid
1: %
from MagmaWithUnit
*: (%, %) -> %
from Magma
*: (%, Fraction Integer) -> % if R has Algebra Fraction Integer
from RightModule Fraction Integer
*: (%, R) -> %
from RightModule R
*: (Fraction Integer, %) -> % if R has Algebra Fraction Integer
from LeftModule Fraction Integer
*: (Integer, %) -> %
from AbelianGroup
*: (NonNegativeInteger, %) -> %
from AbelianMonoid
*: (PositiveInteger, %) -> %
from AbelianSemiGroup
*: (R, %) -> %
from LeftModule R
+: (%, %) -> %
from AbelianSemiGroup
-: % -> %
from AbelianGroup
-: (%, %) -> %
from AbelianGroup
/: (%, R) -> % if R has Field
from AbelianMonoidRing(R, E)
=: (%, %) -> Boolean
from BasicType
^: (%, NonNegativeInteger) -> %
from MagmaWithUnit
^: (%, PositiveInteger) -> %
from Magma
~=: (%, %) -> Boolean
from BasicType
annihilate?: (%, %) -> Boolean
from Rng
antiCommutator: (%, %) -> %
from NonAssociativeSemiRng
associates?: (%, %) -> Boolean if R has EntireRing
from EntireRing
associator: (%, %, %) -> %
from NonAssociativeRng
binomThmExpt: (%, %, NonNegativeInteger) -> % if % has CommutativeRing
from FiniteAbelianMonoidRing(R, E)
characteristic: () -> NonNegativeInteger
from NonAssociativeRing
charthRoot: % -> Union(%, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero
from PolynomialFactorizationExplicit
coefficient: (%, E) -> R
from AbelianMonoidRing(R, E)
coefficient: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
coefficient: (%, OrderedVariableList vl, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
coefficients: % -> List R
from FiniteAbelianMonoidRing(R, E)
coerce: % -> % if R has CommutativeRing
from Algebra %
coerce: % -> OutputForm
from CoercibleTo OutputForm
coerce: Fraction Integer -> % if R has Algebra Fraction Integer or R has RetractableTo Fraction Integer
from Algebra Fraction Integer
coerce: Integer -> %
from NonAssociativeRing
coerce: OrderedVariableList vl -> %
from RetractableTo OrderedVariableList vl
coerce: R -> %
from Algebra R
commutator: (%, %) -> %
from NonAssociativeRng
conditionP: Matrix % -> Union(Vector %, failed) if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
content: % -> R if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
content: (%, OrderedVariableList vl) -> % if R has GcdDomain
from PolynomialCategory(R, E, OrderedVariableList vl)
convert: % -> InputForm if R has ConvertibleTo InputForm
from ConvertibleTo InputForm
convert: % -> Pattern Float if R has ConvertibleTo Pattern Float
from ConvertibleTo Pattern Float
convert: % -> Pattern Integer if R has ConvertibleTo Pattern Integer
from ConvertibleTo Pattern Integer
D: (%, List OrderedVariableList vl) -> %
from PartialDifferentialRing OrderedVariableList vl
D: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
from PartialDifferentialRing OrderedVariableList vl
D: (%, OrderedVariableList vl) -> %
from PartialDifferentialRing OrderedVariableList vl
D: (%, OrderedVariableList vl, NonNegativeInteger) -> %
from PartialDifferentialRing OrderedVariableList vl
degree: % -> E
from AbelianMonoidRing(R, E)
degree: (%, List OrderedVariableList vl) -> List NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
degree: (%, OrderedVariableList vl) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
differentiate: (%, List OrderedVariableList vl) -> %
from PartialDifferentialRing OrderedVariableList vl
differentiate: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
from PartialDifferentialRing OrderedVariableList vl
differentiate: (%, OrderedVariableList vl) -> %
from PartialDifferentialRing OrderedVariableList vl
differentiate: (%, OrderedVariableList vl, NonNegativeInteger) -> %
from PartialDifferentialRing OrderedVariableList vl
discriminant: (%, OrderedVariableList vl) -> % if R has CommutativeRing
from PolynomialCategory(R, E, OrderedVariableList vl)
eval: (%, %, %) -> %
from InnerEvalable(%, %)
eval: (%, Equation %) -> %
from Evalable %
eval: (%, List %, List %) -> %
from InnerEvalable(%, %)
eval: (%, List Equation %) -> %
from Evalable %
eval: (%, List OrderedVariableList vl, List %) -> %
from InnerEvalable(OrderedVariableList vl, %)
eval: (%, List OrderedVariableList vl, List R) -> %
from InnerEvalable(OrderedVariableList vl, R)
eval: (%, OrderedVariableList vl, %) -> %
from InnerEvalable(OrderedVariableList vl, %)
eval: (%, OrderedVariableList vl, R) -> %
from InnerEvalable(OrderedVariableList vl, R)
exquo: (%, %) -> Union(%, failed) if R has EntireRing
from EntireRing
exquo: (%, R) -> Union(%, failed) if R has EntireRing
from FiniteAbelianMonoidRing(R, E)
factor: % -> Factored % if R has PolynomialFactorizationExplicit
from UniqueFactorizationDomain
factorPolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
factorSquareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
fmecg: (%, E, R, %) -> %
from FiniteAbelianMonoidRing(R, E)
gcd: (%, %) -> % if R has GcdDomain
from GcdDomain
gcd: List % -> % if R has GcdDomain
from GcdDomain
gcdPolynomial: (SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> SparseUnivariatePolynomial % if R has GcdDomain
from PolynomialFactorizationExplicit
ground: % -> R
from FiniteAbelianMonoidRing(R, E)
ground?: % -> Boolean
from FiniteAbelianMonoidRing(R, E)
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
isExpt: % -> Union(Record(var: OrderedVariableList vl, exponent: NonNegativeInteger), failed)
from PolynomialCategory(R, E, OrderedVariableList vl)
isPlus: % -> Union(List %, failed)
from PolynomialCategory(R, E, OrderedVariableList vl)
isTimes: % -> Union(List %, failed)
from PolynomialCategory(R, E, OrderedVariableList vl)
latex: % -> String
from SetCategory
lcm: (%, %) -> % if R has GcdDomain
from GcdDomain
lcm: List % -> % if R has GcdDomain
from GcdDomain
lcmCoef: (%, %) -> Record(llcm_res: %, coeff1: %, coeff2: %) if R has GcdDomain
from LeftOreRing
leadingCoefficient: % -> R
from AbelianMonoidRing(R, E)
leadingMonomial: % -> %
from AbelianMonoidRing(R, E)
leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
leftPower: (%, PositiveInteger) -> %
from Magma
leftRecip: % -> Union(%, failed)
from MagmaWithUnit
mainVariable: % -> Union(OrderedVariableList vl, failed)
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
map: (R -> R, %) -> %
from AbelianMonoidRing(R, E)
mapExponents: (E -> E, %) -> %
from FiniteAbelianMonoidRing(R, E)
minimumDegree: % -> E
from FiniteAbelianMonoidRing(R, E)
minimumDegree: (%, List OrderedVariableList vl) -> List NonNegativeInteger
from PolynomialCategory(R, E, OrderedVariableList vl)
minimumDegree: (%, OrderedVariableList vl) -> NonNegativeInteger
from PolynomialCategory(R, E, OrderedVariableList vl)
monicDivide: (%, %, OrderedVariableList vl) -> Record(quotient: %, remainder: %)
from PolynomialCategory(R, E, OrderedVariableList vl)
monomial: (%, List OrderedVariableList vl, List NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
monomial: (%, OrderedVariableList vl, NonNegativeInteger) -> %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
monomial: (R, E) -> %
from AbelianMonoidRing(R, E)
monomial?: % -> Boolean
from AbelianMonoidRing(R, E)
monomials: % -> List %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
multivariate: (SparseUnivariatePolynomial %, OrderedVariableList vl) -> %
from PolynomialCategory(R, E, OrderedVariableList vl)
multivariate: (SparseUnivariatePolynomial R, OrderedVariableList vl) -> %
from PolynomialCategory(R, E, OrderedVariableList vl)
numberOfMonomials: % -> NonNegativeInteger
from FiniteAbelianMonoidRing(R, E)
one?: % -> Boolean
from MagmaWithUnit
opposite?: (%, %) -> Boolean
from AbelianMonoid
patternMatch: (%, Pattern Float, PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if OrderedVariableList vl has PatternMatchable Float and R has PatternMatchable Float
from PatternMatchable Float
patternMatch: (%, Pattern Integer, PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if OrderedVariableList vl has PatternMatchable Integer and R has PatternMatchable Integer
from PatternMatchable Integer
pomopo!: (%, R, E, %) -> %
from FiniteAbelianMonoidRing(R, E)
prime?: % -> Boolean if R has PolynomialFactorizationExplicit
from UniqueFactorizationDomain
primitiveMonomials: % -> List %
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
primitivePart: % -> % if R has GcdDomain
from PolynomialCategory(R, E, OrderedVariableList vl)
primitivePart: (%, OrderedVariableList vl) -> % if R has GcdDomain
from PolynomialCategory(R, E, OrderedVariableList vl)
recip: % -> Union(%, failed)
from MagmaWithUnit
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix Integer, vec: Vector Integer) if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: (Matrix %, Vector %) -> Record(mat: Matrix R, vec: Vector R)
from LinearlyExplicitOver R
reducedSystem: Matrix % -> Matrix Integer if R has LinearlyExplicitOver Integer
from LinearlyExplicitOver Integer
reducedSystem: Matrix % -> Matrix R
from LinearlyExplicitOver R
reductum: % -> %
from AbelianMonoidRing(R, E)
reorder: (%, List Integer) -> %
reorder(p, perm) applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial
resultant: (%, %, OrderedVariableList vl) -> % if R has CommutativeRing
from PolynomialCategory(R, E, OrderedVariableList vl)
retract: % -> Fraction Integer if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retract: % -> Integer if R has RetractableTo Integer
from RetractableTo Integer
retract: % -> OrderedVariableList vl
from RetractableTo OrderedVariableList vl
retract: % -> R
from RetractableTo R
retractIfCan: % -> Union(Fraction Integer, failed) if R has RetractableTo Fraction Integer
from RetractableTo Fraction Integer
retractIfCan: % -> Union(Integer, failed) if R has RetractableTo Integer
from RetractableTo Integer
retractIfCan: % -> Union(OrderedVariableList vl, failed)
from RetractableTo OrderedVariableList vl
retractIfCan: % -> Union(R, failed)
from RetractableTo R
rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit
rightPower: (%, PositiveInteger) -> %
from Magma
rightRecip: % -> Union(%, failed)
from MagmaWithUnit
sample: %
from AbelianMonoid
smaller?: (%, %) -> Boolean if R has Comparable
from Comparable
solveLinearPolynomialEquation: (List SparseUnivariatePolynomial %, SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial %, failed) if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
squareFree: % -> Factored % if R has GcdDomain
from PolynomialCategory(R, E, OrderedVariableList vl)
squareFreePart: % -> % if R has GcdDomain
from PolynomialCategory(R, E, OrderedVariableList vl)
squareFreePolynomial: SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial % if R has PolynomialFactorizationExplicit
from PolynomialFactorizationExplicit
subtractIfCan: (%, %) -> Union(%, failed)
from CancellationAbelianMonoid
totalDegree: % -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
totalDegree: (%, List OrderedVariableList vl) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
totalDegreeSorted: (%, List OrderedVariableList vl) -> NonNegativeInteger
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
unit?: % -> Boolean if R has EntireRing
from EntireRing
unitCanonical: % -> % if R has EntireRing
from EntireRing
unitNormal: % -> Record(unit: %, canonical: %, associate: %) if R has EntireRing
from EntireRing
univariate: % -> SparseUnivariatePolynomial R
from PolynomialCategory(R, E, OrderedVariableList vl)
univariate: (%, OrderedVariableList vl) -> SparseUnivariatePolynomial %
from PolynomialCategory(R, E, OrderedVariableList vl)
variables: % -> List OrderedVariableList vl
from MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)
zero?: % -> Boolean
from AbelianMonoid

AbelianGroup

AbelianMonoid

AbelianMonoidRing(R, E)

AbelianSemiGroup

Algebra % if R has CommutativeRing

Algebra Fraction Integer if R has Algebra Fraction Integer

Algebra R if R has CommutativeRing

BasicType

BiModule(%, %)

BiModule(Fraction Integer, Fraction Integer) if R has Algebra Fraction Integer

BiModule(R, R)

CancellationAbelianMonoid

canonicalUnitNormal if R has canonicalUnitNormal

CharacteristicNonZero if R has CharacteristicNonZero

CharacteristicZero if R has CharacteristicZero

CoercibleTo OutputForm

CommutativeRing if R has CommutativeRing

CommutativeStar if R has CommutativeRing

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

ConvertibleTo Pattern Float if R has ConvertibleTo Pattern Float

ConvertibleTo Pattern Integer if R has ConvertibleTo Pattern Integer

EntireRing if R has EntireRing

Evalable %

FiniteAbelianMonoidRing(R, E)

FullyLinearlyExplicitOver R

FullyRetractableTo R

GcdDomain if R has GcdDomain

InnerEvalable(%, %)

InnerEvalable(OrderedVariableList vl, %)

InnerEvalable(OrderedVariableList vl, R)

IntegralDomain if R has IntegralDomain

LeftModule %

LeftModule Fraction Integer if R has Algebra Fraction Integer

LeftModule R

LeftOreRing if R has GcdDomain

LinearlyExplicitOver Integer if R has LinearlyExplicitOver Integer

LinearlyExplicitOver R

Magma

MagmaWithUnit

MaybeSkewPolynomialCategory(R, E, OrderedVariableList vl)

Module % if R has CommutativeRing

Module Fraction Integer if R has Algebra Fraction Integer

Module R if R has CommutativeRing

Monoid

NonAssociativeRing

NonAssociativeRng

NonAssociativeSemiRing

NonAssociativeSemiRng

noZeroDivisors if R has EntireRing

PartialDifferentialRing OrderedVariableList vl

PatternMatchable Float if OrderedVariableList vl has PatternMatchable Float and R has PatternMatchable Float

PatternMatchable Integer if OrderedVariableList vl has PatternMatchable Integer and R has PatternMatchable Integer

PolynomialCategory(R, E, OrderedVariableList vl)

PolynomialFactorizationExplicit if R has PolynomialFactorizationExplicit

RetractableTo Fraction Integer if R has RetractableTo Fraction Integer

RetractableTo Integer if R has RetractableTo Integer

RetractableTo OrderedVariableList vl

RetractableTo R

RightModule %

RightModule Fraction Integer if R has Algebra Fraction Integer

RightModule R

Ring

Rng

SemiGroup

SemiRing

SemiRng

SetCategory

UniqueFactorizationDomain if R has PolynomialFactorizationExplicit

unitsKnown

VariablesCommuteWithCoefficients