# WeightedPolynomials(R, VarSet, E, P, vl, wl, wtlevel)ΒΆ

wtpol.spad line 1 [edit on github]

R: Ring

VarSet: OrderedSet

P: PolynomialCategory(R, E, VarSet)

vl: List VarSet

wtlevel: NonNegativeInteger

This domain represents truncated weighted polynomials over a general (not necessarily commutative) polynomial type. The variables must be specified, as must the weights. The representation is sparse in the sense that only non-zero terms are represented.

- 0: %
from AbelianMonoid

- 1: %
from MagmaWithUnit

- *: (%, %) -> %
from LeftModule %

- *: (%, R) -> % if R has CommutativeRing
from RightModule R

- *: (Integer, %) -> %
from AbelianGroup

- *: (NonNegativeInteger, %) -> %
from AbelianMonoid

- *: (PositiveInteger, %) -> %
from AbelianSemiGroup

- *: (R, %) -> % if R has CommutativeRing
from LeftModule R

- +: (%, %) -> %
from AbelianSemiGroup

- -: % -> %
from AbelianGroup

- -: (%, %) -> %
from AbelianGroup

- /: (%, %) -> Union(%, failed) if R has Field
`x/y`

division (only works if minimum weight of divisor is zero, and if`R`

is a Field)

- ^: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- ^: (%, PositiveInteger) -> %
from Magma

- annihilate?: (%, %) -> Boolean
from Rng

- antiCommutator: (%, %) -> %

- associator: (%, %, %) -> %
from NonAssociativeRng

- changeWeightLevel: NonNegativeInteger -> Void
`changeWeightLevel(n)`

changes the weight level to the new value given:`NB:`

previously calculated terms are not affected

- characteristic: () -> NonNegativeInteger
from NonAssociativeRing

- coerce: % -> OutputForm
from CoercibleTo OutputForm

- coerce: % -> P
convert back into a

`"P"`

, ignoring weights- coerce: Integer -> %
from NonAssociativeRing

- coerce: P -> %
`coerce(p)`

coerces`p`

into Weighted form, applying weights and ignoring terms- coerce: R -> % if R has CommutativeRing
from Algebra R

- commutator: (%, %) -> %
from NonAssociativeRng

- latex: % -> String
from SetCategory

- leftPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- leftPower: (%, PositiveInteger) -> %
from Magma

- leftRecip: % -> Union(%, failed)
from MagmaWithUnit

- one?: % -> Boolean
from MagmaWithUnit

- opposite?: (%, %) -> Boolean
from AbelianMonoid

- plenaryPower: (%, PositiveInteger) -> % if R has CommutativeRing
from NonAssociativeAlgebra R

- recip: % -> Union(%, failed)
from MagmaWithUnit

- rightPower: (%, NonNegativeInteger) -> %
from MagmaWithUnit

- rightPower: (%, PositiveInteger) -> %
from Magma

- rightRecip: % -> Union(%, failed)
from MagmaWithUnit

- sample: %
from AbelianMonoid

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

- zero?: % -> Boolean
from AbelianMonoid

Algebra R if R has CommutativeRing

BiModule(%, %)

BiModule(R, R) if R has CommutativeRing

LeftModule R if R has CommutativeRing

Module R if R has CommutativeRing

NonAssociativeAlgebra R if R has CommutativeRing

RightModule R if R has CommutativeRing