Polynomial(R)

multpoly.spad line 1 [edit on github]

• R : Ring

This type is the basic representation of sparse recursive multivariate polynomials whose variables are arbitrary symbols. The ordering is alphabetic determined by the Symbol type. The coefficient ring may be non commutative, but the variables are assumed to commute.

* : (%, %) -> %

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, IndexedExponents(Symbol))

0 : () -> %

from AbelianMonoid

1 : () -> %

from MagmaWithUnit

= : (%, %) -> Boolean

from BasicType

D : (%, List(Symbol)) -> %

from PartialDifferentialRing(Symbol)

D : (%, List(Symbol), List(NonNegativeInteger)) -> %

from PartialDifferentialRing(Symbol)

D : (%, Symbol) -> %

from PartialDifferentialRing(Symbol)

D : (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing(Symbol)

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

characteristic : () -> NonNegativeInteger

from NonAssociativeRing

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

from CharacteristicNonZero

coefficient : (%, List(Symbol), List(NonNegativeInteger)) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

coefficient : (%, Symbol, NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

coefficient : (%, IndexedExponents(Symbol)) -> R

from AbelianMonoidRing(R, IndexedExponents(Symbol))

coefficients : % -> List(R)

from FreeModuleCategory(R, IndexedExponents(Symbol))

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 : Symbol -> %

from CoercibleFrom(Symbol)

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 : IndexedExponents(Symbol), c : R)) -> %

from IndexedProductCategory(R, IndexedExponents(Symbol))

constructOrdered : List(Record(k : IndexedExponents(Symbol), c : R)) -> %

from IndexedProductCategory(R, IndexedExponents(Symbol))

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

content : % -> R if R has GcdDomain

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

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 : % -> IndexedExponents(Symbol)

from AbelianMonoidRing(R, IndexedExponents(Symbol))

degree : (%, List(Symbol)) -> List(NonNegativeInteger)

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

degree : (%, Symbol) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

differentiate : (%, List(Symbol)) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, List(Symbol), List(NonNegativeInteger)) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol) -> %

from PartialDifferentialRing(Symbol)

differentiate : (%, Symbol, NonNegativeInteger) -> %

from PartialDifferentialRing(Symbol)

discriminant : (%, Symbol) -> % if R has CommutativeRing

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

eval : (%, %, %) -> %

from InnerEvalable(%, %)

eval : (%, Equation(%)) -> %

from Evalable(%)

eval : (%, List(%), List(%)) -> %

from InnerEvalable(%, %)

eval : (%, List(Equation(%))) -> %

from Evalable(%)

eval : (%, List(Symbol), List(%)) -> %

from InnerEvalable(Symbol, %)

eval : (%, List(Symbol), List(R)) -> %

from InnerEvalable(Symbol, R)

eval : (%, Symbol, %) -> %

from InnerEvalable(Symbol, %)

eval : (%, Symbol, R) -> %

from InnerEvalable(Symbol, R)

exquo : (%, %) -> Union(%, "failed") if R has EntireRing

from EntireRing

exquo : (%, R) -> Union(%, "failed") if R has EntireRing

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

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 : (%, IndexedExponents(Symbol), R, %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

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, IndexedExponents(Symbol))

ground? : % -> Boolean

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

hash : % -> SingleInteger if R has Hashable

from Hashable

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

from Hashable

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

integrate(p, x) computes the integral of p*dx, i.e. integrates the polynomial p with respect to the variable x.

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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, IndexedExponents(Symbol))

leadingMonomial : % -> %

from IndexedProductCategory(R, IndexedExponents(Symbol))

leadingSupport : % -> IndexedExponents(Symbol)

from IndexedProductCategory(R, IndexedExponents(Symbol))

leadingTerm : % -> Record(k : IndexedExponents(Symbol), c : R)

from IndexedProductCategory(R, IndexedExponents(Symbol))

leftPower : (%, NonNegativeInteger) -> %

from MagmaWithUnit

leftPower : (%, PositiveInteger) -> %

from Magma

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

from MagmaWithUnit

linearExtend : (Mapping(R, IndexedExponents(Symbol)), %) -> R if R has CommutativeRing

from FreeModuleCategory(R, IndexedExponents(Symbol))

listOfTerms : % -> List(Record(k : IndexedExponents(Symbol), c : R))

from IndexedDirectProductCategory(R, IndexedExponents(Symbol))

mainVariable : % -> Union(Symbol, "failed")

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from IndexedProductCategory(R, IndexedExponents(Symbol))

mapExponents : (Mapping(IndexedExponents(Symbol), IndexedExponents(Symbol)), %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

minimumDegree : % -> IndexedExponents(Symbol)

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

minimumDegree : (%, List(Symbol)) -> List(NonNegativeInteger)

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

minimumDegree : (%, Symbol) -> NonNegativeInteger

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

monicDivide : (%, %, Symbol) -> Record(quotient : %, remainder : %)

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

monomial : (%, List(Symbol), List(NonNegativeInteger)) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

monomial : (%, Symbol, NonNegativeInteger) -> %

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

monomial : (R, IndexedExponents(Symbol)) -> %

from IndexedProductCategory(R, IndexedExponents(Symbol))

monomial? : % -> Boolean

from IndexedProductCategory(R, IndexedExponents(Symbol))

monomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

multivariate : (SparseUnivariatePolynomial(%), Symbol) -> %

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

multivariate : (SparseUnivariatePolynomial(R), Symbol) -> %

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

numberOfMonomials : % -> NonNegativeInteger

from IndexedDirectProductCategory(R, IndexedExponents(Symbol))

one? : % -> Boolean

from MagmaWithUnit

opposite? : (%, %) -> Boolean

from AbelianMonoid

patternMatch : (%, Pattern(Float), PatternMatchResult(Float, %)) -> PatternMatchResult(Float, %) if R has PatternMatchable(Float)

from PatternMatchable(Float)

patternMatch : (%, Pattern(Integer), PatternMatchResult(Integer, %)) -> PatternMatchResult(Integer, %) if R has PatternMatchable(Integer)

from PatternMatchable(Integer)

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

from NonAssociativeAlgebra(%)

pomopo! : (%, R, IndexedExponents(Symbol), %) -> %

from FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

prime? : % -> Boolean if R has PolynomialFactorizationExplicit

from UniqueFactorizationDomain

primitiveMonomials : % -> List(%)

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

primitivePart : % -> % if R has GcdDomain

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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, IndexedExponents(Symbol))

resultant : (%, %, Symbol) -> % if R has CommutativeRing

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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 : % -> Symbol

from RetractableTo(Symbol)

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(Symbol, "failed")

from RetractableTo(Symbol)

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, IndexedExponents(Symbol), Symbol)

squareFreePart : % -> % if R has GcdDomain

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from PolynomialFactorizationExplicit

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

from CancellationAbelianMonoid

support : % -> List(IndexedExponents(Symbol))

from FreeModuleCategory(R, IndexedExponents(Symbol))

totalDegree : % -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

totalDegree : (%, List(Symbol)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

totalDegreeSorted : (%, List(Symbol)) -> NonNegativeInteger

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

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

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

univariate : % -> SparseUnivariatePolynomial(R)

from PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

variables : % -> List(Symbol)

from MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

zero? : % -> Boolean

from AbelianMonoid

~= : (%, %) -> Boolean

from BasicType

CharacteristicNonZero

Module(Fraction(Integer))

NonAssociativeSemiRing

LeftModule(R)

BiModule(%, %)

ConvertibleTo(InputForm)

canonicalUnitNormal

Rng

FullyLinearlyExplicitOver(R)

TwoSidedRecip

FullyRetractableTo(R)

SemiRing

EntireRing

NonAssociativeAlgebra(Fraction(Integer))

FreeModuleCategory(R, IndexedExponents(Symbol))

unitsKnown

MaybeSkewPolynomialCategory(R, IndexedExponents(Symbol), Symbol)

PatternMatchable(Float)

IndexedProductCategory(R, IndexedExponents(Symbol))

AbelianSemiGroup

noZeroDivisors

UniqueFactorizationDomain

InnerEvalable(%, %)

SemiGroup

Magma

RetractableTo(Symbol)

IntegralDomain

LeftModule(%)

NonAssociativeRing

GcdDomain

PartialDifferentialRing(Symbol)

CharacteristicZero

Module(R)

Algebra(%)

BiModule(R, R)

RightModule(Fraction(Integer))

Algebra(R)

RightModule(R)

NonAssociativeRng

CommutativeRing

NonAssociativeSemiRng

CoercibleFrom(Integer)

CancellationAbelianMonoid

RetractableTo(Integer)

SetCategory

LinearlyExplicitOver(R)

AbelianMonoidRing(R, IndexedExponents(Symbol))

CommutativeStar

VariablesCommuteWithCoefficients

AbelianMonoid

InnerEvalable(Symbol, R)

MagmaWithUnit

Comparable

FiniteAbelianMonoidRing(R, IndexedExponents(Symbol))

RightModule(%)

AbelianProductCategory(R)

Hashable

Evalable(%)

Module(%)

CoercibleTo(OutputForm)

ConvertibleTo(Pattern(Float))

SemiRng

LinearlyExplicitOver(Integer)

CoercibleFrom(Symbol)

Monoid

PolynomialFactorizationExplicit

PolynomialCategory(R, IndexedExponents(Symbol), Symbol)

NonAssociativeAlgebra(R)

LeftOreRing

NonAssociativeAlgebra(%)

Algebra(Fraction(Integer))

BasicType

InnerEvalable(Symbol, %)

Ring

RightModule(Integer)

Canonical

IndexedDirectProductCategory(R, IndexedExponents(Symbol))

ConvertibleTo(Pattern(Integer))

CoercibleFrom(Fraction(Integer))

LeftModule(Fraction(Integer))

CoercibleFrom(R)

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

RetractableTo(Fraction(Integer))

RetractableTo(R)

PatternMatchable(Integer)

AbelianGroup