MathAction SandBox42

Topics

FrontPage
- SandBox
  - SandBox42 <-- You are here.

fricas

(1) -> A := SparseUnivariatePolynomial( Integer)

$\label{eq1}\hbox{\axiomType{SparseUnivariatePolynomial}\ } \left({\hbox{\axiomType{Integer}\ }}\right)$

(1)

Type: Type

fricas

1::A

$\label{eq2}1$

(2)

Type: SparseUnivariatePolynomial?(Integer)

fricas

x := monomial(1,1)$A

$\label{eq3}?$

(3)

Type: SparseUnivariatePolynomial?(Integer)

fricas

y:= x*2

$\label{eq4}2 \ ?$

(4)

Type: SparseUnivariatePolynomial?(Integer)

fricas

a := y*y*y +y*y +y

$\label{eq5}{8 \ {{?}^{3}}}+{4 \ {{?}^{2}}}+{2 \ ?}$

(5)

Type: SparseUnivariatePolynomial?(Integer)

fricas

reductum a

$\label{eq6}{4 \ {{?}^{2}}}+{2 \ ?}$

(6)

Type: SparseUnivariatePolynomial?(Integer)

fricas

monomials a

$\label{eq7}\left[{8 \ {{?}^{3}}}, \:{4 \ {{?}^{2}}}, \:{2 \ ?}\right]$

(7)

Type: List(SparseUnivariatePolynomial?(Integer))

fricas

primitiveMonomials a

$\label{eq8}\left[{{?}^{3}}, \:{{?}^{2}}, \: ? \right]$

(8)

Type: List(SparseUnivariatePolynomial?(Integer))

fricas

)show List

 List(S: Type) is a domain constructor
 Abbreviation for List is LIST 
 This constructor is exposed in this frame.
------------------------------- Operations --------------------------------

 append : (%, %) -> %                  children : % -> List(%)
 concat : (%, S) -> %                  concat : List(%) -> %
 concat : (S, %) -> %                  concat : (%, %) -> %
 concat! : (%, S) -> %                 concat! : (%, %) -> %
 cons : (S, %) -> %                    construct : List(S) -> %
 copy : % -> %                         cycleEntry : % -> %
 cycleTail : % -> %                    cyclic? : % -> Boolean
 delete : (%, Integer) -> %            delete! : (%, Integer) -> %
 distance : (%, %) -> Integer          elt : (%, Integer, S) -> S
 elt : (%, Integer) -> S               elt : (%, last) -> S
 elt : (%, rest) -> %                  elt : (%, first) -> S
 elt : (%, value) -> S                 empty : () -> %
 empty? : % -> Boolean                 entries : % -> List(S)
 eq? : (%, %) -> Boolean               explicitlyFinite? : % -> Boolean
 first : % -> S                        index? : (Integer, %) -> Boolean
 indices : % -> List(Integer)          insert : (S, %, Integer) -> %
 insert : (%, %, Integer) -> %         insert! : (S, %, Integer) -> %
 insert! : (%, %, Integer) -> %        last : % -> S
 leaf? : % -> Boolean                  leaves : % -> List(S)
 list : S -> %                         map : ((S -> S), %) -> %
 nodes : % -> List(%)                  possiblyInfinite? : % -> Boolean
 qelt : (%, Integer) -> S              rest : % -> %
 sample : () -> %                      second : % -> S
 tail : % -> %                         tails : % -> List(%)
 third : % -> S                        value : % -> S
 #? : % -> NonNegativeInteger if % has ATFINAG
 ?<? : (%, %) -> Boolean if % has ATFINAG and S has ORDSET
 ?<=? : (%, %) -> Boolean if % has ATFINAG and S has ORDSET
 ?=? : (%, %) -> Boolean if % has ATFINAG and S has BASTYPE or % has ATFINAG and S has COMPAR or % has ATFINAG and S has ORDSET or S has HASHABL or S has SETCAT
 ?>? : (%, %) -> Boolean if % has ATFINAG and S has ORDSET
 ?>=? : (%, %) -> Boolean if % has ATFINAG and S has ORDSET
 OMwrite : % -> String if S has OM
 OMwrite : (%, Boolean) -> String if S has OM
 OMwrite : (OpenMathDevice, %) -> Void if S has OM
 OMwrite : (OpenMathDevice, %, Boolean) -> Void if S has OM
 any? : ((S -> Boolean), %) -> Boolean if % has ATFINAG
 child? : (%, %) -> Boolean if S has BASTYPE
 coerce : % -> OutputForm if % has ATFINAG and S has COMPAR or % has ATFINAG and S has ORDSET or S has KOERCE(OUTFORM)
 concat! : List(%) -> % if % has ATSHMUT
 convert : % -> InputForm if S has KONVERT(INFORM)
 copyInto! : (%, %, Integer) -> % if % has ATFINAG and % has ATSHMUT
 count : (S, %) -> NonNegativeInteger if % has ATFINAG and S has BASTYPE
 count : ((S -> Boolean), %) -> NonNegativeInteger if % has ATFINAG
 cycleLength : % -> NonNegativeInteger
 cycleSplit! : % -> % if % has ATSHMUT
 delete : (%, UniversalSegment(Integer)) -> %
 delete! : (%, UniversalSegment(Integer)) -> %
 elt : (%, UniversalSegment(Integer)) -> %
 entry? : (S, %) -> Boolean if % has ATFINAG and S has BASTYPE
 eval : (%, List(S), List(S)) -> % if S has EVALAB(S) and S has SETCAT
 eval : (%, S, S) -> % if S has EVALAB(S) and S has SETCAT
 eval : (%, Equation(S)) -> % if S has EVALAB(S) and S has SETCAT
 eval : (%, List(Equation(S))) -> % if S has EVALAB(S) and S has SETCAT
 every? : ((S -> Boolean), %) -> Boolean if % has ATFINAG
 fill! : (%, S) -> % if % has ATSHMUT
 find : ((S -> Boolean), %) -> Union(S,"failed")
 first : (%, NonNegativeInteger) -> %
 hash : % -> SingleInteger if S has HASHABL
 hashUpdate! : (HashState, %) -> HashState if S has HASHABL
 last : (%, NonNegativeInteger) -> %
 latex : % -> String if % has ATFINAG and S has COMPAR or % has ATFINAG and S has ORDSET or S has SETCAT
 leftTrim : (%, S) -> % if % has ATFINAG and S has BASTYPE
 less? : (%, NonNegativeInteger) -> Boolean
 map : (((S, S) -> S), %, %) -> %
 map! : ((S -> S), %) -> % if % has ATSHMUT
 max : (%, %) -> % if % has ATFINAG and S has ORDSET
 max : % -> S if % has ATFINAG and S has ORDSET
 max : (((S, S) -> Boolean), %) -> S if % has ATFINAG
 maxIndex : % -> Integer if Integer has ORDSET
 member? : (S, %) -> Boolean if % has ATFINAG and S has BASTYPE
 members : % -> List(S) if % has ATFINAG
 merge : (((S, S) -> Boolean), %, %) -> % if % has ATFINAG
 merge : (%, %) -> % if % has ATFINAG and S has ORDSET
 merge! : (((S, S) -> Boolean), %, %) -> %
 merge! : (%, %) -> % if S has ORDSET
 min : (%, %) -> % if % has ATFINAG and S has ORDSET
 min : % -> S if % has ATFINAG and S has ORDSET
 minIndex : % -> Integer if Integer has ORDSET
 more? : (%, NonNegativeInteger) -> Boolean
 new : (NonNegativeInteger, S) -> %
 node? : (%, %) -> Boolean if S has BASTYPE
 parts : % -> List(S) if % has ATFINAG
 position : ((S -> Boolean), %) -> Integer if % has ATFINAG
 position : (S, %) -> Integer if % has ATFINAG and S has BASTYPE
 position : (S, %, Integer) -> Integer if % has ATFINAG and S has BASTYPE
 qsetelt! : (%, Integer, S) -> S if % has ATSHMUT
 qsetfirst! : (%, S) -> S if % has ATSHMUT
 qsetrest! : (%, %) -> % if % has ATSHMUT
 reduce : (((S, S) -> S), %, S, S) -> S if % has ATFINAG and S has BASTYPE
 reduce : (((S, S) -> S), %, S) -> S if % has ATFINAG
 reduce : (((S, S) -> S), %) -> S if % has ATFINAG
 remove : (S, %) -> % if % has ATFINAG and S has BASTYPE
 remove : ((S -> Boolean), %) -> % if % has ATFINAG
 remove! : ((S -> Boolean), %) -> %
 remove! : (S, %) -> % if S has BASTYPE
 removeDuplicates : % -> % if % has ATFINAG and S has BASTYPE
 removeDuplicates! : % -> % if S has BASTYPE
 rest : (%, NonNegativeInteger) -> %
 reverse : % -> % if % has ATFINAG
 reverse! : % -> % if % has ATFINAG and % has ATSHMUT
 rightTrim : (%, S) -> % if % has ATFINAG and S has BASTYPE
 select : ((S -> Boolean), %) -> % if % has ATFINAG
 select! : ((S -> Boolean), %) -> %
 setDifference : (%, %) -> % if S has BASTYPE
 setIntersection : (%, %) -> % if S has BASTYPE
 setUnion : (%, %) -> % if S has BASTYPE
 setchildren! : (%, List(%)) -> % if % has ATSHMUT
 setelt! : (%, Integer, S) -> S if % has ATSHMUT
 setelt! : (%, UniversalSegment(Integer), S) -> S if % has ATSHMUT
 setelt! : (%, last, S) -> S if % has ATSHMUT
 setelt! : (%, rest, %) -> % if % has ATSHMUT
 setelt! : (%, first, S) -> S if % has ATSHMUT
 setelt! : (%, value, S) -> S if % has ATSHMUT
 setfirst! : (%, S) -> S if % has ATSHMUT
 setlast! : (%, S) -> S if % has ATSHMUT
 setrest! : (%, %) -> % if % has ATSHMUT
 setvalue! : (%, S) -> S if % has ATSHMUT
 size? : (%, NonNegativeInteger) -> Boolean
 smaller? : (%, %) -> Boolean if % has ATFINAG and S has COMPAR or % has ATFINAG and S has ORDSET
 sort : (((S, S) -> Boolean), %) -> % if % has ATFINAG
 sort : % -> % if % has ATFINAG and S has ORDSET
 sort! : (((S, S) -> Boolean), %) -> % if % has ATFINAG and % has ATSHMUT
 sort! : % -> % if % has ATFINAG and % has ATSHMUT and S has ORDSET
 sorted? : (((S, S) -> Boolean), %) -> Boolean if % has ATFINAG
 sorted? : % -> Boolean if % has ATFINAG and S has ORDSET
 split! : (%, NonNegativeInteger) -> % if % has ATSHMUT
 swap! : (%, Integer, Integer) -> Void if % has ATSHMUT
 trim : (%, S) -> % if % has ATFINAG and S has BASTYPE
 ?~=? : (%, %) -> Boolean if % has ATFINAG and S has BASTYPE or % has ATFINAG and S has COMPAR or % has ATFINAG and S has ORDSET or S has HASHABL or S has SETCAT

Subject: Be Bold !!

	( 15 subscribers )