DistributedMultivariatePolynomial(vl, R)

gdpoly.spad line 258 [edit on github]

• vl : List(Symbol)
• R : Ring

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 lexicographic specified by the variable list parameter with the most significant variable first in the list.

* : (%, %) -> %

from Magma

* : (%, R) -> %

from RightModule(R)

* : (%, Fraction(Integer)) -> % if R has Algebra(Fraction(Integer))

from RightModule(Fraction(Integer))

* : (%, Integer) -> % if R has LinearlyExplicitOver(Integer)

from RightModule(Integer)

* : (R, %) -> %

from LeftModule(R)

* : (Fraction(Integer), %) -> % if R has Algebra(Fraction(Integer))

from LeftModule(Fraction(Integer))

* : (Integer, %) -> %

from AbelianGroup

* : (NonNegativeInteger, %) -> %

from AbelianMonoid

* : (PositiveInteger, %) -> %

from AbelianSemiGroup

+ : (%, %) -> %

from AbelianSemiGroup

- : % -> %

from AbelianGroup

- : (%, %) -> %

from AbelianGroup

/ : (%, R) -> % if R has Field

from AbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

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

^ : (%, NonNegativeInteger) -> %

from MagmaWithUnit

^ : (%, PositiveInteger) -> %

from Magma

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, DirectProduct(#(vl), NonNegativeInteger))

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

charthRoot : % -> Union(%, "failed") if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit or R has CharacteristicNonZero

from PolynomialFactorizationExplicit

coefficient : (%, List(OrderedVariableList(vl)), List(NonNegativeInteger)) -> %

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

coefficient : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

coefficient : (%, DirectProduct(#(vl), NonNegativeInteger)) -> R

from AbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

coefficients : % -> List(R)

from FreeModuleCategory(R, DirectProduct(#(vl), NonNegativeInteger))

coerce : % -> % if R has CommutativeRing

from Algebra(%)

coerce : R -> %

from Algebra(R)

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 CoercibleFrom(OrderedVariableList(vl))

coerce : % -> OutputForm

from CoercibleTo(OutputForm)

commutator : (%, %) -> %

from NonAssociativeRng

conditionP : Matrix(%) -> Union(Vector(%), "failed") if % has CharacteristicNonZero and R has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

construct : List(Record(k : DirectProduct(#(vl), NonNegativeInteger), c : R)) -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

constructOrdered : List(Record(k : DirectProduct(#(vl), NonNegativeInteger), c : R)) -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

content : (%, OrderedVariableList(vl)) -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

content : % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

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

degree : % -> DirectProduct(#(vl), NonNegativeInteger)

from AbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

degree : (%, List(OrderedVariableList(vl))) -> List(NonNegativeInteger)

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

degree : (%, OrderedVariableList(vl)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), 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, DirectProduct(#(vl), NonNegativeInteger), 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, DirectProduct(#(vl), NonNegativeInteger))

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 : (%, DirectProduct(#(vl), NonNegativeInteger), R, %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

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, DirectProduct(#(vl), NonNegativeInteger))

ground? : % -> Boolean

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

hash : % -> SingleInteger if R has Hashable

from Hashable

hashUpdate! : (HashState, %) -> HashState if R has Hashable

from Hashable

isExpt : % -> Union(Record(var : OrderedVariableList(vl), exponent : NonNegativeInteger), "failed")

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

isPlus : % -> Union(List(%), "failed")

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

isTimes : % -> Union(List(%), "failed")

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), 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 IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

leadingMonomial : % -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

leadingSupport : % -> DirectProduct(#(vl), NonNegativeInteger)

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

leadingTerm : % -> Record(k : DirectProduct(#(vl), NonNegativeInteger), c : R)

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

leftRecip : % -> Union(%, "failed")

from MagmaWithUnit

linearExtend : (Mapping(R, DirectProduct(#(vl), NonNegativeInteger)), %) -> R if R has CommutativeRing

from FreeModuleCategory(R, DirectProduct(#(vl), NonNegativeInteger))

listOfTerms : % -> List(Record(k : DirectProduct(#(vl), NonNegativeInteger), c : R))

from IndexedDirectProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

mainVariable : % -> Union(OrderedVariableList(vl), "failed")

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

map : (Mapping(R, R), %) -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

mapExponents : (Mapping(DirectProduct(#(vl), NonNegativeInteger), DirectProduct(#(vl), NonNegativeInteger)), %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

minimumDegree : % -> DirectProduct(#(vl), NonNegativeInteger)

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

minimumDegree : (%, List(OrderedVariableList(vl))) -> List(NonNegativeInteger)

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

minimumDegree : (%, OrderedVariableList(vl)) -> NonNegativeInteger

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monicDivide : (%, %, OrderedVariableList(vl)) -> Record(quotient : %, remainder : %)

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monomial : (%, List(OrderedVariableList(vl)), List(NonNegativeInteger)) -> %

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monomial : (%, OrderedVariableList(vl), NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

monomial : (R, DirectProduct(#(vl), NonNegativeInteger)) -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

monomial? : % -> Boolean

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

monomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

multivariate : (SparseUnivariatePolynomial(%), OrderedVariableList(vl)) -> %

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

multivariate : (SparseUnivariatePolynomial(R), OrderedVariableList(vl)) -> %

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

numberOfMonomials : % -> NonNegativeInteger

from IndexedDirectProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

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)

plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra(Fraction(Integer))

from NonAssociativeAlgebra(%)

pomopo! : (%, R, DirectProduct(#(vl), NonNegativeInteger), %) -> %

from FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

prime? : % -> Boolean if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

primitiveMonomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

primitivePart : % -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

primitivePart : (%, OrderedVariableList(vl)) -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

recip : % -> Union(%, "failed")

from MagmaWithUnit

reducedSystem : Matrix(%) -> Matrix(R)

from LinearlyExplicitOver(R)

reducedSystem : Matrix(%) -> Matrix(Integer) if R has LinearlyExplicitOver(Integer)

from LinearlyExplicitOver(Integer)

reducedSystem : (Matrix(%), Vector(%)) -> Record(mat : Matrix(R), vec : Vector(R))

from LinearlyExplicitOver(R)

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

from LinearlyExplicitOver(Integer)

reductum : % -> %

from IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

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, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

retract : % -> R

from RetractableTo(R)

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

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

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

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, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

squareFreePart : % -> % if R has GcdDomain

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if R has PolynomialFactorizationExplicit

from PolynomialFactorizationExplicit

subtractIfCan : (%, %) -> Union(%, "failed")

from CancellationAbelianMonoid

support : % -> List(DirectProduct(#(vl), NonNegativeInteger))

from FreeModuleCategory(R, DirectProduct(#(vl), NonNegativeInteger))

totalDegree : % -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

totalDegree : (%, List(OrderedVariableList(vl))) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

totalDegreeSorted : (%, List(OrderedVariableList(vl))) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), 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 : (%, OrderedVariableList(vl)) -> SparseUnivariatePolynomial(%)

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

univariate : % -> SparseUnivariatePolynomial(R)

from PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

variables : % -> List(OrderedVariableList(vl))

from MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

CharacteristicNonZero

Module(Fraction(Integer))

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

canonicalUnitNormal

Rng

PolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

CoercibleFrom(Integer)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

EntireRing

NonAssociativeAlgebra(Fraction(Integer))

unitsKnown

FullyLinearlyExplicitOver(R)

PatternMatchable(Float)

SetCategory

CoercibleFrom(OrderedVariableList(vl))

CoercibleTo(OutputForm)

noZeroDivisors

RetractableTo(Fraction(Integer))

Magma

InnerEvalable(%, %)

SemiGroup

GcdDomain

IntegralDomain

LeftModule(%)

NonAssociativeRing

InnerEvalable(OrderedVariableList(vl), R)

UniqueFactorizationDomain

MaybeSkewPolynomialCategory(R, DirectProduct(#(vl), NonNegativeInteger), OrderedVariableList(vl))

AbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

CharacteristicZero

Module(R)

AbelianGroup

Algebra(%)

BiModule(R, R)

RightModule(Fraction(Integer))

Algebra(R)

LinearlyExplicitOver(R)

InnerEvalable(OrderedVariableList(vl), %)

RightModule(R)

NonAssociativeRng

CommutativeRing

NonAssociativeSemiRng

CancellationAbelianMonoid

RetractableTo(Integer)

CommutativeStar

VariablesCommuteWithCoefficients

AbelianMonoid

MagmaWithUnit

Comparable

RightModule(%)

AbelianProductCategory(R)

Hashable

Evalable(%)

FreeModuleCategory(R, DirectProduct(#(vl), NonNegativeInteger))

Module(%)

LinearlyExplicitOver(Integer)

ConvertibleTo(Pattern(Float))

SemiRng

IndexedDirectProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

Monoid

PolynomialFactorizationExplicit

NonAssociativeAlgebra(R)

LeftOreRing

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

BasicType

Ring

RightModule(Integer)

FiniteAbelianMonoidRing(R, DirectProduct(#(vl), NonNegativeInteger))

AbelianSemiGroup

ConvertibleTo(Pattern(Integer))

CoercibleFrom(Fraction(Integer))

LeftModule(Fraction(Integer))

PatternMatchable(Integer)

PartialDifferentialRing(OrderedVariableList(vl))

CoercibleFrom(R)

BiModule(Fraction(Integer), Fraction(Integer))

RetractableTo(R)

IndexedProductCategory(R, DirectProduct(#(vl), NonNegativeInteger))

RetractableTo(OrderedVariableList(vl))