Edit detail for SandBox42 revision 6 of 10

)show SparseUnivariatePolynomial

 SparseUnivariatePolynomial R: Ring  is a domain constructor
 Abbreviation for SparseUnivariatePolynomial is SUP
 This constructor is not exposed in this frame.
 Issue )edit /usr/local/lib/axiom/target/x86_64-unknown-linux/../../src/algebra/SUP.spad to
see algebra source code for SUP 

------------------------------- Operations --------------------------------
 ?*? : (%,R) -> %                      ?*? : (R,%) -> %
 ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
 ?*? : (PositiveInteger,%) -> %        ?**? : (%,PositiveInteger) ->
%
 ?+? : (%,%) -> %                      ?-? : (%,%) -> %
 -? : % -> %                           ?=? : (%,%) -> Boolean
 D : (%,(R -> R)) -> %                 D : % -> %
 D : (%,NonNegativeInteger) -> %       1 : () -> %
 0 : () -> %                           ?^? : (%,PositiveInteger) -> %
 coefficients : % -> List R            coerce : R -> %
 coerce : Integer -> %                 coerce : % -> OutputForm
 degree : % -> NonNegativeInteger      differentiate : % -> %
 ?.? : (%,%) -> %                      ?.? : (%,R) -> R
 eval : (%,List %,List %) -> %         eval : (%,%,%) -> %
 eval : (%,Equation %) -> %            eval : (%,List Equation %) -> %
 ground : % -> R                       ground? : % -> Boolean
 hash : % -> SingleInteger             init : () -> % if R has STEP
 latex : % -> String                   leadingCoefficient : % -> R
 leadingMonomial : % -> %              map : ((R -> R),%) -> %
 monomial? : % -> Boolean              monomials : % -> List %
 one? : % -> Boolean                   primitiveMonomials : % -> List %
 pseudoRemainder : (%,%) -> %          recip : % -> Union(%,"failed")
 reductum : % -> %                     retract : % -> R
 sample : () -> %                      zero? : % -> Boolean
 ?~=? : (%,%) -> Boolean
 ?*? : (Fraction Integer,%) -> % if R has ALGEBRA FRAC INT
 ?*? : (%,Fraction Integer) -> % if R has ALGEBRA FRAC INT
 ?*? : (NonNegativeInteger,%) -> %
 ?**? : (%,NonNegativeInteger) -> %
 ?/? : (%,R) -> % if R has FIELD
 ?<? : (%,%) -> Boolean if R has ORDSET
 ?<=? : (%,%) -> Boolean if R has ORDSET
 ?>? : (%,%) -> Boolean if R has ORDSET
 ?>=? : (%,%) -> Boolean if R has ORDSET
 D : (%,(R -> R),NonNegativeInteger) -> %
 D : (%,List Symbol,List NonNegativeInteger) -> % if R has PDRING SYMBOL
 D : (%,Symbol,NonNegativeInteger) -> % if R has PDRING SYMBOL
 D : (%,List Symbol) -> % if R has PDRING SYMBOL
 D : (%,Symbol) -> % if R has PDRING SYMBOL
 D : (%,List SingletonAsOrderedSet,List NonNegativeInteger) -> %
 D : (%,SingletonAsOrderedSet,NonNegativeInteger) -> %
 D : (%,List SingletonAsOrderedSet) -> %
 D : (%,SingletonAsOrderedSet) -> %
 ?^? : (%,NonNegativeInteger) -> %
 associates? : (%,%) -> Boolean if R has INTDOM
 binomThmExpt : (%,%,NonNegativeInteger) -> % if R has COMRING
 characteristic : () -> NonNegativeInteger
 charthRoot : % -> Union(%,"failed") if $ has CHARNZ and R has PFECAT or R
has CHARNZ
 coefficient : (%,List SingletonAsOrderedSet,List NonNegativeInteger) -> %
 coefficient : (%,SingletonAsOrderedSet,NonNegativeInteger) -> %
 coefficient : (%,NonNegativeInteger) -> R
 coerce : % -> % if R has INTDOM
 coerce : Fraction Integer -> % if R has ALGEBRA FRAC INT or R has RETRACT FRAC INT
 coerce : SingletonAsOrderedSet -> %
 composite : (Fraction %,%) -> Union(Fraction %,"failed") if R has INTDOM
 composite : (%,%) -> Union(%,"failed") if R has INTDOM
 conditionP : Matrix % -> Union(Vector %,"failed") if $ has CHARNZ and R
has PFECAT
 content : (%,SingletonAsOrderedSet) -> % if R has GCDDOM
 content : % -> R if R has GCDDOM
 convert : % -> InputForm if SingletonAsOrderedSet has KONVERT INFORM and R has KONVERT
INFORM
 convert : % -> Pattern Integer if SingletonAsOrderedSet has KONVERT PATTERN INT and R
has KONVERT PATTERN INT
 convert : % -> Pattern Float if SingletonAsOrderedSet has KONVERT PATTERN FLOAT and R
has KONVERT PATTERN FLOAT
 degree : (%,List SingletonAsOrderedSet) -> List NonNegativeInteger
 degree : (%,SingletonAsOrderedSet) -> NonNegativeInteger
 differentiate : (%,(R -> R),%) -> %
 differentiate : (%,(R -> R)) -> %
 differentiate : (%,(R -> R),NonNegativeInteger) -> %
 differentiate : (%,List Symbol,List NonNegativeInteger) -> % if R has PDRING SYMBOL
 differentiate : (%,Symbol,NonNegativeInteger) -> % if R has PDRING SYMBOL
 differentiate : (%,List Symbol) -> % if R has PDRING SYMBOL
 differentiate : (%,Symbol) -> % if R has PDRING SYMBOL
 differentiate : (%,NonNegativeInteger) -> %
 differentiate : (%,List SingletonAsOrderedSet,List NonNegativeInteger) -> %
 differentiate : (%,SingletonAsOrderedSet,NonNegativeInteger) -> %
 differentiate : (%,List SingletonAsOrderedSet) -> %
 differentiate : (%,SingletonAsOrderedSet) -> %
 discriminant : % -> R if R has COMRING
 discriminant : (%,SingletonAsOrderedSet) -> % if R has COMRING
 divide : (%,%) -> Record(quotient: %,remainder: %) if R has FIELD
 divideExponents : (%,NonNegativeInteger) -> Union(%,"failed")
 ?.? : (%,Fraction %) -> Fraction % if R has INTDOM
 elt : (Fraction %,R) -> R if R has FIELD
 elt : (Fraction %,Fraction %) -> Fraction % if R has INTDOM
 euclideanSize : % -> NonNegativeInteger if R has FIELD
 eval : (%,List SingletonAsOrderedSet,List %) -> %
 eval : (%,SingletonAsOrderedSet,%) -> %
 eval : (%,List SingletonAsOrderedSet,List R) -> %
 eval : (%,SingletonAsOrderedSet,R) -> %
 expressIdealMember : (List %,%) -> Union(List %,"failed") if R has FIELD
 exquo : (%,%) -> Union(%,"failed") if R has INTDOM
 exquo : (%,R) -> Union(%,"failed") if R has INTDOM
 extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %) if R
has FIELD
 extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2:
%),"failed") if R has FIELD
 factor : % -> Factored % if R has PFECAT
 factorPolynomial : SparseUnivariatePolynomial % -> Factored SparseUnivariatePolynomial
% if R has PFECAT
 factorSquareFreePolynomial : SparseUnivariatePolynomial % -> Factored
SparseUnivariatePolynomial % if R has PFECAT
 fmecg : (%,NonNegativeInteger,R,%) -> %
 gcd : (%,%) -> % if R has GCDDOM
 gcd : List % -> % if R has GCDDOM
 gcdPolynomial : (SparseUnivariatePolynomial %,SparseUnivariatePolynomial %) ->
SparseUnivariatePolynomial % if R has GCDDOM
 integrate : % -> % if R has ALGEBRA FRAC INT
 isExpt : % -> Union(Record(var: SingletonAsOrderedSet,exponent:
NonNegativeInteger),"failed")
 isPlus : % -> Union(List %,"failed")
 isTimes : % -> Union(List %,"failed")
 karatsubaDivide : (%,NonNegativeInteger) -> Record(quotient: %,remainder: %)
 lcm : (%,%) -> % if R has GCDDOM
 lcm : List % -> % if R has GCDDOM
 mainVariable : % -> Union(SingletonAsOrderedSet,"failed")
 makeSUP : % -> SparseUnivariatePolynomial R
 mapExponents : ((NonNegativeInteger -> NonNegativeInteger),%) -> %
 max : (%,%) -> % if R has ORDSET
 min : (%,%) -> % if R has ORDSET
 minimumDegree : (%,List SingletonAsOrderedSet) -> List NonNegativeInteger
 minimumDegree : (%,SingletonAsOrderedSet) -> NonNegativeInteger
 minimumDegree : % -> NonNegativeInteger
 monicDivide : (%,%) -> Record(quotient: %,remainder: %)
 monicDivide : (%,%,SingletonAsOrderedSet) -> Record(quotient: %,remainder: %)
 monomial : (%,List SingletonAsOrderedSet,List NonNegativeInteger) -> %
 monomial : (%,SingletonAsOrderedSet,NonNegativeInteger) -> %
 monomial : (R,NonNegativeInteger) -> %
 multiEuclidean : (List %,%) -> Union(List %,"failed") if R has FIELD
 multiplyExponents : (%,NonNegativeInteger) -> %
 multivariate : (SparseUnivariatePolynomial %,SingletonAsOrderedSet) -> %
 multivariate : (SparseUnivariatePolynomial R,SingletonAsOrderedSet) -> %
 nextItem : % -> Union(%,"failed") if R has STEP
 numberOfMonomials : % -> NonNegativeInteger
 order : (%,%) -> NonNegativeInteger if R has INTDOM
 outputForm : (%,OutputForm) -> OutputForm
 patternMatch : (%,Pattern Integer,PatternMatchResult(Integer,%)) ->
PatternMatchResult(Integer,%) if SingletonAsOrderedSet has PATMAB INT and R has PATMAB INT
 patternMatch : (%,Pattern Float,PatternMatchResult(Float,%)) ->
PatternMatchResult(Float,%) if SingletonAsOrderedSet has PATMAB FLOAT and R has PATMAB FLOAT
 pomopo! : (%,R,NonNegativeInteger,%) -> %
 prime? : % -> Boolean if R has PFECAT
 primitivePart : (%,SingletonAsOrderedSet) -> % if R has GCDDOM
 primitivePart : % -> % if R has GCDDOM
 principalIdeal : List % -> Record(coef: List %,generator: %) if R has FIELD
 pseudoDivide : (%,%) -> Record(coef: R,quotient: %,remainder: %) if R has
INTDOM
 pseudoQuotient : (%,%) -> % if R has INTDOM
 ?quo? : (%,%) -> % if R has FIELD
 reducedSystem : Matrix % -> Matrix R
 reducedSystem : (Matrix %,Vector %) -> Record(mat: Matrix R,vec: Vector R)
 reducedSystem : (Matrix %,Vector %) -> Record(mat: Matrix Integer,vec: Vector
Integer) if R has LINEXP INT
 reducedSystem : Matrix % -> Matrix Integer if R has LINEXP INT
 ?rem? : (%,%) -> % if R has FIELD
 resultant : (%,%) -> R if R has COMRING
 resultant : (%,%,SingletonAsOrderedSet) -> % if R has COMRING
 retract : % -> SingletonAsOrderedSet
 retract : % -> Integer if R has RETRACT INT
 retract : % -> Fraction Integer if R has RETRACT FRAC INT
 retractIfCan : % -> Union(SingletonAsOrderedSet,"failed")
 retractIfCan : % -> Union(Integer,"failed") if R has RETRACT INT
 retractIfCan : % -> Union(Fraction Integer,"failed") if R has RETRACT FRAC
INT
 retractIfCan : % -> Union(R,"failed")
 separate : (%,%) -> Record(primePart: %,commonPart: %) if R has GCDDOM
 shiftLeft : (%,NonNegativeInteger) -> %
 shiftRight : (%,NonNegativeInteger) -> %
 sizeLess? : (%,%) -> Boolean if R has FIELD
 solveLinearPolynomialEquation : (List SparseUnivariatePolynomial
%,SparseUnivariatePolynomial %) -> Union(List SparseUnivariatePolynomial
%,"failed") if R has PFECAT
 squareFree : % -> Factored % if R has GCDDOM
 squareFreePart : % -> % if R has GCDDOM
 squareFreePolynomial : SparseUnivariatePolynomial % -> Factored
SparseUnivariatePolynomial % if R has PFECAT
 subResultantGcd : (%,%) -> % if R has INTDOM
 subtractIfCan : (%,%) -> Union(%,"failed")
 totalDegree : (%,List SingletonAsOrderedSet) -> NonNegativeInteger
 totalDegree : % -> NonNegativeInteger
 unit? : % -> Boolean if R has INTDOM
 unitCanonical : % -> % if R has INTDOM
 unitNormal : % -> Record(unit: %,canonical: %,associate: %) if R has INTDOM
 univariate : % -> SparseUnivariatePolynomial R
 univariate : (%,SingletonAsOrderedSet) -> SparseUnivariatePolynomial %
 unmakeSUP : SparseUnivariatePolynomial R -> %
 variables : % -> List SingletonAsOrderedSet
 vectorise : (%,NonNegativeInteger) -> Vector R

A := SparseUnivariatePolynomial( Integer)

(1)

1::A

(2)

x := monomial(1,1)$A

(3)

x*x*x +x*x +x

(4)