PolynomialRing(R, E)

poly.spad line 317 [edit on github]

This domain represents generalized polynomials with coefficients (from a not necessarily commutative ring), and terms indexed by their exponents (from an arbitrary ordered abelian monoid). This type is used, for example, by the DistributedMultivariatePolynomial domain where the exponent domain is a direct product of non negative integers.

* : (%, %) -> %
from Magma
* : (%, R) -> %
from RightModule(R)
* : (%, Fraction(Integer)) -> % if R has Algebra(Fraction(Integer))
from RightModule(Fraction(Integer))
* : (R, %) -> %
from LeftModule(R)
* : (Fraction(Integer), %) -> % if R has Algebra(Fraction(Integer))
from LeftModule(Fraction(Integer))
* : (Integer, %) -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
* : (NonNegativeInteger, %) -> %
from AbelianMonoid
* : (PositiveInteger, %) -> %
from AbelianSemiGroup
+ : (%, %) -> %
from AbelianSemiGroup
- : % -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
- : (%, %) -> % if % has AbelianGroup or R has AbelianGroup
from AbelianGroup
/ : (%, R) -> % if R has Field
from AbelianMonoidRing(R, E)
0 : () -> %
from AbelianMonoid
1 : () -> % if R has SemiRing
from MagmaWithUnit
= : (%, %) -> Boolean
from BasicType
^ : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
^ : (%, PositiveInteger) -> %
from Magma
annihilate? : (%, %) -> Boolean if R has Ring
from Rng
antiCommutator : (%, %) -> %
from NonAssociativeSemiRng
associates? : (%, %) -> Boolean if R has EntireRing
from EntireRing
associator : (%, %, %) -> % if R has Ring
from NonAssociativeRng
binomThmExpt : (%, %, NonNegativeInteger) -> % if % has CommutativeRing
from FiniteAbelianMonoidRing(R, E)
characteristic : () -> NonNegativeInteger if R has Ring
from NonAssociativeRing
charthRoot : % -> Union(%, "failed") if R has CharacteristicNonZero
from CharacteristicNonZero
coefficient : (%, E) -> R
from AbelianMonoidRing(R, E)
coefficients : % -> List(R)
from FreeModuleCategory(R, E)
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 -> % if R has RetractableTo(Integer) or R has Ring
from NonAssociativeRing
coerce : % -> OutputForm
from CoercibleTo(OutputForm)
commutator : (%, %) -> % if R has Ring
from NonAssociativeRng
construct : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
constructOrdered : List(Record(k : E, c : R)) -> %
from IndexedProductCategory(R, E)
content : % -> R if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
degree : % -> E
from AbelianMonoidRing(R, E)
exquo : (%, %) -> Union(%, "failed") if R has EntireRing
from EntireRing
exquo : (%, R) -> Union(%, "failed") if R has EntireRing
from FiniteAbelianMonoidRing(R, E)
fmecg : (%, E, R, %) -> % if R has Ring
from FiniteAbelianMonoidRing(R, E)
ground : % -> R
from FiniteAbelianMonoidRing(R, E)
ground? : % -> Boolean
from FiniteAbelianMonoidRing(R, E)
hash : % -> SingleInteger if E has Hashable and R has Hashable
from Hashable
hashUpdate! : (HashState, %) -> HashState if E has Hashable and R has Hashable
from Hashable
latex : % -> String
from SetCategory
leadingCoefficient : % -> R
from IndexedProductCategory(R, E)
leadingMonomial : % -> %
from IndexedProductCategory(R, E)
leadingSupport : % -> E
from IndexedProductCategory(R, E)
leadingTerm : % -> Record(k : E, c : R)
from IndexedProductCategory(R, E)
leftPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
leftPower : (%, PositiveInteger) -> %
from Magma
leftRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
linearExtend : (Mapping(R, E), %) -> R if R has CommutativeRing
from FreeModuleCategory(R, E)
listOfTerms : % -> List(Record(k : E, c : R))
from IndexedDirectProductCategory(R, E)
map : (Mapping(R, R), %) -> %
from IndexedProductCategory(R, E)
mapExponents : (Mapping(E, E), %) -> %
from FiniteAbelianMonoidRing(R, E)
minimumDegree : % -> E
from FiniteAbelianMonoidRing(R, E)
monomial : (R, E) -> %
from IndexedProductCategory(R, E)
monomial? : % -> Boolean
from IndexedProductCategory(R, E)
monomials : % -> List(%)
from FreeModuleCategory(R, E)
numberOfMonomials : % -> NonNegativeInteger
from IndexedDirectProductCategory(R, E)
one? : % -> Boolean if R has SemiRing
from MagmaWithUnit
opposite? : (%, %) -> Boolean
from AbelianMonoid
plenaryPower : (%, PositiveInteger) -> % if R has CommutativeRing or R has Algebra(Fraction(Integer))
from NonAssociativeAlgebra(%)
pomopo! : (%, R, E, %) -> %
from FiniteAbelianMonoidRing(R, E)
primitivePart : % -> % if R has GcdDomain
from FiniteAbelianMonoidRing(R, E)
recip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
reductum : % -> %
from IndexedProductCategory(R, E)
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)
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)
rightPower : (%, NonNegativeInteger) -> % if R has SemiRing
from MagmaWithUnit
rightPower : (%, PositiveInteger) -> %
from Magma
rightRecip : % -> Union(%, "failed") if R has SemiRing
from MagmaWithUnit
sample : () -> %
from AbelianMonoid
smaller? : (%, %) -> Boolean if R has Comparable
from Comparable
subtractIfCan : (%, %) -> Union(%, "failed")
from CancellationAbelianMonoid
support : % -> List(E)
from FreeModuleCategory(R, E)
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
zero? : % -> Boolean
from AbelianMonoid
~= : (%, %) -> Boolean
from BasicType

CharacteristicNonZero

Module(Fraction(Integer))

Comparable

LeftModule(Fraction(Integer))

CoercibleFrom(R)

Algebra(%)

noZeroDivisors

RightModule(%)

Algebra(R)

Monoid

IndexedProductCategory(R, E)

AbelianMonoid

BiModule(R, R)

FiniteAbelianMonoidRing(R, E)

NonAssociativeAlgebra(Fraction(Integer))

CancellationAbelianMonoid

FreeModuleCategory(R, E)

MagmaWithUnit

RightModule(R)

RightModule(Fraction(Integer))

RetractableTo(Integer)

AbelianSemiGroup

NonAssociativeSemiRng

NonAssociativeAlgebra(%)

LeftModule(%)

LeftModule(R)

canonicalUnitNormal

Module(%)

SetCategory

CoercibleTo(OutputForm)

Algebra(Fraction(Integer))

Rng

CommutativeRing

IntegralDomain

TwoSidedRecip

Magma

NonAssociativeAlgebra(R)

CoercibleFrom(Fraction(Integer))

SemiGroup

CoercibleFrom(Integer)

AbelianGroup

RetractableTo(Fraction(Integer))

CommutativeStar

NonAssociativeSemiRing

VariablesCommuteWithCoefficients

IndexedDirectProductCategory(R, E)

AbelianProductCategory(R)

Module(R)

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

CharacteristicZero

RetractableTo(R)

NonAssociativeRng

unitsKnown

Ring

AbelianMonoidRing(R, E)

NonAssociativeRing

SemiRng

EntireRing

Hashable

BasicType

BiModule(%, %)

SemiRing

FullyRetractableTo(R)