GeneralPolynomialSet(R, E, VarSet, P)

polset.spad line 343 [edit on github]

• R: Ring

• E: OrderedAbelianMonoidSup

• VarSet: OrderedSet

• P: RecursivePolynomialCategory(R, E, VarSet)

A domain for polynomial sets.

#: % -> NonNegativeInteger

from Aggregate

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

any?: (P -> Boolean, %) -> Boolean

from HomogeneousAggregate P

coerce: % -> List P

from CoercibleTo List P

coerce: % -> OutputForm

from CoercibleTo OutputForm

collect: (%, VarSet) -> %

from PolynomialSetCategory(R, E, VarSet, P)

collectUnder: (%, VarSet) -> %

from PolynomialSetCategory(R, E, VarSet, P)

collectUpper: (%, VarSet) -> %

from PolynomialSetCategory(R, E, VarSet, P)

construct: List P -> %

from Collection P

convert: % -> InputForm

from ConvertibleTo InputForm

convert: List P -> %

convert(lp) returns the polynomial set whose members are the polynomials of lp.

copy: % -> %

from Aggregate

count: (P -> Boolean, %) -> NonNegativeInteger

from HomogeneousAggregate P

count: (P, %) -> NonNegativeInteger

from HomogeneousAggregate P

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

eq?: (%, %) -> Boolean

from Aggregate

eval: (%, Equation P) -> % if P has Evalable P

from Evalable P

eval: (%, List Equation P) -> % if P has Evalable P

from Evalable P

eval: (%, List P, List P) -> % if P has Evalable P

from InnerEvalable(P, P)

eval: (%, P, P) -> % if P has Evalable P

from InnerEvalable(P, P)

every?: (P -> Boolean, %) -> Boolean

from HomogeneousAggregate P

find: (P -> Boolean, %) -> Union(P, failed)

from Collection P

headRemainder: (P, %) -> Record(num: P, den: R) if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

iexactQuo: (R, R) -> R if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

latex: % -> String

from SetCategory

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

mainVariable?: (VarSet, %) -> Boolean

from PolynomialSetCategory(R, E, VarSet, P)

mainVariables: % -> List VarSet

from PolynomialSetCategory(R, E, VarSet, P)

map!: (P -> P, %) -> %

from HomogeneousAggregate P

map: (P -> P, %) -> %

from HomogeneousAggregate P

max: % -> P if P has OrderedSet

from HomogeneousAggregate P

max: ((P, P) -> Boolean, %) -> P

from HomogeneousAggregate P

member?: (P, %) -> Boolean

from HomogeneousAggregate P

members: % -> List P

from HomogeneousAggregate P

min: % -> P if P has OrderedSet

from HomogeneousAggregate P

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

mvar: % -> VarSet

from PolynomialSetCategory(R, E, VarSet, P)

parts: % -> List P

from HomogeneousAggregate P

reduce: ((P, P) -> P, %) -> P

from Collection P

reduce: ((P, P) -> P, %, P) -> P

from Collection P

reduce: ((P, P) -> P, %, P, P) -> P

from Collection P

remainder: (P, %) -> Record(rnum: R, polnum: P, den: R) if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

remove: (P -> Boolean, %) -> %

from Collection P

remove: (P, %) -> %

from Collection P

removeDuplicates: % -> %

from Collection P

retract: List P -> %

from RetractableFrom List P

retractIfCan: List P -> Union(%, failed)

from RetractableFrom List P

rewriteIdealWithHeadRemainder: (List P, %) -> List P if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

rewriteIdealWithRemainder: (List P, %) -> List P if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

roughBase?: % -> Boolean if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

roughEqualIdeals?: (%, %) -> Boolean if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

roughSubIdeal?: (%, %) -> Boolean if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

roughUnitIdeal?: % -> Boolean if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

sample: %

from Aggregate

select: (P -> Boolean, %) -> %

from Collection P

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

sort: (%, VarSet) -> Record(under: %, floor: %, upper: %)

from PolynomialSetCategory(R, E, VarSet, P)

triangular?: % -> Boolean if R has IntegralDomain

from PolynomialSetCategory(R, E, VarSet, P)

trivialIdeal?: % -> Boolean

from PolynomialSetCategory(R, E, VarSet, P)

variables: % -> List VarSet

from PolynomialSetCategory(R, E, VarSet, P)

Aggregate

BasicType

CoercibleTo List P

CoercibleTo OutputForm

Collection P

ConvertibleTo InputForm

Evalable P if P has Evalable P

finiteAggregate

HomogeneousAggregate P

InnerEvalable(P, P) if P has Evalable P

PolynomialSetCategory(R, E, VarSet, P)

RetractableFrom List P

SetCategory

shallowlyMutable