diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet index 781994e..8f25bf9 100644 --- a/books/bookvol10.3.pamphlet +++ b/books/bookvol10.3.pamphlet @@ -142518,6 +142518,243 @@ U16Vector() : OneDimensionalArrayAggregate Integer == add \end{chunk} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +\section{domain U16MAT U16Matrix} + +\begin{chunk}{U16Matrix.input} +)set break resume +)sys rm -f U16Matrix.output +)spool U16Matrix.output +)set message test on +)set message auto off +)clear all + +--S 1 of 1 +)show U16Matrix +--R U16Matrix is a domain constructor +--R Abbreviation for U16Matrix is U16MAT +--R This constructor is exposed in this frame. +--R Issue )edit /tmp/ta.spad to see algebra source code for U16MAT +--R +--R------------------------------- Operations -------------------------------- +--R ?*? : (U16Vector,%) -> U16Vector ?*? : (%,U16Vector) -> U16Vector +--R ?*? : (Integer,%) -> % ?*? : (%,Integer) -> % +--R ?*? : (Integer,%) -> % ?*? : (%,%) -> % +--R ?+? : (%,%) -> % -? : % -> % +--R ?-? : (%,%) -> % antisymmetric? : % -> Boolean +--R coerce : U16Vector -> % column : (%,Integer) -> U16Vector +--R copy : % -> % diagonal? : % -> Boolean +--R diagonalMatrix : List(%) -> % empty : () -> % +--R empty? : % -> Boolean eq? : (%,%) -> Boolean +--R fill! : (%,Integer) -> % horizConcat : (%,%) -> % +--R matrix : List(List(Integer)) -> % maxColIndex : % -> Integer +--R maxRowIndex : % -> Integer minColIndex : % -> Integer +--R minRowIndex : % -> Integer ncols : % -> NonNegativeInteger +--R nrows : % -> NonNegativeInteger parts : % -> List(Integer) +--R qnew : (Integer,Integer) -> % row : (%,Integer) -> U16Vector +--R sample : () -> % square? : % -> Boolean +--R squareTop : % -> % symmetric? : % -> Boolean +--R transpose : % -> % transpose : U16Vector -> % +--R vertConcat : (%,%) -> % +--R #? : % -> NonNegativeInteger if $ has finiteAggregate +--R ?**? : (%,Integer) -> % if Integer has FIELD +--R ?**? : (%,NonNegativeInteger) -> % +--R ?/? : (%,Integer) -> % if Integer has FIELD +--R ?=? : (%,%) -> Boolean if Integer has SETCAT +--R any? : ((Integer -> Boolean),%) -> Boolean if $ has finiteAggregate +--R coerce : % -> OutputForm if Integer has SETCAT +--R columnSpace : % -> List(U16Vector) if Integer has EUCDOM +--R count : (Integer,%) -> NonNegativeInteger if $ has finiteAggregate and Integer has SETCAT +--R count : ((Integer -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate +--R determinant : % -> Integer if Integer has commutative(*) +--R diagonalMatrix : List(Integer) -> % +--R elt : (%,List(Integer),List(Integer)) -> % +--R elt : (%,Integer,Integer,Integer) -> Integer +--R elt : (%,Integer,Integer) -> Integer +--R eval : (%,List(Integer),List(Integer)) -> % if Integer has EVALAB(INT) and Integer has SETCAT +--R eval : (%,Integer,Integer) -> % if Integer has EVALAB(INT) and Integer has SETCAT +--R eval : (%,Equation(Integer)) -> % if Integer has EVALAB(INT) and Integer has SETCAT +--R eval : (%,List(Equation(Integer))) -> % if Integer has EVALAB(INT) and Integer has SETCAT +--R every? : ((Integer -> Boolean),%) -> Boolean if $ has finiteAggregate +--R exquo : (%,Integer) -> Union(%,"failed") if Integer has INTDOM +--R hash : % -> SingleInteger if Integer has SETCAT +--R inverse : % -> Union(%,"failed") if Integer has FIELD +--R latex : % -> String if Integer has SETCAT +--R less? : (%,NonNegativeInteger) -> Boolean +--R listOfLists : % -> List(List(Integer)) +--R map : (((Integer,Integer) -> Integer),%,%,Integer) -> % +--R map : (((Integer,Integer) -> Integer),%,%) -> % +--R map : ((Integer -> Integer),%) -> % +--R map! : ((Integer -> Integer),%) -> % +--R matrix : (NonNegativeInteger,NonNegativeInteger,((Integer,Integer) -> Integer)) -> % +--R member? : (Integer,%) -> Boolean if $ has finiteAggregate and Integer has SETCAT +--R members : % -> List(Integer) if $ has finiteAggregate +--R minordet : % -> Integer if Integer has commutative(*) +--R more? : (%,NonNegativeInteger) -> Boolean +--R new : (NonNegativeInteger,NonNegativeInteger,Integer) -> % +--R nullSpace : % -> List(U16Vector) if Integer has INTDOM +--R nullity : % -> NonNegativeInteger if Integer has INTDOM +--R pfaffian : % -> Integer if Integer has COMRING +--R qelt : (%,Integer,Integer) -> Integer +--R qsetelt! : (%,Integer,Integer,Integer) -> Integer +--R rank : % -> NonNegativeInteger if Integer has INTDOM +--R rowEchelon : % -> % if Integer has EUCDOM +--R scalarMatrix : (NonNegativeInteger,Integer) -> % +--R setColumn! : (%,Integer,U16Vector) -> % +--R setRow! : (%,Integer,U16Vector) -> % +--R setelt : (%,List(Integer),List(Integer),%) -> % +--R setelt : (%,Integer,Integer,Integer) -> Integer +--R setsubMatrix! : (%,Integer,Integer,%) -> % +--R size? : (%,NonNegativeInteger) -> Boolean +--R subMatrix : (%,Integer,Integer,Integer,Integer) -> % +--R swapColumns! : (%,Integer,Integer) -> % +--R swapRows! : (%,Integer,Integer) -> % +--R zero : (NonNegativeInteger,NonNegativeInteger) -> % +--R ?~=? : (%,%) -> Boolean if Integer has SETCAT +--R +--E 1 + +)spool +)lisp (bye) +\end{chunk} +\begin{chunk}{U16Matrix.help} +==================================================================== +U16Matrix examples +==================================================================== + +See Also: +o )show U16Matrix +o )show U32Matrix + +\end{chunk} +\pagehead{U16Matrix}{U16MAT} +\pagepic{ps/v103u16matrix.eps}{U16MAT}{1.00} +{\bf See}\\ + +{\bf Exports:}\\ +\begin{tabular}{llll} +\cross{U16MAT}{\#{}?} & +\cross{U16MAT}{-?} & +\cross{U16MAT}{?**?} & +\cross{U16MAT}{?*?} \\ +\cross{U16MAT}{?+?} & +\cross{U16MAT}{?-?} & +\cross{U16MAT}{?/?} & +\cross{U16MAT}{?=?} \\ +\cross{U16MAT}{?\~{}=?} & +\cross{U16MAT}{antisymmetric?} & +\cross{U16MAT}{any?} & +\cross{U16MAT}{coerce} \\ +\cross{U16MAT}{column} & +\cross{U16MAT}{columnSpace} & +\cross{U16MAT}{copy} & +\cross{U16MAT}{count} \\ +\cross{U16MAT}{determinant} & +\cross{U16MAT}{diagonal?} & +\cross{U16MAT}{diagonalMatrix} & +\cross{U16MAT}{elt} \\ +\cross{U16MAT}{empty} & +\cross{U16MAT}{empty?} & +\cross{U16MAT}{eq?} & +\cross{U16MAT}{eval} \\ +\cross{U16MAT}{every?} & +\cross{U16MAT}{exquo} & +\cross{U16MAT}{fill!} & +\cross{U16MAT}{hash} \\ +\cross{U16MAT}{horizConcat} & +\cross{U16MAT}{inverse} & +\cross{U16MAT}{latex} & +\cross{U16MAT}{less?} \\ +\cross{U16MAT}{listOfLists} & +\cross{U16MAT}{map} & +\cross{U16MAT}{map!} & +\cross{U16MAT}{matrix} \\ +\cross{U16MAT}{maxColIndex} & +\cross{U16MAT}{maxRowIndex} & +\cross{U16MAT}{member?} & +\cross{U16MAT}{members} \\ +\cross{U16MAT}{minColIndex} & +\cross{U16MAT}{minRowIndex} & +\cross{U16MAT}{minordet} & +\cross{U16MAT}{more?} \\ +\cross{U16MAT}{ncols} & +\cross{U16MAT}{new} & +\cross{U16MAT}{nrows} & +\cross{U16MAT}{nullSpace} \\ +\cross{U16MAT}{nullity} & +\cross{U16MAT}{parts} & +\cross{U16MAT}{pfaffian} & +\cross{U16MAT}{qelt} \\ +\cross{U16MAT}{qnew} & +\cross{U16MAT}{qsetelt!} & +\cross{U16MAT}{rank} & +\cross{U16MAT}{row} \\ +\cross{U16MAT}{rowEchelon} & +\cross{U16MAT}{sample} & +\cross{U16MAT}{scalarMatrix} & +\cross{U16MAT}{setColumn!} \\ +\cross{U16MAT}{setRow!} & +\cross{U16MAT}{setelt} & +\cross{U16MAT}{setsubMatrix!} & +\cross{U16MAT}{size?} \\ +\cross{U16MAT}{square?} & +\cross{U16MAT}{squareTop} & +\cross{U16MAT}{subMatrix} & +\cross{U16MAT}{swapColumns!} \\ +\cross{U16MAT}{swapRows!} & +\cross{U16MAT}{symmetric?} & +\cross{U16MAT}{transpose} & +\cross{U16MAT}{vertConcat} \\ +\cross{U16MAT}{zero} & +\end{tabular} + +\begin{chunk}{domain U16MAT U16Matrix} +)abbrev domain U16MAT U16Matrix +++ Description: This is a low-level domain which implements matrices +++ (two dimensional arrays) of 16-bit integers. +++ Indexing is 0 based, there is no bound checking (unless +++ provided by lower level). +U16Matrix : MatrixCategory(Integer, + U16Vector, + U16Vector) with + qnew : (Integer, Integer) -> % + ++ qnew(n, m) creates a new n by m matrix of zeros. + ++ + ++X qnew(3,4)$U16Matrix() + == add + + R ==> Integer + + Qelt2 ==> AREF2U16$Lisp + Qsetelt2 ==> SETAREF2U16$Lisp + Qnrows ==> ANROWSU16$Lisp + Qncols ==> ANCOLSU16$Lisp + Qnew ==> MAKEMATRIXU16$Lisp + Qnew1 ==> MAKEMATRIX1U16$Lisp + + minRowIndex x == 0 + minColIndex x == 0 + nrows x == Qnrows(x) + ncols x == Qncols(x) + maxRowIndex x == Qnrows(x) - 1 + maxColIndex x == Qncols(x) - 1 + + qelt(m, i, j) == Qelt2(m, i, j) + elt(m : %, i : Integer, j : Integer) : R == Qelt2(m, i, j) + qsetelt!(m, i, j, r) == Qsetelt2(m, i, j, r) + setelt(m : %, i : Integer, j : Integer, r : R) == Qsetelt2(m, i, j, r) + + empty() == Qnew(0$Integer, 0$Integer) + qnew(rows, cols) == Qnew(rows, cols) + new(rows, cols, a) == Qnew1(rows, cols, a) + +\end{chunk} +\begin{chunk}{U16MAT.dotabb} +"U16MAT" [color="#88FF44",href="bookvol10.3.pdf#nameddest=U16MAT"] +"MATCAT" [color="#4488FF",href="bookvol10.2.pdf#nameddest=MATCAT"] +"U16MAT" -> "MATCAT" + +\end{chunk} +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% \section{domain U32MAT U32Matrix} \begin{chunk}{U32Matrix.input} @@ -142622,6 +142859,7 @@ U32Matrix examples ==================================================================== See Also: +o )show U16Matrix o )show U32Matrix \end{chunk} @@ -142716,9 +142954,9 @@ U32Matrix : MatrixCategory(Integer, U32Vector, U32Vector) with qnew : (Integer, Integer) -> % - ++ qnew(n, m) creates a new uninitialized n by m matrix. + ++ qnew(n, m) creates a new n by m matrix of zeros. ++ - ++X qnew(3,4) + ++X qnew(3,4)$U32Matrix() == add R ==> Integer @@ -154079,10 +154317,11 @@ Note that this code is not included in the generated catdef.spad file. \getchunk{domain UTSZ UnivariateTaylorSeriesCZero} \getchunk{domain UNISEG UniversalSegment} +\getchunk{domain U16MAT U16Matrix} +\getchunk{domain U32MAT U32Matrix} \getchunk{domain U8VEC U8Vector} \getchunk{domain U16VEC U16Vector} \getchunk{domain U32VEC U32Vector} -\getchunk{domain U32MAT U32Matrix} \getchunk{domain VARIABLE Variable} \getchunk{domain VECTOR Vector} \getchunk{domain VOID Void} diff --git a/books/bookvol5.pamphlet b/books/bookvol5.pamphlet index d8d132a..b9ef07f 100644 --- a/books/bookvol5.pamphlet +++ b/books/bookvol5.pamphlet @@ -24644,10 +24644,11 @@ otherwise the new algebra won't be loaded by the interpreter when needed. (|UniversalSegment| . UNISEG) (|UniversalSegmentFunctions2| . UNISEG2) (|UserDefinedVariableOrdering| . UDVO) + (|U16Matrix| . U16MAT) + (|U32Matrix| . U32MAT) (|U8Vector| . U8VEC) (|U16Vector| . U16VEC) (|U32Vector| . U32VEC) - (|U32Matrix| . U32MAT) (|Vector| . VECTOR) (|VectorFunctions2| . VECTOR2) (|ViewDefaultsPackage| . VIEWDEF) @@ -39408,6 +39409,52 @@ Given a form, $u$, we try to recover the input line that created it. \end{chunk} +\section{U16Matrix} + +\defmacro{aref2U16} +\begin{chunk}{defmacro aref2U16} +(defmacro aref2U16 (v i j) + `(aref (the (simple-array (unsigned-byte 16) (* *)) ,v) ,i ,j)) + +\end{chunk} + +\defmacro{setAref2U16} +\begin{chunk}{defmacro setAref2U16} +(defmacro setAref2U16 (v i j s) + `(setf (aref (the (simple-array (unsigned-byte 16) (* *)) ,v) ,i ,j), s)) + +\end{chunk} + +\defmacro{anrowsU16} +\begin{chunk}{defmacro anrowsU16} +(defmacro anrowsU16 (v) + `(array-dimension (the (simple-array (unsigned-byte 16) (* *)) ,v) 0)) + +\end{chunk} + +\defmacro{ancolsU16} +\begin{chunk}{defmacro ancolsU16} +(defmacro ancolsU16 (v) + `(array-dimension (the (simple-array (unsigned-byte 16) (* *)) ,v) 1)) + +\end{chunk} + +\defmacro{makeMatrixU16} +\begin{chunk}{defmacro makeMatrixU16} +(defmacro makeMatrixU16 (n m) + `(make-array (list ,n ,m) :element-type '(unsigned-byte 16) + :initial-element 0)) + +\end{chunk} + +\defmacro{makeMatrix1U16} +\begin{chunk}{defmacro makeMatrix1U16} +(defmacro makeMatrix1U16 (n m s) + `(make-array (list ,n ,m) :element-type '(unsigned-byte 16) + :initial-element ,s)) + +\end{chunk} + \section{DirectProduct} \defun{vec2list}{vec2list} \begin{chunk}{defun vec2list} @@ -43902,8 +43949,11 @@ This needs to work off the internal exposure list, not the file. ;;; above level 0 macros +\getchunk{defmacro ancolsU16} \getchunk{defmacro ancolsU32} +\getchunk{defmacro anrowsU16} \getchunk{defmacro anrowsU32} +\getchunk{defmacro aref2U16} \getchunk{defmacro aref2U32} \getchunk{defmacro assq} \getchunk{defmacro bvec-setelt} @@ -43965,6 +44015,8 @@ This needs to work off the internal exposure list, not the file. \getchunk{defmacro make-double-matrix1} \getchunk{defmacro make-double-vector} \getchunk{defmacro make-double-vector1} +\getchunk{defmacro makeMatrixU16} +\getchunk{defmacro makeMatrix1U16} \getchunk{defmacro makeMatrixU32} \getchunk{defmacro makeMatrix1U32} \getchunk{defmacro qvlenU8} @@ -43972,6 +44024,7 @@ This needs to work off the internal exposure list, not the file. \getchunk{defmacro qvlenU32} \getchunk{defmacro Rest} \getchunk{defmacro startsId?} +\getchunk{defmacro setAref2U16} \getchunk{defmacro setAref2U32} \getchunk{defmacro seteltU8} \getchunk{defmacro seteltU16} diff --git a/books/ps/v103u16matrix.eps b/books/ps/v103u16matrix.eps new file mode 100644 index 0000000..a13c031 --- /dev/null +++ b/books/ps/v103u16matrix.eps @@ -0,0 +1,278 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%Creator: graphviz version 2.26.3 (20100126.1600) +%%Title: pic +%%Pages: 1 +%%BoundingBox: 36 36 118 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw text fitted to its expected width +/alignedtext { % width text + /text exch def + /width exch def + gsave + width 0 gt { + [] 0 setdash + text stringwidth pop width exch sub text length div 0 text ashow + } if + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +setupLatin1 +%%Page: 1 1 +%%PageBoundingBox: 36 36 118 152 +%%PageOrientation: Portrait +0 0 1 beginpage +gsave +36 36 82 116 boxprim clip newpath +1 1 set_scale 0 rotate 40 41 translate +0.16355 0.45339 0.92549 graphcolor +newpath -4 -5 moveto +-4 112 lineto +79 112 lineto +79 -5 lineto +closepath fill +1 setlinewidth +0.16355 0.45339 0.92549 graphcolor +newpath -4 -5 moveto +-4 112 lineto +79 112 lineto +79 -5 lineto +closepath stroke +% U16MAT +gsave +[ /Rect [ 0 72 74 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.3.pdf#nameddest=U16MAT) >> + /Subtype /Link +/ANN pdfmark +0.27273 0.73333 1 nodecolor +newpath 74 108 moveto +0 108 lineto +0 72 lineto +74 72 lineto +closepath fill +1 setlinewidth +filled +0.27273 0.73333 1 nodecolor +newpath 74 108 moveto +0 108 lineto +0 72 lineto +74 72 lineto +closepath stroke +0 0 0 nodecolor +14 /Times-Roman set_font +7.5 86.4 moveto 59 (U16MAT) alignedtext +grestore +% MATCAT +gsave +[ /Rect [ 0 0 74 36 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=MATCAT) >> + /Subtype /Link +/ANN pdfmark +0.60606 0.73333 1 nodecolor +newpath 74 36 moveto +0 36 lineto +0 0 lineto +74 0 lineto +closepath fill +1 setlinewidth +filled +0.60606 0.73333 1 nodecolor +newpath 74 36 moveto +0 36 lineto +0 0 lineto +74 0 lineto +closepath stroke +0 0 0 nodecolor +14 /Times-Roman set_font +8 14.4 moveto 58 (MATCAT) alignedtext +grestore +% U16MAT->MATCAT +gsave +1 setlinewidth +0 0 0 edgecolor +newpath 37 71.83 moveto +37 64.13 37 54.97 37 46.42 curveto +stroke +0 0 0 edgecolor +newpath 40.5 46.41 moveto +37 36.41 lineto +33.5 46.41 lineto +closepath fill +1 setlinewidth +solid +0 0 0 edgecolor +newpath 40.5 46.41 moveto +37 36.41 lineto +33.5 46.41 lineto +closepath stroke +grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +end +restore +%%EOF diff --git a/changelog b/changelog index b04e6c1..66a526e 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,16 @@ +20130226 tpd src/axiom-website/patches.html 20130226.02.tpd.patch +20130226 tpd books/ps/v103u16matrix.eps added +20130226 tpd books/bookvol10.3 add U16Matrix +20130226 tpd books/bookvol5 support for U16Matrix +20130226 tpd src/algebra/Makefile add U16Matrix +20130226 tpd src/input/machinearithmetic.input add U16Matrix +20130226 tpd src/share/algebra/dependents.daase updated +20130226 tpd src/share/algebra/users.daase updated +20130226 tpd src/share/algebra/operation.daase updated +20130226 tpd src/share/algebra/interp.daase updated +20130226 tpd src/share/algebra/compress.daase updated +20130226 tpd src/share/algebra/category.daase updated +20130226 tpd src/share/algebra/browse.daase updated 20130226 tpd src/axiom-website/patches.html 20130226.01.tpd.patch 20130226 tpd books/bookvol10.4 comment out bad code in GUESS 20130225 tpd src/axiom-website/patches.html 20130225.01.tpd.patch diff --git a/src/algebra/Makefile.pamphlet b/src/algebra/Makefile.pamphlet index cfe129b..a7d5082 100644 --- a/src/algebra/Makefile.pamphlet +++ b/src/algebra/Makefile.pamphlet @@ -4881,7 +4881,7 @@ LAYER9=\ ${OUT}/LODO1.o ${OUT}/LODO2.o ${OUT}/LPOLY.o \ ${OUT}/LSMP.o ${OUT}/LSMP1.o ${OUT}/MATCAT2.o \ ${OUT}/PROJPL.o ${OUT}/PTCAT.o ${OUT}/STRICAT.o ${OUT}/TRIMAT.o \ - ${OUT}/U32MAT.o \ + ${OUT}/U16MAT.o ${OUT}/U32MAT.o \ layer9done @ @@ -5116,6 +5116,19 @@ LAYER9=\ /*"ULSCAT" -> {"TRANFUN"; "TRIGCAT"; "ATRIG"; "HYPCAT"; "AHYP"}*/ /*"ULSCAT" -> {"ELEMFUN"; "FIELD"; "DIVRING"}*/ +"U16MAT" [color="#88FF44",href="bookvol10.3.pdf#nameddest=U16MAT"] +"U16MAT" -> "MATCAT" +/*"U16MAT" -> {"ARR2CAT"; "HOAGG"; "AGG"; "TYPE"; "SETCAT"; "BASTYPE"}*/ +/*"U16MAT" -> {"KOERCE"; "EVALAB"; "IEVALAB"; "INS"; "UFD"; "GCDDOM"}*/ +/*"U16MAT" -> {"INTDOM"; "COMRING"; "RING"; "RNG"; "ABELGRP"; "CABMON"}*/ +/*"U16MAT" -> {"ABELMON"; "ABELSG"; "SGROUP"; "MONOID"; "LMODULE"}*/ +/*"U16MAT" -> {"BMODULE"; "RMODULE"; "ALGEBRA"; "MODULE"; "ENTIRER"}*/ +/*"U16MAT" -> {"EUCDOM"; "PID"; "OINTDOM"; "ORDRING"; "OAGROUP"}*/ +/*"U16MAT" -> {"OCAMON"; "OAMON"; "OASGP"; "ORDSET"; "DIFRING"}*/ +/*"U16MAT" -> {"KONVERT"; "RETRACT"; "LINEXP"; "PATMAB"; "CFCAT"; "REAL"}*/ +/*"U16MAT" -> {"CHARZ"; "STEP"; "A1AGG"; "FLAGG"; "LNAGG"; "IXAGG"}*/ +/*"U16MAT" -> {"ELTAGG"; "ELTAB"; "CLAGG"; "INT"; "OM"; "FIELD"; "DIVRING"}*/ + "U32MAT" [color="#88FF44",href="bookvol10.3.pdf#nameddest=U32MAT"] "U32MAT" -> "MATCAT" /*"U32MAT" -> {"ARR2CAT"; "HOAGG"; "AGG"; "TYPE"; "SETCAT"; "BASTYPE"}*/ @@ -18370,6 +18383,10 @@ REGRESS= \ UnivariateTaylorSeriesCZero.regress \ UnivariateTaylorSeriesCategory.regress \ UniversalSegment.regress \ + U16Matrix.regress \ + U32Matrix.regress \ + U8Vector.regress \ + U16Vector.regress \ U32Vector.regress \ Variable.regress \ Vector.regress \ diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html index a229b84..b6e75e2 100644 --- a/src/axiom-website/patches.html +++ b/src/axiom-website/patches.html @@ -3989,5 +3989,7 @@ buglist add 7233: fill! operation from U8Vector does not show up books/bookvol10.3 add U32Matrix 20130226.01.tpd.patch books/bookvol10.4 comment out bad code in GUESS +20130226.02.tpd.patch +books/bookvol10.3 add U16Matrix diff --git a/src/input/machinearithmetic.input.pamphlet b/src/input/machinearithmetic.input.pamphlet index 56fd17b..eb8b768 100644 --- a/src/input/machinearithmetic.input.pamphlet +++ b/src/input/machinearithmetic.input.pamphlet @@ -18,241 +18,261 @@ )set message auto off )clear all ---S 1 of 34 +--S 1 of 35 t1:=empty()$U32Vector --R --R (1) [] --R Type: U32Vector --E 1 ---S 2 of 34 +--S 2 of 35 t2:=new(10,10)$U32Vector --R --R (2) [10,10,10,10,10,10,10,10,10,10] --R Type: U32Vector --E 2 ---S 3 of 34 +--S 3 of 35 t3:=qelt(t2,2) --R --R (3) 10 --R Type: PositiveInteger --E 3 ---S 4 of 34 +--S 4 of 35 t4:=elt(t2,2) --R --R (4) 10 --R Type: PositiveInteger --E 4 ---S 5 of 34 +--S 5 of 35 t5:=t2.2 --R --R (5) 10 --R Type: PositiveInteger --E 5 ---S 6 of 34 +--S 6 of 35 t6:=qsetelt!(t2,2,5) --R --R (6) 5 --R Type: PositiveInteger --E 6 ---S 7 of 34 +--S 7 of 35 t2.2 --R --R (7) 5 --R Type: PositiveInteger --E 7 ---S 8 of 34 +--S 8 of 35 t7:=setelt(t2,3,6) --R --R (8) 6 --R Type: PositiveInteger --E 8 ---S 9 of 34 +--S 9 of 35 t2.3 --R --R (9) 6 --R Type: PositiveInteger --E 9 ---S 10 of 34 +--S 10 of 35 #t2 --R --R (10) 10 --R Type: PositiveInteger --E 10 ---S 11 of 34 +--S 11 of 35 t8:=fill!(t2,7) --R --R (11) [7,7,7,7,7,7,7,7,7,7] --R Type: U32Vector --E 11 ---S 12 of 34 +--S 12 of 35 ta:=empty()$U16Vector --R --R (12) [] --R Type: U16Vector --E 12 ---S 13 of 34 +--S 13 of 35 tb:=new(10,10)$U16Vector --R --R (13) [10,10,10,10,10,10,10,10,10,10] --R Type: U16Vector --E 13 ---S 14 of 34 +--S 14 of 35 tc:=qelt(tb,2) --R --R (14) 10 --R Type: PositiveInteger --E 14 ---S 15 of 34 +--S 15 of 35 td:=elt(tb,2) --R --R (15) 10 --R Type: PositiveInteger --E 15 ---S 16 of 34 +--S 16 of 35 te:=tb.2 --R --R (16) 10 --R Type: PositiveInteger --E 16 ---S 17 of 34 +--S 17 of 35 tf:=qsetelt!(tb,2,5) --R --R (17) 5 --R Type: PositiveInteger --E 17 ---S 18 of 34 +--S 18 of 35 tb.2 --R --R (18) 5 --R Type: PositiveInteger --E 18 ---S 19 of 34 +--S 19 of 35 tg:=setelt(tb,3,6) --R --R (19) 6 --R Type: PositiveInteger --E 19 ---S 20 of 34 +--S 20 of 35 tb.3 --R --R (20) 6 --R Type: PositiveInteger --E 20 ---S 21 of 34 +--S 21 of 35 #tb --R --R (21) 10 --R Type: PositiveInteger --E 21 ---S 22 of 34 +--S 22 of 35 th:=fill!(tb,7) --R --R (22) [7,7,7,7,7,7,7,7,7,7] --R Type: U16Vector --E 22 ---S 23 of 34 +--S 23 of 35 t1a:=empty()$U8Vector --R --R (23) [] --R Type: U8Vector --E 23 ---S 24 of 34 +--S 24 of 35 t1b:=new(10,10)$U8Vector --R --R (24) [10,10,10,10,10,10,10,10,10,10] --R Type: U8Vector --E 24 ---S 25 of 34 +--S 25 of 35 t1c:=qelt(t1b,2) --R --R (25) 10 --R Type: PositiveInteger --E 25 ---S 26 of 34 +--S 26 of 35 t1d:=elt(t1b,2) --R --R (26) 10 --R Type: PositiveInteger --E 26 ---S 27 of 34 +--S 27 of 35 t1e:=t1b.2 --R --R (27) 10 --R Type: PositiveInteger --E 27 ---S 28 of 34 +--S 28 of 35 t1f:=qsetelt!(t1b,2,5) --R --R (28) 5 --R Type: PositiveInteger --E 28 ---S 29 of 34 +--S 29 of 35 t1b.2 --R --R (29) 5 --R Type: PositiveInteger --E 29 ---S 30 of 34 +--S 30 of 35 t1g:=setelt(t1b,3,6) --R --R (30) 6 --R Type: PositiveInteger --E 30 ---S 31 of 34 +--S 31 of 35 t1b.3 --R --R (31) 6 --R Type: PositiveInteger --E 31 ---S 32 of 34 +--S 32 of 35 #t1b --R --R (32) 10 --R Type: PositiveInteger --E 32 ---S 33 of 34 +--S 33 of 35 t1h:=fill!(t1b,7) --R --R (33) [7,7,7,7,7,7,7,7,7,7] --R Type: U8Vector --E 33 ---S 34 of 34 +--S 34 of 35 v32:=qnew(3,4)$U32Matrix() +--R +--R +--R +0 0 0 0+ +--R | | +--R (34) |0 0 0 0| +--R | | +--R +0 0 0 0+ +--R Type: U32Matrix --E 34 +--S 35 of 35 +v32:=qnew(3,4)$U16Matrix() +--R +--R +--R +0 0 0 0+ +--R | | +--R (35) |0 0 0 0| +--R | | +--R +0 0 0 0+ +--R Type: U16Matrix +--E 35 + )spool )lisp (bye) diff --git a/src/share/algebra/browse.daase b/src/share/algebra/browse.daase index ae720ff..bb14311 100644 --- a/src/share/algebra/browse.daase +++ b/src/share/algebra/browse.daase @@ -1,59 +1,59 @@ -(2472069 . 3524719204) +(2385209 . 3570849592) (-18 A S) -((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) +((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically, these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property, that is, any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over, and access to, elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) NIL NIL (-19 S) -((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically,{} these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property,{} that is,{} any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over,{} and access to,{} elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) -((-4536 . T) (-4535 . T) (-2982 . T)) +((|constructor| (NIL "One-dimensional-array aggregates serves as models for one-dimensional arrays. Categorically, these aggregates are finite linear aggregates with the \\spadatt{shallowlyMutable} property, that is, any component of the array may be changed without affecting the identity of the overall array. Array data structures are typically represented by a fixed area in storage and cannot efficiently grow or shrink on demand as can list structures (see however \\spadtype{FlexibleArray} for a data structure which is a cross between a list and an array). Iteration over, and access to, elements of arrays is extremely fast (and often can be optimized to open-code). Insertion and deletion however is generally slow since an entirely new data structure must be created for the result."))) +((-4572 . T) (-4571 . T) (-4317 . T)) NIL (-20 S) -((|constructor| (NIL "The class of abelian groups,{} \\spadignore{i.e.} additive monoids where each element has an additive inverse. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{-(-x) = x}\\spad{\\br} \\tab{5}\\spad{x+(-x) = 0}")) (* (($ (|Integer|) $) "\\spad{n*x} is the product of \\spad{x} by the integer \\spad{n}.")) (- (($ $ $) "\\spad{x-y} is the difference of \\spad{x} and \\spad{y} \\spadignore{i.e.} \\spad{x + (-y)}.") (($ $) "\\spad{-x} is the additive inverse of \\spad{x}."))) +((|constructor| (NIL "The class of abelian groups, \\spadignore{i.e.} additive monoids where each element has an additive inverse. \\blankline Axioms\\br \\tab{5}\\spad{-(-x) = x}\\br \\tab{5}\\spad{x+(-x) = 0}")) (* (($ (|Integer|) $) "\\spad{n*x} is the product of \\spad{x} by the integer \\spad{n.}")) (- (($ $ $) "\\spad{x-y} is the difference of \\spad{x} and \\spad{y} \\spadignore{i.e.} \\spad{x + (-y)}.") (($ $) "\\spad{-x} is the additive inverse of \\spad{x.}"))) NIL NIL (-21) -((|constructor| (NIL "The class of abelian groups,{} \\spadignore{i.e.} additive monoids where each element has an additive inverse. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{-(-x) = x}\\spad{\\br} \\tab{5}\\spad{x+(-x) = 0}")) (* (($ (|Integer|) $) "\\spad{n*x} is the product of \\spad{x} by the integer \\spad{n}.")) (- (($ $ $) "\\spad{x-y} is the difference of \\spad{x} and \\spad{y} \\spadignore{i.e.} \\spad{x + (-y)}.") (($ $) "\\spad{-x} is the additive inverse of \\spad{x}."))) +((|constructor| (NIL "The class of abelian groups, \\spadignore{i.e.} additive monoids where each element has an additive inverse. \\blankline Axioms\\br \\tab{5}\\spad{-(-x) = x}\\br \\tab{5}\\spad{x+(-x) = 0}")) (* (($ (|Integer|) $) "\\spad{n*x} is the product of \\spad{x} by the integer \\spad{n.}")) (- (($ $ $) "\\spad{x-y} is the difference of \\spad{x} and \\spad{y} \\spadignore{i.e.} \\spad{x + (-y)}.") (($ $) "\\spad{-x} is the additive inverse of \\spad{x.}"))) NIL NIL (-22 S) -((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with an additive identity element. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{leftIdentity(\"+\":(\\%,{}\\%)->\\%,{}0)}\\tab{5}\\spad{ 0+x=x }\\spad{\\br} \\tab{5}\\spad{rightIdentity(\"+\":(\\%,{}\\%)->\\%,{}0)}\\tab{4}\\spad{ x+0=x }")) (* (($ (|NonNegativeInteger|) $) "\\spad{n * x} is left-multiplication by a non negative integer")) (|zero?| (((|Boolean|) $) "\\spad{zero?(x)} tests if \\spad{x} is equal to 0.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) ((|Zero|) (($) "0 is the additive identity element."))) +((|constructor| (NIL "The class of multiplicative monoids, \\spadignore{i.e.} semigroups with an additive identity element. \\blankline Axioms\\br \\tab{5}\\spad{leftIdentity(\"+\":(\\%,\\%)->\\%,0)}\\tab{5}\\spad{ 0+x=x }\\br \\tab{5}\\spad{rightIdentity(\"+\":(\\%,\\%)->\\%,0)}\\tab{4}\\spad{ x+0=x }")) (* (($ (|NonNegativeInteger|) $) "\\spad{n * \\spad{x}} is left-multiplication by a non negative integer")) (|zero?| (((|Boolean|) $) "\\spad{zero?(x)} tests if \\spad{x} is equal to 0.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) ((|Zero|) (($) "0 is the additive identity element."))) NIL NIL (-23) -((|constructor| (NIL "The class of multiplicative monoids,{} \\spadignore{i.e.} semigroups with an additive identity element. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{leftIdentity(\"+\":(\\%,{}\\%)->\\%,{}0)}\\tab{5}\\spad{ 0+x=x }\\spad{\\br} \\tab{5}\\spad{rightIdentity(\"+\":(\\%,{}\\%)->\\%,{}0)}\\tab{4}\\spad{ x+0=x }")) (* (($ (|NonNegativeInteger|) $) "\\spad{n * x} is left-multiplication by a non negative integer")) (|zero?| (((|Boolean|) $) "\\spad{zero?(x)} tests if \\spad{x} is equal to 0.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) ((|Zero|) (($) "0 is the additive identity element."))) +((|constructor| (NIL "The class of multiplicative monoids, \\spadignore{i.e.} semigroups with an additive identity element. \\blankline Axioms\\br \\tab{5}\\spad{leftIdentity(\"+\":(\\%,\\%)->\\%,0)}\\tab{5}\\spad{ 0+x=x }\\br \\tab{5}\\spad{rightIdentity(\"+\":(\\%,\\%)->\\%,0)}\\tab{4}\\spad{ x+0=x }")) (* (($ (|NonNegativeInteger|) $) "\\spad{n * \\spad{x}} is left-multiplication by a non negative integer")) (|zero?| (((|Boolean|) $) "\\spad{zero?(x)} tests if \\spad{x} is equal to 0.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) ((|Zero|) (($) "0 is the additive identity element."))) NIL NIL (-24 S) -((|constructor| (NIL "The class of all additive (commutative) semigroups,{} \\spadignore{i.e.} a set with a commutative and associative operation \\spadop{+}. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{associative(\"+\":(\\%,{}\\%)->\\%)}\\tab{5}\\spad{ (x+y)+z = x+(y+z) }\\spad{\\br} \\tab{6}\\spad{commutative(\"+\":(\\%,{}\\%)->\\%)}\\tab{5}\\spad{ x+y = y+x }")) (* (($ (|PositiveInteger|) $) "\\spad{n*x} computes the left-multiplication of \\spad{x} by the positive integer \\spad{n}. This is equivalent to adding \\spad{x} to itself \\spad{n} times.")) (+ (($ $ $) "\\spad{x+y} computes the sum of \\spad{x} and \\spad{y}."))) +((|constructor| (NIL "The class of all additive (commutative) semigroups, \\spadignore{i.e.} a set with a commutative and associative operation \\spadop{+}. \\blankline Axioms\\br \\tab{5}\\spad{associative(\"+\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ (x+y)+z = x+(y+z) }\\br \\tab{6}\\spad{commutative(\"+\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ x+y = \\spad{y+x} }")) (* (($ (|PositiveInteger|) $) "\\spad{n*x} computes the left-multiplication of \\spad{x} by the positive integer \\spad{n.} This is equivalent to adding \\spad{x} to itself \\spad{n} times.")) (+ (($ $ $) "\\spad{x+y} computes the sum of \\spad{x} and \\spad{y.}"))) NIL NIL (-25) -((|constructor| (NIL "The class of all additive (commutative) semigroups,{} \\spadignore{i.e.} a set with a commutative and associative operation \\spadop{+}. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{associative(\"+\":(\\%,{}\\%)->\\%)}\\tab{5}\\spad{ (x+y)+z = x+(y+z) }\\spad{\\br} \\tab{6}\\spad{commutative(\"+\":(\\%,{}\\%)->\\%)}\\tab{5}\\spad{ x+y = y+x }")) (* (($ (|PositiveInteger|) $) "\\spad{n*x} computes the left-multiplication of \\spad{x} by the positive integer \\spad{n}. This is equivalent to adding \\spad{x} to itself \\spad{n} times.")) (+ (($ $ $) "\\spad{x+y} computes the sum of \\spad{x} and \\spad{y}."))) +((|constructor| (NIL "The class of all additive (commutative) semigroups, \\spadignore{i.e.} a set with a commutative and associative operation \\spadop{+}. \\blankline Axioms\\br \\tab{5}\\spad{associative(\"+\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ (x+y)+z = x+(y+z) }\\br \\tab{6}\\spad{commutative(\"+\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ x+y = \\spad{y+x} }")) (* (($ (|PositiveInteger|) $) "\\spad{n*x} computes the left-multiplication of \\spad{x} by the positive integer \\spad{n.} This is equivalent to adding \\spad{x} to itself \\spad{n} times.")) (+ (($ $ $) "\\spad{x+y} computes the sum of \\spad{x} and \\spad{y.}"))) NIL NIL (-26 S) -((|constructor| (NIL "Model for algebraically closed fields.")) (|zerosOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zerosOf(\\spad{p},{} \\spad{y}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zerosOf(a,{}\\spad{x})") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{zerosOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zerosOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{zerosOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^2+2*x-13 \\spad{X} zerosOf(a)")) (|zeroOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zeroOf(\\spad{p},{} \\spad{y}) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zeroOf(a,{}\\spad{x})") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{zeroOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zeroOf(a)") (($ (|Polynomial| $)) "\\indented{1}{zeroOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^2+2*x-13 \\spad{X} zeroOf(a)")) (|rootsOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootsOf(\\spad{p},{} \\spad{y}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a,{}\\spad{x})") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootsOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{rootsOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a)")) (|rootOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootOf(\\spad{p},{} \\spad{y}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a,{}\\spad{x})") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a)") (($ (|Polynomial| $)) "\\indented{1}{rootOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a)"))) +((|constructor| (NIL "Model for algebraically closed fields.")) (|zerosOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)")) (|zeroOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)") (($ (|Polynomial| $)) "\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)")) (|rootsOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)")) (|rootOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)") (($ (|Polynomial| $)) "\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)"))) NIL NIL (-27) -((|constructor| (NIL "Model for algebraically closed fields.")) (|zerosOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zerosOf(\\spad{p},{} \\spad{y}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zerosOf(a,{}\\spad{x})") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{zerosOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zerosOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{zerosOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{The \\spad{yi}\\spad{'s} are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^2+2*x-13 \\spad{X} zerosOf(a)")) (|zeroOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zeroOf(\\spad{p},{} \\spad{y}) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zeroOf(a,{}\\spad{x})") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{zeroOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} zeroOf(a)") (($ (|Polynomial| $)) "\\indented{1}{zeroOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible,{} \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^2+2*x-13 \\spad{X} zeroOf(a)")) (|rootsOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootsOf(\\spad{p},{} \\spad{y}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a,{}\\spad{x})") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootsOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{rootsOf(\\spad{p}) returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}.} \\indented{1}{Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootsOf(a)")) (|rootOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootOf(\\spad{p},{} \\spad{y}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a,{}\\spad{x})") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} a:SparseUnivariatePolynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a)") (($ (|Polynomial| $)) "\\indented{1}{rootOf(\\spad{p}) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y}.} \\blankline \\spad{X} a:Polynomial(Integer)\\spad{:=}-3*x^3+2*x+13 \\spad{X} rootOf(a)"))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "Model for algebraically closed fields.")) (|zerosOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)")) (|zeroOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)") (($ (|Polynomial| $)) "\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)")) (|rootsOf| (((|List| $) (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)") (((|List| $) (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)") (((|List| $) (|Polynomial| $)) "\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)")) (|rootOf| (($ (|SparseUnivariatePolynomial| $) (|Symbol|)) "\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)") (($ (|SparseUnivariatePolynomial| $)) "\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)") (($ (|Polynomial| $)) "\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)"))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-28 S R) -((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}. The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}. The \\spad{yi}\\spad{'s} are expressed in radicals if possible. The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p,{} y)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}; The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}. Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}; Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,{}y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y}."))) +((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The yi's are expressed in radicals if possible, and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols y1,...,yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The yi's are expressed in radicals if possible. The returned symbols y1,...,yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p, \\spad{y)}} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; The returned roots display as \\spad{'y1},...,\\spad{'yn}. Note that the returned symbols y1,...,yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; Note that the returned symbols y1,...,yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y.}")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y.}"))) NIL NIL (-29 R) -((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}. The \\spad{yi}\\spad{'s} are expressed in radicals if possible,{} and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}. The \\spad{yi}\\spad{'s} are expressed in radicals if possible. The returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p,{} y)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,{}and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}; The returned roots display as \\spad{'y1},{}...,{}\\spad{'yn}. Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p,{} y)} returns \\spad{[y1,{}...,{}yn]} such that \\spad{p(\\spad{yi}) = 0}; Note that the returned symbols \\spad{y1},{}...,{}\\spad{yn} are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y}.")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,{}y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y}."))) -((-4532 . T) (-4530 . T) (-4529 . T) ((-4537 "*") . T) (-4528 . T) (-4533 . T) (-4527 . T) (-2982 . T)) +((|constructor| (NIL "Model for algebraically closed function spaces.")) (|zerosOf| (((|List| $) $ (|Symbol|)) "\\spad{zerosOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The yi's are expressed in radicals if possible, and otherwise as implicit algebraic quantities which display as \\spad{'yi}. The returned symbols y1,...,yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{zerosOf(p)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}. The yi's are expressed in radicals if possible. The returned symbols y1,...,yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable.")) (|zeroOf| (($ $ (|Symbol|)) "\\spad{zeroOf(p, \\spad{y)}} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,and otherwise as an implicit algebraic quantity which displays as \\spad{'y}.") (($ $) "\\spad{zeroOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. The value \\spad{y} is expressed in terms of radicals if possible,and otherwise as an implicit algebraic quantity. Error: if \\spad{p} has more than one variable.")) (|rootsOf| (((|List| $) $ (|Symbol|)) "\\spad{rootsOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; The returned roots display as \\spad{'y1},...,\\spad{'yn}. Note that the returned symbols y1,...,yn are bound in the interpreter to respective root values.") (((|List| $) $) "\\spad{rootsOf(p, \\spad{y)}} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}; Note that the returned symbols y1,...,yn are bound in the interpreter to respective root values. Error: if \\spad{p} has more than one variable \\spad{y.}")) (|rootOf| (($ $ (|Symbol|)) "\\spad{rootOf(p,y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}.") (($ $) "\\spad{rootOf(p)} returns \\spad{y} such that \\spad{p(y) = 0}. Error: if \\spad{p} has more than one variable \\spad{y.}"))) +((-4568 . T) (-4566 . T) (-4565 . T) ((-4573 "*") . T) (-4564 . T) (-4569 . T) (-4563 . T) (-4317 . T)) NIL (-30) -((|constructor| (NIL "Plot a NON-SINGULAR plane algebraic curve \\spad{p}(\\spad{x},{}\\spad{y}) = 0.")) (|refine| (($ $ (|DoubleFloat|)) "\\indented{1}{refine(\\spad{p},{}\\spad{x}) is not documented} \\blankline \\spad{X} sketch:=makeSketch(x+y,{}\\spad{x},{}\\spad{y},{}\\spad{-1/2}..1/2,{}\\spad{-1/2}..1/2)\\$ACPLOT \\spad{X} refined:=refine(sketch,{}0.1)")) (|makeSketch| (($ (|Polynomial| (|Integer|)) (|Symbol|) (|Symbol|) (|Segment| (|Fraction| (|Integer|))) (|Segment| (|Fraction| (|Integer|)))) "\\indented{1}{makeSketch(\\spad{p},{}\\spad{x},{}\\spad{y},{}a..\\spad{b},{}\\spad{c}..\\spad{d}) creates an ACPLOT of the} \\indented{1}{curve \\spad{p = 0} in the region a \\spad{<=} \\spad{x} \\spad{<=} \\spad{b},{} \\spad{c} \\spad{<=} \\spad{y} \\spad{<=} \\spad{d}.} \\indented{1}{More specifically,{} 'makeSketch' plots a non-singular algebraic curve} \\indented{1}{\\spad{p = 0} in an rectangular region xMin \\spad{<=} \\spad{x} \\spad{<=} xMax,{}} \\indented{1}{yMin \\spad{<=} \\spad{y} \\spad{<=} yMax. The user inputs} \\indented{1}{\\spad{makeSketch(p,{}x,{}y,{}xMin..xMax,{}yMin..yMax)}.} \\indented{1}{Here \\spad{p} is a polynomial in the variables \\spad{x} and \\spad{y} with} \\indented{1}{integer coefficients (\\spad{p} belongs to the domain} \\indented{1}{\\spad{Polynomial Integer}). The case} \\indented{1}{where \\spad{p} is a polynomial in only one of the variables is} \\indented{1}{allowed.\\space{2}The variables \\spad{x} and \\spad{y} are input to specify the} \\indented{1}{the coordinate axes.\\space{2}The horizontal axis is the \\spad{x}-axis and} \\indented{1}{the vertical axis is the \\spad{y}-axis.\\space{2}The rational numbers} \\indented{1}{xMin,{}...,{}yMax specify the boundaries of the region in} \\indented{1}{which the curve is to be plotted.} \\blankline \\spad{X} makeSketch(x+y,{}\\spad{x},{}\\spad{y},{}\\spad{-1/2}..1/2,{}\\spad{-1/2}..1/2)\\$ACPLOT"))) +((|constructor| (NIL "Plot a NON-SINGULAR plane algebraic curve p(x,y) = 0.")) (|refine| (($ $ (|DoubleFloat|)) "\\indented{1}{refine(p,x) is not documented} \\blankline \\spad{X} sketch:=makeSketch(x+y,x,y,-1/2..1/2,-1/2..1/2)$ACPLOT \\spad{X} refined:=refine(sketch,0.1)")) (|makeSketch| (($ (|Polynomial| (|Integer|)) (|Symbol|) (|Symbol|) (|Segment| (|Fraction| (|Integer|))) (|Segment| (|Fraction| (|Integer|)))) "\\indented{1}{makeSketch(p,x,y,a..b,c..d) creates an ACPLOT of the} \\indented{1}{curve \\spad{p = 0} in the region a \\spad{<=} \\spad{x} \\spad{<=} \\spad{b,} \\spad{c} \\spad{<=} \\spad{y} \\spad{<=} \\spad{d.}} \\indented{1}{More specifically, 'makeSketch' plots a non-singular algebraic curve} \\indented{1}{\\spad{p = 0} in an rectangular region xMin \\spad{<=} \\spad{x} \\spad{<=} xMax,} \\indented{1}{yMin \\spad{<=} \\spad{y} \\spad{<=} yMax. The user inputs} \\indented{1}{\\spad{makeSketch(p,x,y,xMin..xMax,yMin..yMax)}.} \\indented{1}{Here \\spad{p} is a polynomial in the variables \\spad{x} and \\spad{y} with} \\indented{1}{integer coefficients \\spad{(p} belongs to the domain} \\indented{1}{\\spad{Polynomial Integer}). The case} \\indented{1}{where \\spad{p} is a polynomial in only one of the variables is} \\indented{1}{allowed.\\space{2}The variables \\spad{x} and \\spad{y} are input to specify the} \\indented{1}{the coordinate axes.\\space{2}The horizontal axis is the x-axis and} \\indented{1}{the vertical axis is the y-axis.\\space{2}The rational numbers} \\indented{1}{xMin,...,yMax specify the boundaries of the region in} \\indented{1}{which the curve is to be plotted.} \\blankline \\spad{X} makeSketch(x+y,x,y,-1/2..1/2,-1/2..1/2)$ACPLOT"))) NIL NIL (-31 K |symb| |PolyRing| E |ProjPt|) -((|constructor| (NIL "The following is part of the PAFF package")) (|affineRationalPoints| (((|List| |#5|) |#3| (|PositiveInteger|)) "\\axiom{rationalPoints(\\spad{f},{}\\spad{d})} returns all points on the curve \\axiom{\\spad{f}} in the extension of the ground field of degree \\axiom{\\spad{d}}. For \\axiom{\\spad{d} > 1} this only works if \\axiom{\\spad{K}} is a \\axiomType{LocallyAlgebraicallyClosedField}"))) +((|constructor| (NIL "The following is part of the PAFF package")) (|affineRationalPoints| (((|List| |#5|) |#3| (|PositiveInteger|)) "\\axiom{rationalPoints(f,d)} returns all points on the curve \\axiom{f} in the extension of the ground field of degree \\axiom{d}. For \\axiom{d > 1} this only works if \\axiom{K} is a \\axiomType{LocallyAlgebraicallyClosedField}"))) NIL NIL (-32 K |symb| |PolyRing| E |ProjPt|) @@ -68,280 +68,280 @@ NIL ((|constructor| (NIL "The following is all the categories and domains related to projective space and part of the PAFF package"))) NIL NIL -(-35 -4391 K) +(-35 -4360 K) ((|constructor| (NIL "The following is all the categories and domains related to projective space and part of the PAFF package"))) NIL NIL -(-36 R -1564) -((|constructor| (NIL "This package provides algebraic functions over an integral domain.")) (|iroot| ((|#2| |#1| (|Integer|)) "\\spad{iroot(p,{} n)} should be a non-exported function.")) (|definingPolynomial| ((|#2| |#2|) "\\spad{definingPolynomial(f)} returns the defining polynomial of \\spad{f} as an element of \\spad{F}. Error: if \\spad{f} is not a kernel.")) (|minPoly| (((|SparseUnivariatePolynomial| |#2|) (|Kernel| |#2|)) "\\spad{minPoly(k)} returns the defining polynomial of \\spad{k}.")) (** ((|#2| |#2| (|Fraction| (|Integer|))) "\\spad{x ** q} is \\spad{x} raised to the rational power \\spad{q}.")) (|droot| (((|OutputForm|) (|List| |#2|)) "\\spad{droot(l)} should be a non-exported function.")) (|inrootof| ((|#2| (|SparseUnivariatePolynomial| |#2|) |#2|) "\\spad{inrootof(p,{} x)} should be a non-exported function.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} is \\spad{true} if \\spad{op} is an algebraic operator,{} that is,{} an \\spad{n}th root or implicit algebraic operator.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\spad{F}. Error: if \\spad{op} is not an algebraic operator,{} that is,{} an \\spad{n}th root or implicit algebraic operator.")) (|rootOf| ((|#2| (|SparseUnivariatePolynomial| |#2|) (|Symbol|)) "\\spad{rootOf(p,{} y)} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}."))) +(-36 R -1647) +((|constructor| (NIL "This package provides algebraic functions over an integral domain.")) (|iroot| ((|#2| |#1| (|Integer|)) "\\spad{iroot(p, \\spad{n)}} should be a non-exported function.")) (|definingPolynomial| ((|#2| |#2|) "\\spad{definingPolynomial(f)} returns the defining polynomial of \\spad{f} as an element of \\spad{F}. Error: if \\spad{f} is not a kernel.")) (|minPoly| (((|SparseUnivariatePolynomial| |#2|) (|Kernel| |#2|)) "\\spad{minPoly(k)} returns the defining polynomial of \\spad{k}.")) (** ((|#2| |#2| (|Fraction| (|Integer|))) "\\spad{x \\spad{**} \\spad{q}} is \\spad{x} raised to the rational power \\spad{q}.")) (|droot| (((|OutputForm|) (|List| |#2|)) "\\spad{droot(l)} should be a non-exported function.")) (|inrootof| ((|#2| (|SparseUnivariatePolynomial| |#2|) |#2|) "\\spad{inrootof(p, \\spad{x)}} should be a non-exported function.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} is \\spad{true} if \\spad{op} is an algebraic operator, that is, an \\spad{n}th root or implicit algebraic operator.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\spad{F}. Error: if \\spad{op} is not an algebraic operator, that is, an \\spad{n}th root or implicit algebraic operator.")) (|rootOf| ((|#2| (|SparseUnivariatePolynomial| |#2|) (|Symbol|)) "\\spad{rootOf(p, \\spad{y)}} returns \\spad{y} such that \\spad{p(y) = 0}. The object returned displays as \\spad{'y}."))) NIL -((|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569))))) +((|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569))))) (-37 K) -((|constructor| (NIL "The following is all the categories and domains related to projective space and part of the PAFF package")) (|pointValue| (((|List| |#1|) $) "\\spad{pointValue returns} the coordinates of the point or of the point of origin that represent an infinitly close point")) (|setelt| ((|#1| $ (|Integer|) |#1|) "\\spad{setelt sets} the value of a specified coordinates")) (|elt| ((|#1| $ (|Integer|)) "\\spad{elt returns} the value of a specified coordinates")) (|list| (((|List| |#1|) $) "\\spad{list returns} the list of the coordinates")) (|rational?| (((|Boolean|) $) "\\spad{rational?(p)} test if the point is rational according to the characteristic of the ground field.") (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{rational?(p,{}n)} test if the point is rational according to \\spad{n}.")) (|removeConjugate| (((|List| $) (|List| $)) "\\spad{removeConjugate(lp)} returns removeConjugate(\\spad{lp},{}\\spad{n}) where \\spad{n} is the characteristic of the ground field.") (((|List| $) (|List| $) (|NonNegativeInteger|)) "\\spad{removeConjugate(lp,{}n)} returns a list of points such that no points in the list is the conjugate (according to \\spad{n}) of another point.")) (|conjugate| (($ $) "\\spad{conjugate(p)} returns conjugate(\\spad{p},{}\\spad{n}) where \\spad{n} is the characteristic of the ground field.") (($ $ (|NonNegativeInteger|)) "\\spad{conjugate(p,{}n)} returns p**n,{} that is all the coordinates of \\spad{p} to the power of \\spad{n}")) (|orbit| (((|List| $) $ (|NonNegativeInteger|)) "\\spad{orbit(p,{}n)} returns the orbit of the point \\spad{p} according to \\spad{n},{} that is orbit(\\spad{p},{}\\spad{n}) = \\spad{\\{} \\spad{p},{} p**n,{} \\spad{p**}(\\spad{n**2}),{} \\spad{p**}(\\spad{n**3}),{} ..... \\spad{\\}}") (((|List| $) $) "\\spad{orbit(p)} returns the orbit of the point \\spad{p} according to the characteristic of \\spad{K},{} that is,{} for \\spad{q=} char \\spad{K},{} orbit(\\spad{p}) = \\spad{\\{} \\spad{p},{} p**q,{} \\spad{p**}(\\spad{q**2}),{} \\spad{p**}(\\spad{q**3}),{} ..... \\spad{\\}}")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce a} list of \\spad{K} to a affine point.")) (|affinePoint| (($ (|List| |#1|)) "\\spad{affinePoint creates} a affine point from a list"))) +((|constructor| (NIL "The following is all the categories and domains related to projective space and part of the PAFF package")) (|pointValue| (((|List| |#1|) $) "\\spad{pointValue returns} the coordinates of the point or of the point of origin that represent an infinitly close point")) (|setelt| ((|#1| $ (|Integer|) |#1|) "\\spad{setelt sets} the value of a specified coordinates")) (|elt| ((|#1| $ (|Integer|)) "\\spad{elt returns} the value of a specified coordinates")) (|list| (((|List| |#1|) $) "\\spad{list returns} the list of the coordinates")) (|rational?| (((|Boolean|) $) "\\spad{rational?(p)} test if the point is rational according to the characteristic of the ground field.") (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{rational?(p,n)} test if the point is rational according to \\spad{n.}")) (|removeConjugate| (((|List| $) (|List| $)) "\\spad{removeConjugate(lp)} returns removeConjugate(lp,n) where \\spad{n} is the characteristic of the ground field.") (((|List| $) (|List| $) (|NonNegativeInteger|)) "\\spad{removeConjugate(lp,n)} returns a list of points such that no points in the list is the conjugate (according to \\spad{n)} of another point.")) (|conjugate| (($ $) "\\spad{conjugate(p)} returns conjugate(p,n) where \\spad{n} is the characteristic of the ground field.") (($ $ (|NonNegativeInteger|)) "\\spad{conjugate(p,n)} returns p**n, that is all the coordinates of \\spad{p} to the power of \\spad{n}")) (|orbit| (((|List| $) $ (|NonNegativeInteger|)) "\\spad{orbit(p,n)} returns the orbit of the point \\spad{p} according to \\spad{n,} that is orbit(p,n) = \\spad{\\{} \\spad{p,} p**n, p**(n**2), p**(n**3), ..... \\spad{\\}}") (((|List| $) $) "\\spad{orbit(p)} returns the orbit of the point \\spad{p} according to the characteristic of \\spad{K,} that is, for \\spad{q=} char \\spad{K,} orbit(p) = \\spad{\\{} \\spad{p,} p**q, p**(q**2), p**(q**3), ..... \\spad{\\}}")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce a} list of \\spad{K} to a affine point.")) (|affinePoint| (($ (|List| |#1|)) "\\spad{affinePoint creates} a affine point from a list"))) NIL NIL (-38 S) -((|constructor| (NIL "The notion of aggregate serves to model any data structure aggregate,{} designating any collection of objects,{} with heterogenous or homogeneous members,{} with a finite or infinite number of members,{} explicitly or implicitly represented. An aggregate can in principle represent everything from a string of characters to abstract sets such as \"the set of \\spad{x} satisfying relation \\spad{r}(\\spad{x})\" An attribute \\spadatt{finiteAggregate} is used to assert that a domain has a finite number of elements.")) (|#| (((|NonNegativeInteger|) $) "\\spad{\\# u} returns the number of items in \\spad{u}.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{size?(u,{}n)} tests if \\spad{u} has exactly \\spad{n} elements.")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{more?(u,{}n)} tests if \\spad{u} has greater than \\spad{n} elements.")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{less?(u,{}n)} tests if \\spad{u} has less than \\spad{n} elements.")) (|empty?| (((|Boolean|) $) "\\spad{empty?(u)} tests if \\spad{u} has 0 elements.")) (|empty| (($) "\\spad{empty()}\\$\\spad{D} creates an aggregate of type \\spad{D} with 0 elements. Note that The \\$\\spad{D} can be dropped if understood by context,{} \\spadignore{e.g.} \\axiom{u: \\spad{D} \\spad{:=} empty()}.")) (|copy| (($ $) "\\spad{copy(u)} returns a top-level (non-recursive) copy of \\spad{u}. Note that for collections,{} \\axiom{copy(\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u}]}.")) (|eq?| (((|Boolean|) $ $) "\\spad{eq?(u,{}v)} tests if \\spad{u} and \\spad{v} are same objects."))) +((|constructor| (NIL "The notion of aggregate serves to model any data structure aggregate, designating any collection of objects, with heterogenous or homogeneous members, with a finite or infinite number of members, explicitly or implicitly represented. An aggregate can in principle represent everything from a string of characters to abstract sets such as \"the set of \\spad{x} satisfying relation r(x)\" An attribute \\spadatt{finiteAggregate} is used to assert that a domain has a finite number of elements.")) (|#| (((|NonNegativeInteger|) $) "\\spad{# u} returns the number of items in u.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{size?(u,n)} tests if \\spad{u} has exactly \\spad{n} elements.")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{more?(u,n)} tests if \\spad{u} has greater than \\spad{n} elements.")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{less?(u,n)} tests if \\spad{u} has less than \\spad{n} elements.")) (|empty?| (((|Boolean|) $) "\\spad{empty?(u)} tests if \\spad{u} has 0 elements.")) (|empty| (($) "\\spad{empty()}$D creates an aggregate of type \\spad{D} with 0 elements. Note that The \\spad{$D} can be dropped if understood by context, \\spadignore{e.g.} \\axiom{u: \\spad{D} \\spad{:=} empty()}.")) (|copy| (($ $) "\\spad{copy(u)} returns a top-level (non-recursive) copy of u. Note that for collections, \\axiom{copy(u) \\spad{==} \\spad{[x} for \\spad{x} in u]}.")) (|eq?| (((|Boolean|) $ $) "\\spad{eq?(u,v)} tests if \\spad{u} and \\spad{v} are same objects."))) NIL -((|HasAttribute| |#1| (QUOTE -4535))) +((|HasAttribute| |#1| (QUOTE -4571))) (-39) -((|constructor| (NIL "The notion of aggregate serves to model any data structure aggregate,{} designating any collection of objects,{} with heterogenous or homogeneous members,{} with a finite or infinite number of members,{} explicitly or implicitly represented. An aggregate can in principle represent everything from a string of characters to abstract sets such as \"the set of \\spad{x} satisfying relation \\spad{r}(\\spad{x})\" An attribute \\spadatt{finiteAggregate} is used to assert that a domain has a finite number of elements.")) (|#| (((|NonNegativeInteger|) $) "\\spad{\\# u} returns the number of items in \\spad{u}.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{size?(u,{}n)} tests if \\spad{u} has exactly \\spad{n} elements.")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{more?(u,{}n)} tests if \\spad{u} has greater than \\spad{n} elements.")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{less?(u,{}n)} tests if \\spad{u} has less than \\spad{n} elements.")) (|empty?| (((|Boolean|) $) "\\spad{empty?(u)} tests if \\spad{u} has 0 elements.")) (|empty| (($) "\\spad{empty()}\\$\\spad{D} creates an aggregate of type \\spad{D} with 0 elements. Note that The \\$\\spad{D} can be dropped if understood by context,{} \\spadignore{e.g.} \\axiom{u: \\spad{D} \\spad{:=} empty()}.")) (|copy| (($ $) "\\spad{copy(u)} returns a top-level (non-recursive) copy of \\spad{u}. Note that for collections,{} \\axiom{copy(\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u}]}.")) (|eq?| (((|Boolean|) $ $) "\\spad{eq?(u,{}v)} tests if \\spad{u} and \\spad{v} are same objects."))) -((-2982 . T)) +((|constructor| (NIL "The notion of aggregate serves to model any data structure aggregate, designating any collection of objects, with heterogenous or homogeneous members, with a finite or infinite number of members, explicitly or implicitly represented. An aggregate can in principle represent everything from a string of characters to abstract sets such as \"the set of \\spad{x} satisfying relation r(x)\" An attribute \\spadatt{finiteAggregate} is used to assert that a domain has a finite number of elements.")) (|#| (((|NonNegativeInteger|) $) "\\spad{# u} returns the number of items in u.")) (|sample| (($) "\\spad{sample yields} a value of type \\%")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{size?(u,n)} tests if \\spad{u} has exactly \\spad{n} elements.")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{more?(u,n)} tests if \\spad{u} has greater than \\spad{n} elements.")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\spad{less?(u,n)} tests if \\spad{u} has less than \\spad{n} elements.")) (|empty?| (((|Boolean|) $) "\\spad{empty?(u)} tests if \\spad{u} has 0 elements.")) (|empty| (($) "\\spad{empty()}$D creates an aggregate of type \\spad{D} with 0 elements. Note that The \\spad{$D} can be dropped if understood by context, \\spadignore{e.g.} \\axiom{u: \\spad{D} \\spad{:=} empty()}.")) (|copy| (($ $) "\\spad{copy(u)} returns a top-level (non-recursive) copy of u. Note that for collections, \\axiom{copy(u) \\spad{==} \\spad{[x} for \\spad{x} in u]}.")) (|eq?| (((|Boolean|) $ $) "\\spad{eq?(u,v)} tests if \\spad{u} and \\spad{v} are same objects."))) +((-4317 . T)) NIL (-40) -((|constructor| (NIL "Category for the inverse hyperbolic trigonometric functions.")) (|atanh| (($ $) "\\spad{atanh(x)} returns the hyperbolic arc-tangent of \\spad{x}.")) (|asinh| (($ $) "\\spad{asinh(x)} returns the hyperbolic arc-sine of \\spad{x}.")) (|asech| (($ $) "\\spad{asech(x)} returns the hyperbolic arc-secant of \\spad{x}.")) (|acsch| (($ $) "\\spad{acsch(x)} returns the hyperbolic arc-cosecant of \\spad{x}.")) (|acoth| (($ $) "\\spad{acoth(x)} returns the hyperbolic arc-cotangent of \\spad{x}.")) (|acosh| (($ $) "\\spad{acosh(x)} returns the hyperbolic arc-cosine of \\spad{x}."))) +((|constructor| (NIL "Category for the inverse hyperbolic trigonometric functions.")) (|atanh| (($ $) "\\spad{atanh(x)} returns the hyperbolic arc-tangent of \\spad{x.}")) (|asinh| (($ $) "\\spad{asinh(x)} returns the hyperbolic arc-sine of \\spad{x.}")) (|asech| (($ $) "\\spad{asech(x)} returns the hyperbolic arc-secant of \\spad{x.}")) (|acsch| (($ $) "\\spad{acsch(x)} returns the hyperbolic arc-cosecant of \\spad{x.}")) (|acoth| (($ $) "\\spad{acoth(x)} returns the hyperbolic arc-cotangent of \\spad{x.}")) (|acosh| (($ $) "\\spad{acosh(x)} returns the hyperbolic arc-cosine of \\spad{x.}"))) NIL NIL (-41 |Key| |Entry|) -((|constructor| (NIL "An association list is a list of key entry pairs which may be viewed as a table. It is a poor mans version of a table: searching for a key is a linear operation.")) (|assoc| (((|Union| (|Record| (|:| |key| |#1|) (|:| |entry| |#2|)) "failed") |#1| $) "\\spad{assoc(k,{}u)} returns the element \\spad{x} in association list \\spad{u} stored with key \\spad{k},{} or \"failed\" if \\spad{u} has no key \\spad{k}."))) -((-4535 . T) (-4536 . T) (-2982 . T)) +((|constructor| (NIL "An association list is a list of key entry pairs which may be viewed as a table. It is a poor mans version of a table: searching for a key is a linear operation.")) (|assoc| (((|Union| (|Record| (|:| |key| |#1|) (|:| |entry| |#2|)) "failed") |#1| $) "\\spad{assoc(k,u)} returns the element \\spad{x} in association list \\spad{u} stored with key \\spad{k,} or \"failed\" if \\spad{u} has no key \\spad{k.}"))) +((-4571 . T) (-4572 . T) (-4317 . T)) NIL (-42 S R) -((|constructor| (NIL "The category of associative algebras (modules which are themselves rings). \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{(b+c)::\\% = (b::\\%) + (c::\\%)}\\spad{\\br} \\tab{5}\\spad{(b*c)::\\% = (b::\\%) * (c::\\%)}\\spad{\\br} \\tab{5}\\spad{(1::R)::\\% = 1::\\%}\\spad{\\br} \\tab{5}\\spad{b*x = (b::\\%)*x}\\spad{\\br} \\tab{5}\\spad{r*(a*b) = (r*a)*b = a*(r*b)}")) (|coerce| (($ |#2|) "\\spad{coerce(r)} maps the ring element \\spad{r} to a member of the algebra."))) +((|constructor| (NIL "The category of associative algebras (modules which are themselves rings). \\blankline Axioms\\br \\tab{5}\\spad{(b+c)::% = (b::\\%) + (c::\\%)}\\br \\tab{5}\\spad{(b*c)::% = (b::\\%) * (c::\\%)}\\br \\tab{5}\\spad{(1::R)::% = 1::%}\\br \\tab{5}\\spad{b*x = (b::\\%)*x}\\br \\tab{5}\\spad{r*(a*b) = (r*a)*b = a*(r*b)}")) (|coerce| (($ |#2|) "\\spad{coerce(r)} maps the ring element \\spad{r} to a member of the algebra."))) NIL NIL (-43 R) -((|constructor| (NIL "The category of associative algebras (modules which are themselves rings). \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{(b+c)::\\% = (b::\\%) + (c::\\%)}\\spad{\\br} \\tab{5}\\spad{(b*c)::\\% = (b::\\%) * (c::\\%)}\\spad{\\br} \\tab{5}\\spad{(1::R)::\\% = 1::\\%}\\spad{\\br} \\tab{5}\\spad{b*x = (b::\\%)*x}\\spad{\\br} \\tab{5}\\spad{r*(a*b) = (r*a)*b = a*(r*b)}")) (|coerce| (($ |#1|) "\\spad{coerce(r)} maps the ring element \\spad{r} to a member of the algebra."))) -((-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "The category of associative algebras (modules which are themselves rings). \\blankline Axioms\\br \\tab{5}\\spad{(b+c)::% = (b::\\%) + (c::\\%)}\\br \\tab{5}\\spad{(b*c)::% = (b::\\%) * (c::\\%)}\\br \\tab{5}\\spad{(1::R)::% = 1::%}\\br \\tab{5}\\spad{b*x = (b::\\%)*x}\\br \\tab{5}\\spad{r*(a*b) = (r*a)*b = a*(r*b)}")) (|coerce| (($ |#1|) "\\spad{coerce(r)} maps the ring element \\spad{r} to a member of the algebra."))) +((-4565 . T) (-4566 . T) (-4568 . T)) NIL (-44 UP) -((|constructor| (NIL "Factorization of univariate polynomials with coefficients in \\spadtype{AlgebraicNumber}.")) (|doublyTransitive?| (((|Boolean|) |#1|) "\\spad{doublyTransitive?(p)} is \\spad{true} if \\spad{p} is irreducible over over the field \\spad{K} generated by its coefficients,{} and if \\spad{p(X) / (X - a)} is irreducible over \\spad{K(a)} where \\spad{p(a) = 0}.")) (|split| (((|Factored| |#1|) |#1|) "\\spad{split(p)} returns a prime factorisation of \\spad{p} over its splitting field.")) (|factor| (((|Factored| |#1|) |#1|) "\\spad{factor(p)} returns a prime factorisation of \\spad{p} over the field generated by its coefficients.") (((|Factored| |#1|) |#1| (|List| (|AlgebraicNumber|))) "\\spad{factor(p,{} [a1,{}...,{}an])} returns a prime factorisation of \\spad{p} over the field generated by its coefficients and \\spad{a1},{}...,{}an."))) +((|constructor| (NIL "Factorization of univariate polynomials with coefficients in \\spadtype{AlgebraicNumber}.")) (|doublyTransitive?| (((|Boolean|) |#1|) "\\spad{doublyTransitive?(p)} is \\spad{true} if \\spad{p} is irreducible over over the field \\spad{K} generated by its coefficients, and if \\spad{p(X) / \\spad{(X} - a)} is irreducible over \\spad{K(a)} where \\spad{p(a) = 0}.")) (|split| (((|Factored| |#1|) |#1|) "\\spad{split(p)} returns a prime factorisation of \\spad{p} over its splitting field.")) (|factor| (((|Factored| |#1|) |#1|) "\\spad{factor(p)} returns a prime factorisation of \\spad{p} over the field generated by its coefficients.") (((|Factored| |#1|) |#1| (|List| (|AlgebraicNumber|))) "\\spad{factor(p, [a1,...,an])} returns a prime factorisation of \\spad{p} over the field generated by its coefficients and a1,...,an."))) NIL NIL -(-45 -1564 UP UPUP -3092) -((|constructor| (NIL "Function field defined by \\spad{f}(\\spad{x},{} \\spad{y}) = 0.")) (|knownInfBasis| (((|Void|) (|NonNegativeInteger|)) "\\spad{knownInfBasis(n)} is not documented"))) -((-4528 |has| (-410 |#2|) (-366)) (-4533 |has| (-410 |#2|) (-366)) (-4527 |has| (-410 |#2|) (-366)) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| (-410 |#2|) (QUOTE (-149))) (|HasCategory| (-410 |#2|) (QUOTE (-151))) (|HasCategory| (-410 |#2|) (QUOTE (-351))) (|HasCategory| (-410 |#2|) (QUOTE (-366))) (-2232 (|HasCategory| (-410 |#2|) (QUOTE (-366))) (|HasCategory| (-410 |#2|) (QUOTE (-351)))) (|HasCategory| (-410 |#2|) (QUOTE (-371))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-371))) (-2232 (|HasCategory| (-410 |#2|) (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-2232 (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-410 |#2|) (QUOTE (-351))))) (-12 (|HasCategory| (-410 |#2|) (QUOTE (-226))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-2232 (-12 (|HasCategory| (-410 |#2|) (QUOTE (-226))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (|HasCategory| (-410 |#2|) (QUOTE (-351))))) -(-46 R -1564) -((|constructor| (NIL "AlgebraicManipulations provides functions to simplify and expand expressions involving algebraic operators.")) (|rootKerSimp| ((|#2| (|BasicOperator|) |#2| (|NonNegativeInteger|)) "\\spad{rootKerSimp(op,{}f,{}n)} should be local but conditional.")) (|rootSimp| ((|#2| |#2|) "\\spad{rootSimp(f)} transforms every radical of the form \\spad{(a * b**(q*n+r))**(1/n)} appearing in \\spad{f} into \\spad{b**q * (a * b**r)**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{b}.")) (|rootProduct| ((|#2| |#2|) "\\spad{rootProduct(f)} combines every product of the form \\spad{(a**(1/n))**m * (a**(1/s))**t} into a single power of a root of \\spad{a},{} and transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form.")) (|rootPower| ((|#2| |#2|) "\\spad{rootPower(f)} transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form if \\spad{m} and \\spad{n} have a common factor.")) (|ratPoly| (((|SparseUnivariatePolynomial| |#2|) |#2|) "\\spad{ratPoly(f)} returns a polynomial \\spad{p} such that \\spad{p} has no algebraic coefficients,{} and \\spad{p(f) = 0}.")) (|ratDenom| ((|#2| |#2| (|List| (|Kernel| |#2|))) "\\spad{ratDenom(f,{} [a1,{}...,{}an])} removes the \\spad{ai}\\spad{'s} which are algebraic from the denominators in \\spad{f}.") ((|#2| |#2| (|List| |#2|)) "\\spad{ratDenom(f,{} [a1,{}...,{}an])} removes the \\spad{ai}\\spad{'s} which are algebraic kernels from the denominators in \\spad{f}.") ((|#2| |#2| |#2|) "\\spad{ratDenom(f,{} a)} removes \\spad{a} from the denominators in \\spad{f} if \\spad{a} is an algebraic kernel.") ((|#2| |#2|) "\\spad{ratDenom(f)} rationalizes the denominators appearing in \\spad{f} by moving all the algebraic quantities into the numerators.")) (|rootSplit| ((|#2| |#2|) "\\spad{rootSplit(f)} transforms every radical of the form \\spad{(a/b)**(1/n)} appearing in \\spad{f} into \\spad{a**(1/n) / b**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{a} and \\spad{b}.")) (|coerce| (($ (|SparseMultivariatePolynomial| |#1| (|Kernel| $))) "\\spad{coerce(x)} \\undocumented")) (|denom| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{denom(x)} \\undocumented")) (|numer| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{numer(x)} \\undocumented"))) +(-45 -1647 UP UPUP -4138) +((|constructor| (NIL "Function field defined by f(x, \\spad{y)} = 0.")) (|knownInfBasis| (((|Void|) (|NonNegativeInteger|)) "\\spad{knownInfBasis(n)} is not documented"))) +((-4564 |has| (-410 |#2|) (-366)) (-4569 |has| (-410 |#2|) (-366)) (-4563 |has| (-410 |#2|) (-366)) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| (-410 |#2|) (QUOTE (-149))) (|HasCategory| (-410 |#2|) (QUOTE (-151))) (|HasCategory| (-410 |#2|) (QUOTE (-351))) (|HasCategory| (-410 |#2|) (QUOTE (-366))) (-1929 (|HasCategory| (-410 |#2|) (QUOTE (-366))) (|HasCategory| (-410 |#2|) (QUOTE (-351)))) (|HasCategory| (-410 |#2|) (QUOTE (-371))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| (-410 |#2|) (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-371))) (-1929 (|HasCategory| (-410 |#2|) (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-1929 (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-12 (|HasCategory| (-410 |#2|) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-410 |#2|) (QUOTE (-351))))) (-12 (|HasCategory| (-410 |#2|) (QUOTE (-226))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (-1929 (-12 (|HasCategory| (-410 |#2|) (QUOTE (-226))) (|HasCategory| (-410 |#2|) (QUOTE (-366)))) (|HasCategory| (-410 |#2|) (QUOTE (-351))))) +(-46 R -1647) +((|constructor| (NIL "AlgebraicManipulations provides functions to simplify and expand expressions involving algebraic operators.")) (|rootKerSimp| ((|#2| (|BasicOperator|) |#2| (|NonNegativeInteger|)) "\\spad{rootKerSimp(op,f,n)} should be local but conditional.")) (|rootSimp| ((|#2| |#2|) "\\spad{rootSimp(f)} transforms every radical of the form \\spad{(a * b**(q*n+r))**(1/n)} appearing in \\spad{f} into \\spad{b**q * (a * b**r)**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{b.}")) (|rootProduct| ((|#2| |#2|) "\\spad{rootProduct(f)} combines every product of the form \\spad{(a**(1/n))**m * (a**(1/s))**t} into a single power of a root of \\spad{a}, and transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form.")) (|rootPower| ((|#2| |#2|) "\\spad{rootPower(f)} transforms every radical power of the form \\spad{(a**(1/n))**m} into a simpler form if \\spad{m} and \\spad{n} have a common factor.")) (|ratPoly| (((|SparseUnivariatePolynomial| |#2|) |#2|) "\\spad{ratPoly(f)} returns a polynomial \\spad{p} such that \\spad{p} has no algebraic coefficients, and \\spad{p(f) = 0}.")) (|ratDenom| ((|#2| |#2| (|List| (|Kernel| |#2|))) "\\spad{ratDenom(f, [a1,...,an])} removes the ai's which are algebraic from the denominators in \\spad{f.}") ((|#2| |#2| (|List| |#2|)) "\\spad{ratDenom(f, [a1,...,an])} removes the ai's which are algebraic kernels from the denominators in \\spad{f.}") ((|#2| |#2| |#2|) "\\spad{ratDenom(f, a)} removes \\spad{a} from the denominators in \\spad{f} if \\spad{a} is an algebraic kernel.") ((|#2| |#2|) "\\spad{ratDenom(f)} rationalizes the denominators appearing in \\spad{f} by moving all the algebraic quantities into the numerators.")) (|rootSplit| ((|#2| |#2|) "\\spad{rootSplit(f)} transforms every radical of the form \\spad{(a/b)**(1/n)} appearing in \\spad{f} into \\spad{a**(1/n) / b**(1/n)}. This transformation is not in general valid for all complex numbers \\spad{a} and \\spad{b.}")) (|coerce| (($ (|SparseMultivariatePolynomial| |#1| (|Kernel| $))) "\\spad{coerce(x)} \\undocumented")) (|denom| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{denom(x)} \\undocumented")) (|numer| (((|SparseMultivariatePolynomial| |#1| (|Kernel| $)) $) "\\spad{numer(x)} \\undocumented"))) NIL -((-12 (|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#2| (LIST (QUOTE -433) (|devaluate| |#1|))))) +((-12 (|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#2| (LIST (QUOTE -433) (|devaluate| |#1|))))) (-47 OV E P) -((|constructor| (NIL "This package factors multivariate polynomials over the domain of \\spadtype{AlgebraicNumber} by allowing the user to specify a list of algebraic numbers generating the particular extension to factor over.")) (|factor| (((|Factored| (|SparseUnivariatePolynomial| |#3|)) (|SparseUnivariatePolynomial| |#3|) (|List| (|AlgebraicNumber|))) "\\spad{factor(p,{}lan)} factors the polynomial \\spad{p} over the extension generated by the algebraic numbers given by the list \\spad{lan}. \\spad{p} is presented as a univariate polynomial with multivariate coefficients.") (((|Factored| |#3|) |#3| (|List| (|AlgebraicNumber|))) "\\spad{factor(p,{}lan)} factors the polynomial \\spad{p} over the extension generated by the algebraic numbers given by the list \\spad{lan}."))) +((|constructor| (NIL "This package factors multivariate polynomials over the domain of \\spadtype{AlgebraicNumber} by allowing the user to specify a list of algebraic numbers generating the particular extension to factor over.")) (|factor| (((|Factored| (|SparseUnivariatePolynomial| |#3|)) (|SparseUnivariatePolynomial| |#3|) (|List| (|AlgebraicNumber|))) "\\spad{factor(p,lan)} factors the polynomial \\spad{p} over the extension generated by the algebraic numbers given by the list lan. \\spad{p} is presented as a univariate polynomial with multivariate coefficients.") (((|Factored| |#3|) |#3| (|List| (|AlgebraicNumber|))) "\\spad{factor(p,lan)} factors the polynomial \\spad{p} over the extension generated by the algebraic numbers given by the list lan."))) NIL NIL (-48 R A) -((|constructor| (NIL "AlgebraPackage assembles a variety of useful functions for general algebras.")) (|basis| (((|Vector| |#2|) (|Vector| |#2|)) "\\spad{basis(va)} selects a basis from the elements of \\spad{va}.")) (|radicalOfLeftTraceForm| (((|List| |#2|)) "\\spad{radicalOfLeftTraceForm()} returns basis for null space of \\spad{leftTraceMatrix()},{} if the algebra is associative,{} alternative or a Jordan algebra,{} then this space equals the radical (maximal nil ideal) of the algebra.")) (|basisOfCentroid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfCentroid()} returns a basis of the centroid,{} \\spadignore{i.e.} the endomorphism ring of \\spad{A} considered as \\spad{(A,{}A)}-bimodule.")) (|basisOfRightNucloid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfRightNucloid()} returns a basis of the space of endomorphisms of \\spad{A} as left module. Note that right nucloid coincides with right nucleus if \\spad{A} has a unit.")) (|basisOfLeftNucloid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfLeftNucloid()} returns a basis of the space of endomorphisms of \\spad{A} as right module. Note that left nucloid coincides with left nucleus if \\spad{A} has a unit.")) (|basisOfCenter| (((|List| |#2|)) "\\spad{basisOfCenter()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{commutator(x,{}a) = 0} and \\spad{associator(x,{}a,{}b) = associator(a,{}x,{}b) = associator(a,{}b,{}x) = 0} for all \\spad{a},{}\\spad{b} in \\spad{A}.")) (|basisOfNucleus| (((|List| |#2|)) "\\spad{basisOfNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{associator(x,{}a,{}b) = associator(a,{}x,{}b) = associator(a,{}b,{}x) = 0} for all \\spad{a},{}\\spad{b} in \\spad{A}.")) (|basisOfMiddleNucleus| (((|List| |#2|)) "\\spad{basisOfMiddleNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(a,{}x,{}b)} for all \\spad{a},{}\\spad{b} in \\spad{A}.")) (|basisOfRightNucleus| (((|List| |#2|)) "\\spad{basisOfRightNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(a,{}b,{}x)} for all \\spad{a},{}\\spad{b} in \\spad{A}.")) (|basisOfLeftNucleus| (((|List| |#2|)) "\\spad{basisOfLeftNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(x,{}a,{}b)} for all \\spad{a},{}\\spad{b} in \\spad{A}.")) (|basisOfRightAnnihilator| (((|List| |#2|) |#2|) "\\spad{basisOfRightAnnihilator(a)} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = a*x}.")) (|basisOfLeftAnnihilator| (((|List| |#2|) |#2|) "\\spad{basisOfLeftAnnihilator(a)} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = x*a}.")) (|basisOfCommutingElements| (((|List| |#2|)) "\\spad{basisOfCommutingElements()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = commutator(x,{}a)} for all \\spad{a} in \\spad{A}.")) (|biRank| (((|NonNegativeInteger|) |#2|) "\\spad{biRank(x)} determines the number of linearly independent elements in \\spad{x},{} \\spad{x*bi},{} \\spad{bi*x},{} \\spad{bi*x*bj},{} \\spad{i,{}j=1,{}...,{}n},{} where \\spad{b=[b1,{}...,{}bn]} is a basis. Note that if \\spad{A} has a unit,{} then doubleRank,{} weakBiRank,{} and biRank coincide.")) (|weakBiRank| (((|NonNegativeInteger|) |#2|) "\\spad{weakBiRank(x)} determines the number of linearly independent elements in the \\spad{bi*x*bj},{} \\spad{i,{}j=1,{}...,{}n},{} where \\spad{b=[b1,{}...,{}bn]} is a basis.")) (|doubleRank| (((|NonNegativeInteger|) |#2|) "\\spad{doubleRank(x)} determines the number of linearly independent elements in \\spad{b1*x},{}...,{}\\spad{x*bn},{} where \\spad{b=[b1,{}...,{}bn]} is a basis.")) (|rightRank| (((|NonNegativeInteger|) |#2|) "\\spad{rightRank(x)} determines the number of linearly independent elements in \\spad{b1*x},{}...,{}\\spad{bn*x},{} where \\spad{b=[b1,{}...,{}bn]} is a basis.")) (|leftRank| (((|NonNegativeInteger|) |#2|) "\\spad{leftRank(x)} determines the number of linearly independent elements in \\spad{x*b1},{}...,{}\\spad{x*bn},{} where \\spad{b=[b1,{}...,{}bn]} is a basis."))) +((|constructor| (NIL "AlgebraPackage assembles a variety of useful functions for general algebras.")) (|basis| (((|Vector| |#2|) (|Vector| |#2|)) "\\spad{basis(va)} selects a basis from the elements of va.")) (|radicalOfLeftTraceForm| (((|List| |#2|)) "\\spad{radicalOfLeftTraceForm()} returns basis for null space of \\spad{leftTraceMatrix()}, if the algebra is associative, alternative or a Jordan algebra, then this space equals the radical (maximal nil ideal) of the algebra.")) (|basisOfCentroid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfCentroid()} returns a basis of the centroid, \\spadignore{i.e.} the endomorphism ring of \\spad{A} considered as \\spad{(A,A)}-bimodule.")) (|basisOfRightNucloid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfRightNucloid()} returns a basis of the space of endomorphisms of \\spad{A} as left module. Note that right nucloid coincides with right nucleus if \\spad{A} has a unit.")) (|basisOfLeftNucloid| (((|List| (|Matrix| |#1|))) "\\spad{basisOfLeftNucloid()} returns a basis of the space of endomorphisms of \\spad{A} as right module. Note that left nucloid coincides with left nucleus if \\spad{A} has a unit.")) (|basisOfCenter| (((|List| |#2|)) "\\spad{basisOfCenter()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{commutator(x,a) = 0} and \\spad{associator(x,a,b) = associator(a,x,b) = associator(a,b,x) = 0} for all \\spad{a},b in \\spad{A}.")) (|basisOfNucleus| (((|List| |#2|)) "\\spad{basisOfNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{associator(x,a,b) = associator(a,x,b) = associator(a,b,x) = 0} for all \\spad{a},b in \\spad{A}.")) (|basisOfMiddleNucleus| (((|List| |#2|)) "\\spad{basisOfMiddleNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(a,x,b)} for all \\spad{a},b in \\spad{A}.")) (|basisOfRightNucleus| (((|List| |#2|)) "\\spad{basisOfRightNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(a,b,x)} for all \\spad{a},b in \\spad{A}.")) (|basisOfLeftNucleus| (((|List| |#2|)) "\\spad{basisOfLeftNucleus()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = associator(x,a,b)} for all \\spad{a},b in \\spad{A}.")) (|basisOfRightAnnihilator| (((|List| |#2|) |#2|) "\\spad{basisOfRightAnnihilator(a)} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = a*x}.")) (|basisOfLeftAnnihilator| (((|List| |#2|) |#2|) "\\spad{basisOfLeftAnnihilator(a)} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = x*a}.")) (|basisOfCommutingElements| (((|List| |#2|)) "\\spad{basisOfCommutingElements()} returns a basis of the space of all \\spad{x} of \\spad{A} satisfying \\spad{0 = commutator(x,a)} for all \\spad{a} in \\spad{A}.")) (|biRank| (((|NonNegativeInteger|) |#2|) "\\spad{biRank(x)} determines the number of linearly independent elements in \\spad{x}, \\spad{x*bi}, \\spad{bi*x}, \\spad{bi*x*bj}, \\spad{i,j=1,...,n}, where \\spad{b=[b1,...,bn]} is a basis. Note that if \\spad{A} has a unit, then doubleRank, weakBiRank, and biRank coincide.")) (|weakBiRank| (((|NonNegativeInteger|) |#2|) "\\spad{weakBiRank(x)} determines the number of linearly independent elements in the \\spad{bi*x*bj}, \\spad{i,j=1,...,n}, where \\spad{b=[b1,...,bn]} is a basis.")) (|doubleRank| (((|NonNegativeInteger|) |#2|) "\\spad{doubleRank(x)} determines the number of linearly independent elements in \\spad{b1*x},...,\\spad{x*bn}, where \\spad{b=[b1,...,bn]} is a basis.")) (|rightRank| (((|NonNegativeInteger|) |#2|) "\\spad{rightRank(x)} determines the number of linearly independent elements in \\spad{b1*x},...,\\spad{bn*x}, where \\spad{b=[b1,...,bn]} is a basis.")) (|leftRank| (((|NonNegativeInteger|) |#2|) "\\spad{leftRank(x)} determines the number of linearly independent elements in \\spad{x*b1},...,\\spad{x*bn}, where \\spad{b=[b1,...,bn]} is a basis."))) NIL ((|HasCategory| |#1| (QUOTE (-302)))) (-49 R |n| |ls| |gamma|) -((|constructor| (NIL "AlgebraGivenByStructuralConstants implements finite rank algebras over a commutative ring,{} given by the structural constants \\spad{gamma} with respect to a fixed basis \\spad{[a1,{}..,{}an]},{} where \\spad{gamma} is an \\spad{n}-vector of \\spad{n} by \\spad{n} matrices \\spad{[(gammaijk) for k in 1..rank()]} defined by \\spad{\\spad{ai} * aj = gammaij1 * a1 + ... + gammaijn * an}. The symbols for the fixed basis have to be given as a list of symbols.")) (|coerce| (($ (|Vector| |#1|)) "\\spad{coerce(v)} converts a vector to a member of the algebra by forming a linear combination with the basis element. Note: the vector is assumed to have length equal to the dimension of the algebra."))) -((-4532 |has| |#1| (-559)) (-4530 . T) (-4529 . T)) +((|constructor| (NIL "AlgebraGivenByStructuralConstants implements finite rank algebras over a commutative ring, given by the structural constants \\spad{gamma} with respect to a fixed basis \\spad{[a1,..,an]}, where \\spad{gamma} is an \\spad{n}-vector of \\spad{n} by \\spad{n} matrices \\spad{[(gammaijk) for \\spad{k} in 1..rank()]} defined by \\spad{ai * aj = \\spad{gammaij1} * \\spad{a1} + \\spad{...} + gammaijn * an}. The symbols for the fixed basis have to be given as a list of symbols.")) (|coerce| (($ (|Vector| |#1|)) "\\spad{coerce(v)} converts a vector to a member of the algebra by forming a linear combination with the basis element. Note: the vector is assumed to have length equal to the dimension of the algebra."))) +((-4568 |has| |#1| (-559)) (-4566 . T) (-4565 . T)) ((|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-559)))) (-50 |Key| |Entry|) -((|constructor| (NIL "\\spadtype{AssociationList} implements association lists. These may be viewed as lists of pairs where the first part is a key and the second is the stored value. For example,{} the key might be a string with a persons employee identification number and the value might be a record with personnel data."))) -((-4535 . T) (-4536 . T)) -((|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-843))) (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#2| (QUOTE (-1091))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1091)))) (|HasCategory| (-569) (QUOTE (-843))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091))) (-2232 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091))) (|HasCategory| |#2| (QUOTE (-1091)))) (-2232 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-843))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091))) (|HasCategory| |#2| (QUOTE (-1091)))) (-12 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -2335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3782) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -2335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3782) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-843)))) (-12 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -2335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3782) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091)))))) +((|constructor| (NIL "\\spadtype{AssociationList} implements association lists. These may be viewed as lists of pairs where the first part is a key and the second is the stored value. For example, the key might be a string with a persons employee identification number and the value might be a record with personnel data."))) +((-4571 . T) (-4572 . T)) +((|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-844))) (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#2| (QUOTE (-1093))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1093)))) (|HasCategory| (-569) (QUOTE (-844))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093))) (-1929 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093))) (|HasCategory| |#2| (QUOTE (-1093)))) (-1929 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-844))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093))) (|HasCategory| |#2| (QUOTE (-1093)))) (-12 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -3335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3175) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -3335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3175) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-844)))) (-12 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -3335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3175) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093)))))) (-51 S R E) -((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i,{} elements of the ordered abelian monoid,{} are thought of as exponents or monomials. The monomials commute with each other,{} and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least,{} only the non-zero terms are ever operated on.")) (/ (($ $ |#2|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c}.")) (|coefficient| ((|#2| $ |#3|) "\\spad{coefficient(p,{}e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p},{} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#2| |#3|) "\\spad{monomial(r,{}e)} makes a term from a coefficient \\spad{r} and an exponent \\spad{e}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|map| (($ (|Mapping| |#2| |#2|) $) "\\spad{map(fn,{}u)} maps function \\spad{fn} onto the coefficients of the non-zero monomials of \\spad{u}.")) (|degree| ((|#3| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p}.")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#2| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p}."))) +((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i, elements of the ordered abelian monoid, are thought of as exponents or monomials. The monomials commute with each other, and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least, only the non-zero terms are ever operated on.")) (/ (($ $ |#2|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c.}")) (|coefficient| ((|#2| $ |#3|) "\\spad{coefficient(p,e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p,} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#2| |#3|) "\\spad{monomial(r,e)} makes a term from a coefficient \\spad{r} and an exponent e.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|map| (($ (|Mapping| |#2| |#2|) $) "\\spad{map(fn,u)} maps function \\spad{fn} onto the coefficients of the non-zero monomials of u.")) (|degree| ((|#3| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p.}")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#2| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p.}"))) NIL ((|HasCategory| |#2| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-151))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-366)))) (-52 R E) -((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i,{} elements of the ordered abelian monoid,{} are thought of as exponents or monomials. The monomials commute with each other,{} and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least,{} only the non-zero terms are ever operated on.")) (/ (($ $ |#1|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c}.")) (|coefficient| ((|#1| $ |#2|) "\\spad{coefficient(p,{}e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p},{} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#1| |#2|) "\\spad{monomial(r,{}e)} makes a term from a coefficient \\spad{r} and an exponent \\spad{e}.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(fn,{}u)} maps function \\spad{fn} onto the coefficients of the non-zero monomials of \\spad{u}.")) (|degree| ((|#2| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p}.")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p}."))) -(((-4537 "*") |has| |#1| (-173)) (-4528 |has| |#1| (-559)) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "Abelian monoid ring elements (not necessarily of finite support) of this ring are of the form formal SUM (r_i * e_i) where the r_i are coefficents and the e_i, elements of the ordered abelian monoid, are thought of as exponents or monomials. The monomials commute with each other, and with the coefficients (which themselves may or may not be commutative). See \\spadtype{FiniteAbelianMonoidRing} for the case of finite support a useful common model for polynomials and power series. Conceptually at least, only the non-zero terms are ever operated on.")) (/ (($ $ |#1|) "\\spad{p/c} divides \\spad{p} by the coefficient \\spad{c.}")) (|coefficient| ((|#1| $ |#2|) "\\spad{coefficient(p,e)} extracts the coefficient of the monomial with exponent \\spad{e} from polynomial \\spad{p,} or returns zero if exponent is not present.")) (|reductum| (($ $) "\\spad{reductum(u)} returns \\spad{u} minus its leading monomial returns zero if handed the zero element.")) (|monomial| (($ |#1| |#2|) "\\spad{monomial(r,e)} makes a term from a coefficient \\spad{r} and an exponent e.")) (|monomial?| (((|Boolean|) $) "\\spad{monomial?(p)} tests if \\spad{p} is a single monomial.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(fn,u)} maps function \\spad{fn} onto the coefficients of the non-zero monomials of u.")) (|degree| ((|#2| $) "\\spad{degree(p)} returns the maximum of the exponents of the terms of \\spad{p.}")) (|leadingMonomial| (($ $) "\\spad{leadingMonomial(p)} returns the monomial of \\spad{p} with the highest degree.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the coefficient highest degree term of \\spad{p.}"))) +(((-4573 "*") |has| |#1| (-173)) (-4564 |has| |#1| (-559)) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-53) -((|constructor| (NIL "Algebraic closure of the rational numbers,{} with mathematical =")) (|norm| (($ $ (|List| (|Kernel| $))) "\\spad{norm(f,{}l)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernels \\spad{l}") (($ $ (|Kernel| $)) "\\spad{norm(f,{}k)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernel \\spad{k}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|List| (|Kernel| $))) "\\spad{norm(p,{}l)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernels \\spad{l}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{norm(p,{}k)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernel \\spad{k}")) (|reduce| (($ $) "\\spad{reduce(f)} simplifies all the unreduced algebraic numbers present in \\spad{f} by applying their defining relations.")) (|denom| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{denom(f)} returns the denominator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}.")) (|numer| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{numer(f)} returns the numerator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z}.")) (|coerce| (($ (|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $))) "\\spad{coerce(p)} returns \\spad{p} viewed as an algebraic number."))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| $ (QUOTE (-1048))) (|HasCategory| $ (LIST (QUOTE -1038) (QUOTE (-569))))) +((|constructor| (NIL "Algebraic closure of the rational numbers, with mathematical =")) (|norm| (($ $ (|List| (|Kernel| $))) "\\spad{norm(f,l)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernels \\spad{l}") (($ $ (|Kernel| $)) "\\spad{norm(f,k)} computes the norm of the algebraic number \\spad{f} with respect to the extension generated by kernel \\spad{k}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|List| (|Kernel| $))) "\\spad{norm(p,l)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernels \\spad{l}") (((|SparseUnivariatePolynomial| $) (|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{norm(p,k)} computes the norm of the polynomial \\spad{p} with respect to the extension generated by kernel \\spad{k}")) (|reduce| (($ $) "\\spad{reduce(f)} simplifies all the unreduced algebraic numbers present in \\spad{f} by applying their defining relations.")) (|denom| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{denom(f)} returns the denominator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z.}")) (|numer| (((|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $)) $) "\\spad{numer(f)} returns the numerator of \\spad{f} viewed as a polynomial in the kernels over \\spad{Z.}")) (|coerce| (($ (|SparseMultivariatePolynomial| (|Integer|) (|Kernel| $))) "\\spad{coerce(p)} returns \\spad{p} viewed as an algebraic number."))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| $ (QUOTE (-1049))) (|HasCategory| $ (LIST (QUOTE -1039) (QUOTE (-569))))) (-54) ((|constructor| (NIL "This domain implements anonymous functions"))) NIL NIL (-55 R |lVar|) -((|constructor| (NIL "The domain of antisymmetric polynomials.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(f,{}p)} changes each coefficient of \\spad{p} by the application of \\spad{f}.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} returns the homogeneous degree of \\spad{p}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(p)} tests if \\spad{p} is a 0-form,{} \\spadignore{i.e.} if degree(\\spad{p}) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(p)} tests if all of the terms of \\spad{p} have the same degree.")) (|exp| (($ (|List| (|Integer|))) "\\spad{exp([i1,{}...in])} returns \\spad{u_1\\^{i_1} ... u_n\\^{i_n}}")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th multiplicative generator,{} a basis term.")) (|coefficient| ((|#1| $ $) "\\spad{coefficient(p,{}u)} returns the coefficient of the term in \\spad{p} containing the basis term \\spad{u} if such a term exists,{} and 0 otherwise. Error: if the second argument \\spad{u} is not a basis element.")) (|reductum| (($ $) "\\spad{reductum(p)},{} where \\spad{p} is an antisymmetric polynomial,{} returns \\spad{p} minus the leading term of \\spad{p} if \\spad{p} has at least two terms,{} and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(p)} returns the leading basis term of antisymmetric polynomial \\spad{p}.")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the leading coefficient of antisymmetric polynomial \\spad{p}."))) -((-4532 . T)) +((|constructor| (NIL "The domain of antisymmetric polynomials.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(f,p)} changes each coefficient of \\spad{p} by the application of \\spad{f.}")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(p)} returns the homogeneous degree of \\spad{p.}")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(p)} tests if \\spad{p} is a 0-form, \\spadignore{i.e.} if degree(p) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(p)} tests if all of the terms of \\spad{p} have the same degree.")) (|exp| (($ (|List| (|Integer|))) "\\spad{exp([i1,...in])} returns \\spad{u_1\\^{i_1} \\spad{...} u_n\\^{i_n}}")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th multiplicative generator, a basis term.")) (|coefficient| ((|#1| $ $) "\\spad{coefficient(p,u)} returns the coefficient of the term in \\spad{p} containing the basis term \\spad{u} if such a term exists, and 0 otherwise. Error: if the second argument \\spad{u} is not a basis element.")) (|reductum| (($ $) "\\spad{reductum(p)}, where \\spad{p} is an antisymmetric polynomial, returns \\spad{p} minus the leading term of \\spad{p} if \\spad{p} has at least two terms, and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(p)} returns the leading basis term of antisymmetric polynomial \\spad{p.}")) (|leadingCoefficient| ((|#1| $) "\\spad{leadingCoefficient(p)} returns the leading coefficient of antisymmetric polynomial \\spad{p.}"))) +((-4568 . T)) NIL (-56 S) -((|constructor| (NIL "\\spadtype{AnyFunctions1} implements several utility functions for working with \\spadtype{Any}. These functions are used to go back and forth between objects of \\spadtype{Any} and objects of other types.")) (|retract| ((|#1| (|Any|)) "\\spad{retract(a)} tries to convert \\spad{a} into an object of type \\spad{S}. If possible,{} it returns the object. Error: if no such retraction is possible.")) (|retractable?| (((|Boolean|) (|Any|)) "\\spad{retractable?(a)} tests if \\spad{a} can be converted into an object of type \\spad{S}.")) (|retractIfCan| (((|Union| |#1| "failed") (|Any|)) "\\spad{retractIfCan(a)} tries change \\spad{a} into an object of type \\spad{S}. If it can,{} then such an object is returned. Otherwise,{} \"failed\" is returned.")) (|coerce| (((|Any|) |#1|) "\\spad{coerce(s)} creates an object of \\spadtype{Any} from the object \\spad{s} of type \\spad{S}."))) +((|constructor| (NIL "\\spadtype{AnyFunctions1} implements several utility functions for working with \\spadtype{Any}. These functions are used to go back and forth between objects of \\spadtype{Any} and objects of other types.")) (|retract| ((|#1| (|Any|)) "\\spad{retract(a)} tries to convert \\spad{a} into an object of type \\spad{S}. If possible, it returns the object. Error: if no such retraction is possible.")) (|retractable?| (((|Boolean|) (|Any|)) "\\spad{retractable?(a)} tests if \\spad{a} can be converted into an object of type \\spad{S}.")) (|retractIfCan| (((|Union| |#1| "failed") (|Any|)) "\\spad{retractIfCan(a)} tries change \\spad{a} into an object of type \\spad{S}. If it can, then such an object is returned. Otherwise, \"failed\" is returned.")) (|coerce| (((|Any|) |#1|) "\\spad{coerce(s)} creates an object of \\spadtype{Any} from the object \\spad{s} of type \\spad{S}."))) NIL NIL (-57) -((|constructor| (NIL "\\spadtype{Any} implements a type that packages up objects and their types in objects of \\spadtype{Any}. Roughly speaking that means that if \\spad{s : S} then when converted to \\spadtype{Any},{} the new object will include both the original object and its type. This is a way of converting arbitrary objects into a single type without losing any of the original information. Any object can be converted to one of \\spadtype{Any}.")) (|showTypeInOutput| (((|String|) (|Boolean|)) "\\spad{showTypeInOutput(bool)} affects the way objects of \\spadtype{Any} are displayed. If \\spad{bool} is \\spad{true} then the type of the original object that was converted to \\spadtype{Any} will be printed. If \\spad{bool} is \\spad{false},{} it will not be printed.")) (|obj| (((|None|) $) "\\spad{obj(a)} essentially returns the original object that was converted to \\spadtype{Any} except that the type is forced to be \\spadtype{None}.")) (|dom| (((|SExpression|) $) "\\spad{dom(a)} returns a \\spadgloss{LISP} form of the type of the original object that was converted to \\spadtype{Any}.")) (|objectOf| (((|OutputForm|) $) "\\spad{objectOf(a)} returns a printable form of the original object that was converted to \\spadtype{Any}.")) (|domainOf| (((|OutputForm|) $) "\\spad{domainOf(a)} returns a printable form of the type of the original object that was converted to \\spadtype{Any}.")) (|any| (($ (|SExpression|) (|None|)) "\\spad{any(type,{}object)} is a technical function for creating an \\spad{object} of \\spadtype{Any}. Arugment \\spad{type} is a \\spadgloss{LISP} form for the \\spad{type} of \\spad{object}."))) +((|constructor| (NIL "\\spadtype{Any} implements a type that packages up objects and their types in objects of \\spadtype{Any}. Roughly speaking that means that if \\spad{s : \\spad{S}} then when converted to \\spadtype{Any}, the new object will include both the original object and its type. This is a way of converting arbitrary objects into a single type without losing any of the original information. Any object can be converted to one of \\spadtype{Any}.")) (|showTypeInOutput| (((|String|) (|Boolean|)) "\\spad{showTypeInOutput(bool)} affects the way objects of \\spadtype{Any} are displayed. If \\spad{bool} is \\spad{true} then the type of the original object that was converted to \\spadtype{Any} will be printed. If \\spad{bool} is false, it will not be printed.")) (|obj| (((|None|) $) "\\spad{obj(a)} essentially returns the original object that was converted to \\spadtype{Any} except that the type is forced to be \\spadtype{None}.")) (|dom| (((|SExpression|) $) "\\spad{dom(a)} returns a \\spadgloss{LISP} form of the type of the original object that was converted to \\spadtype{Any}.")) (|objectOf| (((|OutputForm|) $) "\\spad{objectOf(a)} returns a printable form of the original object that was converted to \\spadtype{Any}.")) (|domainOf| (((|OutputForm|) $) "\\spad{domainOf(a)} returns a printable form of the type of the original object that was converted to \\spadtype{Any}.")) (|any| (($ (|SExpression|) (|None|)) "\\spad{any(type,object)} is a technical function for creating an \\spad{object} of \\spadtype{Any}. Arugment \\spad{type} is a \\spadgloss{LISP} form for the \\spad{type} of \\spad{object}."))) NIL NIL (-58) -((|constructor| (NIL "This package contains useful functions that expose Axiom system internals")) (|summary| (((|Void|)) "\\indented{1}{summary() prints a short list of useful console commands} \\blankline \\spad{X} summary()")) (|credits| (((|Void|)) "\\indented{1}{credits() prints a list of people who contributed to Axiom} \\blankline \\spad{X} credits()")) (|getDomains| (((|Set| (|Symbol|)) (|Symbol|)) "\\indented{1}{The getDomains(\\spad{s}) takes a category and returns the list of domains} \\indented{1}{that have that category} \\blankline \\spad{X} getDomains 'IndexedAggregate"))) +((|constructor| (NIL "This package contains useful functions that expose Axiom system internals")) (|summary| (((|Void|)) "\\indented{1}{summary() prints a short list of useful console commands} \\blankline \\spad{X} summary()")) (|credits| (((|Void|)) "\\indented{1}{credits() prints a list of people who contributed to Axiom} \\blankline \\spad{X} credits()")) (|getAncestors| (((|Set| (|Symbol|)) (|Symbol|)) "\\indented{1}{The getAncestor(s) takes a category and returns the list of domains} \\indented{1}{that have that category as ancestors} \\blankline \\spad{X} getAncestors 'IndexedAggregate")) (|getDomains| (((|Set| (|Symbol|)) (|Symbol|)) "\\indented{1}{The getDomains(s) takes a category and returns the list of domains} \\indented{1}{that have that category} \\blankline \\spad{X} getDomains 'IndexedAggregate"))) NIL NIL (-59 R M P) -((|constructor| (NIL "\\spad{ApplyUnivariateSkewPolynomial} (internal) allows univariate skew polynomials to be applied to appropriate modules.")) (|apply| ((|#2| |#3| (|Mapping| |#2| |#2|) |#2|) "\\spad{apply(p,{} f,{} m)} returns \\spad{p(m)} where the action is given by \\spad{x m = f(m)}. \\spad{f} must be an \\spad{R}-pseudo linear map on \\spad{M}."))) +((|constructor| (NIL "\\spad{ApplyUnivariateSkewPolynomial} (internal) allows univariate skew polynomials to be applied to appropriate modules.")) (|apply| ((|#2| |#3| (|Mapping| |#2| |#2|) |#2|) "\\spad{apply(p, \\spad{f,} \\spad{m)}} returns \\spad{p(m)} where the action is given by \\spad{x \\spad{m} = f(m)}. \\spad{f} must be an R-pseudo linear map on \\spad{M.}"))) NIL NIL -(-60 |Base| R -1564) -((|constructor| (NIL "This package apply rewrite rules to expressions,{} calling the pattern matcher.")) (|localUnquote| ((|#3| |#3| (|List| (|Symbol|))) "\\spad{localUnquote(f,{}ls)} is a local function.")) (|applyRules| ((|#3| (|List| (|RewriteRule| |#1| |#2| |#3|)) |#3| (|PositiveInteger|)) "\\spad{applyRules([r1,{}...,{}rn],{} expr,{} n)} applies the rules \\spad{r1},{}...,{}\\spad{rn} to \\spad{f} a most \\spad{n} times.") ((|#3| (|List| (|RewriteRule| |#1| |#2| |#3|)) |#3|) "\\spad{applyRules([r1,{}...,{}rn],{} expr)} applies the rules \\spad{r1},{}...,{}\\spad{rn} to \\spad{f} an unlimited number of times,{} \\spadignore{i.e.} until none of \\spad{r1},{}...,{}\\spad{rn} is applicable to the expression."))) +(-60 |Base| R -1647) +((|constructor| (NIL "This package apply rewrite rules to expressions, calling the pattern matcher.")) (|localUnquote| ((|#3| |#3| (|List| (|Symbol|))) "\\spad{localUnquote(f,ls)} is a local function.")) (|applyRules| ((|#3| (|List| (|RewriteRule| |#1| |#2| |#3|)) |#3| (|PositiveInteger|)) "\\spad{applyRules([r1,...,rn], expr, \\spad{n)}} applies the rules r1,...,rn to \\spad{f} a most \\spad{n} times.") ((|#3| (|List| (|RewriteRule| |#1| |#2| |#3|)) |#3|) "\\spad{applyRules([r1,...,rn], expr)} applies the rules r1,...,rn to \\spad{f} an unlimited number of times, \\spadignore{i.e.} until none of r1,...,rn is applicable to the expression."))) NIL NIL (-61 S R |Row| |Col|) -((|constructor| (NIL "Two dimensional array categories and domains")) (|map!| (($ (|Mapping| |#2| |#2|) $) "\\indented{1}{map!(\\spad{f},{}a)\\space{2}assign \\spad{a(i,{}j)} to \\spad{f(a(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map!(-,{}arr)")) (|map| (($ (|Mapping| |#2| |#2| |#2|) $ $ |#2|) "\\indented{1}{map(\\spad{f},{}a,{}\\spad{b},{}\\spad{r}) returns \\spad{c},{} where \\spad{c(i,{}j) = f(a(i,{}j),{}b(i,{}j))}} \\indented{1}{when both \\spad{a(i,{}j)} and \\spad{b(i,{}j)} exist;} \\indented{1}{else \\spad{c(i,{}j) = f(r,{} b(i,{}j))} when \\spad{a(i,{}j)} does not exist;} \\indented{1}{else \\spad{c(i,{}j) = f(a(i,{}j),{}r)} when \\spad{b(i,{}j)} does not exist;} \\indented{1}{otherwise \\spad{c(i,{}j) = f(r,{}r)}.} \\blankline \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} \\spad{arr1} : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} \\spad{arr2} : \\spad{ARRAY2} INT \\spad{:=} new(3,{}3,{}10) \\spad{X} map(adder,{}\\spad{arr1},{}\\spad{arr2},{}17)") (($ (|Mapping| |#2| |#2| |#2|) $ $) "\\indented{1}{map(\\spad{f},{}a,{}\\spad{b}) returns \\spad{c},{} where \\spad{c(i,{}j) = f(a(i,{}j),{}b(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\blankline \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map(adder,{}arr,{}arr)") (($ (|Mapping| |#2| |#2|) $) "\\indented{1}{map(\\spad{f},{}a) returns \\spad{b},{} where \\spad{b(i,{}j) = f(a(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map(-,{}arr) \\spad{X} map((\\spad{x} +-> \\spad{x} + \\spad{x}),{}arr)")) (|setColumn!| (($ $ (|Integer|) |#4|) "\\indented{1}{setColumn!(\\spad{m},{}\\spad{j},{}\\spad{v}) sets to \\spad{j}th column of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,{}4,{}0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} acol:=construct([1,{}2,{}3,{}4,{}5]::List(INT))\\$\\spad{T2} \\spad{X} setColumn!(arr,{}1,{}acol)\\$\\spad{T1}")) (|setRow!| (($ $ (|Integer|) |#3|) "\\indented{1}{setRow!(\\spad{m},{}\\spad{i},{}\\spad{v}) sets to \\spad{i}th row of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,{}4,{}0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} arow:=construct([1,{}2,{}3,{}4]::List(INT))\\$\\spad{T2} \\spad{X} setRow!(arr,{}1,{}arow)\\$\\spad{T1}")) (|qsetelt!| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{qsetelt!(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) sets the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} qsetelt!(arr,{}1,{}1,{}17)")) (|setelt| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{setelt(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) sets the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} setelt(arr,{}1,{}1,{}17)")) (|parts| (((|List| |#2|) $) "\\indented{1}{parts(\\spad{m}) returns a list of the elements of \\spad{m} in row major order} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} parts(arr)")) (|column| ((|#4| $ (|Integer|)) "\\indented{1}{column(\\spad{m},{}\\spad{j}) returns the \\spad{j}th column of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} column(arr,{}1)")) (|row| ((|#3| $ (|Integer|)) "\\indented{1}{row(\\spad{m},{}\\spad{i}) returns the \\spad{i}th row of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} row(arr,{}1)")) (|qelt| ((|#2| $ (|Integer|) (|Integer|)) "\\indented{1}{qelt(\\spad{m},{}\\spad{i},{}\\spad{j}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} qelt(arr,{}1,{}1)")) (|elt| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{elt(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m},{} if \\spad{m} has an \\spad{i}th row and a \\spad{j}th column,{}} \\indented{1}{and returns \\spad{r} otherwise} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} elt(arr,{}1,{}1,{}6) \\spad{X} elt(arr,{}1,{}10,{}6)") ((|#2| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(\\spad{m},{}\\spad{i},{}\\spad{j}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} elt(arr,{}1,{}1)")) (|ncols| (((|NonNegativeInteger|) $) "\\indented{1}{ncols(\\spad{m}) returns the number of columns in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} ncols(arr)")) (|nrows| (((|NonNegativeInteger|) $) "\\indented{1}{nrows(\\spad{m}) returns the number of rows in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} nrows(arr)")) (|maxColIndex| (((|Integer|) $) "\\indented{1}{maxColIndex(\\spad{m}) returns the index of the 'last' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} maxColIndex(arr)")) (|minColIndex| (((|Integer|) $) "\\indented{1}{minColIndex(\\spad{m}) returns the index of the 'first' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} minColIndex(arr)")) (|maxRowIndex| (((|Integer|) $) "\\indented{1}{maxRowIndex(\\spad{m}) returns the index of the 'last' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} maxRowIndex(arr)")) (|minRowIndex| (((|Integer|) $) "\\indented{1}{minRowIndex(\\spad{m}) returns the index of the 'first' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} minRowIndex(arr)")) (|fill!| (($ $ |#2|) "\\indented{1}{fill!(\\spad{m},{}\\spad{r}) fills \\spad{m} with \\spad{r}\\spad{'s}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} fill!(arr,{}10)")) (|new| (($ (|NonNegativeInteger|) (|NonNegativeInteger|) |#2|) "\\indented{1}{new(\\spad{m},{}\\spad{n},{}\\spad{r}) is an \\spad{m}-by-\\spad{n} array all of whose entries are \\spad{r}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0)")) (|finiteAggregate| ((|attribute|) "two-dimensional arrays are finite")) (|shallowlyMutable| ((|attribute|) "one may destructively alter arrays"))) +((|constructor| (NIL "Two dimensional array categories and domains")) (|map!| (($ (|Mapping| |#2| |#2|) $) "\\indented{1}{map!(f,a)\\space{2}assign \\spad{a(i,j)} to \\spad{f(a(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map!(-,arr)")) (|map| (($ (|Mapping| |#2| |#2| |#2|) $ $ |#2|) "\\indented{1}{map(f,a,b,r) returns \\spad{c}, where \\spad{c(i,j) = f(a(i,j),b(i,j))}} \\indented{1}{when both \\spad{a(i,j)} and \\spad{b(i,j)} exist;} \\indented{1}{else \\spad{c(i,j) = f(r, b(i,j))} when \\spad{a(i,j)} does not exist;} \\indented{1}{else \\spad{c(i,j) = f(a(i,j),r)} when \\spad{b(i,j)} does not exist;} \\indented{1}{otherwise \\spad{c(i,j) = f(r,r)}.} \\blankline \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} \\spad{arr1} : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} \\spad{arr2} : \\spad{ARRAY2} INT \\spad{:=} new(3,3,10) \\spad{X} map(adder,arr1,arr2,17)") (($ (|Mapping| |#2| |#2| |#2|) $ $) "\\indented{1}{map(f,a,b) returns \\spad{c}, where \\spad{c(i,j) = f(a(i,j),b(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\blankline \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map(adder,arr,arr)") (($ (|Mapping| |#2| |#2|) $) "\\indented{1}{map(f,a) returns \\spad{b}, where \\spad{b(i,j) = f(a(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map(-,arr) \\spad{X} map((x \\spad{+->} \\spad{x} + x),arr)")) (|setColumn!| (($ $ (|Integer|) |#4|) "\\indented{1}{setColumn!(m,j,v) sets to \\spad{j}th column of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,4,0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} \\spad{acol:=construct([1,2,3,4,5]::List(INT))$T2} \\spad{X} \\spad{setColumn!(arr,1,acol)$T1}")) (|setRow!| (($ $ (|Integer|) |#3|) "\\indented{1}{setRow!(m,i,v) sets to \\spad{i}th row of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,4,0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} \\spad{arow:=construct([1,2,3,4]::List(INT))$T2} \\spad{X} \\spad{setRow!(arr,1,arow)$T1}")) (|qsetelt!| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{qsetelt!(m,i,j,r) sets the element in the \\spad{i}th row and jth} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} qsetelt!(arr,1,1,17)")) (|setelt| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{setelt(m,i,j,r) sets the element in the \\spad{i}th row and jth} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} setelt(arr,1,1,17)")) (|parts| (((|List| |#2|) $) "\\indented{1}{parts(m) returns a list of the elements of \\spad{m} in row major order} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} parts(arr)")) (|column| ((|#4| $ (|Integer|)) "\\indented{1}{column(m,j) returns the \\spad{j}th column of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} column(arr,1)")) (|row| ((|#3| $ (|Integer|)) "\\indented{1}{row(m,i) returns the \\spad{i}th row of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} row(arr,1)")) (|qelt| ((|#2| $ (|Integer|) (|Integer|)) "\\indented{1}{qelt(m,i,j) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} qelt(arr,1,1)")) (|elt| ((|#2| $ (|Integer|) (|Integer|) |#2|) "\\indented{1}{elt(m,i,j,r) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m,} if \\spad{m} has an \\spad{i}th row and a \\spad{j}th column,} \\indented{1}{and returns \\spad{r} otherwise} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} elt(arr,1,1,6) \\spad{X} elt(arr,1,10,6)") ((|#2| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(m,i,j) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} elt(arr,1,1)")) (|ncols| (((|NonNegativeInteger|) $) "\\indented{1}{ncols(m) returns the number of columns in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} ncols(arr)")) (|nrows| (((|NonNegativeInteger|) $) "\\indented{1}{nrows(m) returns the number of rows in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} nrows(arr)")) (|maxColIndex| (((|Integer|) $) "\\indented{1}{maxColIndex(m) returns the index of the 'last' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} maxColIndex(arr)")) (|minColIndex| (((|Integer|) $) "\\indented{1}{minColIndex(m) returns the index of the 'first' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} minColIndex(arr)")) (|maxRowIndex| (((|Integer|) $) "\\indented{1}{maxRowIndex(m) returns the index of the 'last' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} maxRowIndex(arr)")) (|minRowIndex| (((|Integer|) $) "\\indented{1}{minRowIndex(m) returns the index of the 'first' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} minRowIndex(arr)")) (|fill!| (($ $ |#2|) "\\indented{1}{fill!(m,r) fills \\spad{m} with r's} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} fill!(arr,10)")) (|new| (($ (|NonNegativeInteger|) (|NonNegativeInteger|) |#2|) "\\indented{1}{new(m,n,r) is an m-by-n array all of whose entries are \\spad{r}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0)")) (|finiteAggregate| ((|attribute|) "two-dimensional arrays are finite")) (|shallowlyMutable| ((|attribute|) "one may destructively alter arrays"))) NIL NIL (-62 R |Row| |Col|) -((|constructor| (NIL "Two dimensional array categories and domains")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\indented{1}{map!(\\spad{f},{}a)\\space{2}assign \\spad{a(i,{}j)} to \\spad{f(a(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map!(-,{}arr)")) (|map| (($ (|Mapping| |#1| |#1| |#1|) $ $ |#1|) "\\indented{1}{map(\\spad{f},{}a,{}\\spad{b},{}\\spad{r}) returns \\spad{c},{} where \\spad{c(i,{}j) = f(a(i,{}j),{}b(i,{}j))}} \\indented{1}{when both \\spad{a(i,{}j)} and \\spad{b(i,{}j)} exist;} \\indented{1}{else \\spad{c(i,{}j) = f(r,{} b(i,{}j))} when \\spad{a(i,{}j)} does not exist;} \\indented{1}{else \\spad{c(i,{}j) = f(a(i,{}j),{}r)} when \\spad{b(i,{}j)} does not exist;} \\indented{1}{otherwise \\spad{c(i,{}j) = f(r,{}r)}.} \\blankline \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} \\spad{arr1} : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} \\spad{arr2} : \\spad{ARRAY2} INT \\spad{:=} new(3,{}3,{}10) \\spad{X} map(adder,{}\\spad{arr1},{}\\spad{arr2},{}17)") (($ (|Mapping| |#1| |#1| |#1|) $ $) "\\indented{1}{map(\\spad{f},{}a,{}\\spad{b}) returns \\spad{c},{} where \\spad{c(i,{}j) = f(a(i,{}j),{}b(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\blankline \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map(adder,{}arr,{}arr)") (($ (|Mapping| |#1| |#1|) $) "\\indented{1}{map(\\spad{f},{}a) returns \\spad{b},{} where \\spad{b(i,{}j) = f(a(i,{}j))}} \\indented{1}{for all \\spad{i,{} j}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} map(-,{}arr) \\spad{X} map((\\spad{x} +-> \\spad{x} + \\spad{x}),{}arr)")) (|setColumn!| (($ $ (|Integer|) |#3|) "\\indented{1}{setColumn!(\\spad{m},{}\\spad{j},{}\\spad{v}) sets to \\spad{j}th column of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,{}4,{}0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} acol:=construct([1,{}2,{}3,{}4,{}5]::List(INT))\\$\\spad{T2} \\spad{X} setColumn!(arr,{}1,{}acol)\\$\\spad{T1}")) (|setRow!| (($ $ (|Integer|) |#2|) "\\indented{1}{setRow!(\\spad{m},{}\\spad{i},{}\\spad{v}) sets to \\spad{i}th row of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,{}4,{}0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} arow:=construct([1,{}2,{}3,{}4]::List(INT))\\$\\spad{T2} \\spad{X} setRow!(arr,{}1,{}arow)\\$\\spad{T1}")) (|qsetelt!| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{qsetelt!(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) sets the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} qsetelt!(arr,{}1,{}1,{}17)")) (|setelt| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{setelt(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) sets the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} setelt(arr,{}1,{}1,{}17)")) (|parts| (((|List| |#1|) $) "\\indented{1}{parts(\\spad{m}) returns a list of the elements of \\spad{m} in row major order} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} parts(arr)")) (|column| ((|#3| $ (|Integer|)) "\\indented{1}{column(\\spad{m},{}\\spad{j}) returns the \\spad{j}th column of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} column(arr,{}1)")) (|row| ((|#2| $ (|Integer|)) "\\indented{1}{row(\\spad{m},{}\\spad{i}) returns the \\spad{i}th row of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} row(arr,{}1)")) (|qelt| ((|#1| $ (|Integer|) (|Integer|)) "\\indented{1}{qelt(\\spad{m},{}\\spad{i},{}\\spad{j}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} qelt(arr,{}1,{}1)")) (|elt| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{elt(\\spad{m},{}\\spad{i},{}\\spad{j},{}\\spad{r}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m},{} if \\spad{m} has an \\spad{i}th row and a \\spad{j}th column,{}} \\indented{1}{and returns \\spad{r} otherwise} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} elt(arr,{}1,{}1,{}6) \\spad{X} elt(arr,{}1,{}10,{}6)") ((|#1| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(\\spad{m},{}\\spad{i},{}\\spad{j}) returns the element in the \\spad{i}th row and \\spad{j}th} \\indented{1}{column of the array \\spad{m}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} elt(arr,{}1,{}1)")) (|ncols| (((|NonNegativeInteger|) $) "\\indented{1}{ncols(\\spad{m}) returns the number of columns in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} ncols(arr)")) (|nrows| (((|NonNegativeInteger|) $) "\\indented{1}{nrows(\\spad{m}) returns the number of rows in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} nrows(arr)")) (|maxColIndex| (((|Integer|) $) "\\indented{1}{maxColIndex(\\spad{m}) returns the index of the 'last' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} maxColIndex(arr)")) (|minColIndex| (((|Integer|) $) "\\indented{1}{minColIndex(\\spad{m}) returns the index of the 'first' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} minColIndex(arr)")) (|maxRowIndex| (((|Integer|) $) "\\indented{1}{maxRowIndex(\\spad{m}) returns the index of the 'last' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} maxRowIndex(arr)")) (|minRowIndex| (((|Integer|) $) "\\indented{1}{minRowIndex(\\spad{m}) returns the index of the 'first' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}10) \\spad{X} minRowIndex(arr)")) (|fill!| (($ $ |#1|) "\\indented{1}{fill!(\\spad{m},{}\\spad{r}) fills \\spad{m} with \\spad{r}\\spad{'s}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0) \\spad{X} fill!(arr,{}10)")) (|new| (($ (|NonNegativeInteger|) (|NonNegativeInteger|) |#1|) "\\indented{1}{new(\\spad{m},{}\\spad{n},{}\\spad{r}) is an \\spad{m}-by-\\spad{n} array all of whose entries are \\spad{r}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,{}4,{}0)")) (|finiteAggregate| ((|attribute|) "two-dimensional arrays are finite")) (|shallowlyMutable| ((|attribute|) "one may destructively alter arrays"))) -((-4535 . T) (-4536 . T) (-2982 . T)) +((|constructor| (NIL "Two dimensional array categories and domains")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\indented{1}{map!(f,a)\\space{2}assign \\spad{a(i,j)} to \\spad{f(a(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map!(-,arr)")) (|map| (($ (|Mapping| |#1| |#1| |#1|) $ $ |#1|) "\\indented{1}{map(f,a,b,r) returns \\spad{c}, where \\spad{c(i,j) = f(a(i,j),b(i,j))}} \\indented{1}{when both \\spad{a(i,j)} and \\spad{b(i,j)} exist;} \\indented{1}{else \\spad{c(i,j) = f(r, b(i,j))} when \\spad{a(i,j)} does not exist;} \\indented{1}{else \\spad{c(i,j) = f(a(i,j),r)} when \\spad{b(i,j)} does not exist;} \\indented{1}{otherwise \\spad{c(i,j) = f(r,r)}.} \\blankline \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} \\spad{arr1} : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} \\spad{arr2} : \\spad{ARRAY2} INT \\spad{:=} new(3,3,10) \\spad{X} map(adder,arr1,arr2,17)") (($ (|Mapping| |#1| |#1| |#1|) $ $) "\\indented{1}{map(f,a,b) returns \\spad{c}, where \\spad{c(i,j) = f(a(i,j),b(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\blankline \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map(adder,arr,arr)") (($ (|Mapping| |#1| |#1|) $) "\\indented{1}{map(f,a) returns \\spad{b}, where \\spad{b(i,j) = f(a(i,j))}} \\indented{1}{for all \\spad{i, \\spad{j}}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} map(-,arr) \\spad{X} map((x \\spad{+->} \\spad{x} + x),arr)")) (|setColumn!| (($ $ (|Integer|) |#3|) "\\indented{1}{setColumn!(m,j,v) sets to \\spad{j}th column of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,4,0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} \\spad{acol:=construct([1,2,3,4,5]::List(INT))$T2} \\spad{X} \\spad{setColumn!(arr,1,acol)$T1}")) (|setRow!| (($ $ (|Integer|) |#2|) "\\indented{1}{setRow!(m,i,v) sets to \\spad{i}th row of \\spad{m} to \\spad{v}} \\blankline \\spad{X} T1:=TwoDimensionalArray Integer \\spad{X} arr:T1:= new(5,4,0) \\spad{X} T2:=OneDimensionalArray Integer \\spad{X} \\spad{arow:=construct([1,2,3,4]::List(INT))$T2} \\spad{X} \\spad{setRow!(arr,1,arow)$T1}")) (|qsetelt!| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{qsetelt!(m,i,j,r) sets the element in the \\spad{i}th row and jth} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} qsetelt!(arr,1,1,17)")) (|setelt| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{setelt(m,i,j,r) sets the element in the \\spad{i}th row and jth} \\indented{1}{column of \\spad{m} to \\spad{r}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} setelt(arr,1,1,17)")) (|parts| (((|List| |#1|) $) "\\indented{1}{parts(m) returns a list of the elements of \\spad{m} in row major order} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} parts(arr)")) (|column| ((|#3| $ (|Integer|)) "\\indented{1}{column(m,j) returns the \\spad{j}th column of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} column(arr,1)")) (|row| ((|#2| $ (|Integer|)) "\\indented{1}{row(m,i) returns the \\spad{i}th row of \\spad{m}} \\indented{1}{error check to determine if index is in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} row(arr,1)")) (|qelt| ((|#1| $ (|Integer|) (|Integer|)) "\\indented{1}{qelt(m,i,j) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m}} \\indented{1}{NO error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} qelt(arr,1,1)")) (|elt| ((|#1| $ (|Integer|) (|Integer|) |#1|) "\\indented{1}{elt(m,i,j,r) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m,} if \\spad{m} has an \\spad{i}th row and a \\spad{j}th column,} \\indented{1}{and returns \\spad{r} otherwise} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} elt(arr,1,1,6) \\spad{X} elt(arr,1,10,6)") ((|#1| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(m,i,j) returns the element in the \\spad{i}th row and jth} \\indented{1}{column of the array \\spad{m}} \\indented{1}{error check to determine if indices are in proper ranges} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} elt(arr,1,1)")) (|ncols| (((|NonNegativeInteger|) $) "\\indented{1}{ncols(m) returns the number of columns in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} ncols(arr)")) (|nrows| (((|NonNegativeInteger|) $) "\\indented{1}{nrows(m) returns the number of rows in the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} nrows(arr)")) (|maxColIndex| (((|Integer|) $) "\\indented{1}{maxColIndex(m) returns the index of the 'last' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} maxColIndex(arr)")) (|minColIndex| (((|Integer|) $) "\\indented{1}{minColIndex(m) returns the index of the 'first' column of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} minColIndex(arr)")) (|maxRowIndex| (((|Integer|) $) "\\indented{1}{maxRowIndex(m) returns the index of the 'last' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} maxRowIndex(arr)")) (|minRowIndex| (((|Integer|) $) "\\indented{1}{minRowIndex(m) returns the index of the 'first' row of the array \\spad{m}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,10) \\spad{X} minRowIndex(arr)")) (|fill!| (($ $ |#1|) "\\indented{1}{fill!(m,r) fills \\spad{m} with r's} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0) \\spad{X} fill!(arr,10)")) (|new| (($ (|NonNegativeInteger|) (|NonNegativeInteger|) |#1|) "\\indented{1}{new(m,n,r) is an m-by-n array all of whose entries are \\spad{r}} \\blankline \\spad{X} arr : \\spad{ARRAY2} INT \\spad{:=} new(5,4,0)")) (|finiteAggregate| ((|attribute|) "two-dimensional arrays are finite")) (|shallowlyMutable| ((|attribute|) "one may destructively alter arrays"))) +((-4571 . T) (-4572 . T) (-4317 . T)) NIL (-63 A B) -((|constructor| (NIL "This package provides tools for operating on one-dimensional arrays with unary and binary functions involving different underlying types")) (|map| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1|) (|OneDimensionalArray| |#1|)) "\\indented{1}{map(\\spad{f},{}a) applies function \\spad{f} to each member of one-dimensional array} \\indented{1}{\\spad{a} resulting in a new one-dimensional array over a} \\indented{1}{possibly different underlying domain.} \\blankline \\spad{X} \\spad{T1:=OneDimensionalArrayFunctions2}(Integer,{}Integer) \\spad{X} map(\\spad{x+}-\\spad{>x+2},{}[\\spad{i} for \\spad{i} in 1..10])\\$\\spad{T1}")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\indented{1}{reduce(\\spad{f},{}a,{}\\spad{r}) applies function \\spad{f} to each} \\indented{1}{successive element of the} \\indented{1}{one-dimensional array \\spad{a} and an accumulant initialized to \\spad{r}.} \\indented{1}{For example,{} \\spad{reduce(_+\\$Integer,{}[1,{}2,{}3],{}0)}} \\indented{1}{does \\spad{3+(2+(1+0))}. Note that third argument \\spad{r}} \\indented{1}{may be regarded as the identity element for the function \\spad{f}.} \\blankline \\spad{X} \\spad{T1:=OneDimensionalArrayFunctions2}(Integer,{}Integer) \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} reduce(adder,{}[\\spad{i} for \\spad{i} in 1..10],{}0)\\$\\spad{T1}")) (|scan| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\indented{1}{scan(\\spad{f},{}a,{}\\spad{r}) successively applies} \\indented{1}{\\spad{reduce(f,{}x,{}r)} to more and more leading sub-arrays} \\indented{1}{\\spad{x} of one-dimensional array \\spad{a}.} \\indented{1}{More precisely,{} if \\spad{a} is \\spad{[a1,{}a2,{}...]},{} then} \\indented{1}{\\spad{scan(f,{}a,{}r)} returns} \\indented{1}{\\spad{[reduce(f,{}[a1],{}r),{}reduce(f,{}[a1,{}a2],{}r),{}...]}.} \\blankline \\spad{X} \\spad{T1:=OneDimensionalArrayFunctions2}(Integer,{}Integer) \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} scan(adder,{}[\\spad{i} for \\spad{i} in 1..10],{}0)\\$\\spad{T1}"))) +((|constructor| (NIL "This package provides tools for operating on one-dimensional arrays with unary and binary functions involving different underlying types")) (|map| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1|) (|OneDimensionalArray| |#1|)) "\\indented{1}{map(f,a) applies function \\spad{f} to each member of one-dimensional array} \\indented{1}{\\spad{a} resulting in a new one-dimensional array over a} \\indented{1}{possibly different underlying domain.} \\blankline \\spad{X} T1:=OneDimensionalArrayFunctions2(Integer,Integer) \\spad{X} map(x+->x+2,[i for \\spad{i} in 1..10])$T1")) (|reduce| ((|#2| (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\indented{1}{reduce(f,a,r) applies function \\spad{f} to each} \\indented{1}{successive element of the} \\indented{1}{one-dimensional array \\spad{a} and an accumulant initialized to \\spad{r.}} \\indented{1}{For example, \\spad{reduce(_+$Integer,[1,2,3],0)}} \\indented{1}{does \\spad{3+(2+(1+0))}. Note that third argument \\spad{r}} \\indented{1}{may be regarded as the identity element for the function \\spad{f.}} \\blankline \\spad{X} T1:=OneDimensionalArrayFunctions2(Integer,Integer) \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} reduce(adder,[i for \\spad{i} in 1..10],0)$T1")) (|scan| (((|OneDimensionalArray| |#2|) (|Mapping| |#2| |#1| |#2|) (|OneDimensionalArray| |#1|) |#2|) "\\indented{1}{scan(f,a,r) successively applies} \\indented{1}{\\spad{reduce(f,x,r)} to more and more leading sub-arrays} \\indented{1}{x of one-dimensional array \\spad{a}.} \\indented{1}{More precisely, if \\spad{a} is \\spad{[a1,a2,...]}, then} \\indented{1}{\\spad{scan(f,a,r)} returns} \\indented{1}{\\spad{[reduce(f,[a1],r),reduce(f,[a1,a2],r),...]}.} \\blankline \\spad{X} T1:=OneDimensionalArrayFunctions2(Integer,Integer) \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} scan(adder,[i for \\spad{i} in 1..10],0)$T1"))) NIL NIL (-64 S) -((|constructor| (NIL "This is the domain of 1-based one dimensional arrays")) (|oneDimensionalArray| (($ (|NonNegativeInteger|) |#1|) "\\indented{1}{oneDimensionalArray(\\spad{n},{}\\spad{s}) creates an array from \\spad{n} copies of element \\spad{s}} \\blankline \\spad{X} oneDimensionalArray(10,{}0.0)") (($ (|List| |#1|)) "\\indented{1}{oneDimensionalArray(\\spad{l}) creates an array from a list of elements \\spad{l}} \\blankline \\spad{X} oneDimensionalArray [\\spad{i**2} for \\spad{i} in 1..10]"))) -((-4536 . T) (-4535 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-843))) (-2232 (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#1| (QUOTE (-1091)))) (|HasCategory| (-569) (QUOTE (-843))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-843)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))))) +((|constructor| (NIL "This is the domain of 1-based one dimensional arrays")) (|oneDimensionalArray| (($ (|NonNegativeInteger|) |#1|) "\\indented{1}{oneDimensionalArray(n,s) creates an array from \\spad{n} copies of element \\spad{s}} \\blankline \\spad{X} oneDimensionalArray(10,0.0)") (($ (|List| |#1|)) "\\indented{1}{oneDimensionalArray(l) creates an array from a list of elements \\spad{l}} \\blankline \\spad{X} oneDimensionalArray \\spad{[i**2} for \\spad{i} in 1..10]"))) +((-4572 . T) (-4571 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-844))) (-1929 (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#1| (QUOTE (-1093)))) (|HasCategory| (-569) (QUOTE (-844))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-844)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))))) (-65 R) -((|constructor| (NIL "A TwoDimensionalArray is a two dimensional array with 1-based indexing for both rows and columns.")) (|shallowlyMutable| ((|attribute|) "One may destructively alter TwoDimensionalArray\\spad{'s}."))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) -(-66 -1486) -((|constructor| (NIL "\\spadtype{ASP10} produces Fortran for Type 10 ASPs,{} needed for NAG routine d02kef. This ASP computes the values of a set of functions,{} for example: \\blankline \\tab{5}SUBROUTINE COEFFN(\\spad{P},{}\\spad{Q},{}DQDL,{}\\spad{X},{}ELAM,{}JINT)\\spad{\\br} \\tab{5}DOUBLE PRECISION ELAM,{}\\spad{P},{}\\spad{Q},{}\\spad{X},{}DQDL\\spad{\\br} \\tab{5}INTEGER JINT\\spad{\\br} \\tab{5}\\spad{P=1}.0D0\\spad{\\br} \\tab{5}\\spad{Q=}((\\spad{-1}.0D0*X**3)+ELAM*X*X-2.0D0)/(\\spad{X*X})\\spad{\\br} \\tab{5}\\spad{DQDL=1}.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE JINT) (QUOTE X) (QUOTE ELAM)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +((|constructor| (NIL "A TwoDimensionalArray is a two dimensional array with 1-based indexing for both rows and columns.")) (|shallowlyMutable| ((|attribute|) "One may destructively alter TwoDimensionalArray's."))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) +(-66 -2798) +((|constructor| (NIL "\\spadtype{ASP10} produces Fortran for Type 10 ASPs, needed for NAG routine d02kef. This ASP computes the values of a set of functions, for example: \\blankline \\tab{5}SUBROUTINE COEFFN(P,Q,DQDL,X,ELAM,JINT)\\br \\tab{5}DOUBLE PRECISION ELAM,P,Q,X,DQDL\\br \\tab{5}INTEGER JINT\\br \\tab{5}P=1.0D0\\br \\tab{5}Q=((-1.0D0*X**3)+ELAM*X*X-2.0D0)/(X*X)\\br \\tab{5}DQDL=1.0D0\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE JINT) (QUOTE X) (QUOTE ELAM)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-67 -1486) -((|constructor| (NIL "\\spadtype{Asp12} produces Fortran for Type 12 ASPs,{} needed for NAG routine d02kef etc.,{} for example: \\blankline \\tab{5}SUBROUTINE MONIT (MAXIT,{}IFLAG,{}ELAM,{}FINFO)\\spad{\\br} \\tab{5}DOUBLE PRECISION ELAM,{}FINFO(15)\\spad{\\br} \\tab{5}INTEGER MAXIT,{}IFLAG\\spad{\\br} \\tab{5}IF(MAXIT.EQ.\\spad{-1})THEN\\spad{\\br} \\tab{7}PRINT*,{}\"Output from Monit\"\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}PRINT*,{}MAXIT,{}IFLAG,{}ELAM,{}(FINFO(\\spad{I}),{}\\spad{I=1},{}4)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP12}."))) +(-67 -2798) +((|constructor| (NIL "\\spadtype{Asp12} produces Fortran for Type 12 ASPs, needed for NAG routine d02kef etc., for example: \\blankline \\tab{5}SUBROUTINE MONIT (MAXIT,IFLAG,ELAM,FINFO)\\br \\tab{5}DOUBLE PRECISION ELAM,FINFO(15)\\br \\tab{5}INTEGER MAXIT,IFLAG\\br \\tab{5}IF(MAXIT.EQ.-1)THEN\\br \\tab{7}PRINT*,\"Output from Monit\"\\br \\tab{5}ENDIF\\br \\tab{5}PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4)\\br \\tab{5}RETURN\\br \\tab{5}END\\")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP12}."))) NIL NIL -(-68 -1486) -((|constructor| (NIL "\\spadtype{Asp19} produces Fortran for Type 19 ASPs,{} evaluating a set of functions and their jacobian at a given point,{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{LSFUN2}(\\spad{M},{}\\spad{N},{}\\spad{XC},{}FVECC,{}FJACC,{}\\spad{LJC})\\spad{\\br} \\tab{5}DOUBLE PRECISION FVECC(\\spad{M}),{}FJACC(\\spad{LJC},{}\\spad{N}),{}\\spad{XC}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{M},{}\\spad{N},{}\\spad{LJC}\\spad{\\br} \\tab{5}INTEGER \\spad{I},{}\\spad{J}\\spad{\\br} \\tab{5}DO 25003 \\spad{I=1},{}\\spad{LJC}\\spad{\\br} \\tab{7}DO 25004 \\spad{J=1},{}\\spad{N}\\spad{\\br} \\tab{9}FJACC(\\spad{I},{}\\spad{J})\\spad{=0}.0D0\\spad{\\br} 25004 CONTINUE\\spad{\\br} 25003 CONTINUE\\spad{\\br} \\tab{5}FVECC(1)=((\\spad{XC}(1)\\spad{-0}.14D0)\\spad{*XC}(3)+(15.0D0*XC(1)\\spad{-2}.1D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{+15}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(2)=((\\spad{XC}(1)\\spad{-0}.18D0)\\spad{*XC}(3)+(7.0D0*XC(1)\\spad{-1}.26D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{+7}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(3)=((\\spad{XC}(1)\\spad{-0}.22D0)\\spad{*XC}(3)+(4.333333333333333D0*XC(1)\\spad{-0}.953333\\spad{\\br} \\tab{4}\\spad{&3333333333D0})\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+4}.333333333333333D0*XC(2))\\spad{\\br} \\tab{5}FVECC(4)=((\\spad{XC}(1)\\spad{-0}.25D0)\\spad{*XC}(3)+(3.0D0*XC(1)\\spad{-0}.75D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{+3}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(5)=((\\spad{XC}(1)\\spad{-0}.29D0)\\spad{*XC}(3)+(2.2D0*XC(1)\\spad{-0}.6379999999999999D0)*\\spad{\\br} \\tab{4}\\spad{&XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+2}.2D0*XC(2))\\spad{\\br} \\tab{5}FVECC(6)=((\\spad{XC}(1)\\spad{-0}.32D0)\\spad{*XC}(3)+(1.666666666666667D0*XC(1)\\spad{-0}.533333\\spad{\\br} \\tab{4}\\spad{&3333333333D0})\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+1}.666666666666667D0*XC(2))\\spad{\\br} \\tab{5}FVECC(7)=((\\spad{XC}(1)\\spad{-0}.35D0)\\spad{*XC}(3)+(1.285714285714286D0*XC(1)\\spad{-0}.45D0)*\\spad{\\br} \\tab{4}\\spad{&XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+1}.285714285714286D0*XC(2))\\spad{\\br} \\tab{5}FVECC(8)=((\\spad{XC}(1)\\spad{-0}.39D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-0}.39D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)+\\spad{\\br} \\tab{4}\\spad{&XC}(2))\\spad{\\br} \\tab{5}FVECC(9)=((\\spad{XC}(1)\\spad{-0}.37D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-0}.37D0)\\spad{*XC}(2)\\spad{+1}.285714285714\\spad{\\br} \\tab{4}\\spad{&286D0})/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(10)=((\\spad{XC}(1)\\spad{-0}.58D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-0}.58D0)\\spad{*XC}(2)\\spad{+1}.66666666666\\spad{\\br} \\tab{4}\\spad{&6667D0})/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(11)=((\\spad{XC}(1)\\spad{-0}.73D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-0}.73D0)\\spad{*XC}(2)\\spad{+2}.2D0)/(\\spad{XC}(3)\\spad{\\br} \\tab{4}&+XC(2))\\spad{\\br} \\tab{5}FVECC(12)=((\\spad{XC}(1)\\spad{-0}.96D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-0}.96D0)\\spad{*XC}(2)\\spad{+3}.0D0)/(\\spad{XC}(3)\\spad{\\br} \\tab{4}&+XC(2))\\spad{\\br} \\tab{5}FVECC(13)=((\\spad{XC}(1)\\spad{-1}.34D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-1}.34D0)\\spad{*XC}(2)\\spad{+4}.33333333333\\spad{\\br} \\tab{4}\\spad{&3333D0})/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(14)=((\\spad{XC}(1)\\spad{-2}.1D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-2}.1D0)\\spad{*XC}(2)\\spad{+7}.0D0)/(\\spad{XC}(3)\\spad{+X}\\spad{\\br} \\tab{4}\\spad{&C}(2))\\spad{\\br} \\tab{5}FVECC(15)=((\\spad{XC}(1)\\spad{-4}.39D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-4}.39D0)\\spad{*XC}(2)\\spad{+15}.0D0)/(\\spad{XC}(3\\spad{\\br} \\tab{4}&)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FJACC(1,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(1,{}2)=-15.0D0/(\\spad{XC}(3)\\spad{**2+30}.0D0*XC(2)\\spad{*XC}(3)\\spad{+225}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(1,{}3)=-1.0D0/(\\spad{XC}(3)\\spad{**2+30}.0D0*XC(2)\\spad{*XC}(3)\\spad{+225}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(2,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(2,{}2)=-7.0D0/(\\spad{XC}(3)\\spad{**2+14}.0D0*XC(2)\\spad{*XC}(3)\\spad{+49}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(2,{}3)=-1.0D0/(\\spad{XC}(3)\\spad{**2+14}.0D0*XC(2)\\spad{*XC}(3)\\spad{+49}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(3,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(3,{}2)=((\\spad{-0}.1110223024625157D-15*XC(3))\\spad{-4}.333333333333333D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{**2+8}.666666666666666D0*XC(2)\\spad{*XC}(3)\\spad{+18}.77777777777778D0*XC(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(3,{}3)=(0.1110223024625157D-15*XC(2)\\spad{-1}.0D0)/(\\spad{XC}(3)\\spad{**2+8}.666666\\spad{\\br} \\tab{4}&666666666D0*XC(2)\\spad{*XC}(3)\\spad{+18}.77777777777778D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(4,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(4,{}2)=-3.0D0/(\\spad{XC}(3)\\spad{**2+6}.0D0*XC(2)\\spad{*XC}(3)\\spad{+9}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(4,{}3)=-1.0D0/(\\spad{XC}(3)\\spad{**2+6}.0D0*XC(2)\\spad{*XC}(3)\\spad{+9}.0D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(5,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(5,{}2)=((\\spad{-0}.1110223024625157D-15*XC(3))\\spad{-2}.2D0)/(\\spad{XC}(3)\\spad{**2+4}.399\\spad{\\br} \\tab{4}&999999999999D0*XC(2)\\spad{*XC}(3)\\spad{+4}.839999999999998D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(5,{}3)=(0.1110223024625157D-15*XC(2)\\spad{-1}.0D0)/(\\spad{XC}(3)\\spad{**2+4}.399999\\spad{\\br} \\tab{4}&999999999D0*XC(2)\\spad{*XC}(3)\\spad{+4}.839999999999998D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(6,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(6,{}2)=((\\spad{-0}.2220446049250313D-15*XC(3))\\spad{-1}.666666666666667D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{**2+3}.333333333333333D0*XC(2)\\spad{*XC}(3)\\spad{+2}.777777777777777D0*XC(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(6,{}3)=(0.2220446049250313D-15*XC(2)\\spad{-1}.0D0)/(\\spad{XC}(3)\\spad{**2+3}.333333\\spad{\\br} \\tab{4}&333333333D0*XC(2)\\spad{*XC}(3)\\spad{+2}.777777777777777D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(7,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(7,{}2)=((\\spad{-0}.5551115123125783D-16*XC(3))\\spad{-1}.285714285714286D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{**2+2}.571428571428571D0*XC(2)\\spad{*XC}(3)\\spad{+1}.653061224489796D0*XC(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(7,{}3)=(0.5551115123125783D-16*XC(2)\\spad{-1}.0D0)/(\\spad{XC}(3)\\spad{**2+2}.571428\\spad{\\br} \\tab{4}&571428571D0*XC(2)\\spad{*XC}(3)\\spad{+1}.653061224489796D0*XC(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(8,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(8,{}2)=-1.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(8,{}3)=-1.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(9,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(9,{}2)=-1.285714285714286D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)*\\spad{\\br} \\tab{4}\\spad{&*2})\\spad{\\br} \\tab{5}FJACC(9,{}3)=-1.285714285714286D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)*\\spad{\\br} \\tab{4}\\spad{&*2})\\spad{\\br} \\tab{5}FJACC(10,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(10,{}2)=-1.666666666666667D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(10,{}3)=-1.666666666666667D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(11,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(11,{}2)=-2.2D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(11,{}3)=-2.2D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(12,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(12,{}2)=-3.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(12,{}3)=-3.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(13,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(13,{}2)=-4.333333333333333D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(13,{}3)=-4.333333333333333D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{\\br} \\tab{4}\\spad{&**2})\\spad{\\br} \\tab{5}FJACC(14,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(14,{}2)=-7.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(14,{}3)=-7.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(15,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}FJACC(15,{}2)=-15.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}FJACC(15,{}3)=-15.0D0/(\\spad{XC}(3)\\spad{**2+2}.0D0*XC(2)\\spad{*XC}(3)\\spad{+XC}(2)\\spad{**2})\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-68 -2798) +((|constructor| (NIL "\\spadtype{Asp19} produces Fortran for Type 19 ASPs, evaluating a set of functions and their jacobian at a given point, for example: \\blankline \\tab{5}SUBROUTINE LSFUN2(M,N,XC,FVECC,FJACC,LJC)\\br \\tab{5}DOUBLE PRECISION FVECC(M),FJACC(LJC,N),XC(N)\\br \\tab{5}INTEGER M,N,LJC\\br \\tab{5}INTEGER I,J\\br \\tab{5}DO 25003 I=1,LJC\\br \\tab{7}DO 25004 J=1,N\\br \\tab{9}FJACC(I,J)=0.0D0\\br 25004 CONTINUE\\br 25003 CONTINUE\\br \\tab{5}FVECC(1)=((XC(1)-0.14D0)*XC(3)+(15.0D0*XC(1)-2.1D0)*XC(2)+1.0D0)/(\\br \\tab{4}&XC(3)+15.0D0*XC(2))\\br \\tab{5}FVECC(2)=((XC(1)-0.18D0)*XC(3)+(7.0D0*XC(1)-1.26D0)*XC(2)+1.0D0)/(\\br \\tab{4}&XC(3)+7.0D0*XC(2))\\br \\tab{5}FVECC(3)=((XC(1)-0.22D0)*XC(3)+(4.333333333333333D0*XC(1)-0.953333\\br \\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\\br \\tab{5}FVECC(4)=((XC(1)-0.25D0)*XC(3)+(3.0D0*XC(1)-0.75D0)*XC(2)+1.0D0)/(\\br \\tab{4}&XC(3)+3.0D0*XC(2))\\br \\tab{5}FVECC(5)=((XC(1)-0.29D0)*XC(3)+(2.2D0*XC(1)-0.6379999999999999D0)*\\br \\tab{4}&XC(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\\br \\tab{5}FVECC(6)=((XC(1)-0.32D0)*XC(3)+(1.666666666666667D0*XC(1)-0.533333\\br \\tab{4}&3333333333D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\\br \\tab{5}FVECC(7)=((XC(1)-0.35D0)*XC(3)+(1.285714285714286D0*XC(1)-0.45D0)*\\br \\tab{4}&XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\\br \\tab{5}FVECC(8)=((XC(1)-0.39D0)*XC(3)+(XC(1)-0.39D0)*XC(2)+1.0D0)/(XC(3)+\\br \\tab{4}&XC(2))\\br \\tab{5}FVECC(9)=((XC(1)-0.37D0)*XC(3)+(XC(1)-0.37D0)*XC(2)+1.285714285714\\br \\tab{4}&286D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(10)=((XC(1)-0.58D0)*XC(3)+(XC(1)-0.58D0)*XC(2)+1.66666666666\\br \\tab{4}&6667D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(11)=((XC(1)-0.73D0)*XC(3)+(XC(1)-0.73D0)*XC(2)+2.2D0)/(XC(3)\\br \\tab{4}&+XC(2))\\br \\tab{5}FVECC(12)=((XC(1)-0.96D0)*XC(3)+(XC(1)-0.96D0)*XC(2)+3.0D0)/(XC(3)\\br \\tab{4}&+XC(2))\\br \\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\\br \\tab{4}&3333D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\\br \\tab{4}&C(2))\\br \\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\\br \\tab{4}&)+XC(2))\\br \\tab{5}FJACC(1,1)=1.0D0\\br \\tab{5}FJACC(1,2)=-15.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\\br \\tab{5}FJACC(1,3)=-1.0D0/(XC(3)**2+30.0D0*XC(2)*XC(3)+225.0D0*XC(2)**2)\\br \\tab{5}FJACC(2,1)=1.0D0\\br \\tab{5}FJACC(2,2)=-7.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\\br \\tab{5}FJACC(2,3)=-1.0D0/(XC(3)**2+14.0D0*XC(2)*XC(3)+49.0D0*XC(2)**2)\\br \\tab{5}FJACC(3,1)=1.0D0\\br \\tab{5}FJACC(3,2)=((-0.1110223024625157D-15*XC(3))-4.333333333333333D0)/(\\br \\tab{4}&XC(3)**2+8.666666666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(3,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+8.666666\\br \\tab{4}&666666666D0*XC(2)*XC(3)+18.77777777777778D0*XC(2)**2)\\br \\tab{5}FJACC(4,1)=1.0D0\\br \\tab{5}FJACC(4,2)=-3.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\\br \\tab{5}FJACC(4,3)=-1.0D0/(XC(3)**2+6.0D0*XC(2)*XC(3)+9.0D0*XC(2)**2)\\br \\tab{5}FJACC(5,1)=1.0D0\\br \\tab{5}FJACC(5,2)=((-0.1110223024625157D-15*XC(3))-2.2D0)/(XC(3)**2+4.399\\br \\tab{4}&999999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\\br \\tab{5}FJACC(5,3)=(0.1110223024625157D-15*XC(2)-1.0D0)/(XC(3)**2+4.399999\\br \\tab{4}&999999999D0*XC(2)*XC(3)+4.839999999999998D0*XC(2)**2)\\br \\tab{5}FJACC(6,1)=1.0D0\\br \\tab{5}FJACC(6,2)=((-0.2220446049250313D-15*XC(3))-1.666666666666667D0)/(\\br \\tab{4}&XC(3)**2+3.333333333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(6,3)=(0.2220446049250313D-15*XC(2)-1.0D0)/(XC(3)**2+3.333333\\br \\tab{4}&333333333D0*XC(2)*XC(3)+2.777777777777777D0*XC(2)**2)\\br \\tab{5}FJACC(7,1)=1.0D0\\br \\tab{5}FJACC(7,2)=((-0.5551115123125783D-16*XC(3))-1.285714285714286D0)/(\\br \\tab{4}&XC(3)**2+2.571428571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(7,3)=(0.5551115123125783D-16*XC(2)-1.0D0)/(XC(3)**2+2.571428\\br \\tab{4}&571428571D0*XC(2)*XC(3)+1.653061224489796D0*XC(2)**2)\\br \\tab{5}FJACC(8,1)=1.0D0\\br \\tab{5}FJACC(8,2)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(8,3)=-1.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(9,1)=1.0D0\\br \\tab{5}FJACC(9,2)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\\br \\tab{4}&*2)\\br \\tab{5}FJACC(9,3)=-1.285714285714286D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)*\\br \\tab{4}&*2)\\br \\tab{5}FJACC(10,1)=1.0D0\\br \\tab{5}FJACC(10,2)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(10,3)=-1.666666666666667D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(11,1)=1.0D0\\br \\tab{5}FJACC(11,2)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(11,3)=-2.2D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(12,1)=1.0D0\\br \\tab{5}FJACC(12,2)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(12,3)=-3.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(13,1)=1.0D0\\br \\tab{5}FJACC(13,2)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(13,3)=-4.333333333333333D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)\\br \\tab{4}&**2)\\br \\tab{5}FJACC(14,1)=1.0D0\\br \\tab{5}FJACC(14,2)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(14,3)=-7.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(15,1)=1.0D0\\br \\tab{5}FJACC(15,2)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-69 -1486) -((|constructor| (NIL "\\spadtype{Asp1} produces Fortran for Type 1 ASPs,{} needed for various NAG routines. Type 1 ASPs take a univariate expression (in the symbol \\spad{x}) and turn it into a Fortran Function like the following: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION \\spad{F}(\\spad{X})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}\\spad{\\br} \\tab{5}F=DSIN(\\spad{X})\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) +(-69 -2798) +((|constructor| (NIL "\\spadtype{Asp1} produces Fortran for Type 1 ASPs, needed for various NAG routines. Type 1 ASPs take a univariate expression (in the symbol \\spad{x)} and turn it into a Fortran Function like the following: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION F(X)\\br \\tab{5}DOUBLE PRECISION X\\br \\tab{5}F=DSIN(X)\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) NIL NIL -(-70 -1486) -((|constructor| (NIL "\\spadtype{Asp20} produces Fortran for Type 20 ASPs,{} for example: \\blankline \\tab{5}SUBROUTINE QPHESS(\\spad{N},{}NROWH,{}NCOLH,{}JTHCOL,{}HESS,{}\\spad{X},{}\\spad{HX})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{HX}(\\spad{N}),{}\\spad{X}(\\spad{N}),{}HESS(NROWH,{}NCOLH)\\spad{\\br} \\tab{5}INTEGER JTHCOL,{}\\spad{N},{}NROWH,{}NCOLH\\spad{\\br} \\tab{5}\\spad{HX}(1)\\spad{=2}.0D0*X(1)\\spad{\\br} \\tab{5}\\spad{HX}(2)\\spad{=2}.0D0*X(2)\\spad{\\br} \\tab{5}\\spad{HX}(3)\\spad{=2}.0D0*X(4)\\spad{+2}.0D0*X(3)\\spad{\\br} \\tab{5}\\spad{HX}(4)\\spad{=2}.0D0*X(4)\\spad{+2}.0D0*X(3)\\spad{\\br} \\tab{5}\\spad{HX}(5)\\spad{=2}.0D0*X(5)\\spad{\\br} \\tab{5}\\spad{HX}(6)=(\\spad{-2}.0D0*X(7))+(\\spad{-2}.0D0*X(6))\\spad{\\br} \\tab{5}\\spad{HX}(7)=(\\spad{-2}.0D0*X(7))+(\\spad{-2}.0D0*X(6))\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct|) (|construct| (QUOTE X) (QUOTE HESS)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-70 -2798) +((|constructor| (NIL "\\spadtype{Asp20} produces Fortran for Type 20 ASPs, for example: \\blankline \\tab{5}SUBROUTINE QPHESS(N,NROWH,NCOLH,JTHCOL,HESS,X,HX)\\br \\tab{5}DOUBLE PRECISION HX(N),X(N),HESS(NROWH,NCOLH)\\br \\tab{5}INTEGER JTHCOL,N,NROWH,NCOLH\\br \\tab{5}HX(1)=2.0D0*X(1)\\br \\tab{5}HX(2)=2.0D0*X(2)\\br \\tab{5}HX(3)=2.0D0*X(4)+2.0D0*X(3)\\br \\tab{5}HX(4)=2.0D0*X(4)+2.0D0*X(3)\\br \\tab{5}HX(5)=2.0D0*X(5)\\br \\tab{5}HX(6)=(-2.0D0*X(7))+(-2.0D0*X(6))\\br \\tab{5}HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6))\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct|) (|construct| (QUOTE X) (QUOTE HESS)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-71 -1486) -((|constructor| (NIL "\\spadtype{Asp24} produces Fortran for Type 24 ASPs which evaluate a multivariate function at a point (needed for NAG routine e04jaf),{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{FUNCT1}(\\spad{N},{}\\spad{XC},{}\\spad{FC})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{FC},{}\\spad{XC}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}\\spad{FC=10}.0D0*XC(4)**4+(\\spad{-40}.0D0*XC(1)\\spad{*XC}(4)\\spad{**3})+(60.0D0*XC(1)\\spad{**2+5}\\spad{\\br} \\tab{4}&.0D0)\\spad{*XC}(4)**2+((\\spad{-10}.0D0*XC(3))+(\\spad{-40}.0D0*XC(1)\\spad{**3}))\\spad{*XC}(4)\\spad{+16}.0D0*X\\spad{\\br} \\tab{4}\\spad{&C}(3)**4+(\\spad{-32}.0D0*XC(2)\\spad{*XC}(3)\\spad{**3})+(24.0D0*XC(2)\\spad{**2+5}.0D0)\\spad{*XC}(3)**2+\\spad{\\br} \\tab{4}&(\\spad{-8}.0D0*XC(2)**3*XC(3))\\spad{+XC}(2)\\spad{**4+100}.0D0*XC(2)\\spad{**2+20}.0D0*XC(1)\\spad{*XC}(\\spad{\\br} \\tab{4}\\spad{&2})\\spad{+10}.0D0*XC(1)**4+XC(1)\\spad{**2}\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br}")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|))) "\\spadtype{FortranExpression} and turns it into an ASP. coerce(\\spad{f}) takes an object from the appropriate instantiation of"))) +(-71 -2798) +((|constructor| (NIL "\\spadtype{Asp24} produces Fortran for Type 24 ASPs which evaluate a multivariate function at a point (needed for NAG routine e04jaf), for example: \\blankline \\tab{5}SUBROUTINE FUNCT1(N,XC,FC)\\br \\tab{5}DOUBLE PRECISION FC,XC(N)\\br \\tab{5}INTEGER N\\br \\tab{5}FC=10.0D0*XC(4)**4+(-40.0D0*XC(1)*XC(4)**3)+(60.0D0*XC(1)**2+5\\br \\tab{4}&.0D0)*XC(4)**2+((-10.0D0*XC(3))+(-40.0D0*XC(1)**3))*XC(4)+16.0D0*X\\br \\tab{4}&C(3)**4+(-32.0D0*XC(2)*XC(3)**3)+(24.0D0*XC(2)**2+5.0D0)*XC(3)**2+\\br \\tab{4}&(-8.0D0*XC(2)**3*XC(3))+XC(2)**4+100.0D0*XC(2)**2+20.0D0*XC(1)*XC(\\br \\tab{4}&2)+10.0D0*XC(1)**4+XC(1)**2\\br \\tab{5}RETURN\\br \\tab{5}END\\br")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|))) "\\spadtype{FortranExpression} and turns it into an ASP. coerce(f) takes an object from the appropriate instantiation of"))) NIL NIL -(-72 -1486) -((|constructor| (NIL "\\spadtype{Asp27} produces Fortran for Type 27 ASPs,{} needed for NAG routine f02fjf ,{}for example: \\blankline \\tab{5}FUNCTION DOT(IFLAG,{}\\spad{N},{}\\spad{Z},{}\\spad{W},{}RWORK,{}LRWORK,{}IWORK,{}LIWORK)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{W}(\\spad{N}),{}\\spad{Z}(\\spad{N}),{}RWORK(LRWORK)\\spad{\\br} \\tab{5}INTEGER \\spad{N},{}LIWORK,{}IFLAG,{}LRWORK,{}IWORK(LIWORK)\\spad{\\br} \\tab{5}DOT=(\\spad{W}(16)+(\\spad{-0}.5D0*W(15)))\\spad{*Z}(16)+((\\spad{-0}.5D0*W(16))\\spad{+W}(15)+(\\spad{-0}.5D0*W(1\\spad{\\br} \\tab{4}\\spad{&4})))\\spad{*Z}(15)+((\\spad{-0}.5D0*W(15))\\spad{+W}(14)+(\\spad{-0}.5D0*W(13)))\\spad{*Z}(14)+((\\spad{-0}.5D0*W(\\spad{\\br} \\tab{4}\\spad{&14}))\\spad{+W}(13)+(\\spad{-0}.5D0*W(12)))\\spad{*Z}(13)+((\\spad{-0}.5D0*W(13))\\spad{+W}(12)+(\\spad{-0}.5D0*W(1\\spad{\\br} \\tab{4}\\spad{&1})))\\spad{*Z}(12)+((\\spad{-0}.5D0*W(12))\\spad{+W}(11)+(\\spad{-0}.5D0*W(10)))\\spad{*Z}(11)+((\\spad{-0}.5D0*W(\\spad{\\br} \\tab{4}\\spad{&11}))\\spad{+W}(10)+(\\spad{-0}.5D0*W(9)))\\spad{*Z}(10)+((\\spad{-0}.5D0*W(10))\\spad{+W}(9)+(\\spad{-0}.5D0*W(8))\\spad{\\br} \\tab{4}&)\\spad{*Z}(9)+((\\spad{-0}.5D0*W(9))\\spad{+W}(8)+(\\spad{-0}.5D0*W(7)))\\spad{*Z}(8)+((\\spad{-0}.5D0*W(8))\\spad{+W}(7)\\spad{\\br} \\tab{4}\\spad{&+}(\\spad{-0}.5D0*W(6)))\\spad{*Z}(7)+((\\spad{-0}.5D0*W(7))\\spad{+W}(6)+(\\spad{-0}.5D0*W(5)))\\spad{*Z}(6)+((\\spad{-0}.\\spad{\\br} \\tab{4}&5D0*W(6))\\spad{+W}(5)+(\\spad{-0}.5D0*W(4)))\\spad{*Z}(5)+((\\spad{-0}.5D0*W(5))\\spad{+W}(4)+(\\spad{-0}.5D0*W(3\\spad{\\br} \\tab{4}&)))\\spad{*Z}(4)+((\\spad{-0}.5D0*W(4))\\spad{+W}(3)+(\\spad{-0}.5D0*W(2)))\\spad{*Z}(3)+((\\spad{-0}.5D0*W(3))\\spad{+W}(\\spad{\\br} \\tab{4}\\spad{&2})+(\\spad{-0}.5D0*W(1)))\\spad{*Z}(2)+((\\spad{-0}.5D0*W(2))\\spad{+W}(1))\\spad{*Z}(1)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END"))) +(-72 -2798) +((|constructor| (NIL "\\spadtype{Asp27} produces Fortran for Type 27 ASPs, needed for NAG routine f02fjf ,for example: \\blankline \\tab{5}FUNCTION DOT(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\\br \\tab{5}DOUBLE PRECISION W(N),Z(N),RWORK(LRWORK)\\br \\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\\br \\tab{5}DOT=(W(16)+(-0.5D0*W(15)))*Z(16)+((-0.5D0*W(16))+W(15)+(-0.5D0*W(1\\br \\tab{4}&4)))*Z(15)+((-0.5D0*W(15))+W(14)+(-0.5D0*W(13)))*Z(14)+((-0.5D0*W(\\br \\tab{4}&14))+W(13)+(-0.5D0*W(12)))*Z(13)+((-0.5D0*W(13))+W(12)+(-0.5D0*W(1\\br \\tab{4}&1)))*Z(12)+((-0.5D0*W(12))+W(11)+(-0.5D0*W(10)))*Z(11)+((-0.5D0*W(\\br \\tab{4}&11))+W(10)+(-0.5D0*W(9)))*Z(10)+((-0.5D0*W(10))+W(9)+(-0.5D0*W(8))\\br \\tab{4}&)*Z(9)+((-0.5D0*W(9))+W(8)+(-0.5D0*W(7)))*Z(8)+((-0.5D0*W(8))+W(7)\\br \\tab{4}&+(-0.5D0*W(6)))*Z(7)+((-0.5D0*W(7))+W(6)+(-0.5D0*W(5)))*Z(6)+((-0.\\br \\tab{4}&5D0*W(6))+W(5)+(-0.5D0*W(4)))*Z(5)+((-0.5D0*W(5))+W(4)+(-0.5D0*W(3\\br \\tab{4}&)))*Z(4)+((-0.5D0*W(4))+W(3)+(-0.5D0*W(2)))*Z(3)+((-0.5D0*W(3))+W(\\br \\tab{4}&2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1)\\br \\tab{5}RETURN\\br \\tab{5}END"))) NIL NIL -(-73 -1486) -((|constructor| (NIL "\\spadtype{Asp28} produces Fortran for Type 28 ASPs,{} used in NAG routine f02fjf,{} for example: \\blankline \\tab{5}SUBROUTINE IMAGE(IFLAG,{}\\spad{N},{}\\spad{Z},{}\\spad{W},{}RWORK,{}LRWORK,{}IWORK,{}LIWORK)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{Z}(\\spad{N}),{}\\spad{W}(\\spad{N}),{}IWORK(LRWORK),{}RWORK(LRWORK)\\spad{\\br} \\tab{5}INTEGER \\spad{N},{}LIWORK,{}IFLAG,{}LRWORK\\spad{\\br} \\tab{5}\\spad{W}(1)\\spad{=0}.01707454969713436D0*Z(16)\\spad{+0}.001747395874954051D0*Z(15)\\spad{+0}.00\\spad{\\br} \\tab{4}&2106973900813502D0*Z(14)\\spad{+0}.002957434991769087D0*Z(13)+(\\spad{-0}.00700554\\spad{\\br} \\tab{4}&0882865317D0*Z(12))+(\\spad{-0}.01219194009813166D0*Z(11))\\spad{+0}.0037230647365\\spad{\\br} \\tab{4}&3087D0*Z(10)\\spad{+0}.04932374658377151D0*Z(9)+(\\spad{-0}.03586220812223305D0*Z(\\spad{\\br} \\tab{4}\\spad{&8}))+(\\spad{-0}.04723268012114625D0*Z(7))+(\\spad{-0}.02434652144032987D0*Z(6))\\spad{+0}.\\spad{\\br} \\tab{4}&2264766947290192D0*Z(5)+(\\spad{-0}.1385343580686922D0*Z(4))+(\\spad{-0}.116530050\\spad{\\br} \\tab{4}&8238904D0*Z(3))+(\\spad{-0}.2803531651057233D0*Z(2))\\spad{+1}.019463911841327D0*Z\\spad{\\br} \\tab{4}&(1)\\spad{\\br} \\tab{5}\\spad{W}(2)\\spad{=0}.0227345011107737D0*Z(16)\\spad{+0}.008812321197398072D0*Z(15)\\spad{+0}.010\\spad{\\br} \\tab{4}&94012210519586D0*Z(14)+(\\spad{-0}.01764072463999744D0*Z(13))+(\\spad{-0}.01357136\\spad{\\br} \\tab{4}&72105995D0*Z(12))\\spad{+0}.00157466157362272D0*Z(11)\\spad{+0}.05258889186338282D\\spad{\\br} \\tab{4}&0*Z(10)+(\\spad{-0}.01981532388243379D0*Z(9))+(\\spad{-0}.06095390688679697D0*Z(8)\\spad{\\br} \\tab{4}&)+(\\spad{-0}.04153119955569051D0*Z(7))\\spad{+0}.2176561076571465D0*Z(6)+(\\spad{-0}.0532\\spad{\\br} \\tab{4}&5555586632358D0*Z(5))+(\\spad{-0}.1688977368984641D0*Z(4))+(\\spad{-0}.32440166056\\spad{\\br} \\tab{4}&67343D0*Z(3))\\spad{+0}.9128222941872173D0*Z(2)+(\\spad{-0}.2419652703415429D0*Z(1\\spad{\\br} \\tab{4}&))\\spad{\\br} \\tab{5}\\spad{W}(3)\\spad{=0}.03371198197190302D0*Z(16)\\spad{+0}.02021603150122265D0*Z(15)+(\\spad{-0}.0\\spad{\\br} \\tab{4}&06607305534689702D0*Z(14))+(\\spad{-0}.03032392238968179D0*Z(13))\\spad{+0}.002033\\spad{\\br} \\tab{4}&305231024948D0*Z(12)\\spad{+0}.05375944956767728D0*Z(11)+(\\spad{-0}.0163213312502\\spad{\\br} \\tab{4}&9967D0*Z(10))+(\\spad{-0}.05483186562035512D0*Z(9))+(\\spad{-0}.04901428822579872D\\spad{\\br} \\tab{4}&0*Z(8))\\spad{+0}.2091097927887612D0*Z(7)+(\\spad{-0}.05760560341383113D0*Z(6))+(-\\spad{\\br} \\tab{4}\\spad{&0}.1236679206156403D0*Z(5))+(\\spad{-0}.3523683853026259D0*Z(4))\\spad{+0}.88929961\\spad{\\br} \\tab{4}&32269974D0*Z(3)+(\\spad{-0}.2995429545781457D0*Z(2))+(\\spad{-0}.02986582812574917\\spad{\\br} \\tab{4}&D0*Z(1))\\spad{\\br} \\tab{5}\\spad{W}(4)\\spad{=0}.05141563713660119D0*Z(16)\\spad{+0}.005239165960779299D0*Z(15)+(\\spad{-0}.\\spad{\\br} \\tab{4}&01623427735779699D0*Z(14))+(\\spad{-0}.01965809746040371D0*Z(13))\\spad{+0}.054688\\spad{\\br} \\tab{4}&97337339577D0*Z(12)+(\\spad{-0}.014224695935687D0*Z(11))+(\\spad{-0}.0505181779315\\spad{\\br} \\tab{4}&6355D0*Z(10))+(\\spad{-0}.04353074206076491D0*Z(9))\\spad{+0}.2012230497530726D0*Z\\spad{\\br} \\tab{4}&(8)+(\\spad{-0}.06630874514535952D0*Z(7))+(\\spad{-0}.1280829963720053D0*Z(6))+(\\spad{-0}\\spad{\\br} \\tab{4}&.305169742604165D0*Z(5))\\spad{+0}.8600427128450191D0*Z(4)+(\\spad{-0}.32415033802\\spad{\\br} \\tab{4}&68184D0*Z(3))+(\\spad{-0}.09033531980693314D0*Z(2))\\spad{+0}.09089205517109111D0*\\spad{\\br} \\tab{4}\\spad{&Z}(1)\\spad{\\br} \\tab{5}\\spad{W}(5)\\spad{=0}.04556369767776375D0*Z(16)+(\\spad{-0}.001822737697581869D0*Z(15))+(\\spad{\\br} \\tab{4}&-0.002512226501941856D0*Z(14))\\spad{+0}.02947046460707379D0*Z(13)+(\\spad{-0}.014\\spad{\\br} \\tab{4}&45079632086177D0*Z(12))+(\\spad{-0}.05034242196614937D0*Z(11))+(\\spad{-0}.0376966\\spad{\\br} \\tab{4}&3291725935D0*Z(10))\\spad{+0}.2171103102175198D0*Z(9)+(\\spad{-0}.0824949256021352\\spad{\\br} \\tab{4}&4D0*Z(8))+(\\spad{-0}.1473995209288945D0*Z(7))+(\\spad{-0}.315042193418466D0*Z(6))\\spad{\\br} \\tab{4}\\spad{&+0}.9591623347824002D0*Z(5)+(\\spad{-0}.3852396953763045D0*Z(4))+(\\spad{-0}.141718\\spad{\\br} \\tab{4}&5427288274D0*Z(3))+(\\spad{-0}.03423495461011043D0*Z(2))\\spad{+0}.319820917706851\\spad{\\br} \\tab{4}&6D0*Z(1)\\spad{\\br} \\tab{5}\\spad{W}(6)\\spad{=0}.04015147277405744D0*Z(16)\\spad{+0}.01328585741341559D0*Z(15)\\spad{+0}.048\\spad{\\br} \\tab{4}&26082005465965D0*Z(14)+(\\spad{-0}.04319641116207706D0*Z(13))+(\\spad{-0}.04931323\\spad{\\br} \\tab{4}&319055762D0*Z(12))+(\\spad{-0}.03526886317505474D0*Z(11))\\spad{+0}.22295383396730\\spad{\\br} \\tab{4}&01D0*Z(10)+(\\spad{-0}.07375317649315155D0*Z(9))+(\\spad{-0}.1589391311991561D0*Z(\\spad{\\br} \\tab{4}\\spad{&8}))+(\\spad{-0}.328001910890377D0*Z(7))\\spad{+0}.952576555482747D0*Z(6)+(\\spad{-0}.31583\\spad{\\br} \\tab{4}&09975786731D0*Z(5))+(\\spad{-0}.1846882042225383D0*Z(4))+(\\spad{-0}.0703762046700\\spad{\\br} \\tab{4}&4427D0*Z(3))\\spad{+0}.2311852964327382D0*Z(2)\\spad{+0}.04254083491825025D0*Z(1)\\spad{\\br} \\tab{5}\\spad{W}(7)\\spad{=0}.06069778964023718D0*Z(16)\\spad{+0}.06681263884671322D0*Z(15)+(\\spad{-0}.0\\spad{\\br} \\tab{4}&2113506688615768D0*Z(14))+(\\spad{-0}.083996867458326D0*Z(13))+(\\spad{-0}.0329843\\spad{\\br} \\tab{4}&8523869648D0*Z(12))\\spad{+0}.2276878326327734D0*Z(11)+(\\spad{-0}.067356038933017\\spad{\\br} \\tab{4}&95D0*Z(10))+(\\spad{-0}.1559813965382218D0*Z(9))+(\\spad{-0}.3363262957694705D0*Z(\\spad{\\br} \\tab{4}\\spad{&8}))\\spad{+0}.9442791158560948D0*Z(7)+(\\spad{-0}.3199955249404657D0*Z(6))+(\\spad{-0}.136\\spad{\\br} \\tab{4}&2463839920727D0*Z(5))+(\\spad{-0}.1006185171570586D0*Z(4))\\spad{+0}.2057504515015\\spad{\\br} \\tab{4}&423D0*Z(3)+(\\spad{-0}.02065879269286707D0*Z(2))\\spad{+0}.03160990266745513D0*Z(1\\spad{\\br} \\tab{4}&)\\spad{\\br} \\tab{5}\\spad{W}(8)\\spad{=0}.126386868896738D0*Z(16)\\spad{+0}.002563370039476418D0*Z(15)+(\\spad{-0}.05\\spad{\\br} \\tab{4}&581757739455641D0*Z(14))+(\\spad{-0}.07777893205900685D0*Z(13))\\spad{+0}.23117338\\spad{\\br} \\tab{4}&45834199D0*Z(12)+(\\spad{-0}.06031581134427592D0*Z(11))+(\\spad{-0}.14805474755869\\spad{\\br} \\tab{4}&52D0*Z(10))+(\\spad{-0}.3364014128402243D0*Z(9))\\spad{+0}.9364014128402244D0*Z(8)\\spad{\\br} \\tab{4}\\spad{&+}(\\spad{-0}.3269452524413048D0*Z(7))+(\\spad{-0}.1396841886557241D0*Z(6))+(\\spad{-0}.056\\spad{\\br} \\tab{4}&1733845834199D0*Z(5))\\spad{+0}.1777789320590069D0*Z(4)+(\\spad{-0}.04418242260544\\spad{\\br} \\tab{4}&359D0*Z(3))+(\\spad{-0}.02756337003947642D0*Z(2))\\spad{+0}.07361313110326199D0*Z(\\spad{\\br} \\tab{4}\\spad{&1})\\spad{\\br} \\tab{5}\\spad{W}(9)\\spad{=0}.07361313110326199D0*Z(16)+(\\spad{-0}.02756337003947642D0*Z(15))+(-\\spad{\\br} \\tab{4}\\spad{&0}.04418242260544359D0*Z(14))\\spad{+0}.1777789320590069D0*Z(13)+(\\spad{-0}.056173\\spad{\\br} \\tab{4}&3845834199D0*Z(12))+(\\spad{-0}.1396841886557241D0*Z(11))+(\\spad{-0}.326945252441\\spad{\\br} \\tab{4}&3048D0*Z(10))\\spad{+0}.9364014128402244D0*Z(9)+(\\spad{-0}.3364014128402243D0*Z(8\\spad{\\br} \\tab{4}&))+(\\spad{-0}.1480547475586952D0*Z(7))+(\\spad{-0}.06031581134427592D0*Z(6))\\spad{+0}.23\\spad{\\br} \\tab{4}&11733845834199D0*Z(5)+(\\spad{-0}.07777893205900685D0*Z(4))+(\\spad{-0}.0558175773\\spad{\\br} \\tab{4}&9455641D0*Z(3))\\spad{+0}.002563370039476418D0*Z(2)\\spad{+0}.126386868896738D0*Z(\\spad{\\br} \\tab{4}\\spad{&1})\\spad{\\br} \\tab{5}\\spad{W}(10)\\spad{=0}.03160990266745513D0*Z(16)+(\\spad{-0}.02065879269286707D0*Z(15))\\spad{+0}\\spad{\\br} \\tab{4}&.2057504515015423D0*Z(14)+(\\spad{-0}.1006185171570586D0*Z(13))+(\\spad{-0}.136246\\spad{\\br} \\tab{4}&3839920727D0*Z(12))+(\\spad{-0}.3199955249404657D0*Z(11))\\spad{+0}.94427911585609\\spad{\\br} \\tab{4}&48D0*Z(10)+(\\spad{-0}.3363262957694705D0*Z(9))+(\\spad{-0}.1559813965382218D0*Z(8\\spad{\\br} \\tab{4}&))+(\\spad{-0}.06735603893301795D0*Z(7))\\spad{+0}.2276878326327734D0*Z(6)+(\\spad{-0}.032\\spad{\\br} \\tab{4}&98438523869648D0*Z(5))+(\\spad{-0}.083996867458326D0*Z(4))+(\\spad{-0}.02113506688\\spad{\\br} \\tab{4}&615768D0*Z(3))\\spad{+0}.06681263884671322D0*Z(2)\\spad{+0}.06069778964023718D0*Z(\\spad{\\br} \\tab{4}\\spad{&1})\\spad{\\br} \\tab{5}\\spad{W}(11)\\spad{=0}.04254083491825025D0*Z(16)\\spad{+0}.2311852964327382D0*Z(15)+(\\spad{-0}.0\\spad{\\br} \\tab{4}&7037620467004427D0*Z(14))+(\\spad{-0}.1846882042225383D0*Z(13))+(\\spad{-0}.315830\\spad{\\br} \\tab{4}&9975786731D0*Z(12))\\spad{+0}.952576555482747D0*Z(11)+(\\spad{-0}.328001910890377D\\spad{\\br} \\tab{4}&0*Z(10))+(\\spad{-0}.1589391311991561D0*Z(9))+(\\spad{-0}.07375317649315155D0*Z(8)\\spad{\\br} \\tab{4}&)\\spad{+0}.2229538339673001D0*Z(7)+(\\spad{-0}.03526886317505474D0*Z(6))+(\\spad{-0}.0493\\spad{\\br} \\tab{4}&1323319055762D0*Z(5))+(\\spad{-0}.04319641116207706D0*Z(4))\\spad{+0}.048260820054\\spad{\\br} \\tab{4}&65965D0*Z(3)\\spad{+0}.01328585741341559D0*Z(2)\\spad{+0}.04015147277405744D0*Z(1)\\spad{\\br} \\tab{5}\\spad{W}(12)\\spad{=0}.3198209177068516D0*Z(16)+(\\spad{-0}.03423495461011043D0*Z(15))+(-\\spad{\\br} \\tab{4}\\spad{&0}.1417185427288274D0*Z(14))+(\\spad{-0}.3852396953763045D0*Z(13))\\spad{+0}.959162\\spad{\\br} \\tab{4}&3347824002D0*Z(12)+(\\spad{-0}.315042193418466D0*Z(11))+(\\spad{-0}.14739952092889\\spad{\\br} \\tab{4}&45D0*Z(10))+(\\spad{-0}.08249492560213524D0*Z(9))\\spad{+0}.2171103102175198D0*Z(8\\spad{\\br} \\tab{4}&)+(\\spad{-0}.03769663291725935D0*Z(7))+(\\spad{-0}.05034242196614937D0*Z(6))+(\\spad{-0}.\\spad{\\br} \\tab{4}&01445079632086177D0*Z(5))\\spad{+0}.02947046460707379D0*Z(4)+(\\spad{-0}.002512226\\spad{\\br} \\tab{4}&501941856D0*Z(3))+(\\spad{-0}.001822737697581869D0*Z(2))\\spad{+0}.045563697677763\\spad{\\br} \\tab{4}&75D0*Z(1)\\spad{\\br} \\tab{5}\\spad{W}(13)\\spad{=0}.09089205517109111D0*Z(16)+(\\spad{-0}.09033531980693314D0*Z(15))+(\\spad{\\br} \\tab{4}&-0.3241503380268184D0*Z(14))\\spad{+0}.8600427128450191D0*Z(13)+(\\spad{-0}.305169\\spad{\\br} \\tab{4}&742604165D0*Z(12))+(\\spad{-0}.1280829963720053D0*Z(11))+(\\spad{-0}.0663087451453\\spad{\\br} \\tab{4}&5952D0*Z(10))\\spad{+0}.2012230497530726D0*Z(9)+(\\spad{-0}.04353074206076491D0*Z(\\spad{\\br} \\tab{4}\\spad{&8}))+(\\spad{-0}.05051817793156355D0*Z(7))+(\\spad{-0}.014224695935687D0*Z(6))\\spad{+0}.05\\spad{\\br} \\tab{4}&468897337339577D0*Z(5)+(\\spad{-0}.01965809746040371D0*Z(4))+(\\spad{-0}.016234277\\spad{\\br} \\tab{4}&35779699D0*Z(3))\\spad{+0}.005239165960779299D0*Z(2)\\spad{+0}.05141563713660119D0\\spad{\\br} \\tab{4}\\spad{&*Z}(1)\\spad{\\br} \\tab{5}\\spad{W}(14)=(\\spad{-0}.02986582812574917D0*Z(16))+(\\spad{-0}.2995429545781457D0*Z(15))\\spad{\\br} \\tab{4}\\spad{&+0}.8892996132269974D0*Z(14)+(\\spad{-0}.3523683853026259D0*Z(13))+(\\spad{-0}.1236\\spad{\\br} \\tab{4}&679206156403D0*Z(12))+(\\spad{-0}.05760560341383113D0*Z(11))\\spad{+0}.20910979278\\spad{\\br} \\tab{4}&87612D0*Z(10)+(\\spad{-0}.04901428822579872D0*Z(9))+(\\spad{-0}.05483186562035512D\\spad{\\br} \\tab{4}&0*Z(8))+(\\spad{-0}.01632133125029967D0*Z(7))\\spad{+0}.05375944956767728D0*Z(6)\\spad{+0}\\spad{\\br} \\tab{4}&.002033305231024948D0*Z(5)+(\\spad{-0}.03032392238968179D0*Z(4))+(\\spad{-0}.00660\\spad{\\br} \\tab{4}&7305534689702D0*Z(3))\\spad{+0}.02021603150122265D0*Z(2)\\spad{+0}.033711981971903\\spad{\\br} \\tab{4}&02D0*Z(1)\\spad{\\br} \\tab{5}\\spad{W}(15)=(\\spad{-0}.2419652703415429D0*Z(16))\\spad{+0}.9128222941872173D0*Z(15)+(\\spad{-0}\\spad{\\br} \\tab{4}&.3244016605667343D0*Z(14))+(\\spad{-0}.1688977368984641D0*Z(13))+(\\spad{-0}.05325\\spad{\\br} \\tab{4}&555586632358D0*Z(12))\\spad{+0}.2176561076571465D0*Z(11)+(\\spad{-0}.0415311995556\\spad{\\br} \\tab{4}&9051D0*Z(10))+(\\spad{-0}.06095390688679697D0*Z(9))+(\\spad{-0}.01981532388243379D\\spad{\\br} \\tab{4}&0*Z(8))\\spad{+0}.05258889186338282D0*Z(7)\\spad{+0}.00157466157362272D0*Z(6)+(\\spad{-0}.\\spad{\\br} \\tab{4}&0135713672105995D0*Z(5))+(\\spad{-0}.01764072463999744D0*Z(4))\\spad{+0}.010940122\\spad{\\br} \\tab{4}&10519586D0*Z(3)\\spad{+0}.008812321197398072D0*Z(2)\\spad{+0}.0227345011107737D0*Z\\spad{\\br} \\tab{4}&(1)\\spad{\\br} \\tab{5}\\spad{W}(16)\\spad{=1}.019463911841327D0*Z(16)+(\\spad{-0}.2803531651057233D0*Z(15))+(\\spad{-0}.\\spad{\\br} \\tab{4}&1165300508238904D0*Z(14))+(\\spad{-0}.1385343580686922D0*Z(13))\\spad{+0}.22647669\\spad{\\br} \\tab{4}&47290192D0*Z(12)+(\\spad{-0}.02434652144032987D0*Z(11))+(\\spad{-0}.04723268012114\\spad{\\br} \\tab{4}&625D0*Z(10))+(\\spad{-0}.03586220812223305D0*Z(9))\\spad{+0}.04932374658377151D0*Z\\spad{\\br} \\tab{4}&(8)\\spad{+0}.00372306473653087D0*Z(7)+(\\spad{-0}.01219194009813166D0*Z(6))+(\\spad{-0}.0\\spad{\\br} \\tab{4}&07005540882865317D0*Z(5))\\spad{+0}.002957434991769087D0*Z(4)\\spad{+0}.0021069739\\spad{\\br} \\tab{4}&00813502D0*Z(3)\\spad{+0}.001747395874954051D0*Z(2)\\spad{+0}.01707454969713436D0*\\spad{\\br} \\tab{4}\\spad{&Z}(1)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br}"))) +(-73 -2798) +((|constructor| (NIL "\\spadtype{Asp28} produces Fortran for Type 28 ASPs, used in NAG routine f02fjf, for example: \\blankline \\tab{5}SUBROUTINE IMAGE(IFLAG,N,Z,W,RWORK,LRWORK,IWORK,LIWORK)\\br \\tab{5}DOUBLE PRECISION Z(N),W(N),IWORK(LRWORK),RWORK(LRWORK)\\br \\tab{5}INTEGER N,LIWORK,IFLAG,LRWORK\\br \\tab{5}W(1)=0.01707454969713436D0*Z(16)+0.001747395874954051D0*Z(15)+0.00\\br \\tab{4}&2106973900813502D0*Z(14)+0.002957434991769087D0*Z(13)+(-0.00700554\\br \\tab{4}&0882865317D0*Z(12))+(-0.01219194009813166D0*Z(11))+0.0037230647365\\br \\tab{4}&3087D0*Z(10)+0.04932374658377151D0*Z(9)+(-0.03586220812223305D0*Z(\\br \\tab{4}&8))+(-0.04723268012114625D0*Z(7))+(-0.02434652144032987D0*Z(6))+0.\\br \\tab{4}&2264766947290192D0*Z(5)+(-0.1385343580686922D0*Z(4))+(-0.116530050\\br \\tab{4}&8238904D0*Z(3))+(-0.2803531651057233D0*Z(2))+1.019463911841327D0*Z\\br \\tab{4}&(1)\\br \\tab{5}W(2)=0.0227345011107737D0*Z(16)+0.008812321197398072D0*Z(15)+0.010\\br \\tab{4}&94012210519586D0*Z(14)+(-0.01764072463999744D0*Z(13))+(-0.01357136\\br \\tab{4}&72105995D0*Z(12))+0.00157466157362272D0*Z(11)+0.05258889186338282D\\br \\tab{4}&0*Z(10)+(-0.01981532388243379D0*Z(9))+(-0.06095390688679697D0*Z(8)\\br \\tab{4}&)+(-0.04153119955569051D0*Z(7))+0.2176561076571465D0*Z(6)+(-0.0532\\br \\tab{4}&5555586632358D0*Z(5))+(-0.1688977368984641D0*Z(4))+(-0.32440166056\\br \\tab{4}&67343D0*Z(3))+0.9128222941872173D0*Z(2)+(-0.2419652703415429D0*Z(1\\br \\tab{4}&))\\br \\tab{5}W(3)=0.03371198197190302D0*Z(16)+0.02021603150122265D0*Z(15)+(-0.0\\br \\tab{4}&06607305534689702D0*Z(14))+(-0.03032392238968179D0*Z(13))+0.002033\\br \\tab{4}&305231024948D0*Z(12)+0.05375944956767728D0*Z(11)+(-0.0163213312502\\br \\tab{4}&9967D0*Z(10))+(-0.05483186562035512D0*Z(9))+(-0.04901428822579872D\\br \\tab{4}&0*Z(8))+0.2091097927887612D0*Z(7)+(-0.05760560341383113D0*Z(6))+(-\\br \\tab{4}&0.1236679206156403D0*Z(5))+(-0.3523683853026259D0*Z(4))+0.88929961\\br \\tab{4}&32269974D0*Z(3)+(-0.2995429545781457D0*Z(2))+(-0.02986582812574917\\br \\tab{4}&D0*Z(1))\\br \\tab{5}W(4)=0.05141563713660119D0*Z(16)+0.005239165960779299D0*Z(15)+(-0.\\br \\tab{4}&01623427735779699D0*Z(14))+(-0.01965809746040371D0*Z(13))+0.054688\\br \\tab{4}&97337339577D0*Z(12)+(-0.014224695935687D0*Z(11))+(-0.0505181779315\\br \\tab{4}&6355D0*Z(10))+(-0.04353074206076491D0*Z(9))+0.2012230497530726D0*Z\\br \\tab{4}&(8)+(-0.06630874514535952D0*Z(7))+(-0.1280829963720053D0*Z(6))+(-0\\br \\tab{4}&.305169742604165D0*Z(5))+0.8600427128450191D0*Z(4)+(-0.32415033802\\br \\tab{4}&68184D0*Z(3))+(-0.09033531980693314D0*Z(2))+0.09089205517109111D0*\\br \\tab{4}&Z(1)\\br \\tab{5}W(5)=0.04556369767776375D0*Z(16)+(-0.001822737697581869D0*Z(15))+(\\br \\tab{4}&-0.002512226501941856D0*Z(14))+0.02947046460707379D0*Z(13)+(-0.014\\br \\tab{4}&45079632086177D0*Z(12))+(-0.05034242196614937D0*Z(11))+(-0.0376966\\br \\tab{4}&3291725935D0*Z(10))+0.2171103102175198D0*Z(9)+(-0.0824949256021352\\br \\tab{4}&4D0*Z(8))+(-0.1473995209288945D0*Z(7))+(-0.315042193418466D0*Z(6))\\br \\tab{4}&+0.9591623347824002D0*Z(5)+(-0.3852396953763045D0*Z(4))+(-0.141718\\br \\tab{4}&5427288274D0*Z(3))+(-0.03423495461011043D0*Z(2))+0.319820917706851\\br \\tab{4}&6D0*Z(1)\\br \\tab{5}W(6)=0.04015147277405744D0*Z(16)+0.01328585741341559D0*Z(15)+0.048\\br \\tab{4}&26082005465965D0*Z(14)+(-0.04319641116207706D0*Z(13))+(-0.04931323\\br \\tab{4}&319055762D0*Z(12))+(-0.03526886317505474D0*Z(11))+0.22295383396730\\br \\tab{4}&01D0*Z(10)+(-0.07375317649315155D0*Z(9))+(-0.1589391311991561D0*Z(\\br \\tab{4}&8))+(-0.328001910890377D0*Z(7))+0.952576555482747D0*Z(6)+(-0.31583\\br \\tab{4}&09975786731D0*Z(5))+(-0.1846882042225383D0*Z(4))+(-0.0703762046700\\br \\tab{4}&4427D0*Z(3))+0.2311852964327382D0*Z(2)+0.04254083491825025D0*Z(1)\\br \\tab{5}W(7)=0.06069778964023718D0*Z(16)+0.06681263884671322D0*Z(15)+(-0.0\\br \\tab{4}&2113506688615768D0*Z(14))+(-0.083996867458326D0*Z(13))+(-0.0329843\\br \\tab{4}&8523869648D0*Z(12))+0.2276878326327734D0*Z(11)+(-0.067356038933017\\br \\tab{4}&95D0*Z(10))+(-0.1559813965382218D0*Z(9))+(-0.3363262957694705D0*Z(\\br \\tab{4}&8))+0.9442791158560948D0*Z(7)+(-0.3199955249404657D0*Z(6))+(-0.136\\br \\tab{4}&2463839920727D0*Z(5))+(-0.1006185171570586D0*Z(4))+0.2057504515015\\br \\tab{4}&423D0*Z(3)+(-0.02065879269286707D0*Z(2))+0.03160990266745513D0*Z(1\\br \\tab{4}&)\\br \\tab{5}W(8)=0.126386868896738D0*Z(16)+0.002563370039476418D0*Z(15)+(-0.05\\br \\tab{4}&581757739455641D0*Z(14))+(-0.07777893205900685D0*Z(13))+0.23117338\\br \\tab{4}&45834199D0*Z(12)+(-0.06031581134427592D0*Z(11))+(-0.14805474755869\\br \\tab{4}&52D0*Z(10))+(-0.3364014128402243D0*Z(9))+0.9364014128402244D0*Z(8)\\br \\tab{4}&+(-0.3269452524413048D0*Z(7))+(-0.1396841886557241D0*Z(6))+(-0.056\\br \\tab{4}&1733845834199D0*Z(5))+0.1777789320590069D0*Z(4)+(-0.04418242260544\\br \\tab{4}&359D0*Z(3))+(-0.02756337003947642D0*Z(2))+0.07361313110326199D0*Z(\\br \\tab{4}&1)\\br \\tab{5}W(9)=0.07361313110326199D0*Z(16)+(-0.02756337003947642D0*Z(15))+(-\\br \\tab{4}&0.04418242260544359D0*Z(14))+0.1777789320590069D0*Z(13)+(-0.056173\\br \\tab{4}&3845834199D0*Z(12))+(-0.1396841886557241D0*Z(11))+(-0.326945252441\\br \\tab{4}&3048D0*Z(10))+0.9364014128402244D0*Z(9)+(-0.3364014128402243D0*Z(8\\br \\tab{4}&))+(-0.1480547475586952D0*Z(7))+(-0.06031581134427592D0*Z(6))+0.23\\br \\tab{4}&11733845834199D0*Z(5)+(-0.07777893205900685D0*Z(4))+(-0.0558175773\\br \\tab{4}&9455641D0*Z(3))+0.002563370039476418D0*Z(2)+0.126386868896738D0*Z(\\br \\tab{4}&1)\\br \\tab{5}W(10)=0.03160990266745513D0*Z(16)+(-0.02065879269286707D0*Z(15))+0\\br \\tab{4}&.2057504515015423D0*Z(14)+(-0.1006185171570586D0*Z(13))+(-0.136246\\br \\tab{4}&3839920727D0*Z(12))+(-0.3199955249404657D0*Z(11))+0.94427911585609\\br \\tab{4}&48D0*Z(10)+(-0.3363262957694705D0*Z(9))+(-0.1559813965382218D0*Z(8\\br \\tab{4}&))+(-0.06735603893301795D0*Z(7))+0.2276878326327734D0*Z(6)+(-0.032\\br \\tab{4}&98438523869648D0*Z(5))+(-0.083996867458326D0*Z(4))+(-0.02113506688\\br \\tab{4}&615768D0*Z(3))+0.06681263884671322D0*Z(2)+0.06069778964023718D0*Z(\\br \\tab{4}&1)\\br \\tab{5}W(11)=0.04254083491825025D0*Z(16)+0.2311852964327382D0*Z(15)+(-0.0\\br \\tab{4}&7037620467004427D0*Z(14))+(-0.1846882042225383D0*Z(13))+(-0.315830\\br \\tab{4}&9975786731D0*Z(12))+0.952576555482747D0*Z(11)+(-0.328001910890377D\\br \\tab{4}&0*Z(10))+(-0.1589391311991561D0*Z(9))+(-0.07375317649315155D0*Z(8)\\br \\tab{4}&)+0.2229538339673001D0*Z(7)+(-0.03526886317505474D0*Z(6))+(-0.0493\\br \\tab{4}&1323319055762D0*Z(5))+(-0.04319641116207706D0*Z(4))+0.048260820054\\br \\tab{4}&65965D0*Z(3)+0.01328585741341559D0*Z(2)+0.04015147277405744D0*Z(1)\\br \\tab{5}W(12)=0.3198209177068516D0*Z(16)+(-0.03423495461011043D0*Z(15))+(-\\br \\tab{4}&0.1417185427288274D0*Z(14))+(-0.3852396953763045D0*Z(13))+0.959162\\br \\tab{4}&3347824002D0*Z(12)+(-0.315042193418466D0*Z(11))+(-0.14739952092889\\br \\tab{4}&45D0*Z(10))+(-0.08249492560213524D0*Z(9))+0.2171103102175198D0*Z(8\\br \\tab{4}&)+(-0.03769663291725935D0*Z(7))+(-0.05034242196614937D0*Z(6))+(-0.\\br \\tab{4}&01445079632086177D0*Z(5))+0.02947046460707379D0*Z(4)+(-0.002512226\\br \\tab{4}&501941856D0*Z(3))+(-0.001822737697581869D0*Z(2))+0.045563697677763\\br \\tab{4}&75D0*Z(1)\\br \\tab{5}W(13)=0.09089205517109111D0*Z(16)+(-0.09033531980693314D0*Z(15))+(\\br \\tab{4}&-0.3241503380268184D0*Z(14))+0.8600427128450191D0*Z(13)+(-0.305169\\br \\tab{4}&742604165D0*Z(12))+(-0.1280829963720053D0*Z(11))+(-0.0663087451453\\br \\tab{4}&5952D0*Z(10))+0.2012230497530726D0*Z(9)+(-0.04353074206076491D0*Z(\\br \\tab{4}&8))+(-0.05051817793156355D0*Z(7))+(-0.014224695935687D0*Z(6))+0.05\\br \\tab{4}&468897337339577D0*Z(5)+(-0.01965809746040371D0*Z(4))+(-0.016234277\\br \\tab{4}&35779699D0*Z(3))+0.005239165960779299D0*Z(2)+0.05141563713660119D0\\br \\tab{4}&*Z(1)\\br \\tab{5}W(14)=(-0.02986582812574917D0*Z(16))+(-0.2995429545781457D0*Z(15))\\br \\tab{4}&+0.8892996132269974D0*Z(14)+(-0.3523683853026259D0*Z(13))+(-0.1236\\br \\tab{4}&679206156403D0*Z(12))+(-0.05760560341383113D0*Z(11))+0.20910979278\\br \\tab{4}&87612D0*Z(10)+(-0.04901428822579872D0*Z(9))+(-0.05483186562035512D\\br \\tab{4}&0*Z(8))+(-0.01632133125029967D0*Z(7))+0.05375944956767728D0*Z(6)+0\\br \\tab{4}&.002033305231024948D0*Z(5)+(-0.03032392238968179D0*Z(4))+(-0.00660\\br \\tab{4}&7305534689702D0*Z(3))+0.02021603150122265D0*Z(2)+0.033711981971903\\br \\tab{4}&02D0*Z(1)\\br \\tab{5}W(15)=(-0.2419652703415429D0*Z(16))+0.9128222941872173D0*Z(15)+(-0\\br \\tab{4}&.3244016605667343D0*Z(14))+(-0.1688977368984641D0*Z(13))+(-0.05325\\br \\tab{4}&555586632358D0*Z(12))+0.2176561076571465D0*Z(11)+(-0.0415311995556\\br \\tab{4}&9051D0*Z(10))+(-0.06095390688679697D0*Z(9))+(-0.01981532388243379D\\br \\tab{4}&0*Z(8))+0.05258889186338282D0*Z(7)+0.00157466157362272D0*Z(6)+(-0.\\br \\tab{4}&0135713672105995D0*Z(5))+(-0.01764072463999744D0*Z(4))+0.010940122\\br \\tab{4}&10519586D0*Z(3)+0.008812321197398072D0*Z(2)+0.0227345011107737D0*Z\\br \\tab{4}&(1)\\br \\tab{5}W(16)=1.019463911841327D0*Z(16)+(-0.2803531651057233D0*Z(15))+(-0.\\br \\tab{4}&1165300508238904D0*Z(14))+(-0.1385343580686922D0*Z(13))+0.22647669\\br \\tab{4}&47290192D0*Z(12)+(-0.02434652144032987D0*Z(11))+(-0.04723268012114\\br \\tab{4}&625D0*Z(10))+(-0.03586220812223305D0*Z(9))+0.04932374658377151D0*Z\\br \\tab{4}&(8)+0.00372306473653087D0*Z(7)+(-0.01219194009813166D0*Z(6))+(-0.0\\br \\tab{4}&07005540882865317D0*Z(5))+0.002957434991769087D0*Z(4)+0.0021069739\\br \\tab{4}&00813502D0*Z(3)+0.001747395874954051D0*Z(2)+0.01707454969713436D0*\\br \\tab{4}&Z(1)\\br \\tab{5}RETURN\\br \\tab{5}END\\br"))) NIL NIL -(-74 -1486) -((|constructor| (NIL "\\spadtype{Asp29} produces Fortran for Type 29 ASPs,{} needed for NAG routine f02fjf,{} for example: \\blankline \\tab{5}SUBROUTINE MONIT(ISTATE,{}NEXTIT,{}NEVALS,{}NEVECS,{}\\spad{K},{}\\spad{F},{}\\spad{D})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{D}(\\spad{K}),{}\\spad{F}(\\spad{K})\\spad{\\br} \\tab{5}INTEGER \\spad{K},{}NEXTIT,{}NEVALS,{}NVECS,{}ISTATE\\spad{\\br} \\tab{5}CALL F02FJZ(ISTATE,{}NEXTIT,{}NEVALS,{}NEVECS,{}\\spad{K},{}\\spad{F},{}\\spad{D})\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br}")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP29}."))) +(-74 -2798) +((|constructor| (NIL "\\spadtype{Asp29} produces Fortran for Type 29 ASPs, needed for NAG routine f02fjf, for example: \\blankline \\tab{5}SUBROUTINE MONIT(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\\br \\tab{5}DOUBLE PRECISION D(K),F(K)\\br \\tab{5}INTEGER K,NEXTIT,NEVALS,NVECS,ISTATE\\br \\tab{5}CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)\\br \\tab{5}RETURN\\br \\tab{5}END\\br")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP29}."))) NIL NIL -(-75 -1486) -((|constructor| (NIL "\\spadtype{Asp30} produces Fortran for Type 30 ASPs,{} needed for NAG routine f04qaf,{} for example: \\blankline \\tab{5}SUBROUTINE APROD(MODE,{}\\spad{M},{}\\spad{N},{}\\spad{X},{}\\spad{Y},{}RWORK,{}LRWORK,{}IWORK,{}LIWORK)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}(\\spad{N}),{}\\spad{Y}(\\spad{M}),{}RWORK(LRWORK)\\spad{\\br} \\tab{5}INTEGER \\spad{M},{}\\spad{N},{}LIWORK,{}IFAIL,{}LRWORK,{}IWORK(LIWORK),{}MODE\\spad{\\br} \\tab{5}DOUBLE PRECISION A(5,{}5)\\spad{\\br} \\tab{5}EXTERNAL F06PAF\\spad{\\br} \\tab{5}A(1,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}A(1,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(1,{}4)=-1.0D0\\spad{\\br} \\tab{5}A(1,{}5)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(2,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}A(2,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(2,{}4)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(2,{}5)=-1.0D0\\spad{\\br} \\tab{5}A(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(3,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(3,{}3)\\spad{=1}.0D0\\spad{\\br} \\tab{5}A(3,{}4)=-1.0D0\\spad{\\br} \\tab{5}A(3,{}5)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(4,{}1)=-1.0D0\\spad{\\br} \\tab{5}A(4,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(4,{}3)=-1.0D0\\spad{\\br} \\tab{5}A(4,{}4)\\spad{=4}.0D0\\spad{\\br} \\tab{5}A(4,{}5)=-1.0D0\\spad{\\br} \\tab{5}A(5,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(5,{}2)=-1.0D0\\spad{\\br} \\tab{5}A(5,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}A(5,{}4)=-1.0D0\\spad{\\br} \\tab{5}A(5,{}5)\\spad{=4}.0D0\\spad{\\br} \\tab{5}IF(MODE.EQ.1)THEN\\spad{\\br} \\tab{7}CALL F06PAF(\\spad{'N'},{}\\spad{M},{}\\spad{N},{}1.0D0,{}A,{}\\spad{M},{}\\spad{X},{}1,{}1.0D0,{}\\spad{Y},{}1)\\spad{\\br} \\tab{5}ELSEIF(MODE.EQ.2)THEN\\spad{\\br} \\tab{7}CALL F06PAF(\\spad{'T'},{}\\spad{M},{}\\spad{N},{}1.0D0,{}A,{}\\spad{M},{}\\spad{Y},{}1,{}1.0D0,{}\\spad{X},{}1)\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END"))) +(-75 -2798) +((|constructor| (NIL "\\spadtype{Asp30} produces Fortran for Type 30 ASPs, needed for NAG routine f04qaf, for example: \\blankline \\tab{5}SUBROUTINE APROD(MODE,M,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\\br \\tab{5}DOUBLE PRECISION X(N),Y(M),RWORK(LRWORK)\\br \\tab{5}INTEGER M,N,LIWORK,IFAIL,LRWORK,IWORK(LIWORK),MODE\\br \\tab{5}DOUBLE PRECISION A(5,5)\\br \\tab{5}EXTERNAL F06PAF\\br \\tab{5}A(1,1)=1.0D0\\br \\tab{5}A(1,2)=0.0D0\\br \\tab{5}A(1,3)=0.0D0\\br \\tab{5}A(1,4)=-1.0D0\\br \\tab{5}A(1,5)=0.0D0\\br \\tab{5}A(2,1)=0.0D0\\br \\tab{5}A(2,2)=1.0D0\\br \\tab{5}A(2,3)=0.0D0\\br \\tab{5}A(2,4)=0.0D0\\br \\tab{5}A(2,5)=-1.0D0\\br \\tab{5}A(3,1)=0.0D0\\br \\tab{5}A(3,2)=0.0D0\\br \\tab{5}A(3,3)=1.0D0\\br \\tab{5}A(3,4)=-1.0D0\\br \\tab{5}A(3,5)=0.0D0\\br \\tab{5}A(4,1)=-1.0D0\\br \\tab{5}A(4,2)=0.0D0\\br \\tab{5}A(4,3)=-1.0D0\\br \\tab{5}A(4,4)=4.0D0\\br \\tab{5}A(4,5)=-1.0D0\\br \\tab{5}A(5,1)=0.0D0\\br \\tab{5}A(5,2)=-1.0D0\\br \\tab{5}A(5,3)=0.0D0\\br \\tab{5}A(5,4)=-1.0D0\\br \\tab{5}A(5,5)=4.0D0\\br \\tab{5}IF(MODE.EQ.1)THEN\\br \\tab{7}CALL F06PAF('N',M,N,1.0D0,A,M,X,1,1.0D0,Y,1)\\br \\tab{5}ELSEIF(MODE.EQ.2)THEN\\br \\tab{7}CALL F06PAF('T',M,N,1.0D0,A,M,Y,1,1.0D0,X,1)\\br \\tab{5}ENDIF\\br \\tab{5}RETURN\\br \\tab{5}END"))) NIL NIL -(-76 -1486) -((|constructor| (NIL "\\spadtype{Asp31} produces Fortran for Type 31 ASPs,{} needed for NAG routine d02ejf,{} for example: \\blankline \\tab{5}SUBROUTINE PEDERV(\\spad{X},{}\\spad{Y},{}\\spad{PW})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X},{}\\spad{Y}(*)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{PW}(3,{}3)\\spad{\\br} \\tab{5}\\spad{PW}(1,{}1)=-0.03999999999999999D0\\spad{\\br} \\tab{5}\\spad{PW}(1,{}2)\\spad{=10000}.0D0*Y(3)\\spad{\\br} \\tab{5}\\spad{PW}(1,{}3)\\spad{=10000}.0D0*Y(2)\\spad{\\br} \\tab{5}\\spad{PW}(2,{}1)\\spad{=0}.03999999999999999D0\\spad{\\br} \\tab{5}\\spad{PW}(2,{}2)=(\\spad{-10000}.0D0*Y(3))+(\\spad{-60000000}.0D0*Y(2))\\spad{\\br} \\tab{5}\\spad{PW}(2,{}3)=-10000.0D0*Y(2)\\spad{\\br} \\tab{5}\\spad{PW}(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{PW}(3,{}2)\\spad{=60000000}.0D0*Y(2)\\spad{\\br} \\tab{5}\\spad{PW}(3,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-76 -2798) +((|constructor| (NIL "\\spadtype{Asp31} produces Fortran for Type 31 ASPs, needed for NAG routine d02ejf, for example: \\blankline \\tab{5}SUBROUTINE PEDERV(X,Y,PW)\\br \\tab{5}DOUBLE PRECISION X,Y(*)\\br \\tab{5}DOUBLE PRECISION PW(3,3)\\br \\tab{5}PW(1,1)=-0.03999999999999999D0\\br \\tab{5}PW(1,2)=10000.0D0*Y(3)\\br \\tab{5}PW(1,3)=10000.0D0*Y(2)\\br \\tab{5}PW(2,1)=0.03999999999999999D0\\br \\tab{5}PW(2,2)=(-10000.0D0*Y(3))+(-60000000.0D0*Y(2))\\br \\tab{5}PW(2,3)=-10000.0D0*Y(2)\\br \\tab{5}PW(3,1)=0.0D0\\br \\tab{5}PW(3,2)=60000000.0D0*Y(2)\\br \\tab{5}PW(3,3)=0.0D0\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-77 -1486) -((|constructor| (NIL "\\spadtype{Asp33} produces Fortran for Type 33 ASPs,{} needed for NAG routine d02kef. The code is a dummy ASP: \\blankline \\tab{5}SUBROUTINE REPORT(\\spad{X},{}\\spad{V},{}JINT)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{V}(3),{}\\spad{X}\\spad{\\br} \\tab{5}INTEGER JINT\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP33}."))) +(-77 -2798) +((|constructor| (NIL "\\spadtype{Asp33} produces Fortran for Type 33 ASPs, needed for NAG routine d02kef. The code is a dummy ASP: \\blankline \\tab{5}SUBROUTINE REPORT(X,V,JINT)\\br \\tab{5}DOUBLE PRECISION V(3),X\\br \\tab{5}INTEGER JINT\\br \\tab{5}RETURN\\br \\tab{5}END")) (|outputAsFortran| (((|Void|)) "\\spad{outputAsFortran()} generates the default code for \\spadtype{ASP33}."))) NIL NIL -(-78 -1486) -((|constructor| (NIL "\\spadtype{Asp34} produces Fortran for Type 34 ASPs,{} needed for NAG routine f04mbf,{} for example: \\blankline \\tab{5}SUBROUTINE MSOLVE(IFLAG,{}\\spad{N},{}\\spad{X},{}\\spad{Y},{}RWORK,{}LRWORK,{}IWORK,{}LIWORK)\\spad{\\br} \\tab{5}DOUBLE PRECISION RWORK(LRWORK),{}\\spad{X}(\\spad{N}),{}\\spad{Y}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{I},{}\\spad{J},{}\\spad{N},{}LIWORK,{}IFLAG,{}LRWORK,{}IWORK(LIWORK)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{W1}(3),{}\\spad{W2}(3),{}\\spad{MS}(3,{}3)\\spad{\\br} \\tab{5}IFLAG=-1\\spad{\\br} \\tab{5}\\spad{MS}(1,{}1)\\spad{=2}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(1,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(2,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(2,{}2)\\spad{=2}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(2,{}3)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(3,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{MS}(3,{}3)\\spad{=2}.0D0\\spad{\\br} \\tab{5}CALL F04ASF(\\spad{MS},{}\\spad{N},{}\\spad{X},{}\\spad{N},{}\\spad{Y},{}\\spad{W1},{}\\spad{W2},{}IFLAG)\\spad{\\br} \\tab{5}IFLAG=-IFLAG\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END"))) +(-78 -2798) +((|constructor| (NIL "\\spadtype{Asp34} produces Fortran for Type 34 ASPs, needed for NAG routine f04mbf, for example: \\blankline \\tab{5}SUBROUTINE MSOLVE(IFLAG,N,X,Y,RWORK,LRWORK,IWORK,LIWORK)\\br \\tab{5}DOUBLE PRECISION RWORK(LRWORK),X(N),Y(N)\\br \\tab{5}INTEGER I,J,N,LIWORK,IFLAG,LRWORK,IWORK(LIWORK)\\br \\tab{5}DOUBLE PRECISION W1(3),W2(3),MS(3,3)\\br \\tab{5}IFLAG=-1\\br \\tab{5}MS(1,1)=2.0D0\\br \\tab{5}MS(1,2)=1.0D0\\br \\tab{5}MS(1,3)=0.0D0\\br \\tab{5}MS(2,1)=1.0D0\\br \\tab{5}MS(2,2)=2.0D0\\br \\tab{5}MS(2,3)=1.0D0\\br \\tab{5}MS(3,1)=0.0D0\\br \\tab{5}MS(3,2)=1.0D0\\br \\tab{5}MS(3,3)=2.0D0\\br \\tab{5}CALL F04ASF(MS,N,X,N,Y,W1,W2,IFLAG)\\br \\tab{5}IFLAG=-IFLAG\\br \\tab{5}RETURN\\br \\tab{5}END"))) NIL NIL -(-79 -1486) -((|constructor| (NIL "\\spadtype{Asp35} produces Fortran for Type 35 ASPs,{} needed for NAG routines c05pbf,{} c05pcf,{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{FCN}(\\spad{N},{}\\spad{X},{}FVEC,{}FJAC,{}LDFJAC,{}IFLAG)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}(\\spad{N}),{}FVEC(\\spad{N}),{}FJAC(LDFJAC,{}\\spad{N})\\spad{\\br} \\tab{5}INTEGER LDFJAC,{}\\spad{N},{}IFLAG\\spad{\\br} \\tab{5}IF(IFLAG.EQ.1)THEN\\spad{\\br} \\tab{7}FVEC(1)=(\\spad{-1}.0D0*X(2))\\spad{+X}(1)\\spad{\\br} \\tab{7}FVEC(2)=(\\spad{-1}.0D0*X(3))\\spad{+2}.0D0*X(2)\\spad{\\br} \\tab{7}FVEC(3)\\spad{=3}.0D0*X(3)\\spad{\\br} \\tab{5}ELSEIF(IFLAG.EQ.2)THEN\\spad{\\br} \\tab{7}FJAC(1,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{7}FJAC(1,{}2)=-1.0D0\\spad{\\br} \\tab{7}FJAC(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{7}FJAC(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{7}FJAC(2,{}2)\\spad{=2}.0D0\\spad{\\br} \\tab{7}FJAC(2,{}3)=-1.0D0\\spad{\\br} \\tab{7}FJAC(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{7}FJAC(3,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{7}FJAC(3,{}3)\\spad{=3}.0D0\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-79 -2798) +((|constructor| (NIL "\\spadtype{Asp35} produces Fortran for Type 35 ASPs, needed for NAG routines c05pbf, c05pcf, for example: \\blankline \\tab{5}SUBROUTINE FCN(N,X,FVEC,FJAC,LDFJAC,IFLAG)\\br \\tab{5}DOUBLE PRECISION X(N),FVEC(N),FJAC(LDFJAC,N)\\br \\tab{5}INTEGER LDFJAC,N,IFLAG\\br \\tab{5}IF(IFLAG.EQ.1)THEN\\br \\tab{7}FVEC(1)=(-1.0D0*X(2))+X(1)\\br \\tab{7}FVEC(2)=(-1.0D0*X(3))+2.0D0*X(2)\\br \\tab{7}FVEC(3)=3.0D0*X(3)\\br \\tab{5}ELSEIF(IFLAG.EQ.2)THEN\\br \\tab{7}FJAC(1,1)=1.0D0\\br \\tab{7}FJAC(1,2)=-1.0D0\\br \\tab{7}FJAC(1,3)=0.0D0\\br \\tab{7}FJAC(2,1)=0.0D0\\br \\tab{7}FJAC(2,2)=2.0D0\\br \\tab{7}FJAC(2,3)=-1.0D0\\br \\tab{7}FJAC(3,1)=0.0D0\\br \\tab{7}FJAC(3,2)=0.0D0\\br \\tab{7}FJAC(3,3)=3.0D0\\br \\tab{5}ENDIF\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL (-80 |nameOne| |nameTwo| |nameThree|) -((|constructor| (NIL "\\spadtype{Asp41} produces Fortran for Type 41 ASPs,{} needed for NAG routines d02raf and d02saf in particular. These ASPs are in fact three Fortran routines which return a vector of functions,{} and their derivatives \\spad{wrt} \\spad{Y}(\\spad{i}) and also a continuation parameter EPS,{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{FCN}(\\spad{X},{}EPS,{}\\spad{Y},{}\\spad{F},{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}\\spad{F}(\\spad{N}),{}\\spad{X},{}\\spad{Y}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}\\spad{F}(1)\\spad{=Y}(2)\\spad{\\br} \\tab{5}\\spad{F}(2)\\spad{=Y}(3)\\spad{\\br} \\tab{5}\\spad{F}(3)=(\\spad{-1}.0D0*Y(1)\\spad{*Y}(3))\\spad{+2}.0D0*EPS*Y(2)**2+(\\spad{-2}.0D0*EPS)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br} \\tab{5}SUBROUTINE JACOBF(\\spad{X},{}EPS,{}\\spad{Y},{}\\spad{F},{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}\\spad{F}(\\spad{N},{}\\spad{N}),{}\\spad{X},{}\\spad{Y}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}\\spad{F}(1,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(1,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{F}(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2,{}3)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{F}(3,{}1)=-1.0D0*Y(3)\\spad{\\br} \\tab{5}\\spad{F}(3,{}2)\\spad{=4}.0D0*EPS*Y(2)\\spad{\\br} \\tab{5}\\spad{F}(3,{}3)=-1.0D0*Y(1)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br} \\tab{5}SUBROUTINE JACEPS(\\spad{X},{}EPS,{}\\spad{Y},{}\\spad{F},{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}\\spad{F}(\\spad{N}),{}\\spad{X},{}\\spad{Y}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}\\spad{F}(1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(3)\\spad{=2}.0D0*Y(2)\\spad{**2}-2.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X) (QUOTE EPS)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +((|constructor| (NIL "\\spadtype{Asp41} produces Fortran for Type 41 ASPs, needed for NAG routines d02raf and d02saf in particular. These ASPs are in fact three Fortran routines which return a vector of functions, and their derivatives \\spad{wrt} Y(i) and also a continuation parameter EPS, for example: \\blankline \\tab{5}SUBROUTINE FCN(X,EPS,Y,F,N)\\br \\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\\br \\tab{5}INTEGER N\\br \\tab{5}F(1)=Y(2)\\br \\tab{5}F(2)=Y(3)\\br \\tab{5}F(3)=(-1.0D0*Y(1)*Y(3))+2.0D0*EPS*Y(2)**2+(-2.0D0*EPS)\\br \\tab{5}RETURN\\br \\tab{5}END\\br \\tab{5}SUBROUTINE JACOBF(X,EPS,Y,F,N)\\br \\tab{5}DOUBLE PRECISION EPS,F(N,N),X,Y(N)\\br \\tab{5}INTEGER N\\br \\tab{5}F(1,1)=0.0D0\\br \\tab{5}F(1,2)=1.0D0\\br \\tab{5}F(1,3)=0.0D0\\br \\tab{5}F(2,1)=0.0D0\\br \\tab{5}F(2,2)=0.0D0\\br \\tab{5}F(2,3)=1.0D0\\br \\tab{5}F(3,1)=-1.0D0*Y(3)\\br \\tab{5}F(3,2)=4.0D0*EPS*Y(2)\\br \\tab{5}F(3,3)=-1.0D0*Y(1)\\br \\tab{5}RETURN\\br \\tab{5}END\\br \\tab{5}SUBROUTINE JACEPS(X,EPS,Y,F,N)\\br \\tab{5}DOUBLE PRECISION EPS,F(N),X,Y(N)\\br \\tab{5}INTEGER N\\br \\tab{5}F(1)=0.0D0\\br \\tab{5}F(2)=0.0D0\\br \\tab{5}F(3)=2.0D0*Y(2)**2-2.0D0\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X) (QUOTE EPS)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL (-81 |nameOne| |nameTwo| |nameThree|) -((|constructor| (NIL "\\spadtype{Asp42} produces Fortran for Type 42 ASPs,{} needed for NAG routines d02raf and d02saf in particular. These ASPs are in fact three Fortran routines which return a vector of functions,{} and their derivatives \\spad{wrt} \\spad{Y}(\\spad{i}) and also a continuation parameter EPS,{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{G}(EPS,{}YA,{}\\spad{YB},{}\\spad{BC},{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}YA(\\spad{N}),{}\\spad{YB}(\\spad{N}),{}\\spad{BC}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}\\spad{BC}(1)=YA(1)\\spad{\\br} \\tab{5}\\spad{BC}(2)=YA(2)\\spad{\\br} \\tab{5}\\spad{BC}(3)\\spad{=YB}(2)\\spad{-1}.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br} \\tab{5}SUBROUTINE JACOBG(EPS,{}YA,{}\\spad{YB},{}AJ,{}\\spad{BJ},{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}YA(\\spad{N}),{}AJ(\\spad{N},{}\\spad{N}),{}\\spad{BJ}(\\spad{N},{}\\spad{N}),{}\\spad{YB}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}AJ(1,{}1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}AJ(1,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(2,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}AJ(2,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(3,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}AJ(3,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(1,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(1,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(2,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(2,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(3,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(3,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{BJ}(3,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END\\spad{\\br} \\tab{5}SUBROUTINE JACGEP(EPS,{}YA,{}\\spad{YB},{}BCEP,{}\\spad{N})\\spad{\\br} \\tab{5}DOUBLE PRECISION EPS,{}YA(\\spad{N}),{}\\spad{YB}(\\spad{N}),{}BCEP(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{N}\\spad{\\br} \\tab{5}BCEP(1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}BCEP(2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}BCEP(3)\\spad{=0}.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE EPS)) (|construct| (QUOTE YA) (QUOTE YB)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +((|constructor| (NIL "\\spadtype{Asp42} produces Fortran for Type 42 ASPs, needed for NAG routines d02raf and d02saf in particular. These ASPs are in fact three Fortran routines which return a vector of functions, and their derivatives \\spad{wrt} Y(i) and also a continuation parameter EPS, for example: \\blankline \\tab{5}SUBROUTINE G(EPS,YA,YB,BC,N)\\br \\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BC(N)\\br \\tab{5}INTEGER N\\br \\tab{5}BC(1)=YA(1)\\br \\tab{5}BC(2)=YA(2)\\br \\tab{5}BC(3)=YB(2)-1.0D0\\br \\tab{5}RETURN\\br \\tab{5}END\\br \\tab{5}SUBROUTINE JACOBG(EPS,YA,YB,AJ,BJ,N)\\br \\tab{5}DOUBLE PRECISION EPS,YA(N),AJ(N,N),BJ(N,N),YB(N)\\br \\tab{5}INTEGER N\\br \\tab{5}AJ(1,1)=1.0D0\\br \\tab{5}AJ(1,2)=0.0D0\\br \\tab{5}AJ(1,3)=0.0D0\\br \\tab{5}AJ(2,1)=0.0D0\\br \\tab{5}AJ(2,2)=1.0D0\\br \\tab{5}AJ(2,3)=0.0D0\\br \\tab{5}AJ(3,1)=0.0D0\\br \\tab{5}AJ(3,2)=0.0D0\\br \\tab{5}AJ(3,3)=0.0D0\\br \\tab{5}BJ(1,1)=0.0D0\\br \\tab{5}BJ(1,2)=0.0D0\\br \\tab{5}BJ(1,3)=0.0D0\\br \\tab{5}BJ(2,1)=0.0D0\\br \\tab{5}BJ(2,2)=0.0D0\\br \\tab{5}BJ(2,3)=0.0D0\\br \\tab{5}BJ(3,1)=0.0D0\\br \\tab{5}BJ(3,2)=1.0D0\\br \\tab{5}BJ(3,3)=0.0D0\\br \\tab{5}RETURN\\br \\tab{5}END\\br \\tab{5}SUBROUTINE JACGEP(EPS,YA,YB,BCEP,N)\\br \\tab{5}DOUBLE PRECISION EPS,YA(N),YB(N),BCEP(N)\\br \\tab{5}INTEGER N\\br \\tab{5}BCEP(1)=0.0D0\\br \\tab{5}BCEP(2)=0.0D0\\br \\tab{5}BCEP(3)=0.0D0\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE EPS)) (|construct| (QUOTE YA) (QUOTE YB)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-82 -1486) -((|constructor| (NIL "\\spadtype{Asp49} produces Fortran for Type 49 ASPs,{} needed for NAG routines e04dgf,{} e04ucf,{} for example: \\blankline \\tab{5}SUBROUTINE OBJFUN(MODE,{}\\spad{N},{}\\spad{X},{}OBJF,{}OBJGRD,{}NSTATE,{}IUSER,{}USER)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}(\\spad{N}),{}OBJF,{}OBJGRD(\\spad{N}),{}USER(*)\\spad{\\br} \\tab{5}INTEGER \\spad{N},{}IUSER(*),{}MODE,{}NSTATE\\spad{\\br} \\tab{5}OBJF=X(4)\\spad{*X}(9)+((\\spad{-1}.0D0*X(5))\\spad{+X}(3))\\spad{*X}(8)+((\\spad{-1}.0D0*X(3))\\spad{+X}(1))\\spad{*X}(7)\\spad{\\br} \\tab{4}\\spad{&+}(\\spad{-1}.0D0*X(2)\\spad{*X}(6))\\spad{\\br} \\tab{5}OBJGRD(1)\\spad{=X}(7)\\spad{\\br} \\tab{5}OBJGRD(2)=-1.0D0*X(6)\\spad{\\br} \\tab{5}OBJGRD(3)\\spad{=X}(8)+(\\spad{-1}.0D0*X(7))\\spad{\\br} \\tab{5}OBJGRD(4)\\spad{=X}(9)\\spad{\\br} \\tab{5}OBJGRD(5)=-1.0D0*X(8)\\spad{\\br} \\tab{5}OBJGRD(6)=-1.0D0*X(2)\\spad{\\br} \\tab{5}OBJGRD(7)=(\\spad{-1}.0D0*X(3))\\spad{+X}(1)\\spad{\\br} \\tab{5}OBJGRD(8)=(\\spad{-1}.0D0*X(5))\\spad{+X}(3)\\spad{\\br} \\tab{5}OBJGRD(9)\\spad{=X}(4)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) +(-82 -2798) +((|constructor| (NIL "\\spadtype{Asp49} produces Fortran for Type 49 ASPs, needed for NAG routines e04dgf, e04ucf, for example: \\blankline \\tab{5}SUBROUTINE OBJFUN(MODE,N,X,OBJF,OBJGRD,NSTATE,IUSER,USER)\\br \\tab{5}DOUBLE PRECISION X(N),OBJF,OBJGRD(N),USER(*)\\br \\tab{5}INTEGER N,IUSER(*),MODE,NSTATE\\br \\tab{5}OBJF=X(4)*X(9)+((-1.0D0*X(5))+X(3))*X(8)+((-1.0D0*X(3))+X(1))*X(7)\\br \\tab{4}&+(-1.0D0*X(2)*X(6))\\br \\tab{5}OBJGRD(1)=X(7)\\br \\tab{5}OBJGRD(2)=-1.0D0*X(6)\\br \\tab{5}OBJGRD(3)=X(8)+(-1.0D0*X(7))\\br \\tab{5}OBJGRD(4)=X(9)\\br \\tab{5}OBJGRD(5)=-1.0D0*X(8)\\br \\tab{5}OBJGRD(6)=-1.0D0*X(2)\\br \\tab{5}OBJGRD(7)=(-1.0D0*X(3))+X(1)\\br \\tab{5}OBJGRD(8)=(-1.0D0*X(5))+X(3)\\br \\tab{5}OBJGRD(9)=X(4)\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) NIL NIL -(-83 -1486) -((|constructor| (NIL "\\spadtype{Asp4} produces Fortran for Type 4 ASPs,{} which take an expression in \\spad{X}(1) .. \\spad{X}(NDIM) and produce a real function of the form: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION FUNCTN(NDIM,{}\\spad{X})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}(NDIM)\\spad{\\br} \\tab{5}INTEGER NDIM\\spad{\\br} \\tab{5}FUNCTN=(4.0D0*X(1)\\spad{*X}(3)**2*DEXP(2.0D0*X(1)\\spad{*X}(3)))/(\\spad{X}(4)**2+(2.0D0*\\spad{\\br} \\tab{4}\\spad{&X}(2)\\spad{+2}.0D0)\\spad{*X}(4)\\spad{+X}(2)\\spad{**2+2}.0D0*X(2)\\spad{+1}.0D0)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) +(-83 -2798) +((|constructor| (NIL "\\spadtype{Asp4} produces Fortran for Type 4 ASPs, which take an expression in X(1) \\spad{..} X(NDIM) and produce a real function of the form: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION FUNCTN(NDIM,X)\\br \\tab{5}DOUBLE PRECISION X(NDIM)\\br \\tab{5}INTEGER NDIM\\br \\tab{5}FUNCTN=(4.0D0*X(1)*X(3)**2*DEXP(2.0D0*X(1)*X(3)))/(X(4)**2+(2.0D0*\\br \\tab{4}&X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0)\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) NIL NIL -(-84 -1486) -((|constructor| (NIL "\\spadtype{Asp50} produces Fortran for Type 50 ASPs,{} needed for NAG routine e04fdf,{} for example: \\blankline \\tab{5}SUBROUTINE \\spad{LSFUN1}(\\spad{M},{}\\spad{N},{}\\spad{XC},{}FVECC)\\spad{\\br} \\tab{5}DOUBLE PRECISION FVECC(\\spad{M}),{}\\spad{XC}(\\spad{N})\\spad{\\br} \\tab{5}INTEGER \\spad{I},{}\\spad{M},{}\\spad{N}\\spad{\\br} \\tab{5}FVECC(1)=((\\spad{XC}(1)\\spad{-2}.4D0)\\spad{*XC}(3)+(15.0D0*XC(1)\\spad{-36}.0D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{\\br} \\tab{4}\\spad{&XC}(3)\\spad{+15}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(2)=((\\spad{XC}(1)\\spad{-2}.8D0)\\spad{*XC}(3)+(7.0D0*XC(1)\\spad{-19}.6D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{X}\\spad{\\br} \\tab{4}\\spad{&C}(3)\\spad{+7}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(3)=((\\spad{XC}(1)\\spad{-3}.2D0)\\spad{*XC}(3)+(4.333333333333333D0*XC(1)\\spad{-13}.866666\\spad{\\br} \\tab{4}\\spad{&66666667D0})\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+4}.333333333333333D0*XC(2))\\spad{\\br} \\tab{5}FVECC(4)=((\\spad{XC}(1)\\spad{-3}.5D0)\\spad{*XC}(3)+(3.0D0*XC(1)\\spad{-10}.5D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{X}\\spad{\\br} \\tab{4}\\spad{&C}(3)\\spad{+3}.0D0*XC(2))\\spad{\\br} \\tab{5}FVECC(5)=((\\spad{XC}(1)\\spad{-3}.9D0)\\spad{*XC}(3)+(2.2D0*XC(1)\\spad{-8}.579999999999998D0)\\spad{*XC}\\spad{\\br} \\tab{4}&(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+2}.2D0*XC(2))\\spad{\\br} \\tab{5}FVECC(6)=((\\spad{XC}(1)\\spad{-4}.199999999999999D0)\\spad{*XC}(3)+(1.666666666666667D0*X\\spad{\\br} \\tab{4}\\spad{&C}(1)\\spad{-7}.0D0)\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+1}.666666666666667D0*XC(2))\\spad{\\br} \\tab{5}FVECC(7)=((\\spad{XC}(1)\\spad{-4}.5D0)\\spad{*XC}(3)+(1.285714285714286D0*XC(1)\\spad{-5}.7857142\\spad{\\br} \\tab{4}\\spad{&85714286D0})\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+1}.285714285714286D0*XC(2))\\spad{\\br} \\tab{5}FVECC(8)=((\\spad{XC}(1)\\spad{-4}.899999999999999D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-4}.8999999999999\\spad{\\br} \\tab{4}\\spad{&99D0})\\spad{*XC}(2)\\spad{+1}.0D0)/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(9)=((\\spad{XC}(1)\\spad{-4}.699999999999999D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-4}.6999999999999\\spad{\\br} \\tab{4}\\spad{&99D0})\\spad{*XC}(2)\\spad{+1}.285714285714286D0)/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(10)=((\\spad{XC}(1)\\spad{-6}.8D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-6}.8D0)\\spad{*XC}(2)\\spad{+1}.6666666666666\\spad{\\br} \\tab{4}\\spad{&67D0})/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(11)=((\\spad{XC}(1)\\spad{-8}.299999999999999D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-8}.299999999999\\spad{\\br} \\tab{4}\\spad{&999D0})\\spad{*XC}(2)\\spad{+2}.2D0)/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(12)=((\\spad{XC}(1)\\spad{-10}.6D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-10}.6D0)\\spad{*XC}(2)\\spad{+3}.0D0)/(\\spad{XC}(3)\\spad{\\br} \\tab{4}&+XC(2))\\spad{\\br} \\tab{5}FVECC(13)=((\\spad{XC}(1)\\spad{-1}.34D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-1}.34D0)\\spad{*XC}(2)\\spad{+4}.33333333333\\spad{\\br} \\tab{4}\\spad{&3333D0})/(\\spad{XC}(3)\\spad{+XC}(2))\\spad{\\br} \\tab{5}FVECC(14)=((\\spad{XC}(1)\\spad{-2}.1D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-2}.1D0)\\spad{*XC}(2)\\spad{+7}.0D0)/(\\spad{XC}(3)\\spad{+X}\\spad{\\br} \\tab{4}\\spad{&C}(2))\\spad{\\br} \\tab{5}FVECC(15)=((\\spad{XC}(1)\\spad{-4}.39D0)\\spad{*XC}(3)+(\\spad{XC}(1)\\spad{-4}.39D0)\\spad{*XC}(2)\\spad{+15}.0D0)/(\\spad{XC}(3\\spad{\\br} \\tab{4}&)\\spad{+XC}(2))\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-84 -2798) +((|constructor| (NIL "\\spadtype{Asp50} produces Fortran for Type 50 ASPs, needed for NAG routine e04fdf, for example: \\blankline \\tab{5}SUBROUTINE LSFUN1(M,N,XC,FVECC)\\br \\tab{5}DOUBLE PRECISION FVECC(M),XC(N)\\br \\tab{5}INTEGER I,M,N\\br \\tab{5}FVECC(1)=((XC(1)-2.4D0)*XC(3)+(15.0D0*XC(1)-36.0D0)*XC(2)+1.0D0)/(\\br \\tab{4}&XC(3)+15.0D0*XC(2))\\br \\tab{5}FVECC(2)=((XC(1)-2.8D0)*XC(3)+(7.0D0*XC(1)-19.6D0)*XC(2)+1.0D0)/(X\\br \\tab{4}&C(3)+7.0D0*XC(2))\\br \\tab{5}FVECC(3)=((XC(1)-3.2D0)*XC(3)+(4.333333333333333D0*XC(1)-13.866666\\br \\tab{4}&66666667D0)*XC(2)+1.0D0)/(XC(3)+4.333333333333333D0*XC(2))\\br \\tab{5}FVECC(4)=((XC(1)-3.5D0)*XC(3)+(3.0D0*XC(1)-10.5D0)*XC(2)+1.0D0)/(X\\br \\tab{4}&C(3)+3.0D0*XC(2))\\br \\tab{5}FVECC(5)=((XC(1)-3.9D0)*XC(3)+(2.2D0*XC(1)-8.579999999999998D0)*XC\\br \\tab{4}&(2)+1.0D0)/(XC(3)+2.2D0*XC(2))\\br \\tab{5}FVECC(6)=((XC(1)-4.199999999999999D0)*XC(3)+(1.666666666666667D0*X\\br \\tab{4}&C(1)-7.0D0)*XC(2)+1.0D0)/(XC(3)+1.666666666666667D0*XC(2))\\br \\tab{5}FVECC(7)=((XC(1)-4.5D0)*XC(3)+(1.285714285714286D0*XC(1)-5.7857142\\br \\tab{4}&85714286D0)*XC(2)+1.0D0)/(XC(3)+1.285714285714286D0*XC(2))\\br \\tab{5}FVECC(8)=((XC(1)-4.899999999999999D0)*XC(3)+(XC(1)-4.8999999999999\\br \\tab{4}&99D0)*XC(2)+1.0D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(9)=((XC(1)-4.699999999999999D0)*XC(3)+(XC(1)-4.6999999999999\\br \\tab{4}&99D0)*XC(2)+1.285714285714286D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(10)=((XC(1)-6.8D0)*XC(3)+(XC(1)-6.8D0)*XC(2)+1.6666666666666\\br \\tab{4}&67D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(11)=((XC(1)-8.299999999999999D0)*XC(3)+(XC(1)-8.299999999999\\br \\tab{4}&999D0)*XC(2)+2.2D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(12)=((XC(1)-10.6D0)*XC(3)+(XC(1)-10.6D0)*XC(2)+3.0D0)/(XC(3)\\br \\tab{4}&+XC(2))\\br \\tab{5}FVECC(13)=((XC(1)-1.34D0)*XC(3)+(XC(1)-1.34D0)*XC(2)+4.33333333333\\br \\tab{4}&3333D0)/(XC(3)+XC(2))\\br \\tab{5}FVECC(14)=((XC(1)-2.1D0)*XC(3)+(XC(1)-2.1D0)*XC(2)+7.0D0)/(XC(3)+X\\br \\tab{4}&C(2))\\br \\tab{5}FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3\\br \\tab{4}&)+XC(2))\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE XC)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-85 -1486) -((|constructor| (NIL "\\spadtype{Asp55} produces Fortran for Type 55 ASPs,{} needed for NAG routines e04dgf and e04ucf,{} for example: \\blankline \\tab{5}SUBROUTINE CONFUN(MODE,{}NCNLN,{}\\spad{N},{}NROWJ,{}NEEDC,{}\\spad{X},{}\\spad{C},{}CJAC,{}NSTATE,{}IUSER\\spad{\\br} \\tab{4}&,{}USER)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{C}(NCNLN),{}\\spad{X}(\\spad{N}),{}CJAC(NROWJ,{}\\spad{N}),{}USER(*)\\spad{\\br} \\tab{5}INTEGER \\spad{N},{}IUSER(*),{}NEEDC(NCNLN),{}NROWJ,{}MODE,{}NCNLN,{}NSTATE\\spad{\\br} \\tab{5}IF(NEEDC(1).\\spad{GT}.0)THEN\\spad{\\br} \\tab{7}\\spad{C}(1)\\spad{=X}(6)**2+X(1)\\spad{**2}\\spad{\\br} \\tab{7}CJAC(1,{}1)\\spad{=2}.0D0*X(1)\\spad{\\br} \\tab{7}CJAC(1,{}2)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(1,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(1,{}4)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(1,{}5)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(1,{}6)\\spad{=2}.0D0*X(6)\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}IF(NEEDC(2).\\spad{GT}.0)THEN\\spad{\\br} \\tab{7}\\spad{C}(2)\\spad{=X}(2)**2+(\\spad{-2}.0D0*X(1)\\spad{*X}(2))\\spad{+X}(1)\\spad{**2}\\spad{\\br} \\tab{7}CJAC(2,{}1)=(\\spad{-2}.0D0*X(2))\\spad{+2}.0D0*X(1)\\spad{\\br} \\tab{7}CJAC(2,{}2)\\spad{=2}.0D0*X(2)+(\\spad{-2}.0D0*X(1))\\spad{\\br} \\tab{7}CJAC(2,{}3)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(2,{}4)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(2,{}5)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(2,{}6)\\spad{=0}.0D0\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}IF(NEEDC(3).\\spad{GT}.0)THEN\\spad{\\br} \\tab{7}\\spad{C}(3)\\spad{=X}(3)**2+(\\spad{-2}.0D0*X(1)\\spad{*X}(3))\\spad{+X}(2)**2+X(1)\\spad{**2}\\spad{\\br} \\tab{7}CJAC(3,{}1)=(\\spad{-2}.0D0*X(3))\\spad{+2}.0D0*X(1)\\spad{\\br} \\tab{7}CJAC(3,{}2)\\spad{=2}.0D0*X(2)\\spad{\\br} \\tab{7}CJAC(3,{}3)\\spad{=2}.0D0*X(3)+(\\spad{-2}.0D0*X(1))\\spad{\\br} \\tab{7}CJAC(3,{}4)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(3,{}5)\\spad{=0}.0D0\\spad{\\br} \\tab{7}CJAC(3,{}6)\\spad{=0}.0D0\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-85 -2798) +((|constructor| (NIL "\\spadtype{Asp55} produces Fortran for Type 55 ASPs, needed for NAG routines e04dgf and e04ucf, for example: \\blankline \\tab{5}SUBROUTINE CONFUN(MODE,NCNLN,N,NROWJ,NEEDC,X,C,CJAC,NSTATE,IUSER\\br \\tab{4}&,USER)\\br \\tab{5}DOUBLE PRECISION C(NCNLN),X(N),CJAC(NROWJ,N),USER(*)\\br \\tab{5}INTEGER N,IUSER(*),NEEDC(NCNLN),NROWJ,MODE,NCNLN,NSTATE\\br \\tab{5}IF(NEEDC(1).GT.0)THEN\\br \\tab{7}C(1)=X(6)**2+X(1)**2\\br \\tab{7}CJAC(1,1)=2.0D0*X(1)\\br \\tab{7}CJAC(1,2)=0.0D0\\br \\tab{7}CJAC(1,3)=0.0D0\\br \\tab{7}CJAC(1,4)=0.0D0\\br \\tab{7}CJAC(1,5)=0.0D0\\br \\tab{7}CJAC(1,6)=2.0D0*X(6)\\br \\tab{5}ENDIF\\br \\tab{5}IF(NEEDC(2).GT.0)THEN\\br \\tab{7}C(2)=X(2)**2+(-2.0D0*X(1)*X(2))+X(1)**2\\br \\tab{7}CJAC(2,1)=(-2.0D0*X(2))+2.0D0*X(1)\\br \\tab{7}CJAC(2,2)=2.0D0*X(2)+(-2.0D0*X(1))\\br \\tab{7}CJAC(2,3)=0.0D0\\br \\tab{7}CJAC(2,4)=0.0D0\\br \\tab{7}CJAC(2,5)=0.0D0\\br \\tab{7}CJAC(2,6)=0.0D0\\br \\tab{5}ENDIF\\br \\tab{5}IF(NEEDC(3).GT.0)THEN\\br \\tab{7}C(3)=X(3)**2+(-2.0D0*X(1)*X(3))+X(2)**2+X(1)**2\\br \\tab{7}CJAC(3,1)=(-2.0D0*X(3))+2.0D0*X(1)\\br \\tab{7}CJAC(3,2)=2.0D0*X(2)\\br \\tab{7}CJAC(3,3)=2.0D0*X(3)+(-2.0D0*X(1))\\br \\tab{7}CJAC(3,4)=0.0D0\\br \\tab{7}CJAC(3,5)=0.0D0\\br \\tab{7}CJAC(3,6)=0.0D0\\br \\tab{5}ENDIF\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-86 -1486) -((|constructor| (NIL "\\spadtype{Asp6} produces Fortran for Type 6 ASPs,{} needed for NAG routines c05nbf,{} c05ncf. These represent vectors of functions of \\spad{X}(\\spad{i}) and look like: \\blankline \\tab{5}SUBROUTINE \\spad{FCN}(\\spad{N},{}\\spad{X},{}FVEC,{}IFLAG) \\tab{5}DOUBLE PRECISION \\spad{X}(\\spad{N}),{}FVEC(\\spad{N}) \\tab{5}INTEGER \\spad{N},{}IFLAG \\tab{5}FVEC(1)=(\\spad{-2}.0D0*X(2))+(\\spad{-2}.0D0*X(1)\\spad{**2})\\spad{+3}.0D0*X(1)\\spad{+1}.0D0 \\tab{5}FVEC(2)=(\\spad{-2}.0D0*X(3))+(\\spad{-2}.0D0*X(2)\\spad{**2})\\spad{+3}.0D0*X(2)+(\\spad{-1}.0D0*X(1))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(3)=(\\spad{-2}.0D0*X(4))+(\\spad{-2}.0D0*X(3)\\spad{**2})\\spad{+3}.0D0*X(3)+(\\spad{-1}.0D0*X(2))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(4)=(\\spad{-2}.0D0*X(5))+(\\spad{-2}.0D0*X(4)\\spad{**2})\\spad{+3}.0D0*X(4)+(\\spad{-1}.0D0*X(3))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(5)=(\\spad{-2}.0D0*X(6))+(\\spad{-2}.0D0*X(5)\\spad{**2})\\spad{+3}.0D0*X(5)+(\\spad{-1}.0D0*X(4))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(6)=(\\spad{-2}.0D0*X(7))+(\\spad{-2}.0D0*X(6)\\spad{**2})\\spad{+3}.0D0*X(6)+(\\spad{-1}.0D0*X(5))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(7)=(\\spad{-2}.0D0*X(8))+(\\spad{-2}.0D0*X(7)\\spad{**2})\\spad{+3}.0D0*X(7)+(\\spad{-1}.0D0*X(6))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(8)=(\\spad{-2}.0D0*X(9))+(\\spad{-2}.0D0*X(8)\\spad{**2})\\spad{+3}.0D0*X(8)+(\\spad{-1}.0D0*X(7))\\spad{+1}. \\tab{4}\\spad{&0D0} \\tab{5}FVEC(9)=(\\spad{-2}.0D0*X(9)\\spad{**2})\\spad{+3}.0D0*X(9)+(\\spad{-1}.0D0*X(8))\\spad{+1}.0D0 \\tab{5}RETURN \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-86 -2798) +((|constructor| (NIL "\\spadtype{Asp6} produces Fortran for Type 6 ASPs, needed for NAG routines c05nbf, c05ncf. These represent vectors of functions of X(i) and look like: \\blankline \\tab{5}SUBROUTINE FCN(N,X,FVEC,IFLAG) \\tab{5}DOUBLE PRECISION X(N),FVEC(N) \\tab{5}INTEGER N,IFLAG \\tab{5}FVEC(1)=(-2.0D0*X(2))+(-2.0D0*X(1)**2)+3.0D0*X(1)+1.0D0 \\tab{5}FVEC(2)=(-2.0D0*X(3))+(-2.0D0*X(2)**2)+3.0D0*X(2)+(-1.0D0*X(1))+1. \\tab{4}&0D0 \\tab{5}FVEC(3)=(-2.0D0*X(4))+(-2.0D0*X(3)**2)+3.0D0*X(3)+(-1.0D0*X(2))+1. \\tab{4}&0D0 \\tab{5}FVEC(4)=(-2.0D0*X(5))+(-2.0D0*X(4)**2)+3.0D0*X(4)+(-1.0D0*X(3))+1. \\tab{4}&0D0 \\tab{5}FVEC(5)=(-2.0D0*X(6))+(-2.0D0*X(5)**2)+3.0D0*X(5)+(-1.0D0*X(4))+1. \\tab{4}&0D0 \\tab{5}FVEC(6)=(-2.0D0*X(7))+(-2.0D0*X(6)**2)+3.0D0*X(6)+(-1.0D0*X(5))+1. \\tab{4}&0D0 \\tab{5}FVEC(7)=(-2.0D0*X(8))+(-2.0D0*X(7)**2)+3.0D0*X(7)+(-1.0D0*X(6))+1. \\tab{4}&0D0 \\tab{5}FVEC(8)=(-2.0D0*X(9))+(-2.0D0*X(8)**2)+3.0D0*X(8)+(-1.0D0*X(7))+1. \\tab{4}&0D0 \\tab{5}FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0 \\tab{5}RETURN \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct|) (|construct| (QUOTE X)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-87 -1486) -((|constructor| (NIL "\\spadtype{Asp73} produces Fortran for Type 73 ASPs,{} needed for NAG routine d03eef,{} for example: \\blankline \\tab{5}SUBROUTINE PDEF(\\spad{X},{}\\spad{Y},{}ALPHA,{}BETA,{}GAMMA,{}DELTA,{}EPSOLN,{}PHI,{}PSI)\\spad{\\br} \\tab{5}DOUBLE PRECISION ALPHA,{}EPSOLN,{}PHI,{}\\spad{X},{}\\spad{Y},{}BETA,{}DELTA,{}GAMMA,{}PSI\\spad{\\br} \\tab{5}ALPHA=DSIN(\\spad{X})\\spad{\\br} \\tab{5}BETA=Y\\spad{\\br} \\tab{5}GAMMA=X*Y\\spad{\\br} \\tab{5}DELTA=DCOS(\\spad{X})*DSIN(\\spad{Y})\\spad{\\br} \\tab{5}EPSOLN=Y+X\\spad{\\br} \\tab{5}PHI=X\\spad{\\br} \\tab{5}PSI=Y\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X) (QUOTE Y)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-87 -2798) +((|constructor| (NIL "\\spadtype{Asp73} produces Fortran for Type 73 ASPs, needed for NAG routine d03eef, for example: \\blankline \\tab{5}SUBROUTINE PDEF(X,Y,ALPHA,BETA,GAMMA,DELTA,EPSOLN,PHI,PSI)\\br \\tab{5}DOUBLE PRECISION ALPHA,EPSOLN,PHI,X,Y,BETA,DELTA,GAMMA,PSI\\br \\tab{5}ALPHA=DSIN(X)\\br \\tab{5}BETA=Y\\br \\tab{5}GAMMA=X*Y\\br \\tab{5}DELTA=DCOS(X)*DSIN(Y)\\br \\tab{5}EPSOLN=Y+X\\br \\tab{5}PHI=X\\br \\tab{5}PSI=Y\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X) (QUOTE Y)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-88 -1486) -((|constructor| (NIL "\\spadtype{Asp74} produces Fortran for Type 74 ASPs,{} needed for NAG routine d03eef,{} for example: \\blankline \\tab{5} SUBROUTINE BNDY(\\spad{X},{}\\spad{Y},{}A,{}\\spad{B},{}\\spad{C},{}IBND)\\spad{\\br} \\tab{5} DOUBLE PRECISION A,{}\\spad{B},{}\\spad{C},{}\\spad{X},{}\\spad{Y}\\spad{\\br} \\tab{5} INTEGER IBND\\spad{\\br} \\tab{5} IF(IBND.EQ.0)THEN\\spad{\\br} \\tab{7} \\spad{A=0}.0D0\\spad{\\br} \\tab{7} \\spad{B=1}.0D0\\spad{\\br} \\tab{7} \\spad{C=}-1.0D0*DSIN(\\spad{X})\\spad{\\br} \\tab{5} ELSEIF(IBND.EQ.1)THEN\\spad{\\br} \\tab{7} \\spad{A=1}.0D0\\spad{\\br} \\tab{7} \\spad{B=0}.0D0\\spad{\\br} \\tab{7} C=DSIN(\\spad{X})*DSIN(\\spad{Y})\\spad{\\br} \\tab{5} ELSEIF(IBND.EQ.2)THEN\\spad{\\br} \\tab{7} \\spad{A=1}.0D0\\spad{\\br} \\tab{7} \\spad{B=0}.0D0\\spad{\\br} \\tab{7} C=DSIN(\\spad{X})*DSIN(\\spad{Y})\\spad{\\br} \\tab{5} ELSEIF(IBND.EQ.3)THEN\\spad{\\br} \\tab{7} \\spad{A=0}.0D0\\spad{\\br} \\tab{7} \\spad{B=1}.0D0\\spad{\\br} \\tab{7} \\spad{C=}-1.0D0*DSIN(\\spad{Y})\\spad{\\br} \\tab{5} ENDIF\\spad{\\br} \\tab{5} END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE X) (QUOTE Y)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-88 -2798) +((|constructor| (NIL "\\spadtype{Asp74} produces Fortran for Type 74 ASPs, needed for NAG routine d03eef, for example: \\blankline \\tab{5} SUBROUTINE BNDY(X,Y,A,B,C,IBND)\\br \\tab{5} DOUBLE PRECISION A,B,C,X,Y\\br \\tab{5} INTEGER IBND\\br \\tab{5} IF(IBND.EQ.0)THEN\\br \\tab{7} A=0.0D0\\br \\tab{7} B=1.0D0\\br \\tab{7} C=-1.0D0*DSIN(X)\\br \\tab{5} ELSEIF(IBND.EQ.1)THEN\\br \\tab{7} A=1.0D0\\br \\tab{7} B=0.0D0\\br \\tab{7} C=DSIN(X)*DSIN(Y)\\br \\tab{5} ELSEIF(IBND.EQ.2)THEN\\br \\tab{7} A=1.0D0\\br \\tab{7} B=0.0D0\\br \\tab{7} C=DSIN(X)*DSIN(Y)\\br \\tab{5} ELSEIF(IBND.EQ.3)THEN\\br \\tab{7} A=0.0D0\\br \\tab{7} B=1.0D0\\br \\tab{7} C=-1.0D0*DSIN(Y)\\br \\tab{5} ENDIF\\br \\tab{5} END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE X) (QUOTE Y)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-89 -1486) -((|constructor| (NIL "\\spadtype{Asp77} produces Fortran for Type 77 ASPs,{} needed for NAG routine d02gbf,{} for example: \\blankline \\tab{5}SUBROUTINE FCNF(\\spad{X},{}\\spad{F})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X}\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{F}(2,{}2)\\spad{\\br} \\tab{5}\\spad{F}(1,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(1,{}2)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2,{}1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{F}(2,{}2)=-10.0D0\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-89 -2798) +((|constructor| (NIL "\\spadtype{Asp77} produces Fortran for Type 77 ASPs, needed for NAG routine d02gbf, for example: \\blankline \\tab{5}SUBROUTINE FCNF(X,F)\\br \\tab{5}DOUBLE PRECISION X\\br \\tab{5}DOUBLE PRECISION F(2,2)\\br \\tab{5}F(1,1)=0.0D0\\br \\tab{5}F(1,2)=1.0D0\\br \\tab{5}F(2,1)=0.0D0\\br \\tab{5}F(2,2)=-10.0D0\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-90 -1486) -((|constructor| (NIL "\\spadtype{Asp78} produces Fortran for Type 78 ASPs,{} needed for NAG routine d02gbf,{} for example: \\blankline \\tab{5}SUBROUTINE FCNG(\\spad{X},{}\\spad{G})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{G}(*),{}\\spad{X}\\spad{\\br} \\tab{5}\\spad{G}(1)\\spad{=0}.0D0\\spad{\\br} \\tab{5}\\spad{G}(2)\\spad{=0}.0D0\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-90 -2798) +((|constructor| (NIL "\\spadtype{Asp78} produces Fortran for Type 78 ASPs, needed for NAG routine d02gbf, for example: \\blankline \\tab{5}SUBROUTINE FCNG(X,G)\\br \\tab{5}DOUBLE PRECISION G(*),X\\br \\tab{5}G(1)=0.0D0\\br \\tab{5}G(2)=0.0D0\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-91 -1486) -((|constructor| (NIL "\\spadtype{Asp7} produces Fortran for Type 7 ASPs,{} needed for NAG routines d02bbf,{} d02gaf. These represent a vector of functions of the scalar \\spad{X} and the array \\spad{Z},{} and look like: \\blankline \\tab{5}SUBROUTINE \\spad{FCN}(\\spad{X},{}\\spad{Z},{}\\spad{F})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{F}(*),{}\\spad{X},{}\\spad{Z}(*)\\spad{\\br} \\tab{5}\\spad{F}(1)=DTAN(\\spad{Z}(3))\\spad{\\br} \\tab{5}\\spad{F}(2)=((\\spad{-0}.03199999999999999D0*DCOS(\\spad{Z}(3))*DTAN(\\spad{Z}(3)))+(\\spad{-0}.02D0*Z(2)\\spad{\\br} \\tab{4}\\spad{&**2}))/(\\spad{Z}(2)*DCOS(\\spad{Z}(3)))\\spad{\\br} \\tab{5}\\spad{F}(3)=-0.03199999999999999D0/(\\spad{X*Z}(2)\\spad{**2})\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-91 -2798) +((|constructor| (NIL "\\spadtype{Asp7} produces Fortran for Type 7 ASPs, needed for NAG routines d02bbf, d02gaf. These represent a vector of functions of the scalar \\spad{X} and the array \\spad{Z,} and look like: \\blankline \\tab{5}SUBROUTINE FCN(X,Z,F)\\br \\tab{5}DOUBLE PRECISION F(*),X,Z(*)\\br \\tab{5}F(1)=DTAN(Z(3))\\br \\tab{5}F(2)=((-0.03199999999999999D0*DCOS(Z(3))*DTAN(Z(3)))+(-0.02D0*Z(2)\\br \\tab{4}&**2))/(Z(2)*DCOS(Z(3)))\\br \\tab{5}F(3)=-0.03199999999999999D0/(X*Z(2)**2)\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Vector| (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-92 -1486) -((|constructor| (NIL "\\spadtype{Asp80} produces Fortran for Type 80 ASPs,{} needed for NAG routine d02kef,{} for example: \\blankline \\tab{5}SUBROUTINE BDYVAL(\\spad{XL},{}\\spad{XR},{}ELAM,{}\\spad{YL},{}\\spad{YR})\\spad{\\br} \\tab{5}DOUBLE PRECISION ELAM,{}\\spad{XL},{}\\spad{YL}(3),{}\\spad{XR},{}\\spad{YR}(3)\\spad{\\br} \\tab{5}\\spad{YL}(1)\\spad{=XL}\\spad{\\br} \\tab{5}\\spad{YL}(2)\\spad{=2}.0D0\\spad{\\br} \\tab{5}\\spad{YR}(1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}\\spad{YR}(2)=-1.0D0*DSQRT(\\spad{XR+}(\\spad{-1}.0D0*ELAM))\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE XL) (QUOTE XR) (QUOTE ELAM)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) +(-92 -2798) +((|constructor| (NIL "\\spadtype{Asp80} produces Fortran for Type 80 ASPs, needed for NAG routine d02kef, for example: \\blankline \\tab{5}SUBROUTINE BDYVAL(XL,XR,ELAM,YL,YR)\\br \\tab{5}DOUBLE PRECISION ELAM,XL,YL(3),XR,YR(3)\\br \\tab{5}YL(1)=XL\\br \\tab{5}YL(2)=2.0D0\\br \\tab{5}YR(1)=1.0D0\\br \\tab{5}YR(2)=-1.0D0*DSQRT(XR+(-1.0D0*ELAM))\\br \\tab{5}RETURN\\br \\tab{5}END")) (|coerce| (($ (|Matrix| (|FortranExpression| (|construct| (QUOTE XL) (QUOTE XR) (QUOTE ELAM)) (|construct|) (|MachineFloat|)))) "\\spad{coerce(f)} takes objects from the appropriate instantiation of \\spadtype{FortranExpression} and turns them into an ASP."))) NIL NIL -(-93 -1486) -((|constructor| (NIL "\\spadtype{Asp8} produces Fortran for Type 8 ASPs,{} needed for NAG routine d02bbf. This ASP prints intermediate values of the computed solution of an ODE and might look like: \\blankline \\tab{5}SUBROUTINE OUTPUT(XSOL,{}\\spad{Y},{}COUNT,{}\\spad{M},{}\\spad{N},{}RESULT,{}FORWRD)\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{Y}(\\spad{N}),{}RESULT(\\spad{M},{}\\spad{N}),{}XSOL\\spad{\\br} \\tab{5}INTEGER \\spad{M},{}\\spad{N},{}COUNT\\spad{\\br} \\tab{5}LOGICAL FORWRD\\spad{\\br} \\tab{5}DOUBLE PRECISION X02ALF,{}POINTS(8)\\spad{\\br} \\tab{5}EXTERNAL X02ALF\\spad{\\br} \\tab{5}INTEGER \\spad{I}\\spad{\\br} \\tab{5}POINTS(1)\\spad{=1}.0D0\\spad{\\br} \\tab{5}POINTS(2)\\spad{=2}.0D0\\spad{\\br} \\tab{5}POINTS(3)\\spad{=3}.0D0\\spad{\\br} \\tab{5}POINTS(4)\\spad{=4}.0D0\\spad{\\br} \\tab{5}POINTS(5)\\spad{=5}.0D0\\spad{\\br} \\tab{5}POINTS(6)\\spad{=6}.0D0\\spad{\\br} \\tab{5}POINTS(7)\\spad{=7}.0D0\\spad{\\br} \\tab{5}POINTS(8)\\spad{=8}.0D0\\spad{\\br} \\tab{5}\\spad{COUNT=COUNT+1}\\spad{\\br} \\tab{5}DO 25001 \\spad{I=1},{}\\spad{N}\\spad{\\br} \\tab{7} RESULT(COUNT,{}\\spad{I})\\spad{=Y}(\\spad{I})\\spad{\\br} 25001 CONTINUE\\spad{\\br} \\tab{5}IF(COUNT.EQ.\\spad{M})THEN\\spad{\\br} \\tab{7}IF(FORWRD)THEN\\spad{\\br} \\tab{9}XSOL=X02ALF()\\spad{\\br} \\tab{7}ELSE\\spad{\\br} \\tab{9}XSOL=-X02ALF()\\spad{\\br} \\tab{7}ENDIF\\spad{\\br} \\tab{5}ELSE\\spad{\\br} \\tab{7} XSOL=POINTS(COUNT)\\spad{\\br} \\tab{5}ENDIF\\spad{\\br} \\tab{5}END"))) +(-93 -2798) +((|constructor| (NIL "\\spadtype{Asp8} produces Fortran for Type 8 ASPs, needed for NAG routine d02bbf. This ASP prints intermediate values of the computed solution of an ODE and might look like: \\blankline \\tab{5}SUBROUTINE OUTPUT(XSOL,Y,COUNT,M,N,RESULT,FORWRD)\\br \\tab{5}DOUBLE PRECISION Y(N),RESULT(M,N),XSOL\\br \\tab{5}INTEGER M,N,COUNT\\br \\tab{5}LOGICAL FORWRD\\br \\tab{5}DOUBLE PRECISION X02ALF,POINTS(8)\\br \\tab{5}EXTERNAL X02ALF\\br \\tab{5}INTEGER I\\br \\tab{5}POINTS(1)=1.0D0\\br \\tab{5}POINTS(2)=2.0D0\\br \\tab{5}POINTS(3)=3.0D0\\br \\tab{5}POINTS(4)=4.0D0\\br \\tab{5}POINTS(5)=5.0D0\\br \\tab{5}POINTS(6)=6.0D0\\br \\tab{5}POINTS(7)=7.0D0\\br \\tab{5}POINTS(8)=8.0D0\\br \\tab{5}COUNT=COUNT+1\\br \\tab{5}DO 25001 I=1,N\\br \\tab{7} RESULT(COUNT,I)=Y(I)\\br 25001 CONTINUE\\br \\tab{5}IF(COUNT.EQ.M)THEN\\br \\tab{7}IF(FORWRD)THEN\\br \\tab{9}XSOL=X02ALF()\\br \\tab{7}ELSE\\br \\tab{9}XSOL=-X02ALF()\\br \\tab{7}ENDIF\\br \\tab{5}ELSE\\br \\tab{7} XSOL=POINTS(COUNT)\\br \\tab{5}ENDIF\\br \\tab{5}END"))) NIL NIL -(-94 -1486) -((|constructor| (NIL "\\spadtype{Asp9} produces Fortran for Type 9 ASPs,{} needed for NAG routines d02bhf,{} d02cjf,{} d02ejf. These ASPs represent a function of a scalar \\spad{X} and a vector \\spad{Y},{} for example: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION \\spad{G}(\\spad{X},{}\\spad{Y})\\spad{\\br} \\tab{5}DOUBLE PRECISION \\spad{X},{}\\spad{Y}(*)\\spad{\\br} \\tab{5}G=X+Y(1)\\spad{\\br} \\tab{5}RETURN\\spad{\\br} \\tab{5}END \\blankline If the user provides a constant value for \\spad{G},{} then extra information is added via COMMON blocks used by certain routines. This specifies that the value returned by \\spad{G} in this case is to be ignored.")) (|coerce| (($ (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) +(-94 -2798) +((|constructor| (NIL "\\spadtype{Asp9} produces Fortran for Type 9 ASPs, needed for NAG routines d02bhf, d02cjf, d02ejf. These ASPs represent a function of a scalar \\spad{X} and a vector \\spad{Y,} for example: \\blankline \\tab{5}DOUBLE PRECISION FUNCTION G(X,Y)\\br \\tab{5}DOUBLE PRECISION X,Y(*)\\br \\tab{5}G=X+Y(1)\\br \\tab{5}RETURN\\br \\tab{5}END \\blankline If the user provides a constant value for \\spad{G,} then extra information is added via COMMON blocks used by certain routines. This specifies that the value returned by \\spad{G} in this case is to be ignored.")) (|coerce| (($ (|FortranExpression| (|construct| (QUOTE X)) (|construct| (QUOTE Y)) (|MachineFloat|))) "\\spad{coerce(f)} takes an object from the appropriate instantiation of \\spadtype{FortranExpression} and turns it into an ASP."))) NIL NIL (-95 R L) -((|constructor| (NIL "\\spadtype{AssociatedEquations} provides functions to compute the associated equations needed for factoring operators")) (|associatedEquations| (((|Record| (|:| |minor| (|List| (|PositiveInteger|))) (|:| |eq| |#2|) (|:| |minors| (|List| (|List| (|PositiveInteger|)))) (|:| |ops| (|List| |#2|))) |#2| (|PositiveInteger|)) "\\spad{associatedEquations(op,{} m)} returns \\spad{[w,{} eq,{} lw,{} lop]} such that \\spad{eq(w) = 0} where \\spad{w} is the given minor,{} and \\spad{lw_i = lop_i(w)} for all the other minors.")) (|uncouplingMatrices| (((|Vector| (|Matrix| |#1|)) (|Matrix| |#1|)) "\\spad{uncouplingMatrices(M)} returns \\spad{[A_1,{}...,{}A_n]} such that if \\spad{y = [y_1,{}...,{}y_n]} is a solution of \\spad{y' = M y},{} then \\spad{[\\$y_j',{}y_j'',{}...,{}y_j^{(n)}\\$] = \\$A_j y\\$} for all \\spad{j}\\spad{'s}.")) (|associatedSystem| (((|Record| (|:| |mat| (|Matrix| |#1|)) (|:| |vec| (|Vector| (|List| (|PositiveInteger|))))) |#2| (|PositiveInteger|)) "\\spad{associatedSystem(op,{} m)} returns \\spad{[M,{}w]} such that the \\spad{m}-th associated equation system to \\spad{L} is \\spad{w' = M w}."))) +((|constructor| (NIL "\\spadtype{AssociatedEquations} provides functions to compute the associated equations needed for factoring operators")) (|associatedEquations| (((|Record| (|:| |minor| (|List| (|PositiveInteger|))) (|:| |eq| |#2|) (|:| |minors| (|List| (|List| (|PositiveInteger|)))) (|:| |ops| (|List| |#2|))) |#2| (|PositiveInteger|)) "\\spad{associatedEquations(op, \\spad{m)}} returns \\spad{[w, eq, \\spad{lw,} lop]} such that \\spad{eq(w) = 0} where \\spad{w} is the given minor, and \\spad{lw_i = lop_i(w)} for all the other minors.")) (|uncouplingMatrices| (((|Vector| (|Matrix| |#1|)) (|Matrix| |#1|)) "\\spad{uncouplingMatrices(M)} returns \\spad{[A_1,...,A_n]} such that if \\spad{y = [y_1,...,y_n]} is a solution of \\spad{y' = \\spad{M} \\spad{y},} then \\spad{[$y_j',y_j'',...,y_j^{(n)}$] = $A_j \\spad{y$}} for all j's.")) (|associatedSystem| (((|Record| (|:| |mat| (|Matrix| |#1|)) (|:| |vec| (|Vector| (|List| (|PositiveInteger|))))) |#2| (|PositiveInteger|)) "\\spad{associatedSystem(op, \\spad{m)}} returns \\spad{[M,w]} such that the \\spad{m}-th associated equation system to \\spad{L} is \\spad{w' = \\spad{M} \\spad{w}.}"))) NIL ((|HasCategory| |#1| (QUOTE (-366)))) (-96 S) -((|constructor| (NIL "A stack represented as a flexible array.")) (|member?| (((|Boolean|) |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} member?(3,{}a)")) (|members| (((|List| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} members a")) (|parts| (((|List| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} parts a")) (|#| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} \\#a")) (|count| (((|NonNegativeInteger|) |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} count(4,{}a)") (((|NonNegativeInteger|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} count(\\spad{x+}->(\\spad{x>2}),{}a)")) (|any?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} any?(\\spad{x+}->(\\spad{x=4}),{}a)")) (|every?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} every?(\\spad{x+}->(\\spad{x=4}),{}a)")) (~= (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} b:=copy a \\spad{X} (a~=b)")) (= (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} b:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} (a=b)@Boolean")) (|coerce| (((|OutputForm|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} coerce a")) (|hash| (((|SingleInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} hash a")) (|latex| (((|String|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} latex a")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} map!(\\spad{x+}-\\spad{>x+10},{}a) \\spad{X} a")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} map(\\spad{x+}-\\spad{>x+10},{}a) \\spad{X} a")) (|eq?| (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} b:=copy a \\spad{X} eq?(a,{}\\spad{b})")) (|copy| (($ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} copy a")) (|sample| (($) "\\blankline \\spad{X} sample()\\$ArrayStack(INT)")) (|empty| (($) "\\blankline \\spad{X} b:=empty()\\$(ArrayStack INT)")) (|empty?| (((|Boolean|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} empty? a")) (|bag| (($ (|List| |#1|)) "\\blankline \\spad{X} bag([1,{}2,{}3,{}4,{}5])\\$ArrayStack(INT)")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} size?(a,{}5)")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} more?(a,{}9)")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} less?(a,{}9)")) (|depth| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} depth a")) (|top| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} top a")) (|inspect| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} inspect a")) (|insert!| (($ |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} insert!(8,{}a) \\spad{X} a")) (|push!| ((|#1| |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} push!(9,{}a) \\spad{X} a")) (|extract!| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} extract! a \\spad{X} a")) (|pop!| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5] \\spad{X} pop! a \\spad{X} a")) (|arrayStack| (($ (|List| |#1|)) "\\indented{1}{arrayStack([\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]) creates an array stack with first (top)} \\indented{1}{element \\spad{x},{} second element \\spad{y},{}...,{}and last element \\spad{z}.} \\blankline \\spad{E} c:ArrayStack INT:= arrayStack [1,{}2,{}3,{}4,{}5]"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "A stack represented as a flexible array.")) (|member?| (((|Boolean|) |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} member?(3,a)")) (|members| (((|List| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} members a")) (|parts| (((|List| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} parts a")) (|#| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} \\#a")) (|count| (((|NonNegativeInteger|) |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} count(4,a)") (((|NonNegativeInteger|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} count(x+->(x>2),a)")) (|any?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} any?(x+->(x=4),a)")) (|every?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} every?(x+->(x=4),a)")) (~= (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} b:=copy a \\spad{X} (a~=b)")) (= (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} b:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} (a=b)@Boolean")) (|coerce| (((|OutputForm|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} coerce a")) (|hash| (((|SingleInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} hash a")) (|latex| (((|String|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} latex a")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} map!(x+->x+10,a) \\spad{X} a")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} map(x+->x+10,a) \\spad{X} a")) (|eq?| (((|Boolean|) $ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} b:=copy a \\spad{X} eq?(a,b)")) (|copy| (($ $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} copy a")) (|sample| (($) "\\blankline \\spad{X} sample()$ArrayStack(INT)")) (|empty| (($) "\\blankline \\spad{X} b:=empty()$(ArrayStack INT)")) (|empty?| (((|Boolean|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} empty? a")) (|bag| (($ (|List| |#1|)) "\\blankline \\spad{X} bag([1,2,3,4,5])$ArrayStack(INT)")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} size?(a,5)")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} more?(a,9)")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} less?(a,9)")) (|depth| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} depth a")) (|top| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} top a")) (|inspect| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} inspect a")) (|insert!| (($ |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} insert!(8,a) \\spad{X} a")) (|push!| ((|#1| |#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} push!(9,a) \\spad{X} a")) (|extract!| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} extract! a \\spad{X} a")) (|pop!| ((|#1| $) "\\blankline \\spad{X} a:ArrayStack INT:= arrayStack [1,2,3,4,5] \\spad{X} pop! a \\spad{X} a")) (|arrayStack| (($ (|List| |#1|)) "\\indented{1}{arrayStack([x,y,...,z]) creates an array stack with first (top)} \\indented{1}{element \\spad{x,} second element y,...,and last element \\spad{z.}} \\blankline \\spad{E} c:ArrayStack INT:= arrayStack [1,2,3,4,5]"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-97 S) -((|constructor| (NIL "Category for the inverse trigonometric functions.")) (|atan| (($ $) "\\spad{atan(x)} returns the arc-tangent of \\spad{x}.")) (|asin| (($ $) "\\spad{asin(x)} returns the arc-sine of \\spad{x}.")) (|asec| (($ $) "\\spad{asec(x)} returns the arc-secant of \\spad{x}.")) (|acsc| (($ $) "\\spad{acsc(x)} returns the arc-cosecant of \\spad{x}.")) (|acot| (($ $) "\\spad{acot(x)} returns the arc-cotangent of \\spad{x}.")) (|acos| (($ $) "\\spad{acos(x)} returns the arc-cosine of \\spad{x}."))) +((|constructor| (NIL "Category for the inverse trigonometric functions.")) (|atan| (($ $) "\\spad{atan(x)} returns the arc-tangent of \\spad{x.}")) (|asin| (($ $) "\\spad{asin(x)} returns the arc-sine of \\spad{x.}")) (|asec| (($ $) "\\spad{asec(x)} returns the arc-secant of \\spad{x.}")) (|acsc| (($ $) "\\spad{acsc(x)} returns the arc-cosecant of \\spad{x.}")) (|acot| (($ $) "\\spad{acot(x)} returns the arc-cotangent of \\spad{x.}")) (|acos| (($ $) "\\spad{acos(x)} returns the arc-cosine of \\spad{x.}"))) NIL NIL (-98) -((|constructor| (NIL "Category for the inverse trigonometric functions.")) (|atan| (($ $) "\\spad{atan(x)} returns the arc-tangent of \\spad{x}.")) (|asin| (($ $) "\\spad{asin(x)} returns the arc-sine of \\spad{x}.")) (|asec| (($ $) "\\spad{asec(x)} returns the arc-secant of \\spad{x}.")) (|acsc| (($ $) "\\spad{acsc(x)} returns the arc-cosecant of \\spad{x}.")) (|acot| (($ $) "\\spad{acot(x)} returns the arc-cotangent of \\spad{x}.")) (|acos| (($ $) "\\spad{acos(x)} returns the arc-cosine of \\spad{x}."))) +((|constructor| (NIL "Category for the inverse trigonometric functions.")) (|atan| (($ $) "\\spad{atan(x)} returns the arc-tangent of \\spad{x.}")) (|asin| (($ $) "\\spad{asin(x)} returns the arc-sine of \\spad{x.}")) (|asec| (($ $) "\\spad{asec(x)} returns the arc-secant of \\spad{x.}")) (|acsc| (($ $) "\\spad{acsc(x)} returns the arc-cosecant of \\spad{x.}")) (|acot| (($ $) "\\spad{acot(x)} returns the arc-cotangent of \\spad{x.}")) (|acos| (($ $) "\\spad{acos(x)} returns the arc-cosine of \\spad{x.}"))) NIL NIL (-99) -((|constructor| (NIL "\\axiomType{AttributeButtons} implements a database and associated adjustment mechanisms for a set of attributes. \\blankline For ODEs these attributes are \"stiffness\",{} \"stability\" (\\spadignore{i.e.} how much affect the cosine or sine component of the solution has on the stability of the result),{} \"accuracy\" and \"expense\" (\\spadignore{i.e.} how expensive is the evaluation of the ODE). All these have bearing on the cost of calculating the solution given that reducing the step-length to achieve greater accuracy requires considerable number of evaluations and calculations. \\blankline The effect of each of these attributes can be altered by increasing or decreasing the button value. \\blankline For Integration there is a button for increasing and decreasing the preset number of function evaluations for each method. This is automatically used by ANNA when a method fails due to insufficient workspace or where the limit of function evaluations has been reached before the required accuracy is achieved.")) (|setButtonValue| (((|Float|) (|String|) (|String|) (|Float|)) "\\axiom{setButtonValue(attributeName,{}routineName,{}\\spad{n})} sets the value of the button of attribute \\spad{attributeName} to routine \\spad{routineName} to \\spad{n}. \\spad{n} must be in the range [0..1]. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|Float|)) "\\axiom{setButtonValue(attributeName,{}\\spad{n})} sets the value of all buttons of attribute \\spad{attributeName} to \\spad{n}. \\spad{n} must be in the range [0..1]. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".")) (|setAttributeButtonStep| (((|Float|) (|Float|)) "\\axiom{setAttributeButtonStep(\\spad{n})} sets the value of the steps for increasing and decreasing the button values. \\axiom{\\spad{n}} must be greater than 0 and less than 1. The preset value is 0.5.")) (|resetAttributeButtons| (((|Void|)) "\\axiom{resetAttributeButtons()} resets the Attribute buttons to a neutral level.")) (|getButtonValue| (((|Float|) (|String|) (|String|)) "\\axiom{getButtonValue(routineName,{}attributeName)} returns the current value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".")) (|decrease| (((|Float|) (|String|)) "\\axiom{decrease(attributeName)} decreases the value for the effect of the attribute \\axiom{attributeName} with all routines. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|String|)) "\\axiom{decrease(routineName,{}attributeName)} decreases the value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".")) (|increase| (((|Float|) (|String|)) "\\axiom{increase(attributeName)} increases the value for the effect of the attribute \\axiom{attributeName} with all routines. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|String|)) "\\axiom{increase(routineName,{}attributeName)} increases the value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\",{} \"stability\",{} \"accuracy\",{} \"expense\" or \"functionEvaluations\"."))) -((-4535 . T)) +((|constructor| (NIL "\\axiomType{AttributeButtons} implements a database and associated adjustment mechanisms for a set of attributes. \\blankline For ODEs these attributes are \"stiffness\", \"stability\" (\\spadignore{i.e.} how much affect the cosine or sine component of the solution has on the stability of the result), \"accuracy\" and \"expense\" (\\spadignore{i.e.} how expensive is the evaluation of the ODE). All these have bearing on the cost of calculating the solution given that reducing the step-length to achieve greater accuracy requires considerable number of evaluations and calculations. \\blankline The effect of each of these attributes can be altered by increasing or decreasing the button value. \\blankline For Integration there is a button for increasing and decreasing the preset number of function evaluations for each method. This is automatically used by ANNA when a method fails due to insufficient workspace or where the limit of function evaluations has been reached before the required accuracy is achieved.")) (|setButtonValue| (((|Float|) (|String|) (|String|) (|Float|)) "\\axiom{setButtonValue(attributeName,routineName,n)} sets the value of the button of attribute \\spad{attributeName} to routine \\spad{routineName} to \\spad{n}. \\spad{n} must be in the range [0..1]. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|Float|)) "\\axiom{setButtonValue(attributeName,n)} sets the value of all buttons of attribute \\spad{attributeName} to \\spad{n}. \\spad{n} must be in the range [0..1]. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".")) (|setAttributeButtonStep| (((|Float|) (|Float|)) "\\axiom{setAttributeButtonStep(n)} sets the value of the steps for increasing and decreasing the button values. \\axiom{n} must be greater than 0 and less than 1. The preset value is 0.5.")) (|resetAttributeButtons| (((|Void|)) "\\axiom{resetAttributeButtons()} resets the Attribute buttons to a neutral level.")) (|getButtonValue| (((|Float|) (|String|) (|String|)) "\\axiom{getButtonValue(routineName,attributeName)} returns the current value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".")) (|decrease| (((|Float|) (|String|)) "\\axiom{decrease(attributeName)} decreases the value for the effect of the attribute \\axiom{attributeName} with all routines. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|String|)) "\\axiom{decrease(routineName,attributeName)} decreases the value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".")) (|increase| (((|Float|) (|String|)) "\\axiom{increase(attributeName)} increases the value for the effect of the attribute \\axiom{attributeName} with all routines. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\".") (((|Float|) (|String|) (|String|)) "\\axiom{increase(routineName,attributeName)} increases the value for the effect of the attribute \\axiom{attributeName} with routine \\axiom{routineName}. \\blankline \\axiom{attributeName} should be one of the values \"stiffness\", \"stability\", \"accuracy\", \"expense\" or \"functionEvaluations\"."))) +((-4571 . T)) NIL (-100) -((|constructor| (NIL "This category exports the attributes in the AXIOM Library")) (|approximate| ((|attribute|) "\\spad{approximate} means \"is an approximation to the real numbers\".")) (|canonical| ((|attribute|) "\\spad{canonical} is \\spad{true} if and only if distinct elements have distinct data structures. For example,{} a domain of mathematical objects which has the \\spad{canonical} attribute means that two objects are mathematically equal if and only if their data structures are equal.")) (|multiplicativeValuation| ((|attribute|) "\\spad{multiplicativeValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}.")) (|additiveValuation| ((|attribute|) "\\spad{additiveValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)+euclideanSize(b)}.")) (|noetherian| ((|attribute|) "\\spad{noetherian} is \\spad{true} if all of its ideals are finitely generated.")) (|central| ((|attribute|) "\\spad{central} is \\spad{true} if,{} given an algebra over a ring \\spad{R},{} the image of \\spad{R} is the center of the algebra,{} \\spadignore{i.e.} the set of members of the algebra which commute with all others is precisely the image of \\spad{R} in the algebra.")) (|partiallyOrderedSet| ((|attribute|) "\\spad{partiallyOrderedSet} is \\spad{true} if a set with \\spadop{<} which is transitive,{} but \\spad{not(a < b or a = b)} does not necessarily imply \\spad{b D} which is commutative.")) (|finiteAggregate| ((|attribute|) "\\spad{finiteAggregate} is \\spad{true} if it is an aggregate with a finite number of elements."))) -((-4535 . T) ((-4537 "*") . T) (-4536 . T) (-4532 . T) (-4530 . T) (-4529 . T) (-4528 . T) (-4533 . T) (-4527 . T) (-4526 . T) (-4525 . T) (-4524 . T) (-4523 . T) (-4531 . T) (-4534 . T) (|NullSquare| . T) (|JacobiIdentity| . T) (-4522 . T) (-2994 . T)) +((|constructor| (NIL "This category exports the attributes in the AXIOM Library")) (|approximate| ((|attribute|) "\\spad{approximate} means \"is an approximation to the real numbers\".")) (|canonical| ((|attribute|) "\\spad{canonical} is \\spad{true} if and only if distinct elements have distinct data structures. For example, a domain of mathematical objects which has the \\spad{canonical} attribute means that two objects are mathematically equal if and only if their data structures are equal.")) (|multiplicativeValuation| ((|attribute|) "\\spad{multiplicativeValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)}.")) (|additiveValuation| ((|attribute|) "\\spad{additiveValuation} implies \\spad{euclideanSize(a*b)=euclideanSize(a)+euclideanSize(b)}.")) (|noetherian| ((|attribute|) "\\spad{noetherian} is \\spad{true} if all of its ideals are finitely generated.")) (|central| ((|attribute|) "\\spad{central} is \\spad{true} if, given an algebra over a ring \\spad{R,} the image of \\spad{R} is the center of the algebra, \\spadignore{i.e.} the set of members of the algebra which commute with all others is precisely the image of \\spad{R} in the algebra.")) (|partiallyOrderedSet| ((|attribute|) "\\spad{partiallyOrderedSet} is \\spad{true} if a set with \\spadop{<} which is transitive, but \\spad{not(a < \\spad{b} or a = \\spad{b)}} does not necessarily imply \\spad{b} \\spad{D}} which is commutative.")) (|finiteAggregate| ((|attribute|) "\\spad{finiteAggregate} is \\spad{true} if it is an aggregate with a finite number of elements."))) +((-4571 . T) ((-4573 "*") . T) (-4572 . T) (-4568 . T) (-4566 . T) (-4565 . T) (-4564 . T) (-4569 . T) (-4563 . T) (-4562 . T) (-4561 . T) (-4560 . T) (-4559 . T) (-4567 . T) (-4570 . T) (|NullSquare| . T) (|JacobiIdentity| . T) (-4558 . T) (-4334 . T)) NIL (-101 R) -((|constructor| (NIL "Automorphism \\spad{R} is the multiplicative group of automorphisms of \\spad{R}.")) (|morphism| (($ (|Mapping| |#1| |#1| (|Integer|))) "\\spad{morphism(f)} returns the morphism given by \\spad{f^n(x) = f(x,{}n)}.") (($ (|Mapping| |#1| |#1|) (|Mapping| |#1| |#1|)) "\\spad{morphism(f,{} g)} returns the invertible morphism given by \\spad{f},{} where \\spad{g} is the inverse of \\spad{f}..") (($ (|Mapping| |#1| |#1|)) "\\spad{morphism(f)} returns the non-invertible morphism given by \\spad{f}."))) -((-4532 . T)) +((|constructor| (NIL "Automorphism \\spad{R} is the multiplicative group of automorphisms of \\spad{R.}")) (|morphism| (($ (|Mapping| |#1| |#1| (|Integer|))) "\\spad{morphism(f)} returns the morphism given by \\spad{f^n(x) = f(x,n)}.") (($ (|Mapping| |#1| |#1|) (|Mapping| |#1| |#1|)) "\\spad{morphism(f, \\spad{g)}} returns the invertible morphism given by \\spad{f,} where \\spad{g} is the inverse of \\spad{f..}") (($ (|Mapping| |#1| |#1|)) "\\spad{morphism(f)} returns the non-invertible morphism given by \\spad{f.}"))) +((-4568 . T)) NIL (-102) ((|constructor| (NIL "This package provides a functions to support a web server for the new Axiom Browser functions."))) NIL NIL (-103 R UP) -((|constructor| (NIL "This package provides balanced factorisations of polynomials.")) (|balancedFactorisation| (((|Factored| |#2|) |#2| (|List| |#2|)) "\\spad{balancedFactorisation(a,{} [b1,{}...,{}bn])} returns a factorisation \\spad{a = p1^e1 ... pm^em} such that each \\spad{pi} is balanced with respect to \\spad{[b1,{}...,{}bm]}.") (((|Factored| |#2|) |#2| |#2|) "\\spad{balancedFactorisation(a,{} b)} returns a factorisation \\spad{a = p1^e1 ... pm^em} such that each \\spad{\\spad{pi}} is balanced with respect to \\spad{b}."))) +((|constructor| (NIL "This package provides balanced factorisations of polynomials.")) (|balancedFactorisation| (((|Factored| |#2|) |#2| (|List| |#2|)) "\\spad{balancedFactorisation(a, [b1,...,bn])} returns a factorisation \\spad{a = \\spad{p1^e1} \\spad{...} pm^em} such that each \\spad{pi} is balanced with respect to \\spad{[b1,...,bm]}.") (((|Factored| |#2|) |#2| |#2|) "\\spad{balancedFactorisation(a, \\spad{b)}} returns a factorisation \\spad{a = \\spad{p1^e1} \\spad{...} pm^em} such that each \\spad{pi} is balanced with respect to \\spad{b.}"))) NIL NIL (-104 S) @@ -353,43 +353,43 @@ NIL NIL NIL (-106 S) -((|constructor| (NIL "\\spadtype{BalancedBinaryTree(S)} is the domain of balanced binary trees (bbtree). A balanced binary tree of \\spad{2**k} leaves,{} for some \\spad{k > 0},{} is symmetric,{} that is,{} the left and right subtree of each interior node have identical shape. In general,{} the left and right subtree of a given node can differ by at most leaf node.")) (|mapDown!| (($ $ |#1| (|Mapping| (|List| |#1|) |#1| |#1| |#1|)) "\\indented{1}{mapDown!(\\spad{t},{}\\spad{p},{}\\spad{f}) returns \\spad{t} after traversing \\spad{t} in \"preorder\"} \\indented{1}{(node then left then right) fashion replacing the successive} \\indented{1}{interior nodes as follows. Let \\spad{l} and \\spad{r} denote the left and} \\indented{1}{right subtrees of \\spad{t}. The root value \\spad{x} of \\spad{t} is replaced by \\spad{p}.} \\indented{1}{Then \\spad{f}(value \\spad{l},{} value \\spad{r},{} \\spad{p}),{} where \\spad{l} and \\spad{r} denote the left} \\indented{1}{and right subtrees of \\spad{t},{} is evaluated producing two values} \\indented{1}{\\spad{pl} and \\spad{pr}. Then \\spad{mapDown!(l,{}pl,{}f)} and \\spad{mapDown!(l,{}pr,{}f)}} \\indented{1}{are evaluated.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4,{} 0)\\$\\spad{T1} \\spad{X} setleaves!(\\spad{t2},{}[1,{}2,{}3,{}4]::List(Integer)) \\spad{X} \\spad{adder3}(i:Integer,{}j:Integer,{}k:Integer):List Integer \\spad{==} [i+j,{}\\spad{j+k}] \\spad{X} mapDown!(\\spad{t2},{}4::INT,{}\\spad{adder3}) \\spad{X} \\spad{t2}") (($ $ |#1| (|Mapping| |#1| |#1| |#1|)) "\\indented{1}{mapDown!(\\spad{t},{}\\spad{p},{}\\spad{f}) returns \\spad{t} after traversing \\spad{t} in \"preorder\"} \\indented{1}{(node then left then right) fashion replacing the successive} \\indented{1}{interior nodes as follows. The root value \\spad{x} is} \\indented{1}{replaced by \\spad{q} \\spad{:=} \\spad{f}(\\spad{p},{}\\spad{x}). The mapDown!(\\spad{l},{}\\spad{q},{}\\spad{f}) and} \\indented{1}{mapDown!(\\spad{r},{}\\spad{q},{}\\spad{f}) are evaluated for the left and right subtrees} \\indented{1}{\\spad{l} and \\spad{r} of \\spad{t}.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4,{} 0)\\$\\spad{T1} \\spad{X} setleaves!(\\spad{t2},{}[1,{}2,{}3,{}4]::List(Integer)) \\spad{X} adder(i:Integer,{}j:Integer):Integer \\spad{==} i+j \\spad{X} mapDown!(\\spad{t2},{}4::INT,{}adder) \\spad{X} \\spad{t2}")) (|mapUp!| (($ $ $ (|Mapping| |#1| |#1| |#1| |#1| |#1|)) "\\indented{1}{mapUp!(\\spad{t},{}\\spad{t1},{}\\spad{f}) traverses balanced binary tree \\spad{t} in an \"endorder\"} \\indented{1}{(left then right then node) fashion returning \\spad{t} with the value} \\indented{1}{at each successive interior node of \\spad{t} replaced by} \\indented{1}{\\spad{f}(\\spad{l},{}\\spad{r},{}\\spad{l1},{}\\spad{r1}) where \\spad{l} and \\spad{r} are the values at the immediate} \\indented{1}{left and right nodes. Values \\spad{l1} and \\spad{r1} are values at the} \\indented{1}{corresponding nodes of a balanced binary tree \\spad{t1},{} of identical} \\indented{1}{shape at \\spad{t}.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4,{} 0)\\$\\spad{T1} \\spad{X} setleaves!(\\spad{t2},{}[1,{}2,{}3,{}4]::List(Integer)) \\spad{X} \\spad{adder4}(i:INT,{}j:INT,{}k:INT,{}l:INT):INT \\spad{==} i+j+k+l \\spad{X} mapUp!(\\spad{t2},{}\\spad{t2},{}\\spad{adder4}) \\spad{X} \\spad{t2}") ((|#1| $ (|Mapping| |#1| |#1| |#1|)) "\\indented{1}{mapUp!(\\spad{t},{}\\spad{f}) traverses balanced binary tree \\spad{t} in an \"endorder\"} \\indented{1}{(left then right then node) fashion returning \\spad{t} with the value} \\indented{1}{at each successive interior node of \\spad{t} replaced by} \\indented{1}{\\spad{f}(\\spad{l},{}\\spad{r}) where \\spad{l} and \\spad{r} are the values at the immediate} \\indented{1}{left and right nodes.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4,{} 0)\\$\\spad{T1} \\spad{X} setleaves!(\\spad{t2},{}[1,{}2,{}3,{}4]::List(Integer)) \\spad{X} adder(a:Integer,{}b:Integer):Integer \\spad{==} a+b \\spad{X} mapUp!(\\spad{t2},{}adder) \\spad{X} \\spad{t2}")) (|setleaves!| (($ $ (|List| |#1|)) "\\indented{1}{setleaves!(\\spad{t},{} \\spad{ls}) sets the leaves of \\spad{t} in left-to-right order} \\indented{1}{to the elements of \\spad{ls}.} \\blankline \\spad{X} t1:=balancedBinaryTree(4,{} 0) \\spad{X} setleaves!(\\spad{t1},{}[1,{}2,{}3,{}4])")) (|balancedBinaryTree| (($ (|NonNegativeInteger|) |#1|) "\\indented{1}{balancedBinaryTree(\\spad{n},{} \\spad{s}) creates a balanced binary tree with} \\indented{1}{\\spad{n} nodes each with value \\spad{s}.} \\blankline \\spad{X} balancedBinaryTree(4,{} 0)"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "\\spadtype{BalancedBinaryTree(S)} is the domain of balanced binary trees (bbtree). A balanced binary tree of \\spad{2**k} leaves, for some \\spad{k > 0}, is symmetric, that is, the left and right subtree of each interior node have identical shape. In general, the left and right subtree of a given node can differ by at most leaf node.")) (|mapDown!| (($ $ |#1| (|Mapping| (|List| |#1|) |#1| |#1| |#1|)) "\\indented{1}{mapDown!(t,p,f) returns \\spad{t} after traversing \\spad{t} in \"preorder\"} \\indented{1}{(node then left then right) fashion replacing the successive} \\indented{1}{interior nodes as follows. Let \\spad{l} and \\spad{r} denote the left and} \\indented{1}{right subtrees of \\spad{t.} The root value \\spad{x} of \\spad{t} is replaced by \\spad{p.}} \\indented{1}{Then f(value \\spad{l,} value \\spad{r,} \\spad{p),} where \\spad{l} and \\spad{r} denote the left} \\indented{1}{and right subtrees of \\spad{t,} is evaluated producing two values} \\indented{1}{pl and \\spad{pr.} Then \\spad{mapDown!(l,pl,f)} and \\spad{mapDown!(l,pr,f)}} \\indented{1}{are evaluated.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4, 0)$T1 \\spad{X} setleaves!(t2,[1,2,3,4]::List(Integer)) \\spad{X} adder3(i:Integer,j:Integer,k:Integer):List Integer \\spad{==} [i+j,j+k] \\spad{X} mapDown!(t2,4::INT,adder3) \\spad{X} \\spad{t2}") (($ $ |#1| (|Mapping| |#1| |#1| |#1|)) "\\indented{1}{mapDown!(t,p,f) returns \\spad{t} after traversing \\spad{t} in \"preorder\"} \\indented{1}{(node then left then right) fashion replacing the successive} \\indented{1}{interior nodes as follows. The root value \\spad{x} is} \\indented{1}{replaced by \\spad{q} \\spad{:=} f(p,x). The mapDown!(l,q,f) and} \\indented{1}{mapDown!(r,q,f) are evaluated for the left and right subtrees} \\indented{1}{l and \\spad{r} of \\spad{t.}} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4, 0)$T1 \\spad{X} setleaves!(t2,[1,2,3,4]::List(Integer)) \\spad{X} adder(i:Integer,j:Integer):Integer \\spad{==} i+j \\spad{X} mapDown!(t2,4::INT,adder) \\spad{X} \\spad{t2}")) (|mapUp!| (($ $ $ (|Mapping| |#1| |#1| |#1| |#1| |#1|)) "\\indented{1}{mapUp!(t,t1,f) traverses balanced binary tree \\spad{t} in an \"endorder\"} \\indented{1}{(left then right then node) fashion returning \\spad{t} with the value} \\indented{1}{at each successive interior node of \\spad{t} replaced \\spad{by}} \\indented{1}{f(l,r,l1,r1) where \\spad{l} and \\spad{r} are the values at the immediate} \\indented{1}{left and right nodes. Values \\spad{l1} and \\spad{r1} are values at the} \\indented{1}{corresponding nodes of a balanced binary tree \\spad{t1,} of identical} \\indented{1}{shape at \\spad{t.}} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4, 0)$T1 \\spad{X} setleaves!(t2,[1,2,3,4]::List(Integer)) \\spad{X} adder4(i:INT,j:INT,k:INT,l:INT):INT \\spad{==} i+j+k+l \\spad{X} mapUp!(t2,t2,adder4) \\spad{X} \\spad{t2}") ((|#1| $ (|Mapping| |#1| |#1| |#1|)) "\\indented{1}{mapUp!(t,f) traverses balanced binary tree \\spad{t} in an \"endorder\"} \\indented{1}{(left then right then node) fashion returning \\spad{t} with the value} \\indented{1}{at each successive interior node of \\spad{t} replaced \\spad{by}} \\indented{1}{f(l,r) where \\spad{l} and \\spad{r} are the values at the immediate} \\indented{1}{left and right nodes.} \\blankline \\spad{X} T1:=BalancedBinaryTree Integer \\spad{X} t2:=balancedBinaryTree(4, 0)$T1 \\spad{X} setleaves!(t2,[1,2,3,4]::List(Integer)) \\spad{X} adder(a:Integer,b:Integer):Integer \\spad{==} a+b \\spad{X} mapUp!(t2,adder) \\spad{X} \\spad{t2}")) (|setleaves!| (($ $ (|List| |#1|)) "\\indented{1}{setleaves!(t, \\spad{ls)} sets the leaves of \\spad{t} in left-to-right order} \\indented{1}{to the elements of ls.} \\blankline \\spad{X} t1:=balancedBinaryTree(4, 0) \\spad{X} setleaves!(t1,[1,2,3,4])")) (|balancedBinaryTree| (($ (|NonNegativeInteger|) |#1|) "\\indented{1}{balancedBinaryTree(n, \\spad{s)} creates a balanced binary tree with} \\indented{1}{n nodes each with value \\spad{s.}} \\blankline \\spad{X} balancedBinaryTree(4, 0)"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-107 R) -((|constructor| (NIL "Provide linear,{} quadratic,{} and cubic spline bezier curves")) (|cubicBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A cubic Bezier curve is a simple interpolation between the} \\indented{1}{starting point,{} a left-middle point,{},{} a right-middle point,{}} \\indented{1}{and the ending point based on a parameter \\spad{t}.} \\indented{1}{Given a start point a=[\\spad{x1},{}\\spad{y1}],{} the left-middle point \\spad{b=}[\\spad{x2},{}\\spad{y2}],{}} \\indented{1}{the right-middle point \\spad{c=}[\\spad{x3},{}\\spad{y3}] and an endpoint \\spad{d=}[\\spad{x4},{}\\spad{y4}]} \\indented{1}{\\spad{f}(\\spad{t}) \\spad{==} [(1-\\spad{t})\\spad{^3} \\spad{x1} + 3t(1-\\spad{t})\\spad{^2} \\spad{x2} + 3t^2 (1-\\spad{t}) \\spad{x3} + \\spad{t^3} \\spad{x4},{}} \\indented{10}{(1-\\spad{t})\\spad{^3} \\spad{y1} + 3t(1-\\spad{t})\\spad{^2} \\spad{y2} + 3t^2 (1-\\spad{t}) \\spad{y3} + \\spad{t^3} \\spad{y4}]} \\blankline \\spad{X} n:=cubicBezier([2.0,{}2.0],{}[2.0,{}4.0],{}[6.0,{}4.0],{}[6.0,{}2.0]) \\spad{X} [\\spad{n}(\\spad{t/10}.0) for \\spad{t} in 0..10 by 1]")) (|quadraticBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A quadratic Bezier curve is a simple interpolation between the} \\indented{1}{starting point,{} a middle point,{} and the ending point based on} \\indented{1}{a parameter \\spad{t}.} \\indented{1}{Given a start point a=[\\spad{x1},{}\\spad{y1}],{} a middle point \\spad{b=}[\\spad{x2},{}\\spad{y2}],{}} \\indented{1}{and an endpoint \\spad{c=}[\\spad{x3},{}\\spad{y3}]} \\indented{1}{\\spad{f}(\\spad{t}) \\spad{==} [(1-\\spad{t})\\spad{^2} \\spad{x1} + 2t(1-\\spad{t}) \\spad{x2} + \\spad{t^2} \\spad{x3},{}} \\indented{10}{(1-\\spad{t})\\spad{^2} \\spad{y1} + 2t(1-\\spad{t}) \\spad{y2} + \\spad{t^2} \\spad{y3}]} \\blankline \\spad{X} n:=quadraticBezier([2.0,{}2.0],{}[4.0,{}4.0],{}[6.0,{}2.0]) \\spad{X} [\\spad{n}(\\spad{t/10}.0) for \\spad{t} in 0..10 by 1]")) (|linearBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A linear Bezier curve is a simple interpolation between the} \\indented{1}{starting point and the ending point based on a parameter \\spad{t}.} \\indented{1}{Given a start point a=[\\spad{x1},{}\\spad{y1}] and an endpoint \\spad{b=}[\\spad{x2},{}\\spad{y2}]} \\indented{1}{\\spad{f}(\\spad{t}) \\spad{==} [(1-\\spad{t})\\spad{*x1} + \\spad{t*x2},{} (1-\\spad{t})\\spad{*y1} + \\spad{t*y2}]} \\blankline \\spad{X} n:=linearBezier([2.0,{}2.0],{}[4.0,{}4.0]) \\spad{X} [\\spad{n}(\\spad{t/10}.0) for \\spad{t} in 0..10 by 1]"))) +((|constructor| (NIL "Provide linear, quadratic, and cubic spline bezier curves")) (|cubicBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A cubic Bezier curve is a simple interpolation between the} \\indented{1}{starting point, a left-middle point,, a right-middle point,} \\indented{1}{and the ending point based on a parameter \\spad{t.}} \\indented{1}{Given a start point a=[x1,y1], the left-middle point b=[x2,y2],} \\indented{1}{the right-middle point c=[x3,y3] and an endpoint d=[x4,y4]} \\indented{1}{f(t) \\spad{==} \\spad{[(1-t)^3} \\spad{x1} + 3t(1-t)^2 \\spad{x2} + 3t^2 (1-t) \\spad{x3} + \\spad{t^3} x4,} \\indented{10}{(1-t)^3 \\spad{y1} + 3t(1-t)^2 \\spad{y2} + 3t^2 (1-t) \\spad{y3} + \\spad{t^3} y4]} \\blankline \\spad{X} n:=cubicBezier([2.0,2.0],[2.0,4.0],[6.0,4.0],[6.0,2.0]) \\spad{X} [n(t/10.0) for \\spad{t} in 0..10 by 1]")) (|quadraticBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A quadratic Bezier curve is a simple interpolation between the} \\indented{1}{starting point, a middle point, and the ending point based on} \\indented{1}{a parameter \\spad{t.}} \\indented{1}{Given a start point a=[x1,y1], a middle point b=[x2,y2],} \\indented{1}{and an endpoint c=[x3,y3]} \\indented{1}{f(t) \\spad{==} \\spad{[(1-t)^2} \\spad{x1} + 2t(1-t) \\spad{x2} + \\spad{t^2} x3,} \\indented{10}{(1-t)^2 \\spad{y1} + 2t(1-t) \\spad{y2} + \\spad{t^2} y3]} \\blankline \\spad{X} n:=quadraticBezier([2.0,2.0],[4.0,4.0],[6.0,2.0]) \\spad{X} [n(t/10.0) for \\spad{t} in 0..10 by 1]")) (|linearBezier| (((|Mapping| (|List| |#1|) |#1|) (|List| |#1|) (|List| |#1|)) "\\indented{1}{A linear Bezier curve is a simple interpolation between the} \\indented{1}{starting point and the ending point based on a parameter \\spad{t.}} \\indented{1}{Given a start point a=[x1,y1] and an endpoint b=[x2,y2]} \\indented{1}{f(t) \\spad{==} \\spad{[(1-t)*x1} + t*x2, \\spad{(1-t)*y1} + t*y2]} \\blankline \\spad{X} n:=linearBezier([2.0,2.0],[4.0,4.0]) \\spad{X} [n(t/10.0) for \\spad{t} in 0..10 by 1]"))) NIL NIL (-108 R UP M |Row| |Col|) -((|constructor| (NIL "\\spadtype{BezoutMatrix} contains functions for computing resultants and discriminants using Bezout matrices.")) (|bezoutDiscriminant| ((|#1| |#2|) "\\spad{bezoutDiscriminant(p)} computes the discriminant of a polynomial \\spad{p} by computing the determinant of a Bezout matrix.")) (|bezoutResultant| ((|#1| |#2| |#2|) "\\spad{bezoutResultant(p,{}q)} computes the resultant of the two polynomials \\spad{p} and \\spad{q} by computing the determinant of a Bezout matrix.")) (|bezoutMatrix| ((|#3| |#2| |#2|) "\\spad{bezoutMatrix(p,{}q)} returns the Bezout matrix for the two polynomials \\spad{p} and \\spad{q}.")) (|sylvesterMatrix| ((|#3| |#2| |#2|) "\\spad{sylvesterMatrix(p,{}q)} returns the Sylvester matrix for the two polynomials \\spad{p} and \\spad{q}."))) +((|constructor| (NIL "\\spadtype{BezoutMatrix} contains functions for computing resultants and discriminants using Bezout matrices.")) (|bezoutDiscriminant| ((|#1| |#2|) "\\spad{bezoutDiscriminant(p)} computes the discriminant of a polynomial \\spad{p} by computing the determinant of a Bezout matrix.")) (|bezoutResultant| ((|#1| |#2| |#2|) "\\spad{bezoutResultant(p,q)} computes the resultant of the two polynomials \\spad{p} and \\spad{q} by computing the determinant of a Bezout matrix.")) (|bezoutMatrix| ((|#3| |#2| |#2|) "\\spad{bezoutMatrix(p,q)} returns the Bezout matrix for the two polynomials \\spad{p} and \\spad{q.}")) (|sylvesterMatrix| ((|#3| |#2| |#2|) "\\spad{sylvesterMatrix(p,q)} returns the Sylvester matrix for the two polynomials \\spad{p} and \\spad{q.}"))) NIL -((|HasAttribute| |#1| (QUOTE (-4537 "*")))) +((|HasAttribute| |#1| (QUOTE (-4573 "*")))) (-109) ((|constructor| (NIL "A Domain which implements a table containing details of points at which particular functions have evaluation problems.")) (|bfEntry| (((|Record| (|:| |zeros| (|Stream| (|DoubleFloat|))) (|:| |ones| (|Stream| (|DoubleFloat|))) (|:| |singularities| (|Stream| (|DoubleFloat|)))) (|Symbol|)) "\\spad{bfEntry(k)} returns the entry in the \\axiomType{BasicFunctions} table corresponding to \\spad{k}")) (|bfKeys| (((|List| (|Symbol|))) "\\spad{bfKeys()} returns the names of each function in the \\axiomType{BasicFunctions} table"))) -((-4535 . T)) +((-4571 . T)) NIL (-110 A S) -((|constructor| (NIL "A bag aggregate is an aggregate for which one can insert and extract objects,{} and where the order in which objects are inserted determines the order of extraction. Examples of bags are stacks,{} queues,{} and dequeues.")) (|inspect| ((|#2| $) "\\spad{inspect(u)} returns an (random) element from a bag.")) (|insert!| (($ |#2| $) "\\spad{insert!(x,{}u)} inserts item \\spad{x} into bag \\spad{u}.")) (|extract!| ((|#2| $) "\\spad{extract!(u)} destructively removes a (random) item from bag \\spad{u}.")) (|bag| (($ (|List| |#2|)) "\\spad{bag([x,{}y,{}...,{}z])} creates a bag with elements \\spad{x},{}\\spad{y},{}...,{}\\spad{z}.")) (|shallowlyMutable| ((|attribute|) "shallowlyMutable means that elements of bags may be destructively changed."))) +((|constructor| (NIL "A bag aggregate is an aggregate for which one can insert and extract objects, and where the order in which objects are inserted determines the order of extraction. Examples of bags are stacks, queues, and dequeues.")) (|inspect| ((|#2| $) "\\spad{inspect(u)} returns an (random) element from a bag.")) (|insert!| (($ |#2| $) "\\spad{insert!(x,u)} inserts item \\spad{x} into bag u.")) (|extract!| ((|#2| $) "\\spad{extract!(u)} destructively removes a (random) item from bag u.")) (|bag| (($ (|List| |#2|)) "\\spad{bag([x,y,...,z])} creates a bag with elements x,y,...,z.")) (|shallowlyMutable| ((|attribute|) "shallowlyMutable means that elements of bags may be destructively changed."))) NIL NIL (-111 S) -((|constructor| (NIL "A bag aggregate is an aggregate for which one can insert and extract objects,{} and where the order in which objects are inserted determines the order of extraction. Examples of bags are stacks,{} queues,{} and dequeues.")) (|inspect| ((|#1| $) "\\spad{inspect(u)} returns an (random) element from a bag.")) (|insert!| (($ |#1| $) "\\spad{insert!(x,{}u)} inserts item \\spad{x} into bag \\spad{u}.")) (|extract!| ((|#1| $) "\\spad{extract!(u)} destructively removes a (random) item from bag \\spad{u}.")) (|bag| (($ (|List| |#1|)) "\\spad{bag([x,{}y,{}...,{}z])} creates a bag with elements \\spad{x},{}\\spad{y},{}...,{}\\spad{z}.")) (|shallowlyMutable| ((|attribute|) "shallowlyMutable means that elements of bags may be destructively changed."))) -((-4536 . T) (-2982 . T)) +((|constructor| (NIL "A bag aggregate is an aggregate for which one can insert and extract objects, and where the order in which objects are inserted determines the order of extraction. Examples of bags are stacks, queues, and dequeues.")) (|inspect| ((|#1| $) "\\spad{inspect(u)} returns an (random) element from a bag.")) (|insert!| (($ |#1| $) "\\spad{insert!(x,u)} inserts item \\spad{x} into bag u.")) (|extract!| ((|#1| $) "\\spad{extract!(u)} destructively removes a (random) item from bag u.")) (|bag| (($ (|List| |#1|)) "\\spad{bag([x,y,...,z])} creates a bag with elements x,y,...,z.")) (|shallowlyMutable| ((|attribute|) "shallowlyMutable means that elements of bags may be destructively changed."))) +((-4572 . T) (-4317 . T)) NIL (-112) -((|constructor| (NIL "This domain allows rational numbers to be presented as repeating binary expansions.")) (|binary| (($ (|Fraction| (|Integer|))) "\\indented{1}{binary(\\spad{r}) converts a rational number to a binary expansion.} \\blankline \\spad{X} binary(22/7)")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(b)} returns the fractional part of a binary expansion.")) (|coerce| (((|RadixExpansion| 2) $) "\\spad{coerce(b)} converts a binary expansion to a radix expansion with base 2.") (((|Fraction| (|Integer|)) $) "\\spad{coerce(b)} converts a binary expansion to a rational number."))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| (-569) (QUOTE (-905))) (|HasCategory| (-569) (LIST (QUOTE -1038) (QUOTE (-1163)))) (|HasCategory| (-569) (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-151))) (|HasCategory| (-569) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-569) (QUOTE (-1022))) (|HasCategory| (-569) (QUOTE (-816))) (|HasCategory| (-569) (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-1137))) (|HasCategory| (-569) (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| (-569) (QUOTE (-226))) (|HasCategory| (-569) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-569) (LIST (QUOTE -524) (QUOTE (-1163)) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -304) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -282) (QUOTE (-569)) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-302))) (|HasCategory| (-569) (QUOTE (-551))) (|HasCategory| (-569) (QUOTE (-843))) (-2232 (|HasCategory| (-569) (QUOTE (-816))) (|HasCategory| (-569) (QUOTE (-843)))) (|HasCategory| (-569) (LIST (QUOTE -631) (QUOTE (-569)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-905)))) (|HasCategory| (-569) (QUOTE (-149))))) +((|constructor| (NIL "This domain allows rational numbers to be presented as repeating binary expansions.")) (|binary| (($ (|Fraction| (|Integer|))) "\\indented{1}{binary(r) converts a rational number to a binary expansion.} \\blankline \\spad{X} binary(22/7)")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(b)} returns the fractional part of a binary expansion.")) (|coerce| (((|RadixExpansion| 2) $) "\\spad{coerce(b)} converts a binary expansion to a radix expansion with base 2.") (((|Fraction| (|Integer|)) $) "\\spad{coerce(b)} converts a binary expansion to a rational number."))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| (-569) (QUOTE (-906))) (|HasCategory| (-569) (LIST (QUOTE -1039) (QUOTE (-1165)))) (|HasCategory| (-569) (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-151))) (|HasCategory| (-569) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-569) (QUOTE (-1023))) (|HasCategory| (-569) (QUOTE (-817))) (|HasCategory| (-569) (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-1139))) (|HasCategory| (-569) (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| (-569) (QUOTE (-226))) (|HasCategory| (-569) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-569) (LIST (QUOTE -524) (QUOTE (-1165)) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -304) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -282) (QUOTE (-569)) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-302))) (|HasCategory| (-569) (QUOTE (-551))) (|HasCategory| (-569) (QUOTE (-844))) (-1929 (|HasCategory| (-569) (QUOTE (-817))) (|HasCategory| (-569) (QUOTE (-844)))) (|HasCategory| (-569) (LIST (QUOTE -631) (QUOTE (-569)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-906)))) (|HasCategory| (-569) (QUOTE (-149))))) (-113) -((|constructor| (NIL "This domain provides an implementation of binary files. Data is accessed one byte at a time as a small integer.")) (|position!| (((|SingleInteger|) $ (|SingleInteger|)) "\\spad{position!(f,{} i)} sets the current byte-position to \\spad{i}.")) (|position| (((|SingleInteger|) $) "\\spad{position(f)} returns the current byte-position in the file \\spad{f}.")) (|readIfCan!| (((|Union| (|SingleInteger|) "failed") $) "\\spad{readIfCan!(f)} returns a value from the file \\spad{f},{} if possible. If \\spad{f} is not open for reading,{} or if \\spad{f} is at the end of file then \\spad{\"failed\"} is the result."))) +((|constructor| (NIL "This domain provides an implementation of binary files. Data is accessed one byte at a time as a small integer.")) (|position!| (((|SingleInteger|) $ (|SingleInteger|)) "\\spad{position!(f, i)} sets the current byte-position to i.")) (|position| (((|SingleInteger|) $) "\\spad{position(f)} returns the current byte-position in the file \\spad{f.}")) (|readIfCan!| (((|Union| (|SingleInteger|) "failed") $) "\\spad{readIfCan!(f)} returns a value from the file \\spad{f,} if possible. If \\spad{f} is not open for reading, or if \\spad{f} is at the end of file then \\spad{\"failed\"} is the result."))) NIL NIL (-114) -((|constructor| (NIL "\\spadtype{Bits} provides logical functions for Indexed Bits.")) (|bits| (($ (|NonNegativeInteger|) (|Boolean|)) "\\spad{bits(n,{}b)} creates bits with \\spad{n} values of \\spad{b}"))) -((-4536 . T) (-4535 . T)) -((|HasCategory| (-121) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-121) (QUOTE (-843))) (|HasCategory| (-569) (QUOTE (-843))) (|HasCategory| (-121) (QUOTE (-1091))) (-12 (|HasCategory| (-121) (LIST (QUOTE -304) (QUOTE (-121)))) (|HasCategory| (-121) (QUOTE (-1091))))) +((|constructor| (NIL "\\spadtype{Bits} provides logical functions for Indexed Bits.")) (|bits| (($ (|NonNegativeInteger|) (|Boolean|)) "\\spad{bits(n,b)} creates bits with \\spad{n} values of \\spad{b}"))) +((-4572 . T) (-4571 . T)) +((|HasCategory| (-121) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-121) (QUOTE (-844))) (|HasCategory| (-569) (QUOTE (-844))) (|HasCategory| (-121) (QUOTE (-1093))) (-12 (|HasCategory| (-121) (LIST (QUOTE -304) (QUOTE (-121)))) (|HasCategory| (-121) (QUOTE (-1093))))) (-115) -((|constructor| (NIL "This package provides an interface to the Blas library (level 1)")) (|dcopy| (((|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dcopy(\\spad{n},{}\\spad{x},{}incx,{}\\spad{y},{}incy) copies \\spad{y} from \\spad{x}} \\indented{1}{for each of the chosen elements of the vectors \\spad{x} and \\spad{y}} \\indented{1}{Note that the vector \\spad{y} is modified with the results.} \\blankline \\spad{X} x:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0,{}4.0,{}5.0,{}6.0] ] \\spad{X} y:PRIMARR(DFLOAT)\\spad{:=}[ [0.0,{}0.0,{}0.0,{}0.0,{}0.0,{}0.0] ] \\spad{X} dcopy(6,{}\\spad{x},{}1,{}\\spad{y},{}1) \\spad{X} \\spad{y} \\spad{X} m:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0] ] \\spad{X} n:PRIMARR(DFLOAT)\\spad{:=}[ [0.0,{}0.0,{}0.0,{}0.0,{}0.0,{}0.0] ] \\spad{X} dcopy(3,{}\\spad{m},{}1,{}\\spad{n},{}2) \\spad{X} \\spad{n}")) (|daxpy| (((|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|DoubleFloat|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{daxpy(\\spad{n},{}da,{}\\spad{x},{}incx,{}\\spad{y},{}incy) computes a \\spad{y} = a*x + \\spad{y}} \\indented{1}{for each of the chosen elements of the vectors \\spad{x} and \\spad{y}} \\indented{1}{and a constant multiplier a} \\indented{1}{Note that the vector \\spad{y} is modified with the results.} \\blankline \\spad{X} x:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0,{}4.0,{}5.0,{}6.0] ] \\spad{X} y:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0,{}4.0,{}5.0,{}6.0] ] \\spad{X} daxpy(6,{}2.0,{}\\spad{x},{}1,{}\\spad{y},{}1) \\spad{X} \\spad{y} \\spad{X} m:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0] ] \\spad{X} n:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0,{}4.0,{}5.0,{}6.0] ] \\spad{X} daxpy(3,{}\\spad{-2}.0,{}\\spad{m},{}1,{}\\spad{n},{}2) \\spad{X} \\spad{n}")) (|dasum| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dasum(\\spad{n},{}array,{}incx) computes the sum of \\spad{n} elements in array} \\indented{1}{using a stride of incx} \\blankline \\spad{X} dx:PRIMARR(DFLOAT)\\spad{:=}[ [1.0,{}2.0,{}3.0,{}4.0,{}5.0,{}6.0] ] \\spad{X} dasum(6,{}\\spad{dx},{}1) \\spad{X} dasum(3,{}\\spad{dx},{}2)")) (|dcabs1| (((|DoubleFloat|) (|Complex| (|DoubleFloat|))) "\\indented{1}{\\spad{dcabs1}(\\spad{z}) computes (+ (abs (realpart \\spad{z})) (abs (imagpart \\spad{z})))} \\blankline \\spad{X} t1:Complex DoubleFloat \\spad{:=} complex(1.0,{}0) \\spad{X} dcabs(\\spad{t1})"))) +((|constructor| (NIL "This package provides an interface to the Blas library (level 1)")) (|zaxpy| (((|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|) (|Complex| (|DoubleFloat|)) (|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|) (|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|)) "\\indented{1}{zaxpy(n,da,x,incx,y,incy) computes a \\spad{y} = a*x + \\spad{y}} \\indented{1}{for each of the chosen elements of the vectors \\spad{x} and \\spad{y}} \\indented{1}{and a constant multiplier a} \\indented{1}{Note that the vector \\spad{y} is modified with the results.} \\blankline \\spad{X} a:PRIMARR(COMPLEX(DFLOAT)) \\spad{X} a:=[[3.+4.*\\%i, -4.+5.*\\%i, 5.+6.*%i, 7.-8.*%i, -9.-2.*\\%i]] \\spad{X} b:PRIMARR(COMPLEX(DFLOAT)) \\spad{X} b:=[[3.+4.*\\%i, -4.+5.*\\%i, 5.+6.*%i, 7.-8.*%i, -9.-2.*\\%i]] \\spad{X} zaxpy(3,2.0,a,1,b,1) \\spad{X} b:=[[3.+4.*\\%i, -4.+5.*\\%i, 5.+6.*%i, 7.-8.*%i, -9.-2.*\\%i]] \\spad{X} zaxpy(5,2.0,a,1,b,1) \\spad{X} b:=[[3.+4.*\\%i, -4.+5.*\\%i, 5.+6.*%i, 7.-8.*%i, -9.-2.*\\%i]] \\spad{X} zaxpy(3,2.0,a,3,b,3) \\spad{X} b:=[[3.+4.*\\%i, -4.+5.*\\%i, 5.+6.*%i, 7.-8.*%i, -9.-2.*\\%i]] \\spad{X} zaxpy(4,2.0,a,2,b,2)")) (|izamax| (((|Integer|) (|SingleInteger|) (|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|)) "\\indented{1}{izamax computes the largest absolute value of the elements} \\indented{1}{of the array and returns the index of the first instance} \\indented{1}{of the maximum.} \\blankline \\spad{X} a:PRIMARR(COMPLEX(DFLOAT)) \\spad{X} a:=[[3.+4.*\\%i,-4.+5.*\\%i,5.+6.*\\%i,7.-8.*\\%i,-9.-2.*\\%i]] \\spad{X} izamax(5,a,1) \\spad{--} should be 3 \\spad{X} izamax(0,a,1) \\spad{--} should be \\spad{-1} \\spad{X} izamax(5,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} izamax(3,a,1) \\spad{--} should be 2 \\spad{X} izamax(3,a,2) \\spad{--} should be 1")) (|isamax| (((|Integer|) (|Integer|) (|PrimitiveArray| (|Float|)) (|Integer|)) "\\indented{1}{isamax computes the largest absolute value of the elements} \\indented{1}{of the array and returns the index of the first instance} \\indented{1}{of the maximum.} \\blankline \\spad{X} a:PRIMARR(FLOAT):=[[3.0, 4.0, -3.0, 5.0, -1.0]] \\spad{X} isamax(5,a,1) \\spad{--} should be 3 \\spad{X} isamax(3,a,1) \\spad{--} should be 1 \\spad{X} isamax(0,a,1) \\spad{--} should be \\spad{-1} \\spad{X} isamax(-5,a,1) \\spad{--} should be \\spad{-1} \\spad{X} isamax(5,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} isamax(5,a,2) \\spad{--} should be 0 \\spad{X} isamax(1,a,0) \\spad{--} should be \\spad{-1} \\spad{X} isamax(1,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} a:PRIMARR(FLOAT):=[[3.0, 4.0, -3.0, -5.0, -1.0]] \\spad{X} isamax(5,a,1) \\spad{--} should be 3")) (|idamax| (((|Integer|) (|Integer|) (|PrimitiveArray| (|DoubleFloat|)) (|Integer|)) "\\indented{1}{idamax computes the largest absolute value of the elements} \\indented{1}{of the array and returns the index of the first instance} \\indented{1}{of the maximum.} \\blankline \\spad{X} a:PRIMARR(DFLOAT):=[[3.0, 4.0, -3.0, 5.0, -1.0]] \\spad{X} idamax(5,a,1) \\spad{--} should be 3 \\spad{X} idamax(3,a,1) \\spad{--} should be 1 \\spad{X} idamax(0,a,1) \\spad{--} should be \\spad{-1} \\spad{X} idamax(-5,a,1) \\spad{--} should be \\spad{-1} \\spad{X} idamax(5,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} idamax(5,a,2) \\spad{--} should be 0 \\spad{X} idamax(1,a,0) \\spad{--} should be \\spad{-1} \\spad{X} idamax(1,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} a:PRIMARR(DFLOAT):=[[3.0, 4.0, -3.0, -5.0, -1.0]] \\spad{X} idamax(5,a,1) \\spad{--} should be 3")) (|icamax| (((|Integer|) (|Integer|) (|PrimitiveArray| (|Complex| (|Float|))) (|Integer|)) "\\indented{1}{icamax computes the largest absolute value of the elements} \\indented{1}{of the array and returns the index of the first instance} \\indented{1}{of the maximum} \\blankline \\spad{X} a:PRIMARR(COMPLEX(FLOAT)) \\spad{X} a:=[[3.+4.*\\%i,-4.+5.*\\%i,5.+6.*\\%i,7.-8.*\\%i,-9.-2.*\\%i]] \\spad{X} icamax(5,a,1) \\spad{--} should be 3 \\spad{X} icamax(0,a,1) \\spad{--} should be \\spad{-1} \\spad{X} icamax(5,a,-1) \\spad{--} should be \\spad{-1} \\spad{X} icamax(3,a,1) \\spad{--} should be 2 \\spad{X} icamax(3,a,2) \\spad{--} should be 1")) (|dznrm2| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|)) "\\indented{1}{dznrm2 returns the norm of a complex vector. It computes} \\indented{1}{sqrt(sum(v*conjugate(v)))} \\blankline \\spad{X} a:PRIMARR(COMPLEX(DFLOAT)) \\spad{X} a:=[[3.+4.*\\%i,-4.+5.*\\%i,5.+6.*\\%i,7.-8.*\\%i,-9.-2.*\\%i]] \\spad{X} dznrm2(5,a,1) \\spad{--} should be 18.028 \\spad{X} dznrm2(3,a,2) \\spad{--} should be 13.077 \\spad{X} dznrm2(3,a,1) \\spad{--} should be 11.269 \\spad{X} dznrm2(3,a,-1) \\spad{--} should be 0.0 \\spad{X} dznrm2(-3,a,-1) \\spad{--} should be 0.0 \\spad{X} dznrm2(1,a,1) \\spad{--} should be 5.0 \\spad{X} dznrm2(1,a,2) \\spad{--} should be 5.0")) (|dzasum| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|Complex| (|DoubleFloat|))) (|SingleInteger|)) "\\indented{1}{dzasum takes the sum over all of the array where each} \\indented{1}{element of the array sum is the sum of the absolute} \\indented{1}{value of the real part and the absolute value of the} \\indented{1}{imaginary part of each array element:} \\indented{3}{for \\spad{i} in array do sum = sum + (real(a(i)) + imag(a(i)))} \\blankline \\spad{X} d:PRIMARR(COMPLEX(DFLOAT)):=[[1.0+2.0*\\%i,-3.0+4.0*\\%i,5.0-6.0*\\%i]] \\spad{X} dzasum(3,d,1) \\spad{--} 21.0 \\spad{X} dzasum(3,d,2) \\spad{--} 14.0 \\spad{X} dzasum(-3,d,1) \\spad{--} 0.0")) (|dswap| (((|List| (|PrimitiveArray| (|DoubleFloat|))) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dswap swaps elements from the first vector with the second} \\indented{1}{Note that the arrays are modified in place.} \\blankline \\spad{X} dx:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dy:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dswap(5,dx,1,dy,1) \\spad{X} dx:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dy:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dswap(3,dx,2,dy,2) \\spad{X} dx:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dy:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dswap(5,dx,1,dy,-1)")) (|dscal| (((|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|DoubleFloat|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dscal scales each element of the vector by the scalar so} \\indented{1}{dscal(n,da,dx,incx) = da*dx for \\spad{n} elements, incremented by incx} \\indented{1}{Note that the \\spad{dx} array is modified in place.} \\blankline \\spad{X} dx:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dscal(6,2.0,dx,1) \\spad{X} \\spad{dx} \\spad{X} dx:PRIMARR(DFLOAT):=[[1.0, 2.0, 3.0, 4.0, 5.0, 6.0]] \\spad{X} dscal(3,0.5,dx,1) \\spad{X} \\spad{dx}")) (|drot| (((|List| (|PrimitiveArray| (|DoubleFloat|))) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|DoubleFloat|) (|DoubleFloat|)) "\\indented{1}{drot computes a 2D plane Givens rotation spanned by two} \\indented{1}{coordinate axes. It modifies the arrays in place.} \\indented{1}{The call drot(n,dx,incx,dy,incy,c,s) has the \\spad{dx} array which} \\indented{1}{contains the \\spad{y} axis locations and dy which contains the} \\indented{1}{y axis locations. They are rotated in parallel where} \\indented{1}{c is the cosine of the angle and \\spad{s} is the sine of the angle and} \\indented{1}{c^2+s^2 = 1} \\blankline \\spad{X} dx:PRIMARR(DFLOAT):=[[6,0, 1.0, 4.0, -1.0, -1.0]] \\spad{X} dy:PRIMARR(DFLOAT):=[[5.0, 1.0, -4.0, 4.0, -4.0]] \\spad{X} drot(5,dx,1,dy,1,0.707106781,0.707106781) \\spad{--} rotate by 45 degrees \\spad{X} \\spad{dx} \\spad{--} \\spad{dx} has been modified \\spad{X} dy \\spad{--} dy has been modified \\spad{X} drot(5,dx,1,dy,1,0.707106781,-0.707106781) \\spad{--} rotate by \\spad{-45} degrees \\spad{X} \\spad{dx} \\spad{--} \\spad{dx} has been modified \\spad{X} dy \\spad{--} dy has been modified")) (|drotg| (((|PrimitiveArray| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\indented{1}{drotg computes a 2D plane Givens rotation spanned by two} \\indented{1}{coordinate axes.} \\blankline \\spad{X} a:MATRIX(DFLOAT):=[[6,5,0],[5,1,4],[0,4,3]] \\spad{X} drotg(elt(a,1,1),elt(a,1,2),0.0D0,0.0D0)")) (|dnrm2| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dnrm2 takes the norm of the vector, ||x||} \\blankline \\spad{X} a:PRIMARR(DFLOAT):=[ [3.0, -4.0, 5.0, -7.0, 9.0] ] \\spad{X} dnrm2(3,a,1) \\spad{--} 7.0710678118654755 = \\spad{sqrt(3.0^2} + \\spad{-4.0^2} + 5.0^2) \\spad{X} dnrm2(5,a,1) \\spad{--} 13.416407864998739 = sqrt(180.0) \\spad{X} dnrm2(3,a,2) \\spad{--} 10.72380529476361 = sqrt(115.0)")) (|ddot| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{ddot(n,x,incx,y,incy) computes the vector dot product} \\indented{1}{of elements from the vector \\spad{x} and the vector \\spad{y}} \\indented{1}{If the indicies are negative the elements are taken} \\indented{1}{relative to the far end of the vector.} \\blankline \\spad{X} x:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0] ] \\spad{X} y:PRIMARR(DFLOAT):=[ [5.0,6.0,7.0,8.0,9.0] ] \\spad{X} ddot(0,a,1,b,1) \\spad{--} handle 0 elements \\spad{==>} 0 \\spad{X} ddot(3,a,1,b,1) \\spad{--} (1,2,3) * (5,6,7) \\spad{==>} 38.0 \\spad{X} ddot(3,a,1,b,2) \\spad{--} increment = 2 in \\spad{b} (1,2,3) * (5,7,9) \\spad{==>} 46.0 \\spad{X} ddot(3,a,2,b,1) \\spad{--} increment = 2 in a (1,3,5) * (5,6,7) \\spad{==>} 58.0 \\spad{X} ddot(3,a,1,b,-2) \\spad{--} increment = \\spad{-2} in \\spad{b} (1,2,3) * (9,7,5) \\spad{==>} 38.0 \\spad{X} ddot(2,a,-2,b,1) \\spad{--} increment = \\spad{-2} in a (5,3,1) * (5,6,7) \\spad{==>} 50.0 \\spad{X} ddot(3,a,-2,b,-2) \\spad{--} (5,3,1) * (9,7,5) \\spad{==>} 71.0")) (|dcopy| (((|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dcopy(n,x,incx,y,incy) copies \\spad{y} from \\spad{x}} \\indented{1}{for each of the chosen elements of the vectors \\spad{x} and \\spad{y}} \\indented{1}{Note that the vector \\spad{y} is modified with the results.} \\blankline \\spad{X} x:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0,6.0] ] \\spad{X} y:PRIMARR(DFLOAT):=[ [0.0,0.0,0.0,0.0,0.0,0.0] ] \\spad{X} dcopy(6,x,1,y,1) \\spad{X} \\spad{y} \\spad{X} m:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0] ] \\spad{X} n:PRIMARR(DFLOAT):=[ [0.0,0.0,0.0,0.0,0.0,0.0] ] \\spad{X} dcopy(3,m,1,n,2) \\spad{X} \\spad{n}")) (|daxpy| (((|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|DoubleFloat|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{daxpy(n,da,x,incx,y,incy) computes a \\spad{y} = a*x + \\spad{y}} \\indented{1}{for each of the chosen elements of the vectors \\spad{x} and \\spad{y}} \\indented{1}{and a constant multiplier a} \\indented{1}{Note that the vector \\spad{y} is modified with the results.} \\blankline \\spad{X} x:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0,6.0] ] \\spad{X} y:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0,6.0] ] \\spad{X} daxpy(6,2.0,x,1,y,1) \\spad{X} \\spad{y} \\spad{X} m:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0] ] \\spad{X} n:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0,6.0] ] \\spad{X} daxpy(3,-2.0,m,1,n,2) \\spad{X} \\spad{n}")) (|dasum| (((|DoubleFloat|) (|SingleInteger|) (|PrimitiveArray| (|DoubleFloat|)) (|SingleInteger|)) "\\indented{1}{dasum(n,array,incx) computes the sum of \\spad{n} elements in array} \\indented{1}{using a stride of incx} \\blankline \\spad{X} dx:PRIMARR(DFLOAT):=[ [1.0,2.0,3.0,4.0,5.0,6.0] ] \\spad{X} dasum(6,dx,1) \\spad{X} dasum(3,dx,2)")) (|dcabs1| (((|DoubleFloat|) (|Complex| (|DoubleFloat|))) "\\indented{1}{dcabs1(z) computes \\spad{(+} (abs (realpart \\spad{z))} (abs (imagpart z)))} \\blankline \\spad{X} t1:Complex DoubleFloat \\spad{:=} complex(1.0,0) \\spad{X} dcabs1(t1)"))) NIL NIL (-116) @@ -405,231 +405,231 @@ NIL ((|QuadraticTransform| . T)) NIL (-119 K |symb| |PolyRing| E BLMET) -((|constructor| (NIL "The following is part of the PAFF package")) (|stepBlowUp| (((|Record| (|:| |mult| (|NonNegativeInteger|)) (|:| |subMult| (|NonNegativeInteger|)) (|:| |blUpRec| (|List| (|Record| (|:| |recTransStr| (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|)) (|:| |recPoint| (|AffinePlane| |#1|)) (|:| |recChart| |#5|) (|:| |definingExtension| |#1|))))) (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|AffinePlane| |#1|) |#5| |#1|) "\\spad{stepBlowUp(pol,{}pt,{}n)} blow-up the point \\spad{pt} on the curve defined by \\spad{pol} in the affine neighbourhood specified by \\spad{n}.")) (|quadTransform| (((|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|NonNegativeInteger|) |#5|) "\\spad{quadTransform(pol,{}n,{}chart)} apply the quadratique transformation to \\spad{pol} specified by \\spad{chart} has in quadTransform(\\spad{pol},{}\\spad{chart}) and extract x**n to it,{} where \\spad{x} is the variable specified by the first integer in \\spad{chart} (blow-up exceptional coordinate).")) (|applyTransform| ((|#3| |#3| |#5|) "quadTransform(pol,{}chart) apply the quadratique transformation to pol specified by chart which consist of 3 integers. The last one indicates which varibles is set to 1,{} the first on indicates which variable remains unchange,{} and the second one indicates which variable oon which the transformation is applied. For example,{} [2,{}3,{}1] correspond to the following: \\spad{x} \\spad{->} 1,{} \\spad{y} \\spad{->} \\spad{y},{} \\spad{z} \\spad{->} \\spad{yz} (here the variable are [\\spad{x},{}\\spad{y},{}\\spad{z}] in BlUpRing)."))) +((|constructor| (NIL "The following is part of the PAFF package")) (|stepBlowUp| (((|Record| (|:| |mult| (|NonNegativeInteger|)) (|:| |subMult| (|NonNegativeInteger|)) (|:| |blUpRec| (|List| (|Record| (|:| |recTransStr| (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|)) (|:| |recPoint| (|AffinePlane| |#1|)) (|:| |recChart| |#5|) (|:| |definingExtension| |#1|))))) (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|AffinePlane| |#1|) |#5| |#1|) "\\spad{stepBlowUp(pol,pt,n)} blow-up the point \\spad{pt} on the curve defined by \\spad{pol} in the affine neighbourhood specified by \\spad{n.}")) (|quadTransform| (((|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|DistributedMultivariatePolynomial| (|construct| (QUOTE X) (QUOTE Y)) |#1|) (|NonNegativeInteger|) |#5|) "\\spad{quadTransform(pol,n,chart)} apply the quadratique transformation to \\spad{pol} specified by \\spad{chart} has in quadTransform(pol,chart) and extract x**n to it, where \\spad{x} is the variable specified by the first integer in \\spad{chart} (blow-up exceptional coordinate).")) (|applyTransform| ((|#3| |#3| |#5|) "quadTransform(pol,chart) apply the quadratique transformation to pol specified by chart which consist of 3 integers. The last one indicates which varibles is set to 1, the first on indicates which variable remains unchange, and the second one indicates which variable oon which the transformation is applied. For example, [2,3,1] correspond to the following: \\spad{x} \\spad{->} 1, \\spad{y} \\spad{->} \\spad{y,} \\spad{z} \\spad{->} \\spad{yz} (here the variable are [x,y,z] in BlUpRing)."))) NIL NIL (-120 R S) -((|constructor| (NIL "A \\spadtype{BiModule} is both a left and right module with respect to potentially different rings. \\blankline Axiom\\spad{\\br} \\tab{5}\\spad{ r*(x*s) = (r*x)*s }")) (|rightUnitary| ((|attribute|) "\\spad{x * 1 = x}")) (|leftUnitary| ((|attribute|) "\\spad{1 * x = x}"))) -((-4530 . T) (-4529 . T)) +((|constructor| (NIL "A \\spadtype{BiModule} is both a left and right module with respect to potentially different rings. \\blankline Axiom\\br \\tab{5}\\spad{ r*(x*s) = (r*x)*s }")) (|rightUnitary| ((|attribute|) "\\spad{x * 1 = \\spad{x}}")) (|leftUnitary| ((|attribute|) "\\spad{1 * \\spad{x} = \\spad{x}}"))) +((-4566 . T) (-4565 . T)) NIL (-121) -((|constructor| (NIL "\\spadtype{Boolean} is the elementary logic with 2 values: \\spad{true} and \\spad{false}")) (|test| (((|Boolean|) $) "\\spad{test(b)} returns \\spad{b} and is provided for compatibility with the new compiler.")) (|implies| (($ $ $) "\\spad{implies(a,{}b)} returns the logical implication of Boolean \\spad{a} and \\spad{b}.")) (|nor| (($ $ $) "\\spad{nor(a,{}b)} returns the logical negation of \\spad{a} or \\spad{b}.")) (|nand| (($ $ $) "\\spad{nand(a,{}b)} returns the logical negation of \\spad{a} and \\spad{b}.")) (|xor| (($ $ $) "\\spad{xor(a,{}b)} returns the logical exclusive or of Boolean \\spad{a} and \\spad{b}.")) (|or| (($ $ $) "\\spad{a or b} returns the logical inclusive or of Boolean \\spad{a} and \\spad{b}.")) (|and| (($ $ $) "\\spad{a and b} returns the logical and of Boolean \\spad{a} and \\spad{b}.")) (|not| (($ $) "\\spad{not n} returns the negation of \\spad{n}.")) (^ (($ $) "\\spad{^ n} returns the negation of \\spad{n}.")) (|false| (($) "\\spad{false} is a logical constant.")) (|true| (($) "\\spad{true} is a logical constant."))) +((|constructor| (NIL "\\spadtype{Boolean} is the elementary logic with 2 values: \\spad{true} and \\spad{false}")) (|test| (((|Boolean|) $) "\\spad{test(b)} returns \\spad{b} and is provided for compatibility with the new compiler.")) (|implies| (($ $ $) "\\spad{implies(a,b)} returns the logical implication of Boolean \\spad{a} and \\spad{b.}")) (|nor| (($ $ $) "\\spad{nor(a,b)} returns the logical negation of \\spad{a} or \\spad{b.}")) (|nand| (($ $ $) "\\spad{nand(a,b)} returns the logical negation of \\spad{a} and \\spad{b.}")) (|xor| (($ $ $) "\\spad{xor(a,b)} returns the logical exclusive or of Boolean \\spad{a} and \\spad{b.}")) (|or| (($ $ $) "\\spad{a or \\spad{b}} returns the logical inclusive or of Boolean \\spad{a} and \\spad{b.}")) (|and| (($ $ $) "\\spad{a and \\spad{b}} returns the logical and of Boolean \\spad{a} and \\spad{b.}")) (|not| (($ $) "\\spad{not \\spad{n}} returns the negation of \\spad{n.}")) (^ (($ $) "\\spad{^ \\spad{n}} returns the negation of \\spad{n.}")) (|false| (($) "\\spad{false} is a logical constant.")) (|true| (($) "\\spad{true} is a logical constant."))) NIL NIL (-122 A) -((|constructor| (NIL "This package exports functions to set some commonly used properties of operators,{} including properties which contain functions.")) (|constantOpIfCan| (((|Union| |#1| "failed") (|BasicOperator|)) "\\spad{constantOpIfCan(op)} returns \\spad{a} if \\spad{op} is the constant nullary operator always returning \\spad{a},{} \"failed\" otherwise.")) (|constantOperator| (((|BasicOperator|) |#1|) "\\spad{constantOperator(a)} returns a nullary operator op such that \\spad{op()} always evaluate to \\spad{a}.")) (|derivative| (((|Union| (|List| (|Mapping| |#1| (|List| |#1|))) "failed") (|BasicOperator|)) "\\spad{derivative(op)} returns the value of the \"\\%diff\" property of \\spad{op} if it has one,{} and \"failed\" otherwise.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| |#1|)) "\\spad{derivative(op,{} foo)} attaches foo as the \"\\%diff\" property of \\spad{op}. If \\spad{op} has an \"\\%diff\" property \\spad{f},{} then applying a derivation \\spad{D} to \\spad{op}(a) returns \\spad{f(a) * D(a)}. Argument \\spad{op} must be unary.") (((|BasicOperator|) (|BasicOperator|) (|List| (|Mapping| |#1| (|List| |#1|)))) "\\spad{derivative(op,{} [foo1,{}...,{}foon])} attaches [\\spad{foo1},{}...,{}foon] as the \"\\%diff\" property of \\spad{op}. If \\spad{op} has an \"\\%diff\" property \\spad{[f1,{}...,{}fn]} then applying a derivation \\spad{D} to \\spad{op(a1,{}...,{}an)} returns \\spad{f1(a1,{}...,{}an) * D(a1) + ... + fn(a1,{}...,{}an) * D(an)}.")) (|evaluate| (((|Union| (|Mapping| |#1| (|List| |#1|)) "failed") (|BasicOperator|)) "\\spad{evaluate(op)} returns the value of the \"\\%eval\" property of \\spad{op} if it has one,{} and \"failed\" otherwise.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| |#1|)) "\\spad{evaluate(op,{} foo)} attaches foo as the \"\\%eval\" property of \\spad{op}. If \\spad{op} has an \"\\%eval\" property \\spad{f},{} then applying \\spad{op} to a returns the result of \\spad{f(a)}. Argument \\spad{op} must be unary.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| (|List| |#1|))) "\\spad{evaluate(op,{} foo)} attaches foo as the \"\\%eval\" property of \\spad{op}. If \\spad{op} has an \"\\%eval\" property \\spad{f},{} then applying \\spad{op} to \\spad{(a1,{}...,{}an)} returns the result of \\spad{f(a1,{}...,{}an)}.") (((|Union| |#1| "failed") (|BasicOperator|) (|List| |#1|)) "\\spad{evaluate(op,{} [a1,{}...,{}an])} checks if \\spad{op} has an \"\\%eval\" property \\spad{f}. If it has,{} then \\spad{f(a1,{}...,{}an)} is returned,{} and \"failed\" otherwise."))) +((|constructor| (NIL "This package exports functions to set some commonly used properties of operators, including properties which contain functions.")) (|constantOpIfCan| (((|Union| |#1| "failed") (|BasicOperator|)) "\\spad{constantOpIfCan(op)} returns \\spad{a} if \\spad{op} is the constant nullary operator always returning \\spad{a}, \"failed\" otherwise.")) (|constantOperator| (((|BasicOperator|) |#1|) "\\spad{constantOperator(a)} returns a nullary operator op such that \\spad{op()} always evaluate to \\spad{a}.")) (|derivative| (((|Union| (|List| (|Mapping| |#1| (|List| |#1|))) "failed") (|BasicOperator|)) "\\spad{derivative(op)} returns the value of the \"\\%diff\" property of \\spad{op} if it has one, and \"failed\" otherwise.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| |#1|)) "\\spad{derivative(op, foo)} attaches foo as the \"\\%diff\" property of op. If \\spad{op} has an \"\\%diff\" property \\spad{f,} then applying a derivation \\spad{D} to op(a) returns \\spad{f(a) * D(a)}. Argument \\spad{op} must be unary.") (((|BasicOperator|) (|BasicOperator|) (|List| (|Mapping| |#1| (|List| |#1|)))) "\\spad{derivative(op, [foo1,...,foon])} attaches [foo1,...,foon] as the \"\\%diff\" property of op. If \\spad{op} has an \"\\%diff\" property \\spad{[f1,...,fn]} then applying a derivation \\spad{D} to \\spad{op(a1,...,an)} returns \\spad{f1(a1,...,an) * D(a1) + \\spad{...} + fn(a1,...,an) * D(an)}.")) (|evaluate| (((|Union| (|Mapping| |#1| (|List| |#1|)) "failed") (|BasicOperator|)) "\\spad{evaluate(op)} returns the value of the \"\\%eval\" property of \\spad{op} if it has one, and \"failed\" otherwise.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| |#1|)) "\\spad{evaluate(op, foo)} attaches foo as the \"\\%eval\" property of op. If \\spad{op} has an \"\\%eval\" property \\spad{f,} then applying \\spad{op} to a returns the result of \\spad{f(a)}. Argument \\spad{op} must be unary.") (((|BasicOperator|) (|BasicOperator|) (|Mapping| |#1| (|List| |#1|))) "\\spad{evaluate(op, foo)} attaches foo as the \"\\%eval\" property of op. If \\spad{op} has an \"\\%eval\" property \\spad{f,} then applying \\spad{op} to \\spad{(a1,...,an)} returns the result of \\spad{f(a1,...,an)}.") (((|Union| |#1| "failed") (|BasicOperator|) (|List| |#1|)) "\\spad{evaluate(op, [a1,...,an])} checks if \\spad{op} has an \"\\%eval\" property \\spad{f.} If it has, then \\spad{f(a1,...,an)} is returned, and \"failed\" otherwise."))) NIL -((|HasCategory| |#1| (QUOTE (-843)))) +((|HasCategory| |#1| (QUOTE (-844)))) (-123) -((|constructor| (NIL "Basic system operators. A basic operator is an object that can be applied to a list of arguments from a set,{} the result being a kernel over that set.")) (|setProperties| (($ $ (|AssociationList| (|String|) (|None|))) "\\spad{setProperties(op,{} l)} sets the property list of \\spad{op} to \\spad{l}. Argument \\spad{op} is modified \"in place\",{} \\spadignore{i.e.} no copy is made.")) (|setProperty| (($ $ (|String|) (|None|)) "\\spad{setProperty(op,{} s,{} v)} attaches property \\spad{s} to \\spad{op},{} and sets its value to \\spad{v}. Argument \\spad{op} is modified \"in place\",{} \\spadignore{i.e.} no copy is made.")) (|property| (((|Union| (|None|) "failed") $ (|String|)) "\\spad{property(op,{} s)} returns the value of property \\spad{s} if it is attached to \\spad{op},{} and \"failed\" otherwise.")) (|deleteProperty!| (($ $ (|String|)) "\\spad{deleteProperty!(op,{} s)} unattaches property \\spad{s} from \\spad{op}. Argument \\spad{op} is modified \"in place\",{} \\spadignore{i.e.} no copy is made.")) (|assert| (($ $ (|String|)) "\\spad{assert(op,{} s)} attaches property \\spad{s} to \\spad{op}. Argument \\spad{op} is modified \"in place\",{} \\spadignore{i.e.} no copy is made.")) (|has?| (((|Boolean|) $ (|String|)) "\\spad{has?(op,{} s)} tests if property \\spad{s} is attached to \\spad{op}.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(op,{} s)} tests if the name of \\spad{op} is \\spad{s}.")) (|input| (((|Union| (|Mapping| (|InputForm|) (|List| (|InputForm|))) "failed") $) "\\spad{input(op)} returns the \"\\%input\" property of \\spad{op} if it has one attached,{} \"failed\" otherwise.") (($ $ (|Mapping| (|InputForm|) (|List| (|InputForm|)))) "\\spad{input(op,{} foo)} attaches foo as the \"\\%input\" property of \\spad{op}. If \\spad{op} has a \"\\%input\" property \\spad{f},{} then \\spad{op(a1,{}...,{}an)} gets converted to InputForm as \\spad{f(a1,{}...,{}an)}.")) (|display| (($ $ (|Mapping| (|OutputForm|) (|OutputForm|))) "\\spad{display(op,{} foo)} attaches foo as the \"\\%display\" property of \\spad{op}. If \\spad{op} has a \"\\%display\" property \\spad{f},{} then \\spad{op(a)} gets converted to OutputForm as \\spad{f(a)}. Argument \\spad{op} must be unary.") (($ $ (|Mapping| (|OutputForm|) (|List| (|OutputForm|)))) "\\spad{display(op,{} foo)} attaches foo as the \"\\%display\" property of \\spad{op}. If \\spad{op} has a \"\\%display\" property \\spad{f},{} then \\spad{op(a1,{}...,{}an)} gets converted to OutputForm as \\spad{f(a1,{}...,{}an)}.") (((|Union| (|Mapping| (|OutputForm|) (|List| (|OutputForm|))) "failed") $) "\\spad{display(op)} returns the \"\\%display\" property of \\spad{op} if it has one attached,{} and \"failed\" otherwise.")) (|comparison| (($ $ (|Mapping| (|Boolean|) $ $)) "\\spad{comparison(op,{} foo?)} attaches foo? as the \"\\%less?\" property to \\spad{op}. If \\spad{op1} and \\spad{op2} have the same name,{} and one of them has a \"\\%less?\" property \\spad{f},{} then \\spad{f(op1,{} op2)} is called to decide whether \\spad{op1 < op2}.")) (|equality| (($ $ (|Mapping| (|Boolean|) $ $)) "\\spad{equality(op,{} foo?)} attaches foo? as the \"\\%equal?\" property to \\spad{op}. If \\spad{op1} and \\spad{op2} have the same name,{} and one of them has an \"\\%equal?\" property \\spad{f},{} then \\spad{f(op1,{} op2)} is called to decide whether \\spad{op1} and \\spad{op2} should be considered equal.")) (|weight| (($ $ (|NonNegativeInteger|)) "\\spad{weight(op,{} n)} attaches the weight \\spad{n} to \\spad{op}.") (((|NonNegativeInteger|) $) "\\spad{weight(op)} returns the weight attached to \\spad{op}.")) (|nary?| (((|Boolean|) $) "\\spad{nary?(op)} tests if \\spad{op} has arbitrary arity.")) (|unary?| (((|Boolean|) $) "\\spad{unary?(op)} tests if \\spad{op} is unary.")) (|nullary?| (((|Boolean|) $) "\\spad{nullary?(op)} tests if \\spad{op} is nullary.")) (|arity| (((|Union| (|NonNegativeInteger|) "failed") $) "\\spad{arity(op)} returns \\spad{n} if \\spad{op} is \\spad{n}-ary,{} and \"failed\" if \\spad{op} has arbitrary arity.")) (|operator| (($ (|Symbol|) (|NonNegativeInteger|)) "\\spad{operator(f,{} n)} makes \\spad{f} into an \\spad{n}-ary operator.") (($ (|Symbol|)) "\\spad{operator(f)} makes \\spad{f} into an operator with arbitrary arity.")) (|copy| (($ $) "\\spad{copy(op)} returns a copy of \\spad{op}.")) (|properties| (((|AssociationList| (|String|) (|None|)) $) "\\spad{properties(op)} returns the list of all the properties currently attached to \\spad{op}.")) (|name| (((|Symbol|) $) "\\spad{name(op)} returns the name of \\spad{op}."))) +((|constructor| (NIL "Basic system operators. A basic operator is an object that can be applied to a list of arguments from a set, the result being a kernel over that set.")) (|setProperties| (($ $ (|AssociationList| (|String|) (|None|))) "\\spad{setProperties(op, \\spad{l)}} sets the property list of \\spad{op} to \\spad{l.} Argument \\spad{op} is modified \"in place\", \\spadignore{i.e.} no copy is made.")) (|setProperty| (($ $ (|String|) (|None|)) "\\spad{setProperty(op, \\spad{s,} \\spad{v)}} attaches property \\spad{s} to op, and sets its value to \\spad{v.} Argument \\spad{op} is modified \"in place\", \\spadignore{i.e.} no copy is made.")) (|property| (((|Union| (|None|) "failed") $ (|String|)) "\\spad{property(op, \\spad{s)}} returns the value of property \\spad{s} if it is attached to op, and \"failed\" otherwise.")) (|deleteProperty!| (($ $ (|String|)) "\\spad{deleteProperty!(op, \\spad{s)}} unattaches property \\spad{s} from op. Argument \\spad{op} is modified \"in place\", \\spadignore{i.e.} no copy is made.")) (|assert| (($ $ (|String|)) "\\spad{assert(op, \\spad{s)}} attaches property \\spad{s} to op. Argument \\spad{op} is modified \"in place\", \\spadignore{i.e.} no copy is made.")) (|has?| (((|Boolean|) $ (|String|)) "\\spad{has?(op, \\spad{s)}} tests if property \\spad{s} is attached to op.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(op, \\spad{s)}} tests if the name of \\spad{op} is \\spad{s.}")) (|input| (((|Union| (|Mapping| (|InputForm|) (|List| (|InputForm|))) "failed") $) "\\spad{input(op)} returns the \"\\%input\" property of \\spad{op} if it has one attached, \"failed\" otherwise.") (($ $ (|Mapping| (|InputForm|) (|List| (|InputForm|)))) "\\spad{input(op, foo)} attaches foo as the \"\\%input\" property of op. If \\spad{op} has a \"\\%input\" property \\spad{f,} then \\spad{op(a1,...,an)} gets converted to InputForm as \\spad{f(a1,...,an)}.")) (|display| (($ $ (|Mapping| (|OutputForm|) (|OutputForm|))) "\\spad{display(op, foo)} attaches foo as the \"\\%display\" property of op. If \\spad{op} has a \"\\%display\" property \\spad{f,} then \\spad{op(a)} gets converted to OutputForm as \\spad{f(a)}. Argument \\spad{op} must be unary.") (($ $ (|Mapping| (|OutputForm|) (|List| (|OutputForm|)))) "\\spad{display(op, foo)} attaches foo as the \"\\%display\" property of op. If \\spad{op} has a \"\\%display\" property \\spad{f,} then \\spad{op(a1,...,an)} gets converted to OutputForm as \\spad{f(a1,...,an)}.") (((|Union| (|Mapping| (|OutputForm|) (|List| (|OutputForm|))) "failed") $) "\\spad{display(op)} returns the \"\\%display\" property of \\spad{op} if it has one attached, and \"failed\" otherwise.")) (|comparison| (($ $ (|Mapping| (|Boolean|) $ $)) "\\spad{comparison(op, foo?)} attaches foo? as the \"\\%less?\" property to op. If \\spad{op1} and \\spad{op2} have the same name, and one of them has a \"\\%less?\" property \\spad{f,} then \\spad{f(op1, op2)} is called to decide whether \\spad{op1 < op2}.")) (|equality| (($ $ (|Mapping| (|Boolean|) $ $)) "\\spad{equality(op, foo?)} attaches foo? as the \"\\%equal?\" property to op. If \\spad{op1} and \\spad{op2} have the same name, and one of them has an \"\\%equal?\" property \\spad{f,} then \\spad{f(op1, op2)} is called to decide whether \\spad{op1} and \\spad{op2} should be considered equal.")) (|weight| (($ $ (|NonNegativeInteger|)) "\\spad{weight(op, \\spad{n)}} attaches the weight \\spad{n} to op.") (((|NonNegativeInteger|) $) "\\spad{weight(op)} returns the weight attached to op.")) (|nary?| (((|Boolean|) $) "\\spad{nary?(op)} tests if \\spad{op} has arbitrary arity.")) (|unary?| (((|Boolean|) $) "\\spad{unary?(op)} tests if \\spad{op} is unary.")) (|nullary?| (((|Boolean|) $) "\\spad{nullary?(op)} tests if \\spad{op} is nullary.")) (|arity| (((|Union| (|NonNegativeInteger|) "failed") $) "\\spad{arity(op)} returns \\spad{n} if \\spad{op} is n-ary, and \"failed\" if \\spad{op} has arbitrary arity.")) (|operator| (($ (|Symbol|) (|NonNegativeInteger|)) "\\spad{operator(f, \\spad{n)}} makes \\spad{f} into an n-ary operator.") (($ (|Symbol|)) "\\spad{operator(f)} makes \\spad{f} into an operator with arbitrary arity.")) (|copy| (($ $) "\\spad{copy(op)} returns a copy of op.")) (|properties| (((|AssociationList| (|String|) (|None|)) $) "\\spad{properties(op)} returns the list of all the properties currently attached to op.")) (|name| (((|Symbol|) $) "\\spad{name(op)} returns the name of op."))) NIL NIL -(-124 -1564 UP) -((|constructor| (NIL "\\spadtype{BoundIntegerRoots} provides functions to find lower bounds on the integer roots of a polynomial.")) (|integerBound| (((|Integer|) |#2|) "\\spad{integerBound(p)} returns a lower bound on the negative integer roots of \\spad{p},{} and 0 if \\spad{p} has no negative integer roots."))) +(-124 -1647 UP) +((|constructor| (NIL "\\spadtype{BoundIntegerRoots} provides functions to find lower bounds on the integer roots of a polynomial.")) (|integerBound| (((|Integer|) |#2|) "\\spad{integerBound(p)} returns a lower bound on the negative integer roots of \\spad{p,} and 0 if \\spad{p} has no negative integer roots."))) NIL NIL (-125 |p|) -((|constructor| (NIL "Stream-based implementation of \\spad{Zp:} \\spad{p}-adic numbers are represented as sum(\\spad{i} = 0..,{} a[\\spad{i}] * p^i),{} where the a[\\spad{i}] lie in -(\\spad{p} - 1)\\spad{/2},{}...,{}(\\spad{p} - 1)\\spad{/2}."))) -((-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "Stream-based implementation of \\spad{Zp:} p-adic numbers are represented as sum(i = 0.., a[i] * p^i), where the a[i] lie in \\spad{-(p} - 1)/2,...,(p - 1)/2."))) +((-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-126 |p|) -((|constructor| (NIL "Stream-based implementation of \\spad{Qp:} numbers are represented as sum(\\spad{i} = \\spad{k}..,{} a[\\spad{i}] * p^i),{} where the a[\\spad{i}] lie in -(\\spad{p} - 1)\\spad{/2},{}...,{}(\\spad{p} - 1)\\spad{/2}."))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| (-125 |#1|) (QUOTE (-905))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -1038) (QUOTE (-1163)))) (|HasCategory| (-125 |#1|) (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-151))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-125 |#1|) (QUOTE (-1022))) (|HasCategory| (-125 |#1|) (QUOTE (-816))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (QUOTE (-1137))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (QUOTE (-226))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -524) (QUOTE (-1163)) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -304) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -282) (LIST (QUOTE -125) (|devaluate| |#1|)) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (QUOTE (-302))) (|HasCategory| (-125 |#1|) (QUOTE (-551))) (|HasCategory| (-125 |#1|) (QUOTE (-843))) (-2232 (|HasCategory| (-125 |#1|) (QUOTE (-816))) (|HasCategory| (-125 |#1|) (QUOTE (-843)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-905)))) (|HasCategory| (-125 |#1|) (QUOTE (-149))))) +((|constructor| (NIL "Stream-based implementation of \\spad{Qp:} numbers are represented as sum(i = k.., a[i] * p^i), where the a[i] lie in \\spad{-(p} - 1)/2,...,(p - 1)/2."))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| (-125 |#1|) (QUOTE (-906))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -1039) (QUOTE (-1165)))) (|HasCategory| (-125 |#1|) (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-151))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-125 |#1|) (QUOTE (-1023))) (|HasCategory| (-125 |#1|) (QUOTE (-817))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (QUOTE (-1139))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-125 |#1|) (QUOTE (-226))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -524) (QUOTE (-1165)) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -304) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (LIST (QUOTE -282) (LIST (QUOTE -125) (|devaluate| |#1|)) (LIST (QUOTE -125) (|devaluate| |#1|)))) (|HasCategory| (-125 |#1|) (QUOTE (-302))) (|HasCategory| (-125 |#1|) (QUOTE (-551))) (|HasCategory| (-125 |#1|) (QUOTE (-844))) (-1929 (|HasCategory| (-125 |#1|) (QUOTE (-817))) (|HasCategory| (-125 |#1|) (QUOTE (-844)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-125 |#1|) (QUOTE (-906)))) (|HasCategory| (-125 |#1|) (QUOTE (-149))))) (-127 A S) -((|constructor| (NIL "A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,{}x)} sets the right child of \\spad{t} to be \\spad{x}.")) (|setleft!| (($ $ $) "\\spad{setleft!(a,{}b)} sets the left child of \\axiom{a} to be \\spad{b}.")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,{}\"right\",{}b)} (also written \\axiom{\\spad{b} . right \\spad{:=} \\spad{b}}) is equivalent to \\axiom{setright!(a,{}\\spad{b})}.") (($ $ "left" $) "\\spad{setelt(a,{}\"left\",{}b)} (also written \\axiom{a . left \\spad{:=} \\spad{b}}) is equivalent to \\axiom{setleft!(a,{}\\spad{b})}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,{}\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,{}\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) +((|constructor| (NIL "A binary-recursive aggregate has 0, 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,x)} sets the right child of \\spad{t} to be \\spad{x.}")) (|setleft!| (($ $ $) "\\spad{setleft!(a,b)} sets the left child of \\axiom{a} to be \\spad{b.}")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,\"right\",b)} (also written \\axiom{b . right \\spad{:=} \\spad{b})} is equivalent to \\axiom{setright!(a,b)}.") (($ $ "left" $) "\\spad{setelt(a,\"left\",b)} (also written \\axiom{a . left \\spad{:=} \\spad{b})} is equivalent to \\axiom{setleft!(a,b)}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) NIL -((|HasAttribute| |#1| (QUOTE -4536))) +((|HasAttribute| |#1| (QUOTE -4572))) (-128 S) -((|constructor| (NIL "A binary-recursive aggregate has 0,{} 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,{}x)} sets the right child of \\spad{t} to be \\spad{x}.")) (|setleft!| (($ $ $) "\\spad{setleft!(a,{}b)} sets the left child of \\axiom{a} to be \\spad{b}.")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,{}\"right\",{}b)} (also written \\axiom{\\spad{b} . right \\spad{:=} \\spad{b}}) is equivalent to \\axiom{setright!(a,{}\\spad{b})}.") (($ $ "left" $) "\\spad{setelt(a,{}\"left\",{}b)} (also written \\axiom{a . left \\spad{:=} \\spad{b}}) is equivalent to \\axiom{setleft!(a,{}\\spad{b})}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,{}\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,{}\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) -((-2982 . T)) +((|constructor| (NIL "A binary-recursive aggregate has 0, 1 or 2 children and serves as a model for a binary tree or a doubly-linked aggregate structure")) (|setright!| (($ $ $) "\\spad{setright!(a,x)} sets the right child of \\spad{t} to be \\spad{x.}")) (|setleft!| (($ $ $) "\\spad{setleft!(a,b)} sets the left child of \\axiom{a} to be \\spad{b.}")) (|setelt| (($ $ "right" $) "\\spad{setelt(a,\"right\",b)} (also written \\axiom{b . right \\spad{:=} \\spad{b})} is equivalent to \\axiom{setright!(a,b)}.") (($ $ "left" $) "\\spad{setelt(a,\"left\",b)} (also written \\axiom{a . left \\spad{:=} \\spad{b})} is equivalent to \\axiom{setleft!(a,b)}.")) (|right| (($ $) "\\spad{right(a)} returns the right child.")) (|elt| (($ $ "right") "\\spad{elt(a,\"right\")} (also written: \\axiom{a . right}) is equivalent to \\axiom{right(a)}.") (($ $ "left") "\\spad{elt(u,\"left\")} (also written: \\axiom{a . left}) is equivalent to \\axiom{left(a)}.")) (|left| (($ $) "\\spad{left(u)} returns the left child."))) +((-4317 . T)) NIL (-129 UP) -((|constructor| (NIL "This package has no description")) (|noLinearFactor?| (((|Boolean|) |#1|) "\\spad{noLinearFactor?(p)} returns \\spad{true} if \\spad{p} can be shown to have no linear factor by a theorem of Lehmer,{} \\spad{false} else. \\spad{I} insist on the fact that \\spad{false} does not mean that \\spad{p} has a linear factor.")) (|brillhartTrials| (((|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{brillhartTrials(n)} sets to \\spad{n} the number of tests in \\spadfun{brillhartIrreducible?} and returns the previous value.") (((|NonNegativeInteger|)) "\\spad{brillhartTrials()} returns the number of tests in \\spadfun{brillhartIrreducible?}.")) (|brillhartIrreducible?| (((|Boolean|) |#1| (|Boolean|)) "\\spad{brillhartIrreducible?(p,{}noLinears)} returns \\spad{true} if \\spad{p} can be shown to be irreducible by a remark of Brillhart,{} \\spad{false} else. If \\spad{noLinears} is \\spad{true},{} we are being told \\spad{p} has no linear factors \\spad{false} does not mean that \\spad{p} is reducible.") (((|Boolean|) |#1|) "\\spad{brillhartIrreducible?(p)} returns \\spad{true} if \\spad{p} can be shown to be irreducible by a remark of Brillhart,{} \\spad{false} is inconclusive."))) +((|constructor| (NIL "This package has no description")) (|noLinearFactor?| (((|Boolean|) |#1|) "\\spad{noLinearFactor?(p)} returns \\spad{true} if \\spad{p} can be shown to have no linear factor by a theorem of Lehmer, \\spad{false} else. \\spad{I} insist on the fact that \\spad{false} does not mean that \\spad{p} has a linear factor.")) (|brillhartTrials| (((|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{brillhartTrials(n)} sets to \\spad{n} the number of tests in \\spadfun{brillhartIrreducible?} and returns the previous value.") (((|NonNegativeInteger|)) "\\spad{brillhartTrials()} returns the number of tests in \\spadfun{brillhartIrreducible?}.")) (|brillhartIrreducible?| (((|Boolean|) |#1| (|Boolean|)) "\\spad{brillhartIrreducible?(p,noLinears)} returns \\spad{true} if \\spad{p} can be shown to be irreducible by a remark of Brillhart, \\spad{false} else. If \\spad{noLinears} is \\spad{true}, we are being told \\spad{p} has no linear factors \\spad{false} does not mean that \\spad{p} is reducible.") (((|Boolean|) |#1|) "\\spad{brillhartIrreducible?(p)} returns \\spad{true} if \\spad{p} can be shown to be irreducible by a remark of Brillhart, \\spad{false} is inconclusive."))) NIL NIL (-130) -((|constructor| (NIL "Based on Symbol: a domain of symbols representing basic stochastic differentials,{} used in StochasticDifferential(\\spad{R}) in the underlying sparse multivariate polynomial representation. \\blankline We create new \\spad{BSD} only by coercion from Symbol using a special function introduce! first of all to add to a private set SDset. We allow a separate function convertIfCan which will check whether the argument has previously been declared as a \\spad{BSD}.")) (|getSmgl| (((|Union| (|Symbol|) "failed") $) "\\indented{1}{getSmgl(\\spad{bsd}) returns the semimartingale \\axiom{\\spad{S}} related} \\indented{1}{to the basic stochastic differential \\axiom{\\spad{bsd}} by} \\indented{1}{\\axiom{introduce!}} \\blankline \\spad{X} introduce!(\\spad{t},{}\\spad{dt}) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} getSmgl(dt::BSD)")) (|copyIto| (((|Table| (|Symbol|) $)) "\\indented{1}{copyIto() returns the table relating semimartingales} \\indented{1}{to basic stochastic differentials.} \\blankline \\spad{X} introduce!(\\spad{t},{}\\spad{dt}) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyIto()")) (|copyBSD| (((|List| $)) "\\indented{1}{copyBSD() returns \\axiom{setBSD} as a list of \\axiom{\\spad{BSD}}.} \\blankline \\spad{X} introduce!(\\spad{t},{}\\spad{dt}) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyBSD()")) (|d| (((|Union| $ (|Integer|)) (|Symbol|)) "\\spad{d(X)} returns \\axiom{\\spad{dX}} if \\axiom{tableIto(\\spad{X})\\spad{=dX}} and otherwise returns \\axiom{0}")) (|introduce!| (((|Union| $ "failed") (|Symbol|) (|Symbol|)) "\\indented{1}{introduce!(\\spad{X},{}\\spad{dX}) returns \\axiom{\\spad{dX}} as \\axiom{\\spad{BSD}} if it} \\indented{1}{isn\\spad{'t} already in \\axiom{\\spad{BSD}}} \\blankline \\spad{X} introduce!(\\spad{t},{}\\spad{dt}) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyBSD()")) (|convert| (($ (|Symbol|)) "\\spad{convert(dX)} transforms \\axiom{\\spad{dX}} into a \\axiom{\\spad{BSD}} if possible and otherwise produces an error.")) (|convertIfCan| (((|Union| $ "failed") (|Symbol|)) "\\spad{convertIfCan(ds)} transforms \\axiom{\\spad{dX}} into a \\axiom{\\spad{BSD}} if possible (if \\axiom{introduce(\\spad{X},{}\\spad{dX})} has been invoked previously)."))) +((|constructor| (NIL "Based on Symbol: a domain of symbols representing basic stochastic differentials, used in StochasticDifferential(R) in the underlying sparse multivariate polynomial representation. \\blankline We create new \\spad{BSD} only by coercion from Symbol using a special function introduce! first of all to add to a private set SDset. We allow a separate function convertIfCan which will check whether the argument has previously been declared as a BSD.")) (|getSmgl| (((|Union| (|Symbol|) "failed") $) "\\indented{1}{getSmgl(bsd) returns the semimartingale \\axiom{S} related} \\indented{1}{to the basic stochastic differential \\axiom{bsd} \\spad{by}} \\indented{1}{\\axiom{introduce!}} \\blankline \\spad{X} introduce!(t,dt) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} getSmgl(dt::BSD)")) (|copyIto| (((|Table| (|Symbol|) $)) "\\indented{1}{copyIto() returns the table relating semimartingales} \\indented{1}{to basic stochastic differentials.} \\blankline \\spad{X} introduce!(t,dt) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyIto()")) (|copyBSD| (((|List| $)) "\\indented{1}{copyBSD() returns \\axiom{setBSD} as a list of \\axiom{BSD}.} \\blankline \\spad{X} introduce!(t,dt) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyBSD()")) (|d| (((|Union| $ (|Integer|)) (|Symbol|)) "\\spad{d(X)} returns \\axiom{dX} if \\axiom{tableIto(X)=dX} and otherwise returns \\axiom{0}")) (|introduce!| (((|Union| $ "failed") (|Symbol|) (|Symbol|)) "\\indented{1}{introduce!(X,dX) returns \\axiom{dX} as \\axiom{BSD} if it} \\indented{1}{isn't already in \\axiom{BSD}} \\blankline \\spad{X} introduce!(t,dt) \\spad{--} \\spad{dt} is a new stochastic differential \\spad{X} copyBSD()")) (|convert| (($ (|Symbol|)) "\\spad{convert(dX)} transforms \\axiom{dX} into a \\axiom{BSD} if possible and otherwise produces an error.")) (|convertIfCan| (((|Union| $ "failed") (|Symbol|)) "\\spad{convertIfCan(ds)} transforms \\axiom{dX} into a \\axiom{BSD} if possible (if \\axiom{introduce(X,dX)} has been invoked previously)."))) NIL NIL (-131 S) -((|constructor| (NIL "BinarySearchTree(\\spad{S}) is the domain of a binary trees where elements are ordered across the tree. A binary search tree is either empty or has a value which is an \\spad{S},{} and a right and left which are both BinaryTree(\\spad{S}) Elements are ordered across the tree.")) (|split| (((|Record| (|:| |less| $) (|:| |greater| $)) |#1| $) "\\indented{1}{split(\\spad{x},{}\\spad{b}) splits binary tree \\spad{b} into two trees,{} one with elements} \\indented{1}{greater than \\spad{x},{} the other with elements less than \\spad{x}.} \\blankline \\spad{X} t1:=binarySearchTree [1,{}2,{}3,{}4] \\spad{X} split(3,{}\\spad{t1})")) (|insertRoot!| (($ |#1| $) "\\indented{1}{insertRoot!(\\spad{x},{}\\spad{b}) inserts element \\spad{x} as a root of binary search tree \\spad{b}.} \\blankline \\spad{X} t1:=binarySearchTree [1,{}2,{}3,{}4] \\spad{X} insertRoot!(5,{}\\spad{t1})")) (|insert!| (($ |#1| $) "\\indented{1}{insert!(\\spad{x},{}\\spad{b}) inserts element \\spad{x} as leaves into binary search tree \\spad{b}.} \\blankline \\spad{X} t1:=binarySearchTree [1,{}2,{}3,{}4] \\spad{X} insert!(5,{}\\spad{t1})")) (|binarySearchTree| (($ (|List| |#1|)) "\\indented{1}{binarySearchTree(\\spad{l}) is not documented} \\blankline \\spad{X} binarySearchTree [1,{}2,{}3,{}4]"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "BinarySearchTree(S) is the domain of a binary trees where elements are ordered across the tree. A binary search tree is either empty or has a value which is an \\spad{S,} and a right and left which are both BinaryTree(S) Elements are ordered across the tree.")) (|split| (((|Record| (|:| |less| $) (|:| |greater| $)) |#1| $) "\\indented{1}{split(x,b) splits binary tree \\spad{b} into two trees, one with elements} \\indented{1}{greater than \\spad{x,} the other with elements less than \\spad{x.}} \\blankline \\spad{X} t1:=binarySearchTree [1,2,3,4] \\spad{X} split(3,t1)")) (|insertRoot!| (($ |#1| $) "\\indented{1}{insertRoot!(x,b) inserts element \\spad{x} as a root of binary search tree \\spad{b.}} \\blankline \\spad{X} t1:=binarySearchTree [1,2,3,4] \\spad{X} insertRoot!(5,t1)")) (|insert!| (($ |#1| $) "\\indented{1}{insert!(x,b) inserts element \\spad{x} as leaves into binary search tree \\spad{b.}} \\blankline \\spad{X} t1:=binarySearchTree [1,2,3,4] \\spad{X} insert!(5,t1)")) (|binarySearchTree| (($ (|List| |#1|)) "\\indented{1}{binarySearchTree(l) is not documented} \\blankline \\spad{X} binarySearchTree [1,2,3,4]"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-132 S) -((|constructor| (NIL "The bit aggregate category models aggregates representing large quantities of Boolean data.")) (|xor| (($ $ $) "\\spad{xor(a,{}b)} returns the logical exclusive-or of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|or| (($ $ $) "\\spad{a or b} returns the logical or of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|and| (($ $ $) "\\spad{a and b} returns the logical and of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nor| (($ $ $) "\\spad{nor(a,{}b)} returns the logical nor of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nand| (($ $ $) "\\spad{nand(a,{}b)} returns the logical nand of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (^ (($ $) "\\spad{^ b} returns the logical not of bit aggregate \\axiom{\\spad{b}}.")) (|not| (($ $) "\\spad{not(b)} returns the logical not of bit aggregate \\axiom{\\spad{b}}."))) +((|constructor| (NIL "The bit aggregate category models aggregates representing large quantities of Boolean data.")) (|xor| (($ $ $) "\\spad{xor(a,b)} returns the logical exclusive-or of bit aggregates \\axiom{a} and \\axiom{b}.")) (|or| (($ $ $) "\\spad{a or \\spad{b}} returns the logical or of bit aggregates \\axiom{a} and \\axiom{b}.")) (|and| (($ $ $) "\\spad{a and \\spad{b}} returns the logical and of bit aggregates \\axiom{a} and \\axiom{b}.")) (|nor| (($ $ $) "\\spad{nor(a,b)} returns the logical nor of bit aggregates \\axiom{a} and \\axiom{b}.")) (|nand| (($ $ $) "\\spad{nand(a,b)} returns the logical nand of bit aggregates \\axiom{a} and \\axiom{b}.")) (^ (($ $) "\\spad{^ \\spad{b}} returns the logical not of bit aggregate \\axiom{b}.")) (|not| (($ $) "\\spad{not(b)} returns the logical not of bit aggregate \\axiom{b}."))) NIL NIL (-133) -((|constructor| (NIL "The bit aggregate category models aggregates representing large quantities of Boolean data.")) (|xor| (($ $ $) "\\spad{xor(a,{}b)} returns the logical exclusive-or of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|or| (($ $ $) "\\spad{a or b} returns the logical or of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|and| (($ $ $) "\\spad{a and b} returns the logical and of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nor| (($ $ $) "\\spad{nor(a,{}b)} returns the logical nor of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (|nand| (($ $ $) "\\spad{nand(a,{}b)} returns the logical nand of bit aggregates \\axiom{a} and \\axiom{\\spad{b}}.")) (^ (($ $) "\\spad{^ b} returns the logical not of bit aggregate \\axiom{\\spad{b}}.")) (|not| (($ $) "\\spad{not(b)} returns the logical not of bit aggregate \\axiom{\\spad{b}}."))) -((-4536 . T) (-4535 . T) (-2982 . T)) +((|constructor| (NIL "The bit aggregate category models aggregates representing large quantities of Boolean data.")) (|xor| (($ $ $) "\\spad{xor(a,b)} returns the logical exclusive-or of bit aggregates \\axiom{a} and \\axiom{b}.")) (|or| (($ $ $) "\\spad{a or \\spad{b}} returns the logical or of bit aggregates \\axiom{a} and \\axiom{b}.")) (|and| (($ $ $) "\\spad{a and \\spad{b}} returns the logical and of bit aggregates \\axiom{a} and \\axiom{b}.")) (|nor| (($ $ $) "\\spad{nor(a,b)} returns the logical nor of bit aggregates \\axiom{a} and \\axiom{b}.")) (|nand| (($ $ $) "\\spad{nand(a,b)} returns the logical nand of bit aggregates \\axiom{a} and \\axiom{b}.")) (^ (($ $) "\\spad{^ \\spad{b}} returns the logical not of bit aggregate \\axiom{b}.")) (|not| (($ $) "\\spad{not(b)} returns the logical not of bit aggregate \\axiom{b}."))) +((-4572 . T) (-4571 . T) (-4317 . T)) NIL (-134 A S) -((|constructor| (NIL "\\spadtype{BinaryTreeCategory(S)} is the category of binary trees: a tree which is either empty or else is a \\spadfun{node} consisting of a value and a \\spadfun{left} and \\spadfun{right},{} both binary trees.")) (|node| (($ $ |#2| $) "\\spad{node(left,{}v,{}right)} creates a binary tree with value \\spad{v},{} a binary tree \\spad{left},{} and a binary tree \\spad{right}. \\blankline")) (|finiteAggregate| ((|attribute|) "Binary trees have a finite number of components")) (|shallowlyMutable| ((|attribute|) "Binary trees have updateable components"))) +((|constructor| (NIL "\\spadtype{BinaryTreeCategory(S)} is the category of binary trees: a tree which is either empty or else is a \\spadfun{node} consisting of a value and a \\spadfun{left} and \\spadfun{right}, both binary trees.")) (|node| (($ $ |#2| $) "\\spad{node(left,v,right)} creates a binary tree with value \\spad{v}, a binary tree \\spad{left}, and a binary tree \\spad{right}. \\blankline")) (|finiteAggregate| ((|attribute|) "Binary trees have a finite number of components")) (|shallowlyMutable| ((|attribute|) "Binary trees have updateable components"))) NIL NIL (-135 S) -((|constructor| (NIL "\\spadtype{BinaryTreeCategory(S)} is the category of binary trees: a tree which is either empty or else is a \\spadfun{node} consisting of a value and a \\spadfun{left} and \\spadfun{right},{} both binary trees.")) (|node| (($ $ |#1| $) "\\spad{node(left,{}v,{}right)} creates a binary tree with value \\spad{v},{} a binary tree \\spad{left},{} and a binary tree \\spad{right}. \\blankline")) (|finiteAggregate| ((|attribute|) "Binary trees have a finite number of components")) (|shallowlyMutable| ((|attribute|) "Binary trees have updateable components"))) -((-4535 . T) (-4536 . T) (-2982 . T)) +((|constructor| (NIL "\\spadtype{BinaryTreeCategory(S)} is the category of binary trees: a tree which is either empty or else is a \\spadfun{node} consisting of a value and a \\spadfun{left} and \\spadfun{right}, both binary trees.")) (|node| (($ $ |#1| $) "\\spad{node(left,v,right)} creates a binary tree with value \\spad{v}, a binary tree \\spad{left}, and a binary tree \\spad{right}. \\blankline")) (|finiteAggregate| ((|attribute|) "Binary trees have a finite number of components")) (|shallowlyMutable| ((|attribute|) "Binary trees have updateable components"))) +((-4571 . T) (-4572 . T) (-4317 . T)) NIL (-136 S) -((|constructor| (NIL "BinaryTournament creates a binary tournament with the elements of \\spad{ls} as values at the nodes.")) (|insert!| (($ |#1| $) "\\indented{1}{insert!(\\spad{x},{}\\spad{b}) inserts element \\spad{x} as leaves into binary tournament \\spad{b}.} \\blankline \\spad{X} t1:=binaryTournament [1,{}2,{}3,{}4] \\spad{X} insert!(5,{}\\spad{t1}) \\spad{X} \\spad{t1}")) (|binaryTournament| (($ (|List| |#1|)) "\\indented{1}{binaryTournament(\\spad{ls}) creates a binary tournament with the} \\indented{1}{elements of \\spad{ls} as values at the nodes.} \\blankline \\spad{X} binaryTournament [1,{}2,{}3,{}4]"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "BinaryTournament creates a binary tournament with the elements of \\spad{ls} as values at the nodes.")) (|insert!| (($ |#1| $) "\\indented{1}{insert!(x,b) inserts element \\spad{x} as leaves into binary tournament \\spad{b.}} \\blankline \\spad{X} t1:=binaryTournament [1,2,3,4] \\spad{X} insert!(5,t1) \\spad{X} \\spad{t1}")) (|binaryTournament| (($ (|List| |#1|)) "\\indented{1}{binaryTournament(ls) creates a binary tournament with the} \\indented{1}{elements of \\spad{ls} as values at the nodes.} \\blankline \\spad{X} binaryTournament [1,2,3,4]"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-137 S) -((|constructor| (NIL "\\spadtype{BinaryTree(S)} is the domain of all binary trees. A binary tree over \\spad{S} is either empty or has a \\spadfun{value} which is an \\spad{S} and a \\spadfun{right} and \\spadfun{left} which are both binary trees.")) (|binaryTree| (($ $ |#1| $) "\\indented{1}{binaryTree(\\spad{l},{}\\spad{v},{}\\spad{r}) creates a binary tree with} \\indented{1}{value \\spad{v} with left subtree \\spad{l} and right subtree \\spad{r}.} \\blankline \\spad{X} t1:=binaryTree([1,{}2,{}3]) \\spad{X} t2:=binaryTree([4,{}5,{}6]) \\spad{X} binaryTree(\\spad{t1},{}[7,{}8,{}9],{}\\spad{t2})") (($ |#1|) "\\indented{1}{binaryTree(\\spad{v}) is an non-empty binary tree} \\indented{1}{with value \\spad{v},{} and left and right empty.} \\blankline \\spad{X} t1:=binaryTree([1,{}2,{}3])"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "\\spadtype{BinaryTree(S)} is the domain of all binary trees. A binary tree over \\spad{S} is either empty or has a \\spadfun{value} which is an \\spad{S} and a \\spadfun{right} and \\spadfun{left} which are both binary trees.")) (|binaryTree| (($ $ |#1| $) "\\indented{1}{binaryTree(l,v,r) creates a binary tree with} \\indented{1}{value \\spad{v} with left subtree \\spad{l} and right subtree \\spad{r.}} \\blankline \\spad{X} t1:=binaryTree([1,2,3]) \\spad{X} t2:=binaryTree([4,5,6]) \\spad{X} binaryTree(t1,[7,8,9],t2)") (($ |#1|) "\\indented{1}{binaryTree(v) is an non-empty binary tree} \\indented{1}{with value \\spad{v,} and left and right empty.} \\blankline \\spad{X} t1:=binaryTree([1,2,3])"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-138) -((|constructor| (NIL "This is an \\spadtype{AbelianMonoid} with the cancellation property,{} \\spadignore{i.e.} \\tab{5}\\spad{ a+b = a+c => b=c }.\\spad{\\br} This is formalised by the partial subtraction operator,{} which satisfies the Axioms\\spad{\\br} \\tab{5}\\spad{c = a+b <=> c-b = a}")) (|subtractIfCan| (((|Union| $ "failed") $ $) "\\spad{subtractIfCan(x,{} y)} returns an element \\spad{z} such that \\spad{z+y=x} or \"failed\" if no such element exists."))) +((|constructor| (NIL "This is an \\spadtype{AbelianMonoid} with the cancellation property, \\spadignore{i.e.} \\tab{5}\\spad{ a+b = a+c \\spad{=>} \\spad{b=c} }.\\br This is formalised by the partial subtraction operator, which satisfies the Axioms\\br \\tab{5}\\spad{c = a+b \\spad{<=>} \\spad{c-b} = a}")) (|subtractIfCan| (((|Union| $ "failed") $ $) "\\spad{subtractIfCan(x, \\spad{y)}} returns an element \\spad{z} such that \\spad{z+y=x} or \"failed\" if no such element exists."))) NIL NIL (-139) -((|constructor| (NIL "A cachable set is a set whose elements keep an integer as part of their structure.")) (|setPosition| (((|Void|) $ (|NonNegativeInteger|)) "\\spad{setPosition(x,{} n)} associates the integer \\spad{n} to \\spad{x}.")) (|position| (((|NonNegativeInteger|) $) "\\spad{position(x)} returns the integer \\spad{n} associated to \\spad{x}."))) +((|constructor| (NIL "A cachable set is a set whose elements keep an integer as part of their structure.")) (|setPosition| (((|Void|) $ (|NonNegativeInteger|)) "\\spad{setPosition(x, \\spad{n)}} associates the integer \\spad{n} to \\spad{x.}")) (|position| (((|NonNegativeInteger|) $) "\\spad{position(x)} returns the integer \\spad{n} associated to \\spad{x.}"))) NIL NIL (-140) -((|constructor| (NIL "Members of the domain CardinalNumber are values indicating the cardinality of sets,{} both finite and infinite. Arithmetic operations are defined on cardinal numbers as follows. \\blankline If \\spad{x = \\#X} and \\spad{y = \\#Y} then\\spad{\\br} \\tab{5}\\spad{x+y = \\#(X+Y)} \\tab{5}disjoint union\\spad{\\br} \\tab{5}\\spad{x-y = \\#(X-Y)} \\tab{5}relative complement\\spad{\\br} \\tab{5}\\spad{x*y = \\#(X*Y)} \\tab{5}cartesian product\\spad{\\br} \\tab{5}\\spad{x**y = \\#(X**Y)} \\tab{4}\\spad{X**Y = g| g:Y->X} \\blankline The non-negative integers have a natural construction as cardinals\\spad{\\br} \\spad{0 = \\#\\{\\}},{} \\spad{1 = \\{0\\}},{} \\spad{2 = \\{0,{} 1\\}},{} ...,{} \\spad{n = \\{i| 0 <= i < n\\}}. \\blankline That \\spad{0} acts as a zero for the multiplication of cardinals is equivalent to the axiom of choice. \\blankline The generalized continuum hypothesis asserts \\spad{\\br} \\spad{2**Aleph i = Aleph(i+1)} and is independent of the axioms of set theory [Goedel 1940]. \\blankline Three commonly encountered cardinal numbers are\\spad{\\br} \\tab{5}\\spad{a = \\#Z} \\tab{5}countable infinity\\spad{\\br} \\tab{5}\\spad{c = \\#R} \\tab{5}the continuum\\spad{\\br} \\tab{5}\\spad{f = \\# g | g:[0,{}1]->R\\} \\blankline In this domain,{} these values are obtained using\\br \\tab{5}\\spad{a := Aleph 0},{} \\spad{c := 2**a},{} \\spad{f := 2**c}.")) (|generalizedContinuumHypothesisAssumed| (((|Boolean|) (|Boolean|)) "\\indented{1}{generalizedContinuumHypothesisAssumed(bool)} \\indented{1}{is used to dictate whether the hypothesis is to be assumed.} \\blankline \\spad{X} generalizedContinuumHypothesisAssumed \\spad{true} \\spad{X} a:=Aleph 0 \\spad{X} c:=2**a \\spad{X} f:=2**c")) (|generalizedContinuumHypothesisAssumed?| (((|Boolean|)) "\\indented{1}{generalizedContinuumHypothesisAssumed?()} \\indented{1}{tests if the hypothesis is currently assumed.} \\blankline \\spad{X} generalizedContinuumHypothesisAssumed?")) (|countable?| (((|Boolean|) $) "\\indented{1}{countable?(\\spad{a}) determines} \\indented{1}{whether \\spad{a} is a countable cardinal,{}} \\indented{1}{\\spadignore{i.e.} an integer or \\spad{Aleph 0}.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} countable? \\spad{c2} \\spad{X} A0:=Aleph 0 \\spad{X} countable? \\spad{A0} \\spad{X} A1:=Aleph 1 \\spad{X} countable? \\spad{A1}")) (|finite?| (((|Boolean|) $) "\\indented{1}{finite?(\\spad{a}) determines whether} \\indented{1}{\\spad{a} is a finite cardinal,{} \\spadignore{i.e.} an integer.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} finite? \\spad{c2} \\spad{X} A0:=Aleph 0 \\spad{X} finite? \\spad{A0}")) (|Aleph| (($ (|NonNegativeInteger|)) "\\indented{1}{Aleph(\\spad{n}) provides the named (infinite) cardinal number.} \\blankline \\spad{X} A0:=Aleph 0")) (** (($ $ $) "\\indented{1}{\\spad{x**y} returns \\spad{\\#(X**Y)} where \\spad{X**Y} is defined} \\indented{2}{as \\spad{\\{g| g:Y->X\\}}.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} \\spad{c2**c2} \\spad{X} A1:=Aleph 1 \\spad{X} \\spad{A1**c2} \\spad{X} generalizedContinuumHypothesisAssumed \\spad{true} \\spad{X} \\spad{A1**A1}")) (- (((|Union| $ "failed") $ $) "\\indented{1}{\\spad{x - y} returns an element \\spad{z} such that} \\indented{1}{\\spad{z+y=x} or \"failed\" if no such element exists.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} \\spad{c2}-\\spad{c2} \\spad{X} A1:=Aleph 1 \\spad{X} \\spad{A1}-\\spad{c2}")) (|commutative| ((|attribute| "*") "a domain \\spad{D} has \\spad{commutative(\"*\")} if it has an operation \\spad{\"*\": (D,{}D) -> D} which is commutative."))) -(((-4537 "*") . T)) +((|constructor| (NIL "Members of the domain CardinalNumber are values indicating the cardinality of sets, both finite and infinite. Arithmetic operations are defined on cardinal numbers as follows. \\blankline If \\spad{x = \\spad{#X}} and \\spad{y = \\spad{#Y}} then\\br \\tab{5}\\spad{x+y = \\#(X+Y)} \\tab{5}disjoint union\\br \\tab{5}\\spad{x-y = \\#(X-Y)} \\tab{5}relative complement\\br \\tab{5}\\spad{x*y = \\#(X*Y)} \\tab{5}cartesian product\\br \\tab{5}\\spad{x**y = \\#(X**Y)} \\tab{4}\\spad{X**Y = \\spad{g|} g:Y->X} \\blankline The non-negative integers have a natural construction as cardinals\\br \\spad{0 = \\#\\{\\}}, \\spad{1 = \\{0\\}}, \\spad{2 = \\{0, 1\\}}, ..., \\spad{n = \\{i| 0 \\spad{<=} \\spad{i} < n\\}}. \\blankline That \\spad{0} acts as a zero for the multiplication of cardinals is equivalent to the axiom of choice. \\blankline The generalized continuum hypothesis asserts \\spad{\\br} \\spad{2**Aleph \\spad{i} = Aleph(i+1)} and is independent of the axioms of set theory [Goedel 1940]. \\blankline Three commonly encountered cardinal numbers are\\br \\tab{5}\\spad{a = \\spad{#Z}} \\tab{5}countable infinity\\br \\tab{5}\\spad{c = \\spad{#R}} \\tab{5}the continuum\\br \\tab{5}\\spad{f = \\# \\spad{g} | g:[0,1]->R\\} \\blankline In this domain, these values are obtained using\\br \\tab{5}\\spad{a \\spad{:=} Aleph 0}, \\spad{c \\spad{:=} 2**a}, \\spad{f \\spad{:=} 2**c}.")) (|generalizedContinuumHypothesisAssumed| (((|Boolean|) (|Boolean|)) "\\indented{1}{generalizedContinuumHypothesisAssumed(bool)} \\indented{1}{is used to dictate whether the hypothesis is to be assumed.} \\blankline \\spad{X} generalizedContinuumHypothesisAssumed \\spad{true} \\spad{X} a:=Aleph 0 \\spad{X} c:=2**a \\spad{X} f:=2**c")) (|generalizedContinuumHypothesisAssumed?| (((|Boolean|)) "\\indented{1}{generalizedContinuumHypothesisAssumed?()} \\indented{1}{tests if the hypothesis is currently assumed.} \\blankline \\spad{X} generalizedContinuumHypothesisAssumed?")) (|countable?| (((|Boolean|) $) "\\indented{1}{countable?(\\spad{a}) determines} \\indented{1}{whether \\spad{a} is a countable cardinal,} \\indented{1}{\\spadignore{i.e.} an integer or \\spad{Aleph 0}.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} countable? \\spad{c2} \\spad{X} A0:=Aleph 0 \\spad{X} countable? \\spad{A0} \\spad{X} A1:=Aleph 1 \\spad{X} countable? \\spad{A1}")) (|finite?| (((|Boolean|) $) "\\indented{1}{finite?(\\spad{a}) determines whether} \\indented{1}{\\spad{a} is a finite cardinal, \\spadignore{i.e.} an integer.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} finite? \\spad{c2} \\spad{X} A0:=Aleph 0 \\spad{X} finite? \\spad{A0}")) (|Aleph| (($ (|NonNegativeInteger|)) "\\indented{1}{Aleph(n) provides the named (infinite) cardinal number.} \\blankline \\spad{X} A0:=Aleph 0")) (** (($ $ $) "\\indented{1}{\\spad{x**y} returns \\spad{\\#(X**Y)} where \\spad{X**Y} is defined} \\indented{2}{as \\spad{\\{g| g:Y->X\\}}.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} \\spad{c2**c2} \\spad{X} A1:=Aleph 1 \\spad{X} \\spad{A1**c2} \\spad{X} generalizedContinuumHypothesisAssumed \\spad{true} \\spad{X} \\spad{A1**A1}")) (- (((|Union| $ "failed") $ $) "\\indented{1}{\\spad{x - \\spad{y}} returns an element \\spad{z} such that} \\indented{1}{\\spad{z+y=x} or \"failed\" if no such element exists.} \\blankline \\spad{X} c2:=2::CardinalNumber \\spad{X} \\spad{c2-c2} \\spad{X} A1:=Aleph 1 \\spad{X} \\spad{A1-c2}")) (|commutative| ((|attribute| "*") "a domain \\spad{D} has \\spad{commutative(\"*\")} if it has an operation \\spad{\"*\": (D,D) \\spad{->} \\spad{D}} which is commutative."))) +(((-4573 "*") . T)) NIL -(-141 |minix| -4391 S T$) -((|constructor| (NIL "This package provides functions to enable conversion of tensors given conversion of the components.")) (|map| (((|CartesianTensor| |#1| |#2| |#4|) (|Mapping| |#4| |#3|) (|CartesianTensor| |#1| |#2| |#3|)) "\\spad{map(f,{}ts)} does a componentwise conversion of the tensor \\spad{ts} to a tensor with components of type \\spad{T}.")) (|reshape| (((|CartesianTensor| |#1| |#2| |#4|) (|List| |#4|) (|CartesianTensor| |#1| |#2| |#3|)) "\\spad{reshape(lt,{}ts)} organizes the list of components \\spad{lt} into a tensor with the same shape as \\spad{ts}."))) +(-141 |minix| -4360 S T$) +((|constructor| (NIL "This package provides functions to enable conversion of tensors given conversion of the components.")) (|map| (((|CartesianTensor| |#1| |#2| |#4|) (|Mapping| |#4| |#3|) (|CartesianTensor| |#1| |#2| |#3|)) "\\spad{map(f,ts)} does a componentwise conversion of the tensor \\spad{ts} to a tensor with components of type \\spad{T.}")) (|reshape| (((|CartesianTensor| |#1| |#2| |#4|) (|List| |#4|) (|CartesianTensor| |#1| |#2| |#3|)) "\\spad{reshape(lt,ts)} organizes the list of components \\spad{lt} into a tensor with the same shape as \\spad{ts.}"))) NIL NIL -(-142 |minix| -4391 R) -((|constructor| (NIL "CartesianTensor(minix,{}dim,{}\\spad{R}) provides Cartesian tensors with components belonging to a commutative ring \\spad{R}. These tensors can have any number of indices. Each index takes values from \\spad{minix} to \\spad{minix + dim - 1}.")) (|sample| (($) "\\spad{sample()} returns an object of type \\%.")) (|unravel| (($ (|List| |#3|)) "\\spad{unravel(t)} produces a tensor from a list of components such that \\indented{2}{\\spad{unravel(ravel(t)) = t}.}")) (|ravel| (((|List| |#3|) $) "\\indented{1}{ravel(\\spad{t}) produces a list of components from a tensor such that} \\indented{3}{\\spad{unravel(ravel(t)) = t}.} \\blankline \\spad{X} n:SquareMatrix(2,{}Integer):=matrix [[2,{}3],{}[0,{}1]] \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=n} \\spad{X} ravel \\spad{tn}")) (|leviCivitaSymbol| (($) "\\indented{1}{leviCivitaSymbol() is the rank \\spad{dim} tensor defined by} \\indented{1}{\\spad{leviCivitaSymbol()(i1,{}...idim) = +1/0/-1}} \\indented{1}{if \\spad{i1,{}...,{}idim} is an even/is nota /is an odd permutation} \\indented{1}{of \\spad{minix,{}...,{}minix+dim-1}.} \\blankline \\spad{X} lcs:CartesianTensor(1,{}2,{}Integer):=leviCivitaSymbol()")) (|kroneckerDelta| (($) "\\indented{1}{kroneckerDelta() is the rank 2 tensor defined by} \\indented{4}{\\spad{kroneckerDelta()(i,{}j)}} \\indented{7}{\\spad{= 1\\space{2}if i = j}} \\indented{7}{\\spad{= 0 if\\space{2}i \\^= j}} \\blankline \\spad{X} delta:CartesianTensor(1,{}2,{}Integer):=kroneckerDelta()")) (|reindex| (($ $ (|List| (|Integer|))) "\\indented{1}{reindex(\\spad{t},{}[\\spad{i1},{}...,{}idim]) permutes the indices of \\spad{t}.} \\indented{1}{For example,{} if \\spad{r = reindex(t,{} [4,{}1,{}2,{}3])}} \\indented{1}{for a rank 4 tensor \\spad{t},{}} \\indented{1}{then \\spad{r} is the rank for tensor given by} \\indented{5}{\\spad{r(i,{}j,{}k,{}l) = t(l,{}i,{}j,{}k)}.} \\blankline \\spad{X} n:SquareMatrix(2,{}Integer):=matrix [[2,{}3],{}[0,{}1]] \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=n} \\spad{X} p:=product(\\spad{tn},{}\\spad{tn}) \\spad{X} reindex(\\spad{p},{}[4,{}3,{}2,{}1])")) (|transpose| (($ $ (|Integer|) (|Integer|)) "\\indented{1}{transpose(\\spad{t},{}\\spad{i},{}\\spad{j}) exchanges the \\spad{i}\\spad{-}th and \\spad{j}\\spad{-}th} \\indented{1}{indices of \\spad{t}. For example,{} if \\spad{r = transpose(t,{}2,{}3)}} \\indented{1}{for a rank 4 tensor \\spad{t},{} then \\spad{r} is the rank 4 tensor} \\indented{1}{given by} \\indented{5}{\\spad{r(i,{}j,{}k,{}l) = t(i,{}k,{}j,{}l)}.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tm},{}\\spad{tm}] \\spad{X} transpose(\\spad{tn},{}1,{}2)") (($ $) "\\indented{1}{transpose(\\spad{t}) exchanges the first and last indices of \\spad{t}.} \\indented{1}{For example,{} if \\spad{r = transpose(t)} for a rank 4} \\indented{1}{tensor \\spad{t},{} then \\spad{r} is the rank 4 tensor given by} \\indented{5}{\\spad{r(i,{}j,{}k,{}l) = t(l,{}j,{}k,{}i)}.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} Tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} transpose(\\spad{Tm})")) (|contract| (($ $ (|Integer|) (|Integer|)) "\\indented{1}{contract(\\spad{t},{}\\spad{i},{}\\spad{j}) is the contraction of tensor \\spad{t} which} \\indented{1}{sums along the \\spad{i}\\spad{-}th and \\spad{j}\\spad{-}th indices.} \\indented{1}{For example,{}\\space{2}if} \\indented{1}{\\spad{r = contract(t,{}1,{}3)} for a rank 4 tensor \\spad{t},{} then} \\indented{1}{\\spad{r} is the rank 2 \\spad{(= 4 - 2)} tensor given by} \\indented{5}{\\spad{r(i,{}j) = sum(h=1..dim,{}t(h,{}i,{}h,{}j))}.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} Tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} v:DirectProduct(2,{}Integer):=directProduct [3,{}4] \\spad{X} Tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} Tmv:=contract(\\spad{Tm},{}2,{}1)") (($ $ (|Integer|) $ (|Integer|)) "\\indented{1}{contract(\\spad{t},{}\\spad{i},{}\\spad{s},{}\\spad{j}) is the inner product of tenors \\spad{s} and \\spad{t}} \\indented{1}{which sums along the \\spad{k1}\\spad{-}th index of} \\indented{1}{\\spad{t} and the \\spad{k2}\\spad{-}th index of \\spad{s}.} \\indented{1}{For example,{} if \\spad{r = contract(s,{}2,{}t,{}1)} for rank 3 tensors} \\indented{1}{rank 3 tensors \\spad{s} and \\spad{t},{} then \\spad{r} is} \\indented{1}{the rank 4 \\spad{(= 3 + 3 - 2)} tensor\\space{2}given by} \\indented{5}{\\spad{r(i,{}j,{}k,{}l) = sum(h=1..dim,{}s(i,{}h,{}j)*t(h,{}k,{}l))}.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} Tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} v:DirectProduct(2,{}Integer):=directProduct [3,{}4] \\spad{X} Tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} Tmv:=contract(\\spad{Tm},{}2,{}\\spad{Tv},{}1)")) (* (($ $ $) "\\indented{1}{\\spad{s*t} is the inner product of the tensors \\spad{s} and \\spad{t} which contracts} \\indented{1}{the last index of \\spad{s} with the first index of \\spad{t},{} that is,{}} \\indented{5}{\\spad{t*s = contract(t,{}rank t,{} s,{} 1)}} \\indented{5}{\\spad{t*s = sum(k=1..N,{} t[i1,{}..,{}iN,{}k]*s[k,{}j1,{}..,{}jM])}} \\indented{1}{This is compatible with the use of \\spad{M*v} to denote} \\indented{1}{the matrix-vector inner product.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} Tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} v:DirectProduct(2,{}Integer):=directProduct [3,{}4] \\spad{X} Tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} Tm*Tv")) (|product| (($ $ $) "\\indented{1}{product(\\spad{s},{}\\spad{t}) is the outer product of the tensors \\spad{s} and \\spad{t}.} \\indented{1}{For example,{} if \\spad{r = product(s,{}t)} for rank 2 tensors} \\indented{1}{\\spad{s} and \\spad{t},{} then \\spad{r} is a rank 4 tensor given by} \\indented{5}{\\spad{r(i,{}j,{}k,{}l) = s(i,{}j)*t(k,{}l)}.} \\blankline \\spad{X} m:SquareMatrix(2,{}Integer):=matrix [[1,{}2],{}[4,{}5]] \\spad{X} Tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=m} \\spad{X} n:SquareMatrix(2,{}Integer):=matrix [[2,{}3],{}[0,{}1]] \\spad{X} Tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=n} \\spad{X} Tmn:=product(\\spad{Tm},{}\\spad{Tn})")) (|elt| ((|#3| $ (|List| (|Integer|))) "\\indented{1}{elt(\\spad{t},{}[\\spad{i1},{}...,{}iN]) gives a component of a rank \\spad{N} tensor.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tv},{}\\spad{tv}] \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tm},{}\\spad{tm}] \\spad{X} tp:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tn},{}\\spad{tn}] \\spad{X} tq:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tp},{}\\spad{tp}] \\spad{X} elt(\\spad{tq},{}[2,{}2,{}2,{}2,{}2])") ((|#3| $ (|Integer|) (|Integer|) (|Integer|) (|Integer|)) "\\indented{1}{elt(\\spad{t},{}\\spad{i},{}\\spad{j},{}\\spad{k},{}\\spad{l}) gives a component of a rank 4 tensor.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tv},{}\\spad{tv}] \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tm},{}\\spad{tm}] \\spad{X} tp:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tn},{}\\spad{tn}] \\spad{X} elt(\\spad{tp},{}2,{}2,{}2,{}2) \\spad{X} \\spad{tp}[2,{}2,{}2,{}2]") ((|#3| $ (|Integer|) (|Integer|) (|Integer|)) "\\indented{1}{elt(\\spad{t},{}\\spad{i},{}\\spad{j},{}\\spad{k}) gives a component of a rank 3 tensor.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tv},{}\\spad{tv}] \\spad{X} tn:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tm},{}\\spad{tm}] \\spad{X} elt(\\spad{tn},{}2,{}2,{}2) \\spad{X} \\spad{tn}[2,{}2,{}2]") ((|#3| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(\\spad{t},{}\\spad{i},{}\\spad{j}) gives a component of a rank 2 tensor.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tv},{}\\spad{tv}] \\spad{X} elt(\\spad{tm},{}2,{}2) \\spad{X} \\spad{tm}[2,{}2]") ((|#3| $ (|Integer|)) "\\indented{1}{elt(\\spad{t},{}\\spad{i}) gives a component of a rank 1 tensor.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} elt(\\spad{tv},{}2) \\spad{X} \\spad{tv}[2]") ((|#3| $) "\\indented{1}{elt(\\spad{t}) gives the component of a rank 0 tensor.} \\blankline \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=8} \\spad{X} elt(\\spad{tv}) \\spad{X} \\spad{tv}[]")) (|rank| (((|NonNegativeInteger|) $) "\\indented{1}{rank(\\spad{t}) returns the tensorial rank of \\spad{t} (that is,{} the} \\indented{1}{number of indices).\\space{2}This is the same as the graded module} \\indented{1}{degree.} \\blankline \\spad{X} CT:=CARTEN(1,{}2,{}Integer) \\spad{X} \\spad{t0:CT:=8} \\spad{X} rank \\spad{t0}")) (|coerce| (($ (|List| $)) "\\indented{1}{coerce([\\spad{t_1},{}...,{}t_dim]) allows tensors to be constructed} \\indented{1}{using lists.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v} \\spad{X} tm:CartesianTensor(1,{}2,{}Integer)\\spad{:=}[\\spad{tv},{}\\spad{tv}]") (($ (|List| |#3|)) "\\indented{1}{coerce([\\spad{r_1},{}...,{}r_dim]) allows tensors to be constructed} \\indented{1}{using lists.} \\blankline \\spad{X} \\spad{v:=}[2,{}3] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v}") (($ (|SquareMatrix| |#2| |#3|)) "\\indented{1}{coerce(\\spad{m}) views a matrix as a rank 2 tensor.} \\blankline \\spad{X} v:SquareMatrix(2,{}Integer)\\spad{:=}[[1,{}2],{}[3,{}4]] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v}") (($ (|DirectProduct| |#2| |#3|)) "\\indented{1}{coerce(\\spad{v}) views a vector as a rank 1 tensor.} \\blankline \\spad{X} v:DirectProduct(2,{}Integer):=directProduct [3,{}4] \\spad{X} tv:CartesianTensor(1,{}2,{}Integer)\\spad{:=v}"))) +(-142 |minix| -4360 R) +((|constructor| (NIL "CartesianTensor(minix,dim,R) provides Cartesian tensors with components belonging to a commutative ring \\spad{R.} These tensors can have any number of indices. Each index takes values from \\spad{minix} to \\spad{minix + dim - 1}.")) (|sample| (($) "\\spad{sample()} returns an object of type \\spad{%.}")) (|unravel| (($ (|List| |#3|)) "\\spad{unravel(t)} produces a tensor from a list of components such that \\indented{2}{\\spad{unravel(ravel(t)) = t}.}")) (|ravel| (((|List| |#3|) $) "\\indented{1}{ravel(t) produces a list of components from a tensor such that} \\indented{3}{\\spad{unravel(ravel(t)) = t}.} \\blankline \\spad{X} n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]] \\spad{X} tn:CartesianTensor(1,2,Integer):=n \\spad{X} ravel \\spad{tn}")) (|leviCivitaSymbol| (($) "\\indented{1}{leviCivitaSymbol() is the rank \\spad{dim} tensor defined \\spad{by}} \\indented{1}{\\spad{leviCivitaSymbol()(i1,...idim) = +1/0/-1}} \\indented{1}{if \\spad{i1,...,idim} is an even/is nota /is an odd permutation} \\indented{1}{of \\spad{minix,...,minix+dim-1}.} \\blankline \\spad{X} lcs:CartesianTensor(1,2,Integer):=leviCivitaSymbol()")) (|kroneckerDelta| (($) "\\indented{1}{kroneckerDelta() is the rank 2 tensor defined \\spad{by}} \\indented{4}{\\spad{kroneckerDelta()(i,j)}} \\indented{7}{\\spad{= 1\\space{2}if \\spad{i} = \\spad{j}}} \\indented{7}{\\spad{= 0 if\\space{2}i \\spad{\\^=} \\spad{j}}} \\blankline \\spad{X} delta:CartesianTensor(1,2,Integer):=kroneckerDelta()")) (|reindex| (($ $ (|List| (|Integer|))) "\\indented{1}{reindex(t,[i1,...,idim]) permutes the indices of \\spad{t.}} \\indented{1}{For example, if \\spad{r = reindex(t, [4,1,2,3])}} \\indented{1}{for a rank 4 tensor \\spad{t,}} \\indented{1}{then \\spad{r} is the rank for tensor given \\spad{by}} \\indented{5}{\\spad{r(i,j,k,l) = t(l,i,j,k)}.} \\blankline \\spad{X} n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]] \\spad{X} tn:CartesianTensor(1,2,Integer):=n \\spad{X} p:=product(tn,tn) \\spad{X} reindex(p,[4,3,2,1])")) (|transpose| (($ $ (|Integer|) (|Integer|)) "\\indented{1}{transpose(t,i,j) exchanges the \\spad{i}-th and \\spad{j}-th} \\indented{1}{indices of \\spad{t.} For example, if \\spad{r = transpose(t,2,3)}} \\indented{1}{for a rank 4 tensor \\spad{t,} then \\spad{r} is the rank 4 tensor} \\indented{1}{given \\spad{by}} \\indented{5}{\\spad{r(i,j,k,l) = t(i,k,j,l)}.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} tm:CartesianTensor(1,2,Integer):=m \\spad{X} tn:CartesianTensor(1,2,Integer):=[tm,tm] \\spad{X} transpose(tn,1,2)") (($ $) "\\indented{1}{transpose(t) exchanges the first and last indices of \\spad{t.}} \\indented{1}{For example, if \\spad{r = transpose(t)} for a rank 4} \\indented{1}{tensor \\spad{t,} then \\spad{r} is the rank 4 tensor given \\spad{by}} \\indented{5}{\\spad{r(i,j,k,l) = t(l,j,k,i)}.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} Tm:CartesianTensor(1,2,Integer):=m \\spad{X} transpose(Tm)")) (|contract| (($ $ (|Integer|) (|Integer|)) "\\indented{1}{contract(t,i,j) is the contraction of tensor \\spad{t} which} \\indented{1}{sums along the \\spad{i}-th and \\spad{j}-th indices.} \\indented{1}{For example,\\space{2}if} \\indented{1}{\\spad{r = contract(t,1,3)} for a rank 4 tensor \\spad{t,} then} \\indented{1}{\\spad{r} is the rank 2 \\spad{(= 4 - 2)} tensor given \\spad{by}} \\indented{5}{\\spad{r(i,j) = sum(h=1..dim,t(h,i,h,j))}.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} Tm:CartesianTensor(1,2,Integer):=m \\spad{X} v:DirectProduct(2,Integer):=directProduct [3,4] \\spad{X} Tv:CartesianTensor(1,2,Integer):=v \\spad{X} Tmv:=contract(Tm,2,1)") (($ $ (|Integer|) $ (|Integer|)) "\\indented{1}{contract(t,i,s,j) is the inner product of tenors \\spad{s} and \\spad{t}} \\indented{1}{which sums along the \\spad{k1}-th index of} \\indented{1}{t and the \\spad{k2}-th index of \\spad{s.}} \\indented{1}{For example, if \\spad{r = contract(s,2,t,1)} for rank 3 tensors} \\indented{1}{rank 3 tensors \\spad{s} and \\spad{t}, then \\spad{r} is} \\indented{1}{the rank 4 \\spad{(= 3 + 3 - 2)} tensor\\space{2}given \\spad{by}} \\indented{5}{\\spad{r(i,j,k,l) = sum(h=1..dim,s(i,h,j)*t(h,k,l))}.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} Tm:CartesianTensor(1,2,Integer):=m \\spad{X} v:DirectProduct(2,Integer):=directProduct [3,4] \\spad{X} Tv:CartesianTensor(1,2,Integer):=v \\spad{X} Tmv:=contract(Tm,2,Tv,1)")) (* (($ $ $) "\\indented{1}{s*t is the inner product of the tensors \\spad{s} and \\spad{t} which contracts} \\indented{1}{the last index of \\spad{s} with the first index of \\spad{t,} that is,} \\indented{5}{\\spad{t*s = contract(t,rank \\spad{t,} \\spad{s,} 1)}} \\indented{5}{\\spad{t*s = sum(k=1..N, t[i1,..,iN,k]*s[k,j1,..,jM])}} \\indented{1}{This is compatible with the use of \\spad{M*v} to denote} \\indented{1}{the matrix-vector inner product.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} Tm:CartesianTensor(1,2,Integer):=m \\spad{X} v:DirectProduct(2,Integer):=directProduct [3,4] \\spad{X} Tv:CartesianTensor(1,2,Integer):=v \\spad{X} Tm*Tv")) (|product| (($ $ $) "\\indented{1}{product(s,t) is the outer product of the tensors \\spad{s} and \\spad{t.}} \\indented{1}{For example, if \\spad{r = product(s,t)} for rank 2 tensors} \\indented{1}{s and \\spad{t,} then \\spad{r} is a rank 4 tensor given \\spad{by}} \\indented{5}{\\spad{r(i,j,k,l) = s(i,j)*t(k,l)}.} \\blankline \\spad{X} m:SquareMatrix(2,Integer):=matrix [[1,2],[4,5]] \\spad{X} Tm:CartesianTensor(1,2,Integer):=m \\spad{X} n:SquareMatrix(2,Integer):=matrix [[2,3],[0,1]] \\spad{X} Tn:CartesianTensor(1,2,Integer):=n \\spad{X} Tmn:=product(Tm,Tn)")) (|elt| ((|#3| $ (|List| (|Integer|))) "\\indented{1}{elt(t,[i1,...,iN]) gives a component of a rank \\spad{N} tensor.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} tm:CartesianTensor(1,2,Integer):=[tv,tv] \\spad{X} tn:CartesianTensor(1,2,Integer):=[tm,tm] \\spad{X} tp:CartesianTensor(1,2,Integer):=[tn,tn] \\spad{X} tq:CartesianTensor(1,2,Integer):=[tp,tp] \\spad{X} elt(tq,[2,2,2,2,2])") ((|#3| $ (|Integer|) (|Integer|) (|Integer|) (|Integer|)) "\\indented{1}{elt(t,i,j,k,l) gives a component of a rank 4 tensor.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} tm:CartesianTensor(1,2,Integer):=[tv,tv] \\spad{X} tn:CartesianTensor(1,2,Integer):=[tm,tm] \\spad{X} tp:CartesianTensor(1,2,Integer):=[tn,tn] \\spad{X} elt(tp,2,2,2,2) \\spad{X} tp[2,2,2,2]") ((|#3| $ (|Integer|) (|Integer|) (|Integer|)) "\\indented{1}{elt(t,i,j,k) gives a component of a rank 3 tensor.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} tm:CartesianTensor(1,2,Integer):=[tv,tv] \\spad{X} tn:CartesianTensor(1,2,Integer):=[tm,tm] \\spad{X} elt(tn,2,2,2) \\spad{X} tn[2,2,2]") ((|#3| $ (|Integer|) (|Integer|)) "\\indented{1}{elt(t,i,j) gives a component of a rank 2 tensor.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} tm:CartesianTensor(1,2,Integer):=[tv,tv] \\spad{X} elt(tm,2,2) \\spad{X} tm[2,2]") ((|#3| $ (|Integer|)) "\\indented{1}{elt(t,i) gives a component of a rank 1 tensor.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} elt(tv,2) \\spad{X} tv[2]") ((|#3| $) "\\indented{1}{elt(t) gives the component of a rank 0 tensor.} \\blankline \\spad{X} \\spad{tv:CartesianTensor(1,2,Integer):=8} \\spad{X} elt(tv) \\spad{X} tv[]")) (|rank| (((|NonNegativeInteger|) $) "\\indented{1}{rank(t) returns the tensorial rank of \\spad{t} (that is, the} \\indented{1}{number of indices).\\space{2}This is the same as the graded module} \\indented{1}{degree.} \\blankline \\spad{X} CT:=CARTEN(1,2,Integer) \\spad{X} \\spad{t0:CT:=8} \\spad{X} rank \\spad{t0}")) (|coerce| (($ (|List| $)) "\\indented{1}{coerce([t_1,...,t_dim]) allows tensors to be constructed} \\indented{1}{using lists.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v \\spad{X} tm:CartesianTensor(1,2,Integer):=[tv,tv]") (($ (|List| |#3|)) "\\indented{1}{coerce([r_1,...,r_dim]) allows tensors to be constructed} \\indented{1}{using lists.} \\blankline \\spad{X} v:=[2,3] \\spad{X} tv:CartesianTensor(1,2,Integer):=v") (($ (|SquareMatrix| |#2| |#3|)) "\\indented{1}{coerce(m) views a matrix as a rank 2 tensor.} \\blankline \\spad{X} v:SquareMatrix(2,Integer):=[[1,2],[3,4]] \\spad{X} tv:CartesianTensor(1,2,Integer):=v") (($ (|DirectProduct| |#2| |#3|)) "\\indented{1}{coerce(v) views a vector as a rank 1 tensor.} \\blankline \\spad{X} v:DirectProduct(2,Integer):=directProduct [3,4] \\spad{X} tv:CartesianTensor(1,2,Integer):=v"))) NIL NIL (-143) -((|constructor| (NIL "This domain allows classes of characters to be defined and manipulated efficiently.")) (|alphanumeric| (($) "\\spad{alphanumeric()} returns the class of all characters for which alphanumeric? is \\spad{true}.")) (|alphabetic| (($) "\\spad{alphabetic()} returns the class of all characters for which alphabetic? is \\spad{true}.")) (|lowerCase| (($) "\\spad{lowerCase()} returns the class of all characters for which lowerCase? is \\spad{true}.")) (|upperCase| (($) "\\spad{upperCase()} returns the class of all characters for which upperCase? is \\spad{true}.")) (|hexDigit| (($) "\\spad{hexDigit()} returns the class of all characters for which hexDigit? is \\spad{true}.")) (|digit| (($) "\\spad{digit()} returns the class of all characters for which digit? is \\spad{true}.")) (|charClass| (($ (|List| (|Character|))) "\\spad{charClass(l)} creates a character class which contains exactly the characters given in the list \\spad{l}.") (($ (|String|)) "\\spad{charClass(s)} creates a character class which contains exactly the characters given in the string \\spad{s}."))) -((-4535 . T) (-4525 . T) (-4536 . T)) -((|HasCategory| (-148) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-148) (QUOTE (-371))) (|HasCategory| (-148) (QUOTE (-843))) (|HasCategory| (-148) (QUOTE (-1091))) (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-371)))) (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-1091)))))) +((|constructor| (NIL "This domain allows classes of characters to be defined and manipulated efficiently.")) (|alphanumeric| (($) "\\spad{alphanumeric()} returns the class of all characters for which alphanumeric? is true.")) (|alphabetic| (($) "\\spad{alphabetic()} returns the class of all characters for which alphabetic? is true.")) (|lowerCase| (($) "\\spad{lowerCase()} returns the class of all characters for which lowerCase? is true.")) (|upperCase| (($) "\\spad{upperCase()} returns the class of all characters for which upperCase? is true.")) (|hexDigit| (($) "\\spad{hexDigit()} returns the class of all characters for which hexDigit? is true.")) (|digit| (($) "\\spad{digit()} returns the class of all characters for which digit? is true.")) (|charClass| (($ (|List| (|Character|))) "\\spad{charClass(l)} creates a character class which contains exactly the characters given in the list \\spad{l.}") (($ (|String|)) "\\spad{charClass(s)} creates a character class which contains exactly the characters given in the string \\spad{s.}"))) +((-4571 . T) (-4561 . T) (-4572 . T)) +((|HasCategory| (-148) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-148) (QUOTE (-371))) (|HasCategory| (-148) (QUOTE (-844))) (|HasCategory| (-148) (QUOTE (-1093))) (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-371)))) (-12 (|HasCategory| (-148) (LIST (QUOTE -304) (QUOTE (-148)))) (|HasCategory| (-148) (QUOTE (-1093)))))) (-144 R Q A) -((|constructor| (NIL "CommonDenominator provides functions to compute the common denominator of a finite linear aggregate of elements of the quotient field of an integral domain.")) (|splitDenominator| (((|Record| (|:| |num| |#3|) (|:| |den| |#1|)) |#3|) "\\spad{splitDenominator([q1,{}...,{}qn])} returns \\spad{[[p1,{}...,{}pn],{} d]} such that \\spad{\\spad{qi} = pi/d} and \\spad{d} is a common denominator for the \\spad{qi}\\spad{'s}.")) (|clearDenominator| ((|#3| |#3|) "\\spad{clearDenominator([q1,{}...,{}qn])} returns \\spad{[p1,{}...,{}pn]} such that \\spad{\\spad{qi} = pi/d} where \\spad{d} is a common denominator for the \\spad{qi}\\spad{'s}.")) (|commonDenominator| ((|#1| |#3|) "\\spad{commonDenominator([q1,{}...,{}qn])} returns a common denominator \\spad{d} for \\spad{q1},{}...,{}\\spad{qn}."))) +((|constructor| (NIL "CommonDenominator provides functions to compute the common denominator of a finite linear aggregate of elements of the quotient field of an integral domain.")) (|splitDenominator| (((|Record| (|:| |num| |#3|) (|:| |den| |#1|)) |#3|) "\\spad{splitDenominator([q1,...,qn])} returns \\spad{[[p1,...,pn], \\spad{d]}} such that \\spad{qi = pi/d} and \\spad{d} is a common denominator for the qi's.")) (|clearDenominator| ((|#3| |#3|) "\\spad{clearDenominator([q1,...,qn])} returns \\spad{[p1,...,pn]} such that \\spad{qi = pi/d} where \\spad{d} is a common denominator for the qi's.")) (|commonDenominator| ((|#1| |#3|) "\\spad{commonDenominator([q1,...,qn])} returns a common denominator \\spad{d} for q1,...,qn."))) NIL NIL (-145) -((|constructor| (NIL "This is a low-level domain which implements matrices (two dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|) (|Integer|)) "\\indented{1}{qnew(\\spad{n},{} \\spad{m}) creates a new uninitialized \\spad{n} by \\spad{m} matrix.} \\blankline \\spad{X} t1:CDFMAT:=qnew(3,{}4)"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| (-170 (-216)) (QUOTE (-1091))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1091)))) (|HasCategory| (-170 (-216)) (QUOTE (-302))) (|HasCategory| (-170 (-216)) (QUOTE (-559))) (|HasAttribute| (-170 (-216)) (QUOTE (-4537 "*"))) (|HasCategory| (-170 (-216)) (QUOTE (-173))) (|HasCategory| (-170 (-216)) (QUOTE (-366)))) +((|constructor| (NIL "This is a low-level domain which implements matrices (two dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based, there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|) (|Integer|)) "\\indented{1}{qnew(n, \\spad{m)} creates a new uninitialized \\spad{n} by \\spad{m} matrix.} \\blankline \\spad{X} t1:CDFMAT:=qnew(3,4)"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| (-170 (-216)) (QUOTE (-1093))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1093)))) (|HasCategory| (-170 (-216)) (QUOTE (-302))) (|HasCategory| (-170 (-216)) (QUOTE (-559))) (|HasAttribute| (-170 (-216)) (QUOTE (-4573 "*"))) (|HasCategory| (-170 (-216)) (QUOTE (-173))) (|HasCategory| (-170 (-216)) (QUOTE (-366)))) (-146) -((|constructor| (NIL "This is a low-level domain which implements vectors (one dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).")) (|vector| (($ (|List| (|Complex| (|DoubleFloat|)))) "\\indented{1}{vector(\\spad{l}) converts the list \\spad{l} to a vector.} \\blankline \\spad{X} t1:List(Complex(DoubleFloat))\\spad{:=}[1+2*\\%\\spad{i},{}3+4*\\%\\spad{i},{}\\spad{-5}-6*\\%\\spad{i}] \\spad{X} t2:CDFVEC:=vector(\\spad{t1})")) (|qnew| (($ (|Integer|)) "\\indented{1}{qnew(\\spad{n}) creates a new uninitialized vector of length \\spad{n}.} \\blankline \\spad{X} t1:CDFVEC:=qnew 7"))) -((-4536 . T) (-4535 . T)) -((|HasCategory| (-170 (-216)) (QUOTE (-1091))) (|HasCategory| (-170 (-216)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-170 (-216)) (QUOTE (-843))) (-2232 (|HasCategory| (-170 (-216)) (QUOTE (-843))) (|HasCategory| (-170 (-216)) (QUOTE (-1091)))) (|HasCategory| (-569) (QUOTE (-843))) (|HasCategory| (-170 (-216)) (QUOTE (-25))) (|HasCategory| (-170 (-216)) (QUOTE (-23))) (|HasCategory| (-170 (-216)) (QUOTE (-21))) (|HasCategory| (-170 (-216)) (QUOTE (-717))) (|HasCategory| (-170 (-216)) (QUOTE (-1048))) (-12 (|HasCategory| (-170 (-216)) (QUOTE (-1003))) (|HasCategory| (-170 (-216)) (QUOTE (-1048)))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-843)))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1091)))))) +((|constructor| (NIL "This is a low-level domain which implements vectors (one dimensional arrays) of complex double precision floating point numbers. Indexing is 0 based, there is no bound checking (unless provided by lower level).")) (|vector| (($ (|List| (|Complex| (|DoubleFloat|)))) "\\indented{1}{vector(l) converts the list \\spad{l} to a vector.} \\blankline \\spad{X} t1:List(Complex(DoubleFloat)):=[1+2*\\%i,3+4*\\%i,-5-6*\\%i] \\spad{X} t2:CDFVEC:=vector(t1)")) (|qnew| (($ (|Integer|)) "\\indented{1}{qnew(n) creates a new uninitialized vector of length \\spad{n.}} \\blankline \\spad{X} t1:CDFVEC:=qnew 7"))) +((-4572 . T) (-4571 . T)) +((|HasCategory| (-170 (-216)) (QUOTE (-1093))) (|HasCategory| (-170 (-216)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-170 (-216)) (QUOTE (-844))) (-1929 (|HasCategory| (-170 (-216)) (QUOTE (-844))) (|HasCategory| (-170 (-216)) (QUOTE (-1093)))) (|HasCategory| (-569) (QUOTE (-844))) (|HasCategory| (-170 (-216)) (QUOTE (-25))) (|HasCategory| (-170 (-216)) (QUOTE (-23))) (|HasCategory| (-170 (-216)) (QUOTE (-21))) (|HasCategory| (-170 (-216)) (QUOTE (-718))) (|HasCategory| (-170 (-216)) (QUOTE (-1049))) (-12 (|HasCategory| (-170 (-216)) (QUOTE (-1004))) (|HasCategory| (-170 (-216)) (QUOTE (-1049)))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-844)))) (-12 (|HasCategory| (-170 (-216)) (LIST (QUOTE -304) (LIST (QUOTE -170) (QUOTE (-216))))) (|HasCategory| (-170 (-216)) (QUOTE (-1093)))))) (-147) -((|constructor| (NIL "Category for the usual combinatorial functions.")) (|permutation| (($ $ $) "\\spad{permutation(n,{} m)} returns the number of permutations of \\spad{n} objects taken \\spad{m} at a time. Note that \\spad{permutation(n,{}m) = n!/(n-m)!}.")) (|factorial| (($ $) "\\spad{factorial(n)} computes the factorial of \\spad{n} (denoted in the literature by \\spad{n!}) Note that \\spad{n! = n (n-1)! when n > 0}; also,{} \\spad{0! = 1}.")) (|binomial| (($ $ $) "\\indented{1}{binomial(\\spad{n},{}\\spad{r}) returns the \\spad{(n,{}r)} binomial coefficient} \\indented{1}{(often denoted in the literature by \\spad{C(n,{}r)}).} \\indented{1}{Note that \\spad{C(n,{}r) = n!/(r!(n-r)!)} where \\spad{n >= r >= 0}.} \\blankline \\spad{X} [binomial(5,{}\\spad{i}) for \\spad{i} in 0..5]"))) +((|constructor| (NIL "Category for the usual combinatorial functions.")) (|permutation| (($ $ $) "\\spad{permutation(n, \\spad{m)}} returns the number of permutations of \\spad{n} objects taken \\spad{m} at a time. Note that \\spad{permutation(n,m) = n!/(n-m)!}.")) (|factorial| (($ $) "\\spad{factorial(n)} computes the factorial of \\spad{n} (denoted in the literature by \\spad{n!}) Note that \\spad{n! = \\spad{n} (n-1)! when \\spad{n} > 0}; also, \\spad{0! = 1}.")) (|binomial| (($ $ $) "\\indented{1}{binomial(n,r) returns the \\spad{(n,r)} binomial coefficient} \\indented{1}{(often denoted in the literature by \\spad{C(n,r)}).} \\indented{1}{Note that \\spad{C(n,r) = n!/(r!(n-r)!)} where \\spad{n \\spad{>=} \\spad{r} \\spad{>=} 0}.} \\blankline \\spad{X} [binomial(5,i) for \\spad{i} in 0..5]"))) NIL NIL (-148) -((|constructor| (NIL "This domain provides the basic character data type.")) (|alphanumeric?| (((|Boolean|) $) "\\indented{1}{alphanumeric?(\\spad{c}) tests if \\spad{c} is either a letter or number,{}} \\indented{1}{\\spadignore{i.e.} one of 0..9,{} a..\\spad{z} or A..\\spad{Z}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [alphanumeric? \\spad{c} for \\spad{c} in chars]")) (|lowerCase?| (((|Boolean|) $) "\\indented{1}{lowerCase?(\\spad{c}) tests if \\spad{c} is an lower case letter,{}} \\indented{1}{\\spadignore{i.e.} one of a..\\spad{z}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [lowerCase? \\spad{c} for \\spad{c} in chars]")) (|upperCase?| (((|Boolean|) $) "\\indented{1}{upperCase?(\\spad{c}) tests if \\spad{c} is an upper case letter,{}} \\indented{1}{\\spadignore{i.e.} one of A..\\spad{Z}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [upperCase? \\spad{c} for \\spad{c} in chars]")) (|alphabetic?| (((|Boolean|) $) "\\indented{1}{alphabetic?(\\spad{c}) tests if \\spad{c} is a letter,{}} \\indented{1}{\\spadignore{i.e.} one of a..\\spad{z} or A..\\spad{Z}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [alphabetic? \\spad{c} for \\spad{c} in chars]")) (|hexDigit?| (((|Boolean|) $) "\\indented{1}{hexDigit?(\\spad{c}) tests if \\spad{c} is a hexadecimal numeral,{}} \\indented{1}{\\spadignore{i.e.} one of 0..9,{} a..\\spad{f} or A..\\spad{F}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [hexDigit? \\spad{c} for \\spad{c} in chars]")) (|digit?| (((|Boolean|) $) "\\indented{1}{digit?(\\spad{c}) tests if \\spad{c} is a digit character,{}} \\indented{1}{\\spadignore{i.e.} one of 0..9.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [digit? \\spad{c} for \\spad{c} in chars]")) (|lowerCase| (($ $) "\\indented{1}{lowerCase(\\spad{c}) converts an upper case letter to the corresponding} \\indented{1}{lower case letter.\\space{2}If \\spad{c} is not an upper case letter,{} then} \\indented{1}{it is returned unchanged.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [lowerCase \\spad{c} for \\spad{c} in chars]")) (|upperCase| (($ $) "\\indented{1}{upperCase(\\spad{c}) converts a lower case letter to the corresponding} \\indented{1}{upper case letter.\\space{2}If \\spad{c} is not a lower case letter,{} then} \\indented{1}{it is returned unchanged.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [upperCase \\spad{c} for \\spad{c} in chars]")) (|escape| (($) "\\indented{1}{escape() provides the escape character,{} \\spad{_},{} which} \\indented{1}{is used to allow quotes and other characters within} \\indented{1}{strings.} \\blankline \\spad{X} escape()")) (|quote| (($) "\\indented{1}{quote() provides the string quote character,{} \\spad{\"}.} \\blankline \\spad{X} quote()")) (|space| (($) "\\indented{1}{space() provides the blank character.} \\blankline \\spad{X} space()")) (|char| (($ (|String|)) "\\indented{1}{char(\\spad{s}) provides a character from a string \\spad{s} of length one.} \\blankline \\spad{X} [char \\spad{c} for \\spad{c} in [\"a\",{}\"A\",{}\\spad{\"X\"},{}\\spad{\"8\"},{}\\spad{\"+\"}]]") (($ (|Integer|)) "\\indented{1}{char(\\spad{i}) provides a character corresponding to the integer} \\indented{1}{code \\spad{i}. It is always \\spad{true} that \\spad{ord char i = i}.} \\blankline \\spad{X} [char \\spad{c} for \\spad{c} in [97,{}65,{}88,{}56,{}43]]")) (|ord| (((|Integer|) $) "\\indented{1}{ord(\\spad{c}) provides an integral code corresponding to the} \\indented{1}{character \\spad{c}.\\space{2}It is always \\spad{true} that \\spad{char ord c = c}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\",{} char \"A\",{} char \\spad{\"X\"},{} char \\spad{\"8\"},{} char \\spad{\"+\"}] \\spad{X} [ord \\spad{c} for \\spad{c} in chars]"))) +((|constructor| (NIL "This domain provides the basic character data type.")) (|alphanumeric?| (((|Boolean|) $) "\\indented{1}{alphanumeric?(c) tests if \\spad{c} is either a letter or number,} \\indented{1}{\\spadignore{i.e.} one of 0..9, a..z or A..Z.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [alphanumeric? \\spad{c} for \\spad{c} in chars]")) (|lowerCase?| (((|Boolean|) $) "\\indented{1}{lowerCase?(c) tests if \\spad{c} is an lower case letter,} \\indented{1}{\\spadignore{i.e.} one of a..z.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [lowerCase? \\spad{c} for \\spad{c} in chars]")) (|upperCase?| (((|Boolean|) $) "\\indented{1}{upperCase?(c) tests if \\spad{c} is an upper case letter,} \\indented{1}{\\spadignore{i.e.} one of A..Z.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [upperCase? \\spad{c} for \\spad{c} in chars]")) (|alphabetic?| (((|Boolean|) $) "\\indented{1}{alphabetic?(c) tests if \\spad{c} is a letter,} \\indented{1}{\\spadignore{i.e.} one of a..z or A..Z.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [alphabetic? \\spad{c} for \\spad{c} in chars]")) (|hexDigit?| (((|Boolean|) $) "\\indented{1}{hexDigit?(c) tests if \\spad{c} is a hexadecimal numeral,} \\indented{1}{\\spadignore{i.e.} one of 0..9, a..f or A..F.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [hexDigit? \\spad{c} for \\spad{c} in chars]")) (|digit?| (((|Boolean|) $) "\\indented{1}{digit?(c) tests if \\spad{c} is a digit character,} \\indented{1}{\\spadignore{i.e.} one of 0..9.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [digit? \\spad{c} for \\spad{c} in chars]")) (|lowerCase| (($ $) "\\indented{1}{lowerCase(c) converts an upper case letter to the corresponding} \\indented{1}{lower case letter.\\space{2}If \\spad{c} is not an upper case letter, then} \\indented{1}{it is returned unchanged.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [lowerCase \\spad{c} for \\spad{c} in chars]")) (|upperCase| (($ $) "\\indented{1}{upperCase(c) converts a lower case letter to the corresponding} \\indented{1}{upper case letter.\\space{2}If \\spad{c} is not a lower case letter, then} \\indented{1}{it is returned unchanged.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [upperCase \\spad{c} for \\spad{c} in chars]")) (|escape| (($) "\\indented{1}{escape() provides the escape character, \\spad{_}, which} \\indented{1}{is used to allow quotes and other characters within} \\indented{1}{strings.} \\blankline \\spad{X} escape()")) (|quote| (($) "\\indented{1}{quote() provides the string quote character, \\spad{\"}.} \\blankline \\spad{X} quote()")) (|space| (($) "\\indented{1}{space() provides the blank character.} \\blankline \\spad{X} space()")) (|char| (($ (|String|)) "\\indented{1}{char(s) provides a character from a string \\spad{s} of length one.} \\blankline \\spad{X} [char \\spad{c} for \\spad{c} in [\"a\",\"A\",\"X\",\"8\",\"+\"]]") (($ (|Integer|)) "\\indented{1}{char(i) provides a character corresponding to the integer} \\indented{1}{code i. It is always \\spad{true} that \\spad{ord char \\spad{i} = i}.} \\blankline \\spad{X} [char \\spad{c} for \\spad{c} in [97,65,88,56,43]]")) (|ord| (((|Integer|) $) "\\indented{1}{ord(c) provides an integral code corresponding to the} \\indented{1}{character c.\\space{2}It is always \\spad{true} that \\spad{char ord \\spad{c} = c}.} \\blankline \\spad{X} chars \\spad{:=} [char \"a\", char \"A\", char \"X\", char \"8\", char \"+\"] \\spad{X} [ord \\spad{c} for \\spad{c} in chars]"))) NIL NIL (-149) ((|constructor| (NIL "Rings of Characteristic Non Zero")) (|charthRoot| (((|Union| $ "failed") $) "\\spad{charthRoot(x)} returns the \\spad{p}th root of \\spad{x} where \\spad{p} is the characteristic of the ring."))) -((-4532 . T)) +((-4568 . T)) NIL (-150 R) -((|constructor| (NIL "This package provides a characteristicPolynomial function for any matrix over a commutative ring.")) (|characteristicPolynomial| ((|#1| (|Matrix| |#1|) |#1|) "\\spad{characteristicPolynomial(m,{}r)} computes the characteristic polynomial of the matrix \\spad{m} evaluated at the point \\spad{r}. In particular,{} if \\spad{r} is the polynomial \\spad{'x},{} then it returns the characteristic polynomial expressed as a polynomial in \\spad{'x}."))) +((|constructor| (NIL "This package provides a characteristicPolynomial function for any matrix over a commutative ring.")) (|characteristicPolynomial| ((|#1| (|Matrix| |#1|) |#1|) "\\spad{characteristicPolynomial(m,r)} computes the characteristic polynomial of the matrix \\spad{m} evaluated at the point \\spad{r.} In particular, if \\spad{r} is the polynomial \\spad{'x,} then it returns the characteristic polynomial expressed as a polynomial in \\spad{'x.}"))) NIL NIL (-151) ((|constructor| (NIL "Rings of Characteristic Zero."))) -((-4532 . T)) +((-4568 . T)) NIL -(-152 -1564 UP UPUP) -((|constructor| (NIL "Tools to send a point to infinity on an algebraic curve.")) (|chvar| (((|Record| (|:| |func| |#3|) (|:| |poly| |#3|) (|:| |c1| (|Fraction| |#2|)) (|:| |c2| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) |#3| |#3|) "\\spad{chvar(f(x,{}y),{} p(x,{}y))} returns \\spad{[g(z,{}t),{} q(z,{}t),{} c1(z),{} c2(z),{} n]} such that under the change of variable \\spad{x = c1(z)},{} \\spad{y = t * c2(z)},{} one gets \\spad{f(x,{}y) = g(z,{}t)}. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x,{} y) = 0}. The algebraic relation between \\spad{z} and \\spad{t} is \\spad{q(z,{} t) = 0}.")) (|eval| ((|#3| |#3| (|Fraction| |#2|) (|Fraction| |#2|)) "\\spad{eval(p(x,{}y),{} f(x),{} g(x))} returns \\spad{p(f(x),{} y * g(x))}.")) (|goodPoint| ((|#1| |#3| |#3|) "\\spad{goodPoint(p,{} q)} returns an integer a such that a is neither a pole of \\spad{p(x,{}y)} nor a branch point of \\spad{q(x,{}y) = 0}.")) (|rootPoly| (((|Record| (|:| |exponent| (|NonNegativeInteger|)) (|:| |coef| (|Fraction| |#2|)) (|:| |radicand| |#2|)) (|Fraction| |#2|) (|NonNegativeInteger|)) "\\spad{rootPoly(g,{} n)} returns \\spad{[m,{} c,{} P]} such that \\spad{c * g ** (1/n) = P ** (1/m)} thus if \\spad{y**n = g},{} then \\spad{z**m = P} where \\spad{z = c * y}.")) (|radPoly| (((|Union| (|Record| (|:| |radicand| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) "failed") |#3|) "\\spad{radPoly(p(x,{} y))} returns \\spad{[c(x),{} n]} if \\spad{p} is of the form \\spad{y**n - c(x)},{} \"failed\" otherwise.")) (|mkIntegral| (((|Record| (|:| |coef| (|Fraction| |#2|)) (|:| |poly| |#3|)) |#3|) "\\spad{mkIntegral(p(x,{}y))} returns \\spad{[c(x),{} q(x,{}z)]} such that \\spad{z = c * y} is integral. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x,{} y) = 0}. The algebraic relation between \\spad{x} and \\spad{z} is \\spad{q(x,{} z) = 0}."))) +(-152 -1647 UP UPUP) +((|constructor| (NIL "Tools to send a point to infinity on an algebraic curve.")) (|chvar| (((|Record| (|:| |func| |#3|) (|:| |poly| |#3|) (|:| |c1| (|Fraction| |#2|)) (|:| |c2| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) |#3| |#3|) "\\spad{chvar(f(x,y), p(x,y))} returns \\spad{[g(z,t), q(z,t), c1(z), c2(z), \\spad{n]}} such that under the change of variable \\spad{x = c1(z)}, \\spad{y = \\spad{t} * c2(z)}, one gets \\spad{f(x,y) = g(z,t)}. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x, \\spad{y)} = 0}. The algebraic relation between \\spad{z} and \\spad{t} is \\spad{q(z, \\spad{t)} = 0}.")) (|eval| ((|#3| |#3| (|Fraction| |#2|) (|Fraction| |#2|)) "\\spad{eval(p(x,y), f(x), g(x))} returns \\spad{p(f(x), \\spad{y} * g(x))}.")) (|goodPoint| ((|#1| |#3| |#3|) "\\spad{goodPoint(p, \\spad{q)}} returns an integer a such that a is neither a pole of \\spad{p(x,y)} nor a branch point of \\spad{q(x,y) = 0}.")) (|rootPoly| (((|Record| (|:| |exponent| (|NonNegativeInteger|)) (|:| |coef| (|Fraction| |#2|)) (|:| |radicand| |#2|)) (|Fraction| |#2|) (|NonNegativeInteger|)) "\\spad{rootPoly(g, \\spad{n)}} returns \\spad{[m, \\spad{c,} \\spad{P]}} such that \\spad{c * \\spad{g} \\spad{**} (1/n) = \\spad{P} \\spad{**} (1/m)} thus if \\spad{y**n = \\spad{g},} then \\spad{z**m = \\spad{P}} where \\spad{z = \\spad{c} * \\spad{y}.}")) (|radPoly| (((|Union| (|Record| (|:| |radicand| (|Fraction| |#2|)) (|:| |deg| (|NonNegativeInteger|))) "failed") |#3|) "\\spad{radPoly(p(x, y))} returns \\spad{[c(x), \\spad{n]}} if \\spad{p} is of the form \\spad{y**n - c(x)}, \"failed\" otherwise.")) (|mkIntegral| (((|Record| (|:| |coef| (|Fraction| |#2|)) (|:| |poly| |#3|)) |#3|) "\\spad{mkIntegral(p(x,y))} returns \\spad{[c(x), q(x,z)]} such that \\spad{z = \\spad{c} * \\spad{y}} is integral. The algebraic relation between \\spad{x} and \\spad{y} is \\spad{p(x, \\spad{y)} = 0}. The algebraic relation between \\spad{x} and \\spad{z} is \\spad{q(x, \\spad{z)} = 0}."))) NIL NIL (-153 R CR) -((|constructor| (NIL "This package provides the generalized euclidean algorithm which is needed as the basic step for factoring polynomials.")) (|solveLinearPolynomialEquation| (((|Union| (|List| (|SparseUnivariatePolynomial| |#2|)) "failed") (|List| (|SparseUnivariatePolynomial| |#2|)) (|SparseUnivariatePolynomial| |#2|)) "\\spad{solveLinearPolynomialEquation([f1,{} ...,{} fn],{} g)} where (\\spad{fi} relatively prime to each other) returns a list of \\spad{ai} such that \\spad{g} = sum \\spad{ai} prod \\spad{fj} (\\spad{j} \\spad{\\=} \\spad{i}) or equivalently g/prod \\spad{fj} = sum (ai/fi) or returns \"failed\" if no such list exists"))) +((|constructor| (NIL "This package provides the generalized euclidean algorithm which is needed as the basic step for factoring polynomials.")) (|solveLinearPolynomialEquation| (((|Union| (|List| (|SparseUnivariatePolynomial| |#2|)) "failed") (|List| (|SparseUnivariatePolynomial| |#2|)) (|SparseUnivariatePolynomial| |#2|)) "\\spad{solveLinearPolynomialEquation([f1, ..., fn], \\spad{g)}} where (fi relatively prime to each other) returns a list of \\spad{ai} such that \\spad{g} = sum \\spad{ai} prod \\spad{fj} \\spad{(j} \\spad{\\=} i) or equivalently g/prod \\spad{fj} = sum (ai/fi) or returns \"failed\" if no such list exists"))) NIL NIL (-154 A S) -((|constructor| (NIL "A collection is a homogeneous aggregate which can built from list of members. The operation used to build the aggregate is generically named \\spadfun{construct}. However,{} each collection provides its own special function with the same name as the data type,{} except with an initial lower case letter,{} \\spadignore{e.g.} \\spadfun{list} for \\spadtype{List},{} \\spadfun{flexibleArray} for \\spadtype{FlexibleArray},{} and so on.")) (|removeDuplicates| (($ $) "\\spad{removeDuplicates(u)} returns a copy of \\spad{u} with all duplicates removed.")) (|select| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select(p,{}u)} returns a copy of \\spad{u} containing only those elements such \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}. Note that \\axiom{select(\\spad{p},{}\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u} | \\spad{p}(\\spad{x})]}.")) (|remove| (($ |#2| $) "\\spad{remove(x,{}u)} returns a copy of \\spad{u} with all elements \\axiom{\\spad{y} = \\spad{x}} removed. Note that \\axiom{remove(\\spad{y},{}\\spad{c}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{c} | \\spad{x} \\spad{^=} \\spad{y}]}.") (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove(p,{}u)} returns a copy of \\spad{u} removing all elements \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}. Note that \\axiom{remove(\\spad{p},{}\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u} | not \\spad{p}(\\spad{x})]}.")) (|reduce| ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2| |#2|) "\\spad{reduce(f,{}u,{}x,{}z)} reduces the binary operation \\spad{f} across \\spad{u},{} stopping when an \"absorbing element\" \\spad{z} is encountered. As for \\axiom{reduce(\\spad{f},{}\\spad{u},{}\\spad{x})},{} \\spad{x} is the identity operation of \\spad{f}. Same as \\axiom{reduce(\\spad{f},{}\\spad{u},{}\\spad{x})} when \\spad{u} contains no element \\spad{z}. Thus the third argument \\spad{x} is returned when \\spad{u} is empty.") ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2|) "\\spad{reduce(f,{}u,{}x)} reduces the binary operation \\spad{f} across \\spad{u},{} where \\spad{x} is the identity operation of \\spad{f}. Same as \\axiom{reduce(\\spad{f},{}\\spad{u})} if \\spad{u} has 2 or more elements. Returns \\axiom{\\spad{f}(\\spad{x},{}\\spad{y})} if \\spad{u} has one element \\spad{y},{} \\spad{x} if \\spad{u} is empty. For example,{} \\axiom{reduce(+,{}\\spad{u},{}0)} returns the sum of the elements of \\spad{u}.") ((|#2| (|Mapping| |#2| |#2| |#2|) $) "\\indented{1}{reduce(\\spad{f},{}\\spad{u}) reduces the binary operation \\spad{f} across \\spad{u}. For example,{}} \\indented{1}{if \\spad{u} is \\axiom{[\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]} then \\axiom{reduce(\\spad{f},{}\\spad{u})}} \\indented{1}{returns \\axiom{\\spad{f}(..\\spad{f}(\\spad{f}(\\spad{x},{}\\spad{y}),{}...),{}\\spad{z})}.} \\indented{1}{Note that if \\spad{u} has one element \\spad{x},{} \\axiom{reduce(\\spad{f},{}\\spad{u})} returns \\spad{x}.} \\indented{1}{Error: if \\spad{u} is empty.} \\blankline \\spad{C} )clear all \\spad{X} reduce(+,{}[\\spad{C}[\\spad{i}]*x**i for \\spad{i} in 1..5])")) (|find| (((|Union| |#2| "failed") (|Mapping| (|Boolean|) |#2|) $) "\\spad{find(p,{}u)} returns the first \\spad{x} in \\spad{u} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true},{} and \"failed\" otherwise.")) (|construct| (($ (|List| |#2|)) "\\axiom{construct(\\spad{x},{}\\spad{y},{}...,{}\\spad{z})} returns the collection of elements \\axiom{\\spad{x},{}\\spad{y},{}...,{}\\spad{z}} ordered as given. Equivalently written as \\axiom{[\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]\\$\\spad{D}},{} where \\spad{D} is the domain. \\spad{D} may be omitted for those of type List."))) +((|constructor| (NIL "A collection is a homogeneous aggregate which can built from list of members. The operation used to build the aggregate is generically named \\spadfun{construct}. However, each collection provides its own special function with the same name as the data type, except with an initial lower case letter, \\spadignore{e.g.} \\spadfun{list} for \\spadtype{List}, \\spadfun{flexibleArray} for \\spadtype{FlexibleArray}, and so on.")) (|removeDuplicates| (($ $) "\\spad{removeDuplicates(u)} returns a copy of \\spad{u} with all duplicates removed.")) (|select| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select(p,u)} returns a copy of \\spad{u} containing only those elements such \\axiom{p(x)} is true. Note that \\axiom{select(p,u) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{u} | p(x)]}.")) (|remove| (($ |#2| $) "\\spad{remove(x,u)} returns a copy of \\spad{u} with all elements \\axiom{y = \\spad{x}} removed. Note that \\axiom{remove(y,c) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{c} | \\spad{x} \\spad{^=} y]}.") (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove(p,u)} returns a copy of \\spad{u} removing all elements \\spad{x} such that \\axiom{p(x)} is true. Note that \\axiom{remove(p,u) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{u} | not p(x)]}.")) (|reduce| ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2| |#2|) "\\spad{reduce(f,u,x,z)} reduces the binary operation \\spad{f} across u, stopping when an \"absorbing element\" \\spad{z} is encountered. As for \\axiom{reduce(f,u,x)}, \\spad{x} is the identity operation of \\spad{f.} Same as \\axiom{reduce(f,u,x)} when \\spad{u} contains no element \\spad{z.} Thus the third argument \\spad{x} is returned when \\spad{u} is empty.") ((|#2| (|Mapping| |#2| |#2| |#2|) $ |#2|) "\\spad{reduce(f,u,x)} reduces the binary operation \\spad{f} across u, where \\spad{x} is the identity operation of \\spad{f.} Same as \\axiom{reduce(f,u)} if \\spad{u} has 2 or more elements. Returns \\axiom{f(x,y)} if \\spad{u} has one element \\spad{y,} \\spad{x} if \\spad{u} is empty. For example, \\axiom{reduce(+,u,0)} returns the sum of the elements of u.") ((|#2| (|Mapping| |#2| |#2| |#2|) $) "\\indented{1}{reduce(f,u) reduces the binary operation \\spad{f} across u. For example,} \\indented{1}{if \\spad{u} is \\axiom{[x,y,...,z]} then \\axiom{reduce(f,u)}} \\indented{1}{returns \\axiom{f(..f(f(x,y),...),z)}.} \\indented{1}{Note that if \\spad{u} has one element \\spad{x,} \\axiom{reduce(f,u)} returns \\spad{x.}} \\indented{1}{Error: if \\spad{u} is empty.} \\blankline \\spad{C} )clear all \\spad{X} reduce(+,[C[i]*x**i for \\spad{i} in 1..5])")) (|find| (((|Union| |#2| "failed") (|Mapping| (|Boolean|) |#2|) $) "\\spad{find(p,u)} returns the first \\spad{x} in \\spad{u} such that \\axiom{p(x)} is true, and \"failed\" otherwise.")) (|construct| (($ (|List| |#2|)) "\\axiom{construct(x,y,...,z)} returns the collection of elements \\axiom{x,y,...,z} ordered as given. Equivalently written as \\axiom{[x,y,...,z]$D}, where \\spad{D} is the domain. \\spad{D} may be omitted for those of type List."))) NIL -((|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (QUOTE (-1091))) (|HasAttribute| |#1| (QUOTE -4535))) +((|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (QUOTE (-1093))) (|HasAttribute| |#1| (QUOTE -4571))) (-155 S) -((|constructor| (NIL "A collection is a homogeneous aggregate which can built from list of members. The operation used to build the aggregate is generically named \\spadfun{construct}. However,{} each collection provides its own special function with the same name as the data type,{} except with an initial lower case letter,{} \\spadignore{e.g.} \\spadfun{list} for \\spadtype{List},{} \\spadfun{flexibleArray} for \\spadtype{FlexibleArray},{} and so on.")) (|removeDuplicates| (($ $) "\\spad{removeDuplicates(u)} returns a copy of \\spad{u} with all duplicates removed.")) (|select| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select(p,{}u)} returns a copy of \\spad{u} containing only those elements such \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}. Note that \\axiom{select(\\spad{p},{}\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u} | \\spad{p}(\\spad{x})]}.")) (|remove| (($ |#1| $) "\\spad{remove(x,{}u)} returns a copy of \\spad{u} with all elements \\axiom{\\spad{y} = \\spad{x}} removed. Note that \\axiom{remove(\\spad{y},{}\\spad{c}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{c} | \\spad{x} \\spad{^=} \\spad{y}]}.") (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove(p,{}u)} returns a copy of \\spad{u} removing all elements \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}. Note that \\axiom{remove(\\spad{p},{}\\spad{u}) \\spad{==} [\\spad{x} for \\spad{x} in \\spad{u} | not \\spad{p}(\\spad{x})]}.")) (|reduce| ((|#1| (|Mapping| |#1| |#1| |#1|) $ |#1| |#1|) "\\spad{reduce(f,{}u,{}x,{}z)} reduces the binary operation \\spad{f} across \\spad{u},{} stopping when an \"absorbing element\" \\spad{z} is encountered. As for \\axiom{reduce(\\spad{f},{}\\spad{u},{}\\spad{x})},{} \\spad{x} is the identity operation of \\spad{f}. Same as \\axiom{reduce(\\spad{f},{}\\spad{u},{}\\spad{x})} when \\spad{u} contains no element \\spad{z}. Thus the third argument \\spad{x} is returned when \\spad{u} is empty.") ((|#1| (|Mapping| |#1| |#1| |#1|) $ |#1|) "\\spad{reduce(f,{}u,{}x)} reduces the binary operation \\spad{f} across \\spad{u},{} where \\spad{x} is the identity operation of \\spad{f}. Same as \\axiom{reduce(\\spad{f},{}\\spad{u})} if \\spad{u} has 2 or more elements. Returns \\axiom{\\spad{f}(\\spad{x},{}\\spad{y})} if \\spad{u} has one element \\spad{y},{} \\spad{x} if \\spad{u} is empty. For example,{} \\axiom{reduce(+,{}\\spad{u},{}0)} returns the sum of the elements of \\spad{u}.") ((|#1| (|Mapping| |#1| |#1| |#1|) $) "\\indented{1}{reduce(\\spad{f},{}\\spad{u}) reduces the binary operation \\spad{f} across \\spad{u}. For example,{}} \\indented{1}{if \\spad{u} is \\axiom{[\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]} then \\axiom{reduce(\\spad{f},{}\\spad{u})}} \\indented{1}{returns \\axiom{\\spad{f}(..\\spad{f}(\\spad{f}(\\spad{x},{}\\spad{y}),{}...),{}\\spad{z})}.} \\indented{1}{Note that if \\spad{u} has one element \\spad{x},{} \\axiom{reduce(\\spad{f},{}\\spad{u})} returns \\spad{x}.} \\indented{1}{Error: if \\spad{u} is empty.} \\blankline \\spad{C} )clear all \\spad{X} reduce(+,{}[\\spad{C}[\\spad{i}]*x**i for \\spad{i} in 1..5])")) (|find| (((|Union| |#1| "failed") (|Mapping| (|Boolean|) |#1|) $) "\\spad{find(p,{}u)} returns the first \\spad{x} in \\spad{u} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true},{} and \"failed\" otherwise.")) (|construct| (($ (|List| |#1|)) "\\axiom{construct(\\spad{x},{}\\spad{y},{}...,{}\\spad{z})} returns the collection of elements \\axiom{\\spad{x},{}\\spad{y},{}...,{}\\spad{z}} ordered as given. Equivalently written as \\axiom{[\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]\\$\\spad{D}},{} where \\spad{D} is the domain. \\spad{D} may be omitted for those of type List."))) -((-2982 . T)) +((|constructor| (NIL "A collection is a homogeneous aggregate which can built from list of members. The operation used to build the aggregate is generically named \\spadfun{construct}. However, each collection provides its own special function with the same name as the data type, except with an initial lower case letter, \\spadignore{e.g.} \\spadfun{list} for \\spadtype{List}, \\spadfun{flexibleArray} for \\spadtype{FlexibleArray}, and so on.")) (|removeDuplicates| (($ $) "\\spad{removeDuplicates(u)} returns a copy of \\spad{u} with all duplicates removed.")) (|select| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select(p,u)} returns a copy of \\spad{u} containing only those elements such \\axiom{p(x)} is true. Note that \\axiom{select(p,u) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{u} | p(x)]}.")) (|remove| (($ |#1| $) "\\spad{remove(x,u)} returns a copy of \\spad{u} with all elements \\axiom{y = \\spad{x}} removed. Note that \\axiom{remove(y,c) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{c} | \\spad{x} \\spad{^=} y]}.") (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove(p,u)} returns a copy of \\spad{u} removing all elements \\spad{x} such that \\axiom{p(x)} is true. Note that \\axiom{remove(p,u) \\spad{==} \\spad{[x} for \\spad{x} in \\spad{u} | not p(x)]}.")) (|reduce| ((|#1| (|Mapping| |#1| |#1| |#1|) $ |#1| |#1|) "\\spad{reduce(f,u,x,z)} reduces the binary operation \\spad{f} across u, stopping when an \"absorbing element\" \\spad{z} is encountered. As for \\axiom{reduce(f,u,x)}, \\spad{x} is the identity operation of \\spad{f.} Same as \\axiom{reduce(f,u,x)} when \\spad{u} contains no element \\spad{z.} Thus the third argument \\spad{x} is returned when \\spad{u} is empty.") ((|#1| (|Mapping| |#1| |#1| |#1|) $ |#1|) "\\spad{reduce(f,u,x)} reduces the binary operation \\spad{f} across u, where \\spad{x} is the identity operation of \\spad{f.} Same as \\axiom{reduce(f,u)} if \\spad{u} has 2 or more elements. Returns \\axiom{f(x,y)} if \\spad{u} has one element \\spad{y,} \\spad{x} if \\spad{u} is empty. For example, \\axiom{reduce(+,u,0)} returns the sum of the elements of u.") ((|#1| (|Mapping| |#1| |#1| |#1|) $) "\\indented{1}{reduce(f,u) reduces the binary operation \\spad{f} across u. For example,} \\indented{1}{if \\spad{u} is \\axiom{[x,y,...,z]} then \\axiom{reduce(f,u)}} \\indented{1}{returns \\axiom{f(..f(f(x,y),...),z)}.} \\indented{1}{Note that if \\spad{u} has one element \\spad{x,} \\axiom{reduce(f,u)} returns \\spad{x.}} \\indented{1}{Error: if \\spad{u} is empty.} \\blankline \\spad{C} )clear all \\spad{X} reduce(+,[C[i]*x**i for \\spad{i} in 1..5])")) (|find| (((|Union| |#1| "failed") (|Mapping| (|Boolean|) |#1|) $) "\\spad{find(p,u)} returns the first \\spad{x} in \\spad{u} such that \\axiom{p(x)} is true, and \"failed\" otherwise.")) (|construct| (($ (|List| |#1|)) "\\axiom{construct(x,y,...,z)} returns the collection of elements \\axiom{x,y,...,z} ordered as given. Equivalently written as \\axiom{[x,y,...,z]$D}, where \\spad{D} is the domain. \\spad{D} may be omitted for those of type List."))) +((-4317 . T)) NIL (-156 |n| K Q) -((|constructor| (NIL "CliffordAlgebra(\\spad{n},{} \\spad{K},{} \\spad{Q}) defines a vector space of dimension \\spad{2**n} over \\spad{K},{} given a quadratic form \\spad{Q} on \\spad{K**n}. \\blankline If \\spad{e[i]},{} \\spad{1<=i<=n} is a basis for \\spad{K**n} then 1,{} \\spad{e[i]} (\\spad{1<=i<=n}),{} \\spad{e[i1]*e[i2]} (\\spad{1<=i1= r >= 0}.} \\indented{1}{This is the number of combinations of \\spad{n} objects taken \\spad{r} at a time.} \\blankline \\spad{X} [binomial(5,{}\\spad{i}) for \\spad{i} in 0..5]"))) +((|constructor| (NIL "The \\spadtype{IntegerCombinatoricFunctions} package provides some standard functions in combinatorics.")) (|stirling2| ((|#1| |#1| |#1|) "\\spad{stirling2(n,m)} returns the Stirling number of the second kind denoted \\spad{SS[n,m]}.")) (|stirling1| ((|#1| |#1| |#1|) "\\spad{stirling1(n,m)} returns the Stirling number of the first kind denoted \\spad{S[n,m]}.")) (|permutation| ((|#1| |#1| |#1|) "\\spad{permutation(n)} returns \\spad{!P(n,r) = n!/(n-r)!}. This is the number of permutations of \\spad{n} objects taken \\spad{r} at a time.")) (|partition| ((|#1| |#1|) "\\spad{partition(n)} returns the number of partitions of the integer \\spad{n.} This is the number of distinct ways that \\spad{n} can be written as a sum of positive integers.")) (|multinomial| ((|#1| |#1| (|List| |#1|)) "\\spad{multinomial(n,[m1,m2,...,mk])} returns the multinomial coefficient \\spad{n!/(m1! \\spad{m2!} \\spad{...} mk!)}.")) (|factorial| ((|#1| |#1|) "\\spad{factorial(n)} returns \\spad{n!}. this is the product of all integers between 1 and \\spad{n} (inclusive). Note that \\spad{0!} is defined to be 1.")) (|binomial| ((|#1| |#1| |#1|) "\\indented{1}{\\spad{binomial(n,r)} returns the binomial coefficient} \\indented{1}{\\spad{C(n,r) = n!/(r! (n-r)!)}, where \\spad{n \\spad{>=} \\spad{r} \\spad{>=} 0}.} \\indented{1}{This is the number of combinations of \\spad{n} objects taken \\spad{r} at a time.} \\blankline \\spad{X} [binomial(5,i) for \\spad{i} in 0..5]"))) NIL NIL (-162) -((|constructor| (NIL "CombinatorialOpsCategory is the category obtaining by adjoining summations and products to the usual combinatorial operations.")) (|product| (($ $ (|SegmentBinding| $)) "\\spad{product(f(n),{} n = a..b)} returns \\spad{f}(a) * ... * \\spad{f}(\\spad{b}) as a formal product.") (($ $ (|Symbol|)) "\\spad{product(f(n),{} n)} returns the formal product \\spad{P}(\\spad{n}) which verifies \\spad{P}(\\spad{n+1})\\spad{/P}(\\spad{n}) = \\spad{f}(\\spad{n}).")) (|summation| (($ $ (|SegmentBinding| $)) "\\spad{summation(f(n),{} n = a..b)} returns \\spad{f}(a) + ... + \\spad{f}(\\spad{b}) as a formal sum.") (($ $ (|Symbol|)) "\\spad{summation(f(n),{} n)} returns the formal sum \\spad{S}(\\spad{n}) which verifies \\spad{S}(\\spad{n+1}) - \\spad{S}(\\spad{n}) = \\spad{f}(\\spad{n}).")) (|factorials| (($ $ (|Symbol|)) "\\spad{factorials(f,{} x)} rewrites the permutations and binomials in \\spad{f} involving \\spad{x} in terms of factorials.") (($ $) "\\spad{factorials(f)} rewrites the permutations and binomials in \\spad{f} in terms of factorials."))) +((|constructor| (NIL "CombinatorialOpsCategory is the category obtaining by adjoining summations and products to the usual combinatorial operations.")) (|product| (($ $ (|SegmentBinding| $)) "\\spad{product(f(n), \\spad{n} = a..b)} returns f(a) * \\spad{...} * f(b) as a formal product.") (($ $ (|Symbol|)) "\\spad{product(f(n), \\spad{n)}} returns the formal product P(n) which verifies P(n+1)/P(n) = f(n).")) (|summation| (($ $ (|SegmentBinding| $)) "\\spad{summation(f(n), \\spad{n} = a..b)} returns f(a) + \\spad{...} + f(b) as a formal sum.") (($ $ (|Symbol|)) "\\spad{summation(f(n), \\spad{n)}} returns the formal sum S(n) which verifies S(n+1) - S(n) = f(n).")) (|factorials| (($ $ (|Symbol|)) "\\spad{factorials(f, \\spad{x)}} rewrites the permutations and binomials in \\spad{f} involving \\spad{x} in terms of factorials.") (($ $) "\\spad{factorials(f)} rewrites the permutations and binomials in \\spad{f} in terms of factorials."))) NIL NIL (-163) -((|constructor| (NIL "A type for basic commutators")) (|mkcomm| (($ $ $) "\\spad{mkcomm(i,{}j)} is not documented") (($ (|Integer|)) "\\spad{mkcomm(i)} is not documented"))) +((|constructor| (NIL "A type for basic commutators")) (|mkcomm| (($ $ $) "\\spad{mkcomm(i,j)} is not documented") (($ (|Integer|)) "\\spad{mkcomm(i)} is not documented"))) NIL NIL (-164) -((|constructor| (NIL "This package exports the elementary operators,{} with some semantics already attached to them. The semantics that is attached here is not dependent on the set in which the operators will be applied.")) (|operator| (((|BasicOperator|) (|Symbol|)) "\\spad{operator(s)} returns an operator with name \\spad{s},{} with the appropriate semantics if \\spad{s} is known. If \\spad{s} is not known,{} the result has no semantics."))) +((|constructor| (NIL "This package exports the elementary operators, with some semantics already attached to them. The semantics that is attached here is not dependent on the set in which the operators will be applied.")) (|operator| (((|BasicOperator|) (|Symbol|)) "\\spad{operator(s)} returns an operator with name \\spad{s,} with the appropriate semantics if \\spad{s} is known. If \\spad{s} is not known, the result has no semantics."))) NIL NIL (-165 R UP UPUP) -((|constructor| (NIL "A package for swapping the order of two variables in a tower of two UnivariatePolynomialCategory extensions.")) (|swap| ((|#3| |#3|) "\\spad{swap(p(x,{}y))} returns \\spad{p}(\\spad{y},{}\\spad{x})."))) +((|constructor| (NIL "A package for swapping the order of two variables in a tower of two UnivariatePolynomialCategory extensions.")) (|swap| ((|#3| |#3|) "\\spad{swap(p(x,y))} returns p(y,x)."))) NIL NIL (-166 S R) -((|constructor| (NIL "This category represents the extension of a ring by a square root of \\spad{-1}.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a rational number,{} or \"failed\" if \\spad{x} is not a rational number.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a rational number.")) (|polarCoordinates| (((|Record| (|:| |r| |#2|) (|:| |phi| |#2|)) $) "\\spad{polarCoordinates(x)} returns (\\spad{r},{} phi) such that \\spad{x} = \\spad{r} * exp(\\%\\spad{i} * phi).")) (|argument| ((|#2| $) "\\spad{argument(x)} returns the angle made by (0,{}1) and (0,{}\\spad{x}).")) (|abs| (($ $) "\\spad{abs(x)} returns the absolute value of \\spad{x} = sqrt(norm(\\spad{x})).")) (|exquo| (((|Union| $ "failed") $ |#2|) "\\spad{exquo(x,{} r)} returns the exact quotient of \\spad{x} by \\spad{r},{} or \"failed\" if \\spad{r} does not divide \\spad{x} exactly.")) (|norm| ((|#2| $) "\\spad{norm(x)} returns \\spad{x} * conjugate(\\spad{x})")) (|real| ((|#2| $) "\\spad{real(x)} returns real part of \\spad{x}.")) (|imag| ((|#2| $) "\\spad{imag(x)} returns imaginary part of \\spad{x}.")) (|conjugate| (($ $) "\\spad{conjugate(x + \\%i y)} returns \\spad{x} - \\%\\spad{i} \\spad{y}.")) (|imaginary| (($) "\\spad{imaginary()} = sqrt(\\spad{-1}) = \\%\\spad{i}.")) (|complex| (($ |#2| |#2|) "\\spad{complex(x,{}y)} constructs \\spad{x} + \\%i*y.") ((|attribute|) "indicates that \\% has sqrt(\\spad{-1})"))) +((|constructor| (NIL "This category represents the extension of a ring by a square root of \\spad{-1.}")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a rational number, or \"failed\" if \\spad{x} is not a rational number.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a rational number.")) (|polarCoordinates| (((|Record| (|:| |r| |#2|) (|:| |phi| |#2|)) $) "\\spad{polarCoordinates(x)} returns \\spad{(r,} phi) such that \\spad{x} = \\spad{r} * exp(\\%i * phi).")) (|argument| ((|#2| $) "\\spad{argument(x)} returns the angle made by (0,1) and (0,x).")) (|abs| (($ $) "\\spad{abs(x)} returns the absolute value of \\spad{x} = sqrt(norm(x)).")) (|exquo| (((|Union| $ "failed") $ |#2|) "\\spad{exquo(x, \\spad{r)}} returns the exact quotient of \\spad{x} by \\spad{r,} or \"failed\" if \\spad{r} does not divide \\spad{x} exactly.")) (|norm| ((|#2| $) "\\spad{norm(x)} returns \\spad{x} * conjugate(x)")) (|real| ((|#2| $) "\\spad{real(x)} returns real part of \\spad{x.}")) (|imag| ((|#2| $) "\\spad{imag(x)} returns imaginary part of \\spad{x.}")) (|conjugate| (($ $) "\\spad{conjugate(x + \\spad{%i} \\spad{y)}} returns \\spad{x} - \\spad{%i} \\spad{y.}")) (|imaginary| (($) "\\spad{imaginary()} = sqrt(-1) = \\%i.")) (|complex| (($ |#2| |#2|) "\\spad{complex(x,y)} constructs \\spad{x} + \\%i*y.") ((|attribute|) "indicates that \\% has sqrt(-1)"))) NIL -((|HasCategory| |#2| (QUOTE (-905))) (|HasCategory| |#2| (QUOTE (-551))) (|HasCategory| |#2| (QUOTE (-1003))) (|HasCategory| |#2| (QUOTE (-1183))) (|HasCategory| |#2| (QUOTE (-1057))) (|HasCategory| |#2| (QUOTE (-1022))) (|HasCategory| |#2| (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-151))) (|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (QUOTE (-366))) (|HasAttribute| |#2| (QUOTE -4531)) (|HasAttribute| |#2| (QUOTE -4534)) (|HasCategory| |#2| (QUOTE (-302))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-843)))) +((|HasCategory| |#2| (QUOTE (-906))) (|HasCategory| |#2| (QUOTE (-551))) (|HasCategory| |#2| (QUOTE (-1004))) (|HasCategory| |#2| (QUOTE (-1185))) (|HasCategory| |#2| (QUOTE (-1058))) (|HasCategory| |#2| (QUOTE (-1023))) (|HasCategory| |#2| (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-151))) (|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (QUOTE (-366))) (|HasAttribute| |#2| (QUOTE -4567)) (|HasAttribute| |#2| (QUOTE -4570)) (|HasCategory| |#2| (QUOTE (-302))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-844)))) (-167 R) -((|constructor| (NIL "This category represents the extension of a ring by a square root of \\spad{-1}.")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a rational number,{} or \"failed\" if \\spad{x} is not a rational number.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a rational number.")) (|polarCoordinates| (((|Record| (|:| |r| |#1|) (|:| |phi| |#1|)) $) "\\spad{polarCoordinates(x)} returns (\\spad{r},{} phi) such that \\spad{x} = \\spad{r} * exp(\\%\\spad{i} * phi).")) (|argument| ((|#1| $) "\\spad{argument(x)} returns the angle made by (0,{}1) and (0,{}\\spad{x}).")) (|abs| (($ $) "\\spad{abs(x)} returns the absolute value of \\spad{x} = sqrt(norm(\\spad{x})).")) (|exquo| (((|Union| $ "failed") $ |#1|) "\\spad{exquo(x,{} r)} returns the exact quotient of \\spad{x} by \\spad{r},{} or \"failed\" if \\spad{r} does not divide \\spad{x} exactly.")) (|norm| ((|#1| $) "\\spad{norm(x)} returns \\spad{x} * conjugate(\\spad{x})")) (|real| ((|#1| $) "\\spad{real(x)} returns real part of \\spad{x}.")) (|imag| ((|#1| $) "\\spad{imag(x)} returns imaginary part of \\spad{x}.")) (|conjugate| (($ $) "\\spad{conjugate(x + \\%i y)} returns \\spad{x} - \\%\\spad{i} \\spad{y}.")) (|imaginary| (($) "\\spad{imaginary()} = sqrt(\\spad{-1}) = \\%\\spad{i}.")) (|complex| (($ |#1| |#1|) "\\spad{complex(x,{}y)} constructs \\spad{x} + \\%i*y.") ((|attribute|) "indicates that \\% has sqrt(\\spad{-1})"))) -((-4528 -2232 (|has| |#1| (-559)) (-12 (|has| |#1| (-302)) (|has| |#1| (-905)))) (-4533 |has| |#1| (-366)) (-4527 |has| |#1| (-366)) (-4531 |has| |#1| (-6 -4531)) (-4534 |has| |#1| (-6 -4534)) (-2997 . T) (-2982 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "This category represents the extension of a ring by a square root of \\spad{-1.}")) (|rationalIfCan| (((|Union| (|Fraction| (|Integer|)) "failed") $) "\\spad{rationalIfCan(x)} returns \\spad{x} as a rational number, or \"failed\" if \\spad{x} is not a rational number.")) (|rational| (((|Fraction| (|Integer|)) $) "\\spad{rational(x)} returns \\spad{x} as a rational number. Error: if \\spad{x} is not a rational number.")) (|rational?| (((|Boolean|) $) "\\spad{rational?(x)} tests if \\spad{x} is a rational number.")) (|polarCoordinates| (((|Record| (|:| |r| |#1|) (|:| |phi| |#1|)) $) "\\spad{polarCoordinates(x)} returns \\spad{(r,} phi) such that \\spad{x} = \\spad{r} * exp(\\%i * phi).")) (|argument| ((|#1| $) "\\spad{argument(x)} returns the angle made by (0,1) and (0,x).")) (|abs| (($ $) "\\spad{abs(x)} returns the absolute value of \\spad{x} = sqrt(norm(x)).")) (|exquo| (((|Union| $ "failed") $ |#1|) "\\spad{exquo(x, \\spad{r)}} returns the exact quotient of \\spad{x} by \\spad{r,} or \"failed\" if \\spad{r} does not divide \\spad{x} exactly.")) (|norm| ((|#1| $) "\\spad{norm(x)} returns \\spad{x} * conjugate(x)")) (|real| ((|#1| $) "\\spad{real(x)} returns real part of \\spad{x.}")) (|imag| ((|#1| $) "\\spad{imag(x)} returns imaginary part of \\spad{x.}")) (|conjugate| (($ $) "\\spad{conjugate(x + \\spad{%i} \\spad{y)}} returns \\spad{x} - \\spad{%i} \\spad{y.}")) (|imaginary| (($) "\\spad{imaginary()} = sqrt(-1) = \\%i.")) (|complex| (($ |#1| |#1|) "\\spad{complex(x,y)} constructs \\spad{x} + \\%i*y.") ((|attribute|) "indicates that \\% has sqrt(-1)"))) +((-4564 -1929 (|has| |#1| (-559)) (-12 (|has| |#1| (-302)) (|has| |#1| (-906)))) (-4569 |has| |#1| (-366)) (-4563 |has| |#1| (-366)) (-4567 |has| |#1| (-6 -4567)) (-4570 |has| |#1| (-6 -4570)) (-4340 . T) (-4317 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-168 RR PR) ((|constructor| (NIL "This package has no description")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} factorizes the polynomial \\spad{p} with complex coefficients."))) NIL NIL (-169 R S) -((|constructor| (NIL "This package extends maps from underlying rings to maps between complex over those rings.")) (|map| (((|Complex| |#2|) (|Mapping| |#2| |#1|) (|Complex| |#1|)) "\\spad{map(f,{}u)} maps \\spad{f} onto real and imaginary parts of \\spad{u}."))) +((|constructor| (NIL "This package extends maps from underlying rings to maps between complex over those rings.")) (|map| (((|Complex| |#2|) (|Mapping| |#2| |#1|) (|Complex| |#1|)) "\\spad{map(f,u)} maps \\spad{f} onto real and imaginary parts of u."))) NIL NIL (-170 R) -((|constructor| (NIL "\\spadtype{Complex(R)} creates the domain of elements of the form \\spad{a + b * i} where \\spad{a} and \\spad{b} come from the ring \\spad{R},{} and \\spad{i} is a new element such that \\spad{i**2 = -1}."))) -((-4528 -2232 (|has| |#1| (-559)) (-12 (|has| |#1| (-302)) (|has| |#1| (-905)))) (-4533 |has| |#1| (-366)) (-4527 |has| |#1| (-366)) (-4531 |has| |#1| (-6 -4531)) (-4534 |has| |#1| (-6 -4534)) (-2997 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-366))) (-2232 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-371))) (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569)))) (-2232 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-559)))) (|HasCategory| |#1| (QUOTE (-1183))) (-12 (|HasCategory| |#1| (QUOTE (-1003))) (|HasCategory| |#1| (QUOTE (-1183)))) (|HasCategory| |#1| (QUOTE (-1022))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1163)) (|devaluate| |#1|))) (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (LIST (QUOTE -282) (|devaluate| |#1|) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-824))) (|HasCategory| |#1| (QUOTE (-1057))) (-12 (|HasCategory| |#1| (QUOTE (-1057))) (|HasCategory| |#1| (QUOTE (-1183)))) (|HasCategory| |#1| (QUOTE (-551))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-366)))) (|HasCategory| |#1| (QUOTE (-302))) (-2232 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559)))) (-2232 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-905))) (|HasCategory| |#1| (QUOTE (-226))) (-2232 (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -282) (|devaluate| |#1|) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1163)) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-226))) (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-371)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-824)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-843)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-1022)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-1183))))) (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (-2232 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-366))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-905))))) (-2232 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (-12 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-905)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-905))))) (-2232 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-366)))) (-2232 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-559)))) (|HasAttribute| |#1| (QUOTE -4531)) (|HasAttribute| |#1| (QUOTE -4534)) (-12 (|HasCategory| |#1| (QUOTE (-226))) (|HasCategory| |#1| (QUOTE (-366)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-366)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-149)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-351))))) +((|constructor| (NIL "\\spadtype{Complex(R)} creates the domain of elements of the form \\spad{a + \\spad{b} * i} where \\spad{a} and \\spad{b} come from the ring \\spad{R,} and \\spad{i} is a new element such that \\spad{i**2 = -1}."))) +((-4564 -1929 (|has| |#1| (-559)) (-12 (|has| |#1| (-302)) (|has| |#1| (-906)))) (-4569 |has| |#1| (-366)) (-4563 |has| |#1| (-366)) (-4567 |has| |#1| (-6 -4567)) (-4570 |has| |#1| (-6 -4570)) (-4340 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-366))) (-1929 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-371))) (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569)))) (-1929 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-559)))) (|HasCategory| |#1| (QUOTE (-1185))) (-12 (|HasCategory| |#1| (QUOTE (-1004))) (|HasCategory| |#1| (QUOTE (-1185)))) (|HasCategory| |#1| (QUOTE (-1023))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1165)) (|devaluate| |#1|))) (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (LIST (QUOTE -282) (|devaluate| |#1|) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-825))) (|HasCategory| |#1| (QUOTE (-1058))) (-12 (|HasCategory| |#1| (QUOTE (-1058))) (|HasCategory| |#1| (QUOTE (-1185)))) (|HasCategory| |#1| (QUOTE (-551))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-366)))) (|HasCategory| |#1| (QUOTE (-302))) (-1929 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559)))) (-1929 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-906))) (|HasCategory| |#1| (QUOTE (-226))) (-1929 (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -282) (|devaluate| |#1|) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1165)) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-351)))) (|HasCategory| |#1| (QUOTE (-226))) (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-351)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-371)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-559)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-825)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-844)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-1023)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-1185))))) (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (-1929 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-366))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-906))))) (-1929 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (-12 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-906)))) (-12 (|HasCategory| |#1| (QUOTE (-351))) (|HasCategory| |#1| (QUOTE (-906))))) (-1929 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-366)))) (-1929 (-12 (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-559)))) (|HasAttribute| |#1| (QUOTE -4567)) (|HasAttribute| |#1| (QUOTE -4570)) (-12 (|HasCategory| |#1| (QUOTE (-226))) (|HasCategory| |#1| (QUOTE (-366)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-366)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-149)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-351))))) (-171 R S CS) ((|constructor| (NIL "This package supports converting complex expressions to patterns")) (|convert| (((|Pattern| |#1|) |#3|) "\\spad{convert(cs)} converts the complex expression \\spad{cs} to a pattern"))) NIL NIL (-172) -((|constructor| (NIL "This domain implements some global properties of subspaces.")) (|copy| (($ $) "\\spad{copy(x)} is not documented")) (|solid| (((|Boolean|) $ (|Boolean|)) "\\spad{solid(x,{}b)} is not documented")) (|close| (((|Boolean|) $ (|Boolean|)) "\\spad{close(x,{}b)} is not documented")) (|solid?| (((|Boolean|) $) "\\spad{solid?(x)} is not documented")) (|closed?| (((|Boolean|) $) "\\spad{closed?(x)} is not documented")) (|new| (($) "\\spad{new()} is not documented"))) +((|constructor| (NIL "This domain implements some global properties of subspaces.")) (|copy| (($ $) "\\spad{copy(x)} is not documented")) (|solid| (((|Boolean|) $ (|Boolean|)) "\\spad{solid(x,b)} is not documented")) (|close| (((|Boolean|) $ (|Boolean|)) "\\spad{close(x,b)} is not documented")) (|solid?| (((|Boolean|) $) "\\spad{solid?(x)} is not documented")) (|closed?| (((|Boolean|) $) "\\spad{closed?(x)} is not documented")) (|new| (($) "\\spad{new()} is not documented"))) NIL NIL (-173) -((|constructor| (NIL "The category of commutative rings with unity,{} \\spadignore{i.e.} rings where \\spadop{*} is commutative,{} and which have a multiplicative identity element.")) (|commutative| ((|attribute| "*") "multiplication is commutative."))) -(((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "The category of commutative rings with unity, \\spadignore{i.e.} rings where \\spadop{*} is commutative, and which have a multiplicative identity element.")) (|commutative| ((|attribute| "*") "multiplication is commutative."))) +(((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-174 R) -((|constructor| (NIL "\\spadtype{ContinuedFraction} implements general continued fractions. This version is not restricted to simple,{} finite fractions and uses the \\spadtype{Stream} as a representation. The arithmetic functions assume that the approximants alternate below/above the convergence point. This is enforced by ensuring the partial numerators and partial denominators are greater than 0 in the Euclidean domain view of \\spad{R} (\\spadignore{i.e.} \\spad{sizeLess?(0,{} x)}).")) (|complete| (($ $) "\\spad{complete(x)} causes all entries in \\spadvar{\\spad{x}} to be computed. Normally entries are only computed as needed. If \\spadvar{\\spad{x}} is an infinite continued fraction,{} a user-initiated interrupt is necessary to stop the computation.")) (|extend| (($ $ (|Integer|)) "\\spad{extend(x,{}n)} causes the first \\spadvar{\\spad{n}} entries in the continued fraction \\spadvar{\\spad{x}} to be computed. Normally entries are only computed as needed.")) (|denominators| (((|Stream| |#1|) $) "\\spad{denominators(x)} returns the stream of denominators of the approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|numerators| (((|Stream| |#1|) $) "\\spad{numerators(x)} returns the stream of numerators of the approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|convergents| (((|Stream| (|Fraction| |#1|)) $) "\\spad{convergents(x)} returns the stream of the convergents of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be finite.")) (|approximants| (((|Stream| (|Fraction| |#1|)) $) "\\spad{approximants(x)} returns the stream of approximants of the continued fraction \\spadvar{\\spad{x}}. If the continued fraction is finite,{} then the stream will be infinite and periodic with period 1.")) (|reducedForm| (($ $) "\\spad{reducedForm(x)} puts the continued fraction \\spadvar{\\spad{x}} in reduced form,{} \\spadignore{i.e.} the function returns an equivalent continued fraction of the form \\spad{continuedFraction(b0,{}[1,{}1,{}1,{}...],{}[b1,{}b2,{}b3,{}...])}.")) (|wholePart| ((|#1| $) "\\spad{wholePart(x)} extracts the whole part of \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0,{} [a1,{}a2,{}a3,{}...],{} [b1,{}b2,{}b3,{}...])},{} then \\spad{wholePart(x) = b0}.")) (|partialQuotients| (((|Stream| |#1|) $) "\\spad{partialQuotients(x)} extracts the partial quotients in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0,{} [a1,{}a2,{}a3,{}...],{} [b1,{}b2,{}b3,{}...])},{} then \\spad{partialQuotients(x) = [b0,{}b1,{}b2,{}b3,{}...]}.")) (|partialDenominators| (((|Stream| |#1|) $) "\\spad{partialDenominators(x)} extracts the denominators in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0,{} [a1,{}a2,{}a3,{}...],{} [b1,{}b2,{}b3,{}...])},{} then \\spad{partialDenominators(x) = [b1,{}b2,{}b3,{}...]}.")) (|partialNumerators| (((|Stream| |#1|) $) "\\spad{partialNumerators(x)} extracts the numerators in \\spadvar{\\spad{x}}. That is,{} if \\spad{x = continuedFraction(b0,{} [a1,{}a2,{}a3,{}...],{} [b1,{}b2,{}b3,{}...])},{} then \\spad{partialNumerators(x) = [a1,{}a2,{}a3,{}...]}.")) (|reducedContinuedFraction| (($ |#1| (|Stream| |#1|)) "\\spad{reducedContinuedFraction(b0,{}b)} constructs a continued fraction in the following way: if \\spad{b = [b1,{}b2,{}...]} then the result is the continued fraction \\spad{b0 + 1/(b1 + 1/(b2 + ...))}. That is,{} the result is the same as \\spad{continuedFraction(b0,{}[1,{}1,{}1,{}...],{}[b1,{}b2,{}b3,{}...])}.")) (|continuedFraction| (($ |#1| (|Stream| |#1|) (|Stream| |#1|)) "\\spad{continuedFraction(b0,{}a,{}b)} constructs a continued fraction in the following way: if \\spad{a = [a1,{}a2,{}...]} and \\spad{b = [b1,{}b2,{}...]} then the result is the continued fraction \\spad{b0 + a1/(b1 + a2/(b2 + ...))}.") (($ (|Fraction| |#1|)) "\\spad{continuedFraction(r)} converts the fraction \\spadvar{\\spad{r}} with components of type \\spad{R} to a continued fraction over \\spad{R}."))) -(((-4537 "*") . T) (-4528 . T) (-4533 . T) (-4527 . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "\\spadtype{ContinuedFraction} implements general continued fractions. This version is not restricted to simple, finite fractions and uses the \\spadtype{Stream} as a representation. The arithmetic functions assume that the approximants alternate below/above the convergence point. This is enforced by ensuring the partial numerators and partial denominators are greater than 0 in the Euclidean domain view of \\spad{R} (\\spadignore{i.e.} \\spad{sizeLess?(0, x)}).")) (|complete| (($ $) "\\spad{complete(x)} causes all entries in \\spadvar{x} to be computed. Normally entries are only computed as needed. If \\spadvar{x} is an infinite continued fraction, a user-initiated interrupt is necessary to stop the computation.")) (|extend| (($ $ (|Integer|)) "\\spad{extend(x,n)} causes the first \\spadvar{n} entries in the continued fraction \\spadvar{x} to be computed. Normally entries are only computed as needed.")) (|denominators| (((|Stream| |#1|) $) "\\spad{denominators(x)} returns the stream of denominators of the approximants of the continued fraction \\spadvar{x}. If the continued fraction is finite, then the stream will be finite.")) (|numerators| (((|Stream| |#1|) $) "\\spad{numerators(x)} returns the stream of numerators of the approximants of the continued fraction \\spadvar{x}. If the continued fraction is finite, then the stream will be finite.")) (|convergents| (((|Stream| (|Fraction| |#1|)) $) "\\spad{convergents(x)} returns the stream of the convergents of the continued fraction \\spadvar{x}. If the continued fraction is finite, then the stream will be finite.")) (|approximants| (((|Stream| (|Fraction| |#1|)) $) "\\spad{approximants(x)} returns the stream of approximants of the continued fraction \\spadvar{x}. If the continued fraction is finite, then the stream will be infinite and periodic with period 1.")) (|reducedForm| (($ $) "\\spad{reducedForm(x)} puts the continued fraction \\spadvar{x} in reduced form, \\spadignore{i.e.} the function returns an equivalent continued fraction of the form \\spad{continuedFraction(b0,[1,1,1,...],[b1,b2,b3,...])}.")) (|wholePart| ((|#1| $) "\\spad{wholePart(x)} extracts the whole part of \\spadvar{x}. That is, if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])}, then \\spad{wholePart(x) = b0}.")) (|partialQuotients| (((|Stream| |#1|) $) "\\spad{partialQuotients(x)} extracts the partial quotients in \\spadvar{x}. That is, if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])}, then \\spad{partialQuotients(x) = [b0,b1,b2,b3,...]}.")) (|partialDenominators| (((|Stream| |#1|) $) "\\spad{partialDenominators(x)} extracts the denominators in \\spadvar{x}. That is, if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])}, then \\spad{partialDenominators(x) = [b1,b2,b3,...]}.")) (|partialNumerators| (((|Stream| |#1|) $) "\\spad{partialNumerators(x)} extracts the numerators in \\spadvar{x}. That is, if \\spad{x = continuedFraction(b0, [a1,a2,a3,...], [b1,b2,b3,...])}, then \\spad{partialNumerators(x) = [a1,a2,a3,...]}.")) (|reducedContinuedFraction| (($ |#1| (|Stream| |#1|)) "\\spad{reducedContinuedFraction(b0,b)} constructs a continued fraction in the following way: if \\spad{b = [b1,b2,...]} then the result is the continued fraction \\spad{b0 + 1/(b1 + 1/(b2 + ...))}. That is, the result is the same as \\spad{continuedFraction(b0,[1,1,1,...],[b1,b2,b3,...])}.")) (|continuedFraction| (($ |#1| (|Stream| |#1|) (|Stream| |#1|)) "\\spad{continuedFraction(b0,a,b)} constructs a continued fraction in the following way: if \\spad{a = [a1,a2,...]} and \\spad{b = [b1,b2,...]} then the result is the continued fraction \\spad{b0 + \\spad{a1/(b1} + \\spad{a2/(b2} + ...))}.") (($ (|Fraction| |#1|)) "\\spad{continuedFraction(r)} converts the fraction \\spadvar{r} with components of type \\spad{R} to a continued fraction over \\spad{R}."))) +(((-4573 "*") . T) (-4564 . T) (-4569 . T) (-4563 . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-175 R) -((|constructor| (NIL "CoordinateSystems provides coordinate transformation functions for plotting. Functions in this package return conversion functions which take points expressed in other coordinate systems and return points with the corresponding Cartesian coordinates.")) (|conical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1| |#1|) "\\spad{conical(a,{}b)} transforms from conical coordinates to Cartesian coordinates: \\spad{conical(a,{}b)} is a function which will map the point \\spad{(lambda,{}mu,{}nu)} to \\spad{x = lambda*mu*nu/(a*b)},{} \\spad{y = lambda/a*sqrt((mu**2-a**2)*(nu**2-a**2)/(a**2-b**2))},{} \\spad{z = lambda/b*sqrt((mu**2-b**2)*(nu**2-b**2)/(b**2-a**2))}.")) (|toroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{toroidal(a)} transforms from toroidal coordinates to Cartesian coordinates: \\spad{toroidal(a)} is a function which will map the point \\spad{(u,{}v,{}phi)} to \\spad{x = a*sinh(v)*cos(phi)/(cosh(v)-cos(u))},{} \\spad{y = a*sinh(v)*sin(phi)/(cosh(v)-cos(u))},{} \\spad{z = a*sin(u)/(cosh(v)-cos(u))}.")) (|bipolarCylindrical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{bipolarCylindrical(a)} transforms from bipolar cylindrical coordinates to Cartesian coordinates: \\spad{bipolarCylindrical(a)} is a function which will map the point \\spad{(u,{}v,{}z)} to \\spad{x = a*sinh(v)/(cosh(v)-cos(u))},{} \\spad{y = a*sin(u)/(cosh(v)-cos(u))},{} \\spad{z}.")) (|bipolar| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{bipolar(a)} transforms from bipolar coordinates to Cartesian coordinates: \\spad{bipolar(a)} is a function which will map the point \\spad{(u,{}v)} to \\spad{x = a*sinh(v)/(cosh(v)-cos(u))},{} \\spad{y = a*sin(u)/(cosh(v)-cos(u))}.")) (|oblateSpheroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{oblateSpheroidal(a)} transforms from oblate spheroidal coordinates to Cartesian coordinates: \\spad{oblateSpheroidal(a)} is a function which will map the point \\spad{(\\spad{xi},{}eta,{}phi)} to \\spad{x = a*sinh(\\spad{xi})*sin(eta)*cos(phi)},{} \\spad{y = a*sinh(\\spad{xi})*sin(eta)*sin(phi)},{} \\spad{z = a*cosh(\\spad{xi})*cos(eta)}.")) (|prolateSpheroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{prolateSpheroidal(a)} transforms from prolate spheroidal coordinates to Cartesian coordinates: \\spad{prolateSpheroidal(a)} is a function which will map the point \\spad{(\\spad{xi},{}eta,{}phi)} to \\spad{x = a*sinh(\\spad{xi})*sin(eta)*cos(phi)},{} \\spad{y = a*sinh(\\spad{xi})*sin(eta)*sin(phi)},{} \\spad{z = a*cosh(\\spad{xi})*cos(eta)}.")) (|ellipticCylindrical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{ellipticCylindrical(a)} transforms from elliptic cylindrical coordinates to Cartesian coordinates: \\spad{ellipticCylindrical(a)} is a function which will map the point \\spad{(u,{}v,{}z)} to \\spad{x = a*cosh(u)*cos(v)},{} \\spad{y = a*sinh(u)*sin(v)},{} \\spad{z}.")) (|elliptic| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{elliptic(a)} transforms from elliptic coordinates to Cartesian coordinates: \\spad{elliptic(a)} is a function which will map the point \\spad{(u,{}v)} to \\spad{x = a*cosh(u)*cos(v)},{} \\spad{y = a*sinh(u)*sin(v)}.")) (|paraboloidal| (((|Point| |#1|) (|Point| |#1|)) "\\spad{paraboloidal(pt)} transforms \\spad{pt} from paraboloidal coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,{}v,{}phi)} to \\spad{x = u*v*cos(phi)},{} \\spad{y = u*v*sin(phi)},{} \\spad{z = 1/2 * (u**2 - v**2)}.")) (|parabolicCylindrical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{parabolicCylindrical(pt)} transforms \\spad{pt} from parabolic cylindrical coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,{}v,{}z)} to \\spad{x = 1/2*(u**2 - v**2)},{} \\spad{y = u*v},{} \\spad{z}.")) (|parabolic| (((|Point| |#1|) (|Point| |#1|)) "\\spad{parabolic(pt)} transforms \\spad{pt} from parabolic coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,{}v)} to \\spad{x = 1/2*(u**2 - v**2)},{} \\spad{y = u*v}.")) (|spherical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{spherical(pt)} transforms \\spad{pt} from spherical coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,{}theta,{}phi)} to \\spad{x = r*sin(phi)*cos(theta)},{} \\spad{y = r*sin(phi)*sin(theta)},{} \\spad{z = r*cos(phi)}.")) (|cylindrical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{cylindrical(pt)} transforms \\spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,{}theta,{}z)} to \\spad{x = r * cos(theta)},{} \\spad{y = r * sin(theta)},{} \\spad{z}.")) (|polar| (((|Point| |#1|) (|Point| |#1|)) "\\spad{polar(pt)} transforms \\spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,{}theta)} to \\spad{x = r * cos(theta)} ,{} \\spad{y = r * sin(theta)}.")) (|cartesian| (((|Point| |#1|) (|Point| |#1|)) "\\spad{cartesian(pt)} returns the Cartesian coordinates of point \\spad{pt}."))) +((|constructor| (NIL "CoordinateSystems provides coordinate transformation functions for plotting. Functions in this package return conversion functions which take points expressed in other coordinate systems and return points with the corresponding Cartesian coordinates.")) (|conical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1| |#1|) "\\spad{conical(a,b)} transforms from conical coordinates to Cartesian coordinates: \\spad{conical(a,b)} is a function which will map the point \\spad{(lambda,mu,nu)} to \\spad{x = lambda*mu*nu/(a*b)}, \\spad{y = lambda/a*sqrt((mu**2-a**2)*(nu**2-a**2)/(a**2-b**2))}, \\spad{z = lambda/b*sqrt((mu**2-b**2)*(nu**2-b**2)/(b**2-a**2))}.")) (|toroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{toroidal(a)} transforms from toroidal coordinates to Cartesian coordinates: \\spad{toroidal(a)} is a function which will map the point \\spad{(u,v,phi)} to \\spad{x = a*sinh(v)*cos(phi)/(cosh(v)-cos(u))}, \\spad{y = a*sinh(v)*sin(phi)/(cosh(v)-cos(u))}, \\spad{z = a*sin(u)/(cosh(v)-cos(u))}.")) (|bipolarCylindrical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{bipolarCylindrical(a)} transforms from bipolar cylindrical coordinates to Cartesian coordinates: \\spad{bipolarCylindrical(a)} is a function which will map the point \\spad{(u,v,z)} to \\spad{x = a*sinh(v)/(cosh(v)-cos(u))}, \\spad{y = a*sin(u)/(cosh(v)-cos(u))}, \\spad{z}.")) (|bipolar| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{bipolar(a)} transforms from bipolar coordinates to Cartesian coordinates: \\spad{bipolar(a)} is a function which will map the point \\spad{(u,v)} to \\spad{x = a*sinh(v)/(cosh(v)-cos(u))}, \\spad{y = a*sin(u)/(cosh(v)-cos(u))}.")) (|oblateSpheroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{oblateSpheroidal(a)} transforms from oblate spheroidal coordinates to Cartesian coordinates: \\spad{oblateSpheroidal(a)} is a function which will map the point \\spad{(xi,eta,phi)} to \\spad{x = a*sinh(xi)*sin(eta)*cos(phi)}, \\spad{y = a*sinh(xi)*sin(eta)*sin(phi)}, \\spad{z = a*cosh(xi)*cos(eta)}.")) (|prolateSpheroidal| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{prolateSpheroidal(a)} transforms from prolate spheroidal coordinates to Cartesian coordinates: \\spad{prolateSpheroidal(a)} is a function which will map the point \\spad{(xi,eta,phi)} to \\spad{x = a*sinh(xi)*sin(eta)*cos(phi)}, \\spad{y = a*sinh(xi)*sin(eta)*sin(phi)}, \\spad{z = a*cosh(xi)*cos(eta)}.")) (|ellipticCylindrical| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{ellipticCylindrical(a)} transforms from elliptic cylindrical coordinates to Cartesian coordinates: \\spad{ellipticCylindrical(a)} is a function which will map the point \\spad{(u,v,z)} to \\spad{x = a*cosh(u)*cos(v)}, \\spad{y = a*sinh(u)*sin(v)}, \\spad{z}.")) (|elliptic| (((|Mapping| (|Point| |#1|) (|Point| |#1|)) |#1|) "\\spad{elliptic(a)} transforms from elliptic coordinates to Cartesian coordinates: \\spad{elliptic(a)} is a function which will map the point \\spad{(u,v)} to \\spad{x = a*cosh(u)*cos(v)}, \\spad{y = a*sinh(u)*sin(v)}.")) (|paraboloidal| (((|Point| |#1|) (|Point| |#1|)) "\\spad{paraboloidal(pt)} transforms \\spad{pt} from paraboloidal coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,v,phi)} to \\spad{x = u*v*cos(phi)}, \\spad{y = u*v*sin(phi)}, \\spad{z = 1/2 * \\spad{(u**2} - v**2)}.")) (|parabolicCylindrical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{parabolicCylindrical(pt)} transforms \\spad{pt} from parabolic cylindrical coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,v,z)} to \\spad{x = 1/2*(u**2 - v**2)}, \\spad{y = u*v}, \\spad{z}.")) (|parabolic| (((|Point| |#1|) (|Point| |#1|)) "\\spad{parabolic(pt)} transforms \\spad{pt} from parabolic coordinates to Cartesian coordinates: the function produced will map the point \\spad{(u,v)} to \\spad{x = 1/2*(u**2 - v**2)}, \\spad{y = u*v}.")) (|spherical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{spherical(pt)} transforms \\spad{pt} from spherical coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,theta,phi)} to \\spad{x = r*sin(phi)*cos(theta)}, \\spad{y = r*sin(phi)*sin(theta)}, \\spad{z = r*cos(phi)}.")) (|cylindrical| (((|Point| |#1|) (|Point| |#1|)) "\\spad{cylindrical(pt)} transforms \\spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,theta,z)} to \\spad{x = \\spad{r} * cos(theta)}, \\spad{y = \\spad{r} * sin(theta)}, \\spad{z}.")) (|polar| (((|Point| |#1|) (|Point| |#1|)) "\\spad{polar(pt)} transforms \\spad{pt} from polar coordinates to Cartesian coordinates: the function produced will map the point \\spad{(r,theta)} to \\spad{x = \\spad{r} * cos(theta)} ,{} \\spad{y = \\spad{r} * sin(theta)}.")) (|cartesian| (((|Point| |#1|) (|Point| |#1|)) "\\spad{cartesian(pt)} returns the Cartesian coordinates of point \\spad{pt.}"))) NIL NIL (-176 R |PolR| E) @@ -637,31 +637,31 @@ NIL NIL NIL (-177 R S CS) -((|constructor| (NIL "This package supports matching patterns involving complex expressions")) (|patternMatch| (((|PatternMatchResult| |#1| |#3|) |#3| (|Pattern| |#1|) (|PatternMatchResult| |#1| |#3|)) "\\spad{patternMatch(cexpr,{} pat,{} res)} matches the pattern \\spad{pat} to the complex expression \\spad{cexpr}. res contains the variables of \\spad{pat} which are already matched and their matches."))) +((|constructor| (NIL "This package supports matching patterns involving complex expressions")) (|patternMatch| (((|PatternMatchResult| |#1| |#3|) |#3| (|Pattern| |#1|) (|PatternMatchResult| |#1| |#3|)) "\\spad{patternMatch(cexpr, pat, res)} matches the pattern \\spad{pat} to the complex expression cexpr. res contains the variables of \\spad{pat} which are already matched and their matches."))) NIL -((|HasCategory| (-954 |#2|) (LIST (QUOTE -882) (|devaluate| |#1|)))) +((|HasCategory| (-955 |#2|) (LIST (QUOTE -883) (|devaluate| |#1|)))) (-178 R) -((|constructor| (NIL "This package has no documentation")) (|multiEuclideanTree| (((|List| |#1|) (|List| |#1|) |#1|) "\\spad{multiEuclideanTree(l,{}r)} \\undocumented{}")) (|chineseRemainder| (((|List| |#1|) (|List| (|List| |#1|)) (|List| |#1|)) "\\spad{chineseRemainder(llv,{}lm)} returns a list of values,{} each of which corresponds to the Chinese remainder of the associated element of \\axiom{\\spad{llv}} and axiom{\\spad{lm}}. This is more efficient than applying chineseRemainder several times.") ((|#1| (|List| |#1|) (|List| |#1|)) "\\spad{chineseRemainder(lv,{}lm)} returns a value \\axiom{\\spad{v}} such that,{} if \\spad{x} is \\axiom{\\spad{lv}.\\spad{i}} modulo \\axiom{\\spad{lm}.\\spad{i}} for all \\axiom{\\spad{i}},{} then \\spad{x} is \\axiom{\\spad{v}} modulo \\axiom{\\spad{lm}(1)\\spad{*lm}(2)*...\\spad{*lm}(\\spad{n})}.")) (|modTree| (((|List| |#1|) |#1| (|List| |#1|)) "\\spad{modTree(r,{}l)} \\undocumented{}"))) +((|constructor| (NIL "This package has no documentation")) (|multiEuclideanTree| (((|List| |#1|) (|List| |#1|) |#1|) "\\spad{multiEuclideanTree(l,r)} \\undocumented{}")) (|chineseRemainder| (((|List| |#1|) (|List| (|List| |#1|)) (|List| |#1|)) "\\spad{chineseRemainder(llv,lm)} returns a list of values, each of which corresponds to the Chinese remainder of the associated element of \\axiom{llv} and axiom{lm}. This is more efficient than applying chineseRemainder several times.") ((|#1| (|List| |#1|) (|List| |#1|)) "\\spad{chineseRemainder(lv,lm)} returns a value \\axiom{v} such that, if \\spad{x} is \\axiom{lv.i} modulo \\axiom{lm.i} for all \\axiom{i}, then \\spad{x} is \\axiom{v} modulo \\axiom{lm(1)*lm(2)*...*lm(n)}.")) (|modTree| (((|List| |#1|) |#1| (|List| |#1|)) "\\spad{modTree(r,l)} \\undocumented{}"))) NIL NIL (-179 R UP) -((|constructor| (NIL "\\spadtype{ComplexRootFindingPackage} provides functions to find all roots of a polynomial \\spad{p} over the complex number by using Plesken\\spad{'s} idea to calculate in the polynomial ring modulo \\spad{f} and employing the Chinese Remainder Theorem. In this first version,{} the precision (see digits) is not increased when this is necessary to avoid rounding errors. Hence it is the user\\spad{'s} responsibility to increase the precision if necessary. Note also,{} if this package is called with \\spadignore{e.g.} \\spadtype{Fraction Integer},{} the precise calculations could require a lot of time. Also note that evaluating the zeros is not necessarily a good check whether the result is correct: already evaluation can cause rounding errors.")) (|startPolynomial| (((|Record| (|:| |start| |#2|) (|:| |factors| (|Factored| |#2|))) |#2|) "\\spad{startPolynomial(p)} uses the ideas of Schoenhage\\spad{'s} variant of Graeffe\\spad{'s} method to construct circles which separate roots to get a good start polynomial,{} \\spadignore{i.e.} one whose image under the Chinese Remainder Isomorphism has both entries of norm smaller and greater or equal to 1. In case the roots are found during internal calculations. The corresponding factors are in factors which are otherwise 1.")) (|setErrorBound| ((|#1| |#1|) "\\spad{setErrorBound(eps)} changes the internal error bound,{} by default being 10 \\spad{**} (\\spad{-3}) to \\spad{eps},{} if \\spad{R} is a member in the category \\spadtype{QuotientFieldCategory Integer}. The internal globalDigits is set to \\em ceiling(1/r)\\spad{**2*10} being 10**7 by default.")) (|schwerpunkt| (((|Complex| |#1|) |#2|) "\\spad{schwerpunkt(p)} determines the 'Schwerpunkt' of the roots of the polynomial \\spad{p} of degree \\spad{n},{} \\spadignore{i.e.} the center of gravity,{} which is coeffient of \\spad{x**(n-1)} divided by \\spad{n} times coefficient of \\spad{x**n}.")) (|rootRadius| ((|#1| |#2|) "\\spad{rootRadius(p)} calculates the root radius of \\spad{p} with a maximal error quotient of 1+globalEps,{} where globalEps is the internal error bound,{} which can be set by setErrorBound.") ((|#1| |#2| |#1|) "\\spad{rootRadius(p,{}errQuot)} calculates the root radius of \\spad{p} with a maximal error quotient of \\spad{errQuot}.")) (|reciprocalPolynomial| ((|#2| |#2|) "\\spad{reciprocalPolynomial(p)} calulates a polynomial which has exactly the inverses of the non-zero roots of \\spad{p} as roots,{} and the same number of 0-roots.")) (|pleskenSplit| (((|Factored| |#2|) |#2| |#1|) "\\spad{pleskenSplit(poly,{} eps)} determines a start polynomial start by using \"startPolynomial then it increases the exponent \\spad{n} of start \\spad{**} \\spad{n} mod \\spad{poly} to get an approximate factor of \\spad{poly},{} in general of degree \"degree \\spad{poly} \\spad{-1\"}. Then a divisor cascade is calculated and the best splitting is chosen,{} as soon as the error is small enough.") (((|Factored| |#2|) |#2| |#1| (|Boolean|)) "\\spad{pleskenSplit(poly,{}eps,{}info)} determines a start polynomial start by using \"startPolynomial then it increases the exponent \\spad{n} of start \\spad{**} \\spad{n} mod \\spad{poly} to get an approximate factor of \\spad{poly},{} in general of degree \"degree \\spad{poly} \\spad{-1\"}. Then a divisor cascade is calculated and the best splitting is chosen,{} as soon as the error is small enough. If \\spad{info} is \\spad{true},{} then information messages are issued.")) (|norm| ((|#1| |#2|) "\\spad{norm(p)} determines sum of absolute values of coefficients Note that this function depends on abs.")) (|graeffe| ((|#2| |#2|) "\\spad{graeffe p} determines \\spad{q} such that \\spad{q(-z**2) = p(z)*p(-z)}. Note that the roots of \\spad{q} are the squares of the roots of \\spad{p}.")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} tries to factor \\spad{p} into linear factors with error atmost globalEps,{} the internal error bound,{} which can be set by setErrorBound. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization.") (((|Factored| |#2|) |#2| |#1|) "\\spad{factor(p,{} eps)} tries to factor \\spad{p} into linear factors with error atmost eps. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization.") (((|Factored| |#2|) |#2| |#1| (|Boolean|)) "\\spad{factor(p,{} eps,{} info)} tries to factor \\spad{p} into linear factors with error atmost \\spad{eps}. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization. If info is \\spad{true},{} then information messages are given.")) (|divisorCascade| (((|List| (|Record| (|:| |factors| (|List| |#2|)) (|:| |error| |#1|))) |#2| |#2|) "\\spad{divisorCascade(p,{}tp)} assumes that degree of polynomial \\spad{tp} is smaller than degree of polynomial \\spad{p},{} both monic. A sequence of divisions is calculated using the remainder,{} made monic,{} as divisor for the the next division. The result contains also the error of the factorizations,{} \\spadignore{i.e.} the norm of the remainder polynomial.") (((|List| (|Record| (|:| |factors| (|List| |#2|)) (|:| |error| |#1|))) |#2| |#2| (|Boolean|)) "\\spad{divisorCascade(p,{}tp)} assumes that degree of polynomial \\spad{tp} is smaller than degree of polynomial \\spad{p},{} both monic. A sequence of divisions are calculated using the remainder,{} made monic,{} as divisor for the the next division. The result contains also the error of the factorizations,{} \\spadignore{i.e.} the norm of the remainder polynomial. If info is \\spad{true},{} then information messages are issued.")) (|complexZeros| (((|List| (|Complex| |#1|)) |#2| |#1|) "\\spad{complexZeros(p,{} eps)} tries to determine all complex zeros of the polynomial \\spad{p} with accuracy given by eps.") (((|List| (|Complex| |#1|)) |#2|) "\\spad{complexZeros(p)} tries to determine all complex zeros of the polynomial \\spad{p} with accuracy given by the package constant globalEps which you may change by setErrorBound."))) +((|constructor| (NIL "\\spadtype{ComplexRootFindingPackage} provides functions to find all roots of a polynomial \\spad{p} over the complex number by using Plesken's idea to calculate in the polynomial ring modulo \\spad{f} and employing the Chinese Remainder Theorem. In this first version, the precision (see digits) is not increased when this is necessary to avoid rounding errors. Hence it is the user's responsibility to increase the precision if necessary. Note also, if this package is called with \\spadignore{e.g.} \\spadtype{Fraction Integer}, the precise calculations could require a lot of time. Also note that evaluating the zeros is not necessarily a good check whether the result is correct: already evaluation can cause rounding errors.")) (|startPolynomial| (((|Record| (|:| |start| |#2|) (|:| |factors| (|Factored| |#2|))) |#2|) "\\spad{startPolynomial(p)} uses the ideas of Schoenhage's variant of Graeffe's method to construct circles which separate roots to get a good start polynomial, \\spadignore{i.e.} one whose image under the Chinese Remainder Isomorphism has both entries of norm smaller and greater or equal to 1. In case the roots are found during internal calculations. The corresponding factors are in factors which are otherwise 1.")) (|setErrorBound| ((|#1| |#1|) "\\spad{setErrorBound(eps)} changes the internal error bound, by default being 10 \\spad{**} (-3) to eps, if \\spad{R} is a member in the category \\spadtype{QuotientFieldCategory Integer}. The internal globalDigits is set to \\em \\spad{ceiling(1/r)**2*10} being 10**7 by default.")) (|schwerpunkt| (((|Complex| |#1|) |#2|) "\\spad{schwerpunkt(p)} determines the 'Schwerpunkt' of the roots of the polynomial \\spad{p} of degree \\spad{n,} \\spadignore{i.e.} the center of gravity, which is coeffient of \\spad{x**(n-1)} divided by \\spad{n} times coefficient of \\spad{x**n}.")) (|rootRadius| ((|#1| |#2|) "\\spad{rootRadius(p)} calculates the root radius of \\spad{p} with a maximal error quotient of 1+globalEps, where globalEps is the internal error bound, which can be set by setErrorBound.") ((|#1| |#2| |#1|) "\\spad{rootRadius(p,errQuot)} calculates the root radius of \\spad{p} with a maximal error quotient of errQuot.")) (|reciprocalPolynomial| ((|#2| |#2|) "\\spad{reciprocalPolynomial(p)} calulates a polynomial which has exactly the inverses of the non-zero roots of \\spad{p} as roots, and the same number of 0-roots.")) (|pleskenSplit| (((|Factored| |#2|) |#2| |#1|) "\\spad{pleskenSplit(poly, eps)} determines a start polynomial start by using \"startPolynomial then it increases the exponent \\spad{n} of start \\spad{**} \\spad{n} mod \\spad{poly} to get an approximate factor of poly, in general of degree \"degree \\spad{poly} -1\". Then a divisor cascade is calculated and the best splitting is chosen, as soon as the error is small enough.") (((|Factored| |#2|) |#2| |#1| (|Boolean|)) "\\spad{pleskenSplit(poly,eps,info)} determines a start polynomial start by using \"startPolynomial then it increases the exponent \\spad{n} of start \\spad{**} \\spad{n} mod \\spad{poly} to get an approximate factor of poly, in general of degree \"degree \\spad{poly} -1\". Then a divisor cascade is calculated and the best splitting is chosen, as soon as the error is small enough. If \\spad{info} is true, then information messages are issued.")) (|norm| ((|#1| |#2|) "\\spad{norm(p)} determines sum of absolute values of coefficients Note that this function depends on abs.")) (|graeffe| ((|#2| |#2|) "\\spad{graeffe \\spad{p}} determines \\spad{q} such that \\spad{q(-z**2) = p(z)*p(-z)}. Note that the roots of \\spad{q} are the squares of the roots of \\spad{p.}")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} tries to factor \\spad{p} into linear factors with error atmost globalEps, the internal error bound, which can be set by setErrorBound. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization.") (((|Factored| |#2|) |#2| |#1|) "\\spad{factor(p, eps)} tries to factor \\spad{p} into linear factors with error atmost eps. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization.") (((|Factored| |#2|) |#2| |#1| (|Boolean|)) "\\spad{factor(p, eps, info)} tries to factor \\spad{p} into linear factors with error atmost eps. An overall error bound \\spad{eps0} is determined and iterated tree-like calls to pleskenSplit are used to get the factorization. If info is true, then information messages are given.")) (|divisorCascade| (((|List| (|Record| (|:| |factors| (|List| |#2|)) (|:| |error| |#1|))) |#2| |#2|) "\\spad{divisorCascade(p,tp)} assumes that degree of polynomial \\spad{tp} is smaller than degree of polynomial \\spad{p,} both monic. A sequence of divisions is calculated using the remainder, made monic, as divisor for the the next division. The result contains also the error of the factorizations, \\spadignore{i.e.} the norm of the remainder polynomial.") (((|List| (|Record| (|:| |factors| (|List| |#2|)) (|:| |error| |#1|))) |#2| |#2| (|Boolean|)) "\\spad{divisorCascade(p,tp)} assumes that degree of polynomial \\spad{tp} is smaller than degree of polynomial \\spad{p,} both monic. A sequence of divisions are calculated using the remainder, made monic, as divisor for the the next division. The result contains also the error of the factorizations, \\spadignore{i.e.} the norm of the remainder polynomial. If info is true, then information messages are issued.")) (|complexZeros| (((|List| (|Complex| |#1|)) |#2| |#1|) "\\spad{complexZeros(p, eps)} tries to determine all complex zeros of the polynomial \\spad{p} with accuracy given by eps.") (((|List| (|Complex| |#1|)) |#2|) "\\spad{complexZeros(p)} tries to determine all complex zeros of the polynomial \\spad{p} with accuracy given by the package constant globalEps which you may change by setErrorBound."))) NIL NIL (-180 S ST) -((|constructor| (NIL "This package provides tools for working with cyclic streams.")) (|computeCycleEntry| ((|#2| |#2| |#2|) "\\indented{1}{computeCycleEntry(\\spad{x},{}cycElt),{} where cycElt is a pointer to a} \\indented{1}{node in the cyclic part of the cyclic stream \\spad{x},{} returns a} \\indented{1}{pointer to the first node in the cycle} \\blankline \\spad{X} p:=repeating([1,{}2,{}3]) \\spad{X} q:=cons(4,{}\\spad{p}) \\spad{X} computeCycleEntry(\\spad{q},{}cycleElt(\\spad{q}))")) (|computeCycleLength| (((|NonNegativeInteger|) |#2|) "\\indented{1}{computeCycleLength(\\spad{s}) returns the length of the cycle of a} \\indented{1}{cyclic stream \\spad{t},{} where \\spad{s} is a pointer to a node in the} \\indented{1}{cyclic part of \\spad{t}.} \\blankline \\spad{X} p:=repeating([1,{}2,{}3]) \\spad{X} q:=cons(4,{}\\spad{p}) \\spad{X} computeCycleLength(cycleElt(\\spad{q}))")) (|cycleElt| (((|Union| |#2| "failed") |#2|) "\\indented{1}{cycleElt(\\spad{s}) returns a pointer to a node in the cycle if the stream} \\indented{1}{\\spad{s} is cyclic and returns \"failed\" if \\spad{s} is not cyclic} \\blankline \\spad{X} p:=repeating([1,{}2,{}3]) \\spad{X} q:=cons(4,{}\\spad{p}) \\spad{X} cycleElt \\spad{q} \\spad{X} \\spad{r:=}[1,{}2,{}3]::Stream(Integer) \\spad{X} cycleElt \\spad{r}"))) +((|constructor| (NIL "This package provides tools for working with cyclic streams.")) (|computeCycleEntry| ((|#2| |#2| |#2|) "\\indented{1}{computeCycleEntry(x,cycElt), where cycElt is a pointer to a} \\indented{1}{node in the cyclic part of the cyclic stream \\spad{x,} returns a} \\indented{1}{pointer to the first node in the cycle} \\blankline \\spad{X} p:=repeating([1,2,3]) \\spad{X} q:=cons(4,p) \\spad{X} computeCycleEntry(q,cycleElt(q))")) (|computeCycleLength| (((|NonNegativeInteger|) |#2|) "\\indented{1}{computeCycleLength(s) returns the length of the cycle of a} \\indented{1}{cyclic stream \\spad{t,} where \\spad{s} is a pointer to a node in the} \\indented{1}{cyclic part of \\spad{t.}} \\blankline \\spad{X} p:=repeating([1,2,3]) \\spad{X} q:=cons(4,p) \\spad{X} computeCycleLength(cycleElt(q))")) (|cycleElt| (((|Union| |#2| "failed") |#2|) "\\indented{1}{cycleElt(s) returns a pointer to a node in the cycle if the stream} \\indented{1}{s is cyclic and returns \"failed\" if \\spad{s} is not cyclic} \\blankline \\spad{X} p:=repeating([1,2,3]) \\spad{X} q:=cons(4,p) \\spad{X} cycleElt \\spad{q} \\spad{X} r:=[1,2,3]::Stream(Integer) \\spad{X} cycleElt \\spad{r}"))) NIL NIL -(-181 R -1564) -((|constructor| (NIL "\\spadtype{ComplexTrigonometricManipulations} provides function that compute the real and imaginary parts of complex functions.")) (|complexForm| (((|Complex| (|Expression| |#1|)) |#2|) "\\spad{complexForm(f)} returns \\spad{[real f,{} imag f]}.")) (|trigs| ((|#2| |#2|) "\\spad{trigs(f)} rewrites all the complex logs and exponentials appearing in \\spad{f} in terms of trigonometric functions.")) (|real?| (((|Boolean|) |#2|) "\\spad{real?(f)} returns \\spad{true} if \\spad{f = real f}.")) (|imag| (((|Expression| |#1|) |#2|) "\\spad{imag(f)} returns the imaginary part of \\spad{f} where \\spad{f} is a complex function.")) (|real| (((|Expression| |#1|) |#2|) "\\spad{real(f)} returns the real part of \\spad{f} where \\spad{f} is a complex function.")) (|complexElementary| ((|#2| |#2| (|Symbol|)) "\\spad{complexElementary(f,{} x)} rewrites the kernels of \\spad{f} involving \\spad{x} in terms of the 2 fundamental complex transcendental elementary functions: \\spad{log,{} exp}.") ((|#2| |#2|) "\\spad{complexElementary(f)} rewrites \\spad{f} in terms of the 2 fundamental complex transcendental elementary functions: \\spad{log,{} exp}.")) (|complexNormalize| ((|#2| |#2| (|Symbol|)) "\\spad{complexNormalize(f,{} x)} rewrites \\spad{f} using the least possible number of complex independent kernels involving \\spad{x}.") ((|#2| |#2|) "\\spad{complexNormalize(f)} rewrites \\spad{f} using the least possible number of complex independent kernels."))) +(-181 R -1647) +((|constructor| (NIL "\\spadtype{ComplexTrigonometricManipulations} provides function that compute the real and imaginary parts of complex functions.")) (|complexForm| (((|Complex| (|Expression| |#1|)) |#2|) "\\spad{complexForm(f)} returns \\spad{[real \\spad{f,} imag f]}.")) (|trigs| ((|#2| |#2|) "\\spad{trigs(f)} rewrites all the complex logs and exponentials appearing in \\spad{f} in terms of trigonometric functions.")) (|real?| (((|Boolean|) |#2|) "\\spad{real?(f)} returns \\spad{true} if \\spad{f = real \\spad{f}.}")) (|imag| (((|Expression| |#1|) |#2|) "\\spad{imag(f)} returns the imaginary part of \\spad{f} where \\spad{f} is a complex function.")) (|real| (((|Expression| |#1|) |#2|) "\\spad{real(f)} returns the real part of \\spad{f} where \\spad{f} is a complex function.")) (|complexElementary| ((|#2| |#2| (|Symbol|)) "\\spad{complexElementary(f, \\spad{x)}} rewrites the kernels of \\spad{f} involving \\spad{x} in terms of the 2 fundamental complex transcendental elementary functions: \\spad{log, exp}.") ((|#2| |#2|) "\\spad{complexElementary(f)} rewrites \\spad{f} in terms of the 2 fundamental complex transcendental elementary functions: \\spad{log, exp}.")) (|complexNormalize| ((|#2| |#2| (|Symbol|)) "\\spad{complexNormalize(f, \\spad{x)}} rewrites \\spad{f} using the least possible number of complex independent kernels involving \\spad{x}.") ((|#2| |#2|) "\\spad{complexNormalize(f)} rewrites \\spad{f} using the least possible number of complex independent kernels."))) NIL NIL (-182 R) -((|constructor| (NIL "CoerceVectorMatrixPackage is an unexposed,{} technical package for data conversions")) (|coerce| (((|Vector| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Vector| (|Matrix| |#1|))) "\\spad{coerce(v)} coerces a vector \\spad{v} with entries in \\spadtype{Matrix R} as vector over \\spadtype{Matrix Fraction Polynomial R}")) (|coerceP| (((|Vector| (|Matrix| (|Polynomial| |#1|))) (|Vector| (|Matrix| |#1|))) "\\spad{coerceP(v)} coerces a vector \\spad{v} with entries in \\spadtype{Matrix R} as vector over \\spadtype{Matrix Polynomial R}"))) +((|constructor| (NIL "CoerceVectorMatrixPackage is an unexposed, technical package for data conversions")) (|coerce| (((|Vector| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Vector| (|Matrix| |#1|))) "\\spad{coerce(v)} coerces a vector \\spad{v} with entries in \\spadtype{Matrix \\spad{R}} as vector over \\spadtype{Matrix Fraction Polynomial \\spad{R}}")) (|coerceP| (((|Vector| (|Matrix| (|Polynomial| |#1|))) (|Vector| (|Matrix| |#1|))) "\\spad{coerceP(v)} coerces a vector \\spad{v} with entries in \\spadtype{Matrix \\spad{R}} as vector over \\spadtype{Matrix Polynomial \\spad{R}}"))) NIL NIL (-183) -((|constructor| (NIL "Polya-Redfield enumeration by cycle indices.")) (|skewSFunction| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|List| (|Integer|)) (|List| (|Integer|))) "\\spad{skewSFunction(li1,{}li2)} is the \\spad{S}-function \\indented{1}{of the partition difference \\spad{li1 - li2}} \\indented{1}{expressed in terms of power sum symmetric functions.}")) (|SFunction| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|List| (|Integer|))) "\\spad{SFunction(\\spad{li})} is the \\spad{S}-function of the partition \\spad{\\spad{li}} \\indented{1}{expressed in terms of power sum symmetric functions.}")) (|wreath| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{wreath(s1,{}s2)} is the cycle index of the wreath product \\indented{1}{of the two groups whose cycle indices are \\spad{s1} and} \\indented{1}{\\spad{s2}.}")) (|eval| (((|Fraction| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{eval s} is the sum of the coefficients of a cycle index.")) (|cup| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{cup(s1,{}s2)},{} introduced by Redfield,{} \\indented{1}{is the scalar product of two cycle indices,{} in which the} \\indented{1}{power sums are retained to produce a cycle index.}")) (|cap| (((|Fraction| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{cap(s1,{}s2)},{} introduced by Redfield,{} \\indented{1}{is the scalar product of two cycle indices.}")) (|graphs| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{graphs n} is the cycle index of the group induced on \\indented{1}{the edges of a graph by applying the symmetric function to the} \\indented{1}{\\spad{n} nodes.}")) (|dihedral| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{dihedral n} is the cycle index of the \\indented{1}{dihedral group of degree \\spad{n}.}")) (|cyclic| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{cyclic n} is the cycle index of the \\indented{1}{cyclic group of degree \\spad{n}.}")) (|alternating| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{alternating n} is the cycle index of the \\indented{1}{alternating group of degree \\spad{n}.}")) (|elementary| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{elementary n} is the \\spad{n} th elementary symmetric \\indented{1}{function expressed in terms of power sums.}")) (|powerSum| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{powerSum n} is the \\spad{n} th power sum symmetric \\indented{1}{function.}")) (|complete| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{complete n} is the \\spad{n} th complete homogeneous \\indented{1}{symmetric function expressed in terms of power sums.} \\indented{1}{Alternatively it is the cycle index of the symmetric} \\indented{1}{group of degree \\spad{n}.}"))) +((|constructor| (NIL "Polya-Redfield enumeration by cycle indices.")) (|skewSFunction| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|List| (|Integer|)) (|List| (|Integer|))) "\\spad{skewSFunction(li1,li2)} is the S-function \\indented{1}{of the partition difference \\spad{li1 - li2}} \\indented{1}{expressed in terms of power sum symmetric functions.}")) (|SFunction| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|List| (|Integer|))) "\\spad{SFunction(li)} is the S-function of the partition \\spad{li} \\indented{1}{expressed in terms of power sum symmetric functions.}")) (|wreath| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{wreath(s1,s2)} is the cycle index of the wreath product \\indented{1}{of the two groups whose cycle indices are \\spad{s1} and} \\indented{1}{\\spad{s2}.}")) (|eval| (((|Fraction| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{eval \\spad{s}} is the sum of the coefficients of a cycle index.")) (|cup| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{cup(s1,s2)}, introduced by Redfield, \\indented{1}{is the scalar product of two cycle indices, in which the} \\indented{1}{power sums are retained to produce a cycle index.}")) (|cap| (((|Fraction| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|))) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{cap(s1,s2)}, introduced by Redfield, \\indented{1}{is the scalar product of two cycle indices.}")) (|graphs| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{graphs \\spad{n}} is the cycle index of the group induced on \\indented{1}{the edges of a graph by applying the symmetric function to the} \\indented{1}{n nodes.}")) (|dihedral| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{dihedral \\spad{n}} is the cycle index of the \\indented{1}{dihedral group of degree \\spad{n.}}")) (|cyclic| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{cyclic \\spad{n}} is the cycle index of the \\indented{1}{cyclic group of degree \\spad{n.}}")) (|alternating| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{alternating \\spad{n}} is the cycle index of the \\indented{1}{alternating group of degree \\spad{n.}}")) (|elementary| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{elementary \\spad{n}} is the \\spad{n} th elementary symmetric \\indented{1}{function expressed in terms of power sums.}")) (|powerSum| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{powerSum \\spad{n}} is the \\spad{n} th power sum symmetric \\indented{1}{function.}")) (|complete| (((|SymmetricPolynomial| (|Fraction| (|Integer|))) (|Integer|)) "\\spad{complete \\spad{n}} is the \\spad{n} th complete homogeneous \\indented{1}{symmetric function expressed in terms of power sums.} \\indented{1}{Alternatively it is the cycle index of the symmetric} \\indented{1}{group of degree \\spad{n.}}"))) NIL NIL (-184) @@ -669,47 +669,47 @@ NIL NIL NIL (-185) -((|constructor| (NIL "\\axiomType{d01AgentsPackage} is a package of numerical agents to be used to investigate attributes of an input function so as to decide the \\axiomFun{measure} of an appropriate numerical integration routine. It contains functions \\axiomFun{rangeIsFinite} to test the input range and \\axiomFun{functionIsContinuousAtEndPoints} to check for continuity at the end points of the range.")) (|changeName| (((|Result|) (|Symbol|) (|Symbol|) (|Result|)) "\\spad{changeName(s,{}t,{}r)} changes the name of item \\axiom{\\spad{s}} in \\axiom{\\spad{r}} to \\axiom{\\spad{t}}.")) (|commaSeparate| (((|String|) (|List| (|String|))) "\\spad{commaSeparate(l)} produces a comma separated string from a list of strings.")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a Stream of \\axiomType{DoubleFloat} to \\axiomType{List String}")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a List of \\axiomType{DoubleFloat} to \\axiomType{List String}")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|singularitiesOf| (((|Stream| (|DoubleFloat|)) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{singularitiesOf(args)} returns a list of potential singularities of the function within the given range")) (|problemPoints| (((|List| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{problemPoints(f,{}var,{}range)} returns a list of possible problem points by looking at the zeros of the denominator of the function if it can be retracted to \\axiomType{Polynomial DoubleFloat}.")) (|functionIsOscillatory| (((|Float|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsOscillatory(a)} tests whether the function \\spad{a.fn} has many zeros of its derivative.")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(x)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\axiom{\\spad{x}}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(x)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\axiom{\\spad{x}}")) (|functionIsContinuousAtEndPoints| (((|Union| (|:| |continuous| "Continuous at the end points") (|:| |lowerSingular| "There is a singularity at the lower end point") (|:| |upperSingular| "There is a singularity at the upper end point") (|:| |bothSingular| "There are singularities at both end points") (|:| |notEvaluated| "End point continuity not yet evaluated")) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsContinuousAtEndPoints(args)} uses power series limits to check for problems at the end points of the range of \\spad{args}.")) (|rangeIsFinite| (((|Union| (|:| |finite| "The range is finite") (|:| |lowerInfinite| "The bottom of range is infinite") (|:| |upperInfinite| "The top of range is infinite") (|:| |bothInfinite| "Both top and bottom points are infinite") (|:| |notEvaluated| "Range not yet evaluated")) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{rangeIsFinite(args)} tests the endpoints of \\spad{args.range} for infinite end points."))) +((|constructor| (NIL "\\axiomType{d01AgentsPackage} is a package of numerical agents to be used to investigate attributes of an input function so as to decide the \\axiomFun{measure} of an appropriate numerical integration routine. It contains functions \\axiomFun{rangeIsFinite} to test the input range and \\axiomFun{functionIsContinuousAtEndPoints} to check for continuity at the end points of the range.")) (|changeName| (((|Result|) (|Symbol|) (|Symbol|) (|Result|)) "\\spad{changeName(s,t,r)} changes the name of item \\axiom{s} in \\axiom{r} to \\axiom{t}.")) (|commaSeparate| (((|String|) (|List| (|String|))) "\\spad{commaSeparate(l)} produces a comma separated string from a list of strings.")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a Stream of \\axiomType{DoubleFloat} to \\axiomType{List String}")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a List of \\axiomType{DoubleFloat} to \\axiomType{List String}")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|singularitiesOf| (((|Stream| (|DoubleFloat|)) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{singularitiesOf(args)} returns a list of potential singularities of the function within the given range")) (|problemPoints| (((|List| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{problemPoints(f,var,range)} returns a list of possible problem points by looking at the zeros of the denominator of the function if it can be retracted to \\axiomType{Polynomial DoubleFloat}.")) (|functionIsOscillatory| (((|Float|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsOscillatory(a)} tests whether the function \\spad{a.fn} has many zeros of its derivative.")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(x)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\axiom{x}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(x)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\axiom{x}")) (|functionIsContinuousAtEndPoints| (((|Union| (|:| |continuous| "Continuous at the end points") (|:| |lowerSingular| "There is a singularity at the lower end point") (|:| |upperSingular| "There is a singularity at the upper end point") (|:| |bothSingular| "There are singularities at both end points") (|:| |notEvaluated| "End point continuity not yet evaluated")) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsContinuousAtEndPoints(args)} uses power series limits to check for problems at the end points of the range of \\spad{args}.")) (|rangeIsFinite| (((|Union| (|:| |finite| "The range is finite") (|:| |lowerInfinite| "The bottom of range is infinite") (|:| |upperInfinite| "The top of range is infinite") (|:| |bothInfinite| "Both top and bottom points are infinite") (|:| |notEvaluated| "Range not yet evaluated")) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{rangeIsFinite(args)} tests the endpoints of \\spad{args.range} for infinite end points."))) NIL NIL (-186) -((|constructor| (NIL "\\axiomType{d01ajfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AJF,{} a general numerical integration routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine D01AJF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01ajfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AJF, a general numerical integration routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine D01AJF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-187) -((|constructor| (NIL "\\axiomType{d01akfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AKF,{} a numerical integration routine which is is suitable for oscillating,{} non-singular functions. The function \\axiomFun{measure} measures the usefulness of the routine D01AKF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01akfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AKF, a numerical integration routine which is is suitable for oscillating, non-singular functions. The function \\axiomFun{measure} measures the usefulness of the routine D01AKF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-188) -((|constructor| (NIL "\\axiomType{d01alfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ALF,{} a general numerical integration routine which can handle a list of singularities. The function \\axiomFun{measure} measures the usefulness of the routine D01ALF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01alfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ALF, a general numerical integration routine which can handle a list of singularities. The function \\axiomFun{measure} measures the usefulness of the routine D01ALF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-189) -((|constructor| (NIL "\\axiomType{d01amfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AMF,{} a general numerical integration routine which can handle infinite or semi-infinite range of the input function. The function \\axiomFun{measure} measures the usefulness of the routine D01AMF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01amfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AMF, a general numerical integration routine which can handle infinite or semi-infinite range of the input function. The function \\axiomFun{measure} measures the usefulness of the routine D01AMF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-190) -((|constructor| (NIL "\\axiomType{d01anfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ANF,{} a numerical integration routine which can handle weight functions of the form cos(\\omega \\spad{x}) or sin(\\omega \\spad{x}). The function \\axiomFun{measure} measures the usefulness of the routine D01ANF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01anfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ANF, a numerical integration routine which can handle weight functions of the form cos(\\omega \\spad{x)} or sin(\\omega \\spad{x).} The function \\axiomFun{measure} measures the usefulness of the routine D01ANF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-191) -((|constructor| (NIL "\\axiomType{d01apfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01APF,{} a general numerical integration routine which can handle end point singularities of the algebraico-logarithmic form \\spad{w}(\\spad{x}) = (\\spad{x}-a)\\spad{^c} * (\\spad{b}-\\spad{x})\\spad{^d}. The function \\axiomFun{measure} measures the usefulness of the routine D01APF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01apfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01APF, a general numerical integration routine which can handle end point singularities of the algebraico-logarithmic form w(x) = (x-a)^c * (b-x)^d. The function \\axiomFun{measure} measures the usefulness of the routine D01APF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-192) -((|constructor| (NIL "\\axiomType{d01aqfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AQF,{} a general numerical integration routine which can solve an integral of the form /home/bjd/Axiom/anna/hypertex/bitmaps/d01aqf.\\spad{xbm} The function \\axiomFun{measure} measures the usefulness of the routine D01AQF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01aqfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01AQF, a general numerical integration routine which can solve an integral of the form /home/bjd/Axiom/anna/hypertex/bitmaps/d01aqf.xbm The function \\axiomFun{measure} measures the usefulness of the routine D01AQF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-193) -((|constructor| (NIL "\\axiomType{d01asfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ASF,{} a numerical integration routine which can handle weight functions of the form cos(\\omega \\spad{x}) or sin(\\omega \\spad{x}) on an semi-infinite range. The function \\axiomFun{measure} measures the usefulness of the routine D01ASF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01asfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01ASF, a numerical integration routine which can handle weight functions of the form cos(\\omega \\spad{x)} or sin(\\omega \\spad{x)} on an semi-infinite range. The function \\axiomFun{measure} measures the usefulness of the routine D01ASF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-194) -((|constructor| (NIL "\\axiomType{d01fcfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01FCF,{} a numerical integration routine which can handle multi-dimensional quadrature over a finite region. The function \\axiomFun{measure} measures the usefulness of the routine D01GBF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01fcfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01FCF, a numerical integration routine which can handle multi-dimensional quadrature over a finite region. The function \\axiomFun{measure} measures the usefulness of the routine D01GBF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-195) -((|constructor| (NIL "\\axiomType{d01gbfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01GBF,{} a numerical integration routine which can handle multi-dimensional quadrature over a finite region. The function \\axiomFun{measure} measures the usefulness of the routine D01GBF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) +((|constructor| (NIL "\\axiomType{d01gbfAnnaType} is a domain of \\axiomType{NumericalIntegrationCategory} for the NAG routine D01GBF, a numerical integration routine which can handle multi-dimensional quadrature over a finite region. The function \\axiomFun{measure} measures the usefulness of the routine D01GBF for the given problem. The function \\axiomFun{numericalIntegration} performs the integration by using \\axiomType{NagIntegrationPackage}."))) NIL NIL (-196) @@ -717,31 +717,31 @@ NIL NIL NIL (-197) -((|constructor| (NIL "\\axiom{d01WeightsPackage} is a package for functions used to investigate whether a function can be divided into a simpler function and a weight function. The types of weights investigated are those giving rise to end-point singularities of the algebraico-logarithmic type,{} and trigonometric weights.")) (|exprHasLogarithmicWeights| (((|Integer|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasLogarithmicWeights} looks for logarithmic weights giving rise to singularities of the function at the end-points.")) (|exprHasAlgebraicWeight| (((|Union| (|List| (|DoubleFloat|)) "failed") (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasAlgebraicWeight} looks for algebraic weights giving rise to singularities of the function at the end-points.")) (|exprHasWeightCosWXorSinWX| (((|Union| (|Record| (|:| |op| (|BasicOperator|)) (|:| |w| (|DoubleFloat|))) "failed") (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasWeightCosWXorSinWX} looks for trigonometric weights in an expression of the form \\axiom{cos \\omega \\spad{x}} or \\axiom{sin \\omega \\spad{x}},{} returning the value of \\omega (\\notequal 1) and the operator."))) +((|constructor| (NIL "\\axiom{d01WeightsPackage} is a package for functions used to investigate whether a function can be divided into a simpler function and a weight function. The types of weights investigated are those giving rise to end-point singularities of the algebraico-logarithmic type, and trigonometric weights.")) (|exprHasLogarithmicWeights| (((|Integer|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasLogarithmicWeights} looks for logarithmic weights giving rise to singularities of the function at the end-points.")) (|exprHasAlgebraicWeight| (((|Union| (|List| (|DoubleFloat|)) "failed") (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasAlgebraicWeight} looks for algebraic weights giving rise to singularities of the function at the end-points.")) (|exprHasWeightCosWXorSinWX| (((|Union| (|Record| (|:| |op| (|BasicOperator|)) (|:| |w| (|DoubleFloat|))) "failed") (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\axiom{exprHasWeightCosWXorSinWX} looks for trigonometric weights in an expression of the form \\axiom{cos \\omega \\spad{x}} or \\axiom{sin \\omega \\spad{x},} returning the value of \\omega (\\notequal 1) and the operator."))) NIL NIL (-198) -((|constructor| (NIL "\\axiom{d02AgentsPackage} contains a set of computational agents for use with Ordinary Differential Equation solvers.")) (|intermediateResultsIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{intermediateResultsIF(o)} returns a value corresponding to the required number of intermediate results required and,{} therefore,{} an indication of how much this would affect the step-length of the calculation. It returns a value in the range [0,{}1].")) (|accuracyIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{accuracyIF(o)} returns the intensity value of the accuracy requirements of the input ODE. A request of accuracy of 10^-6 corresponds to the neutral intensity. It returns a value in the range [0,{}1].")) (|expenseOfEvaluationIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{expenseOfEvaluationIF(o)} returns the intensity value of the cost of evaluating the input ODE. This is in terms of the number of ``operational units\\spad{''}. It returns a value in the range [0,{}1].\\indent{20} 400 ``operation units\\spad{''} \\spad{->} 0.75 200 ``operation units\\spad{''} \\spad{->} 0.5 83 ``operation units\\spad{''} \\spad{->} 0.25 \\indent{15} exponentiation = 4 units ,{} function calls = 10 units.")) (|systemSizeIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{systemSizeIF(ode)} returns the intensity value of the size of the system of ODEs. 20 equations corresponds to the neutral value. It returns a value in the range [0,{}1].")) (|stiffnessAndStabilityOfODEIF| (((|Record| (|:| |stiffnessFactor| (|Float|)) (|:| |stabilityFactor| (|Float|))) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{stiffnessAndStabilityOfODEIF(ode)} calculates the intensity values of stiffness of a system of first-order differential equations (by evaluating the maximum difference in the real parts of the negative eigenvalues of the jacobian of the system for which \\spad{O}(10) equates to mildly stiff wheras stiffness ratios of \\spad{O}(10^6) are not uncommon) and whether the system is likely to show any oscillations (identified by the closeness to the imaginary axis of the complex eigenvalues of the jacobian). \\blankline It returns two values in the range [0,{}1].")) (|stiffnessAndStabilityFactor| (((|Record| (|:| |stiffnessFactor| (|Float|)) (|:| |stabilityFactor| (|Float|))) (|Matrix| (|Expression| (|DoubleFloat|)))) "\\spad{stiffnessAndStabilityFactor(me)} calculates the stability and stiffness factor of a system of first-order differential equations (by evaluating the maximum difference in the real parts of the negative eigenvalues of the jacobian of the system for which \\spad{O}(10) equates to mildly stiff wheras stiffness ratios of \\spad{O}(10^6) are not uncommon) and whether the system is likely to show any oscillations (identified by the closeness to the imaginary axis of the complex eigenvalues of the jacobian).")) (|eval| (((|Matrix| (|Expression| (|DoubleFloat|))) (|Matrix| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|)) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{eval(mat,{}symbols,{}values)} evaluates a multivariable matrix at given \\spad{values} for each of a list of variables")) (|jacobian| (((|Matrix| (|Expression| (|DoubleFloat|))) (|Vector| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|))) "\\spad{jacobian(v,{}w)} is a local function to make a jacobian matrix")) (|sparsityIF| (((|Float|) (|Matrix| (|Expression| (|DoubleFloat|)))) "\\spad{sparsityIF(m)} calculates the sparsity of a jacobian matrix")) (|combineFeatureCompatibility| (((|Float|) (|Float|) (|List| (|Float|))) "\\spad{combineFeatureCompatibility(C1,{}L)} is for interacting attributes") (((|Float|) (|Float|) (|Float|)) "\\spad{combineFeatureCompatibility(C1,{}C2)} is for interacting attributes"))) +((|constructor| (NIL "\\axiom{d02AgentsPackage} contains a set of computational agents for use with Ordinary Differential Equation solvers.")) (|intermediateResultsIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{intermediateResultsIF(o)} returns a value corresponding to the required number of intermediate results required and, therefore, an indication of how much this would affect the step-length of the calculation. It returns a value in the range [0,1].")) (|accuracyIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{accuracyIF(o)} returns the intensity value of the accuracy requirements of the input ODE. A request of accuracy of 10^-6 corresponds to the neutral intensity. It returns a value in the range [0,1].")) (|expenseOfEvaluationIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{expenseOfEvaluationIF(o)} returns the intensity value of the cost of evaluating the input ODE. This is in terms of the number of ``operational units''. It returns a value in the range [0,1].\\indent{20} 400 ``operation units'' \\spad{->} 0.75 200 ``operation units'' \\spad{->} 0.5 83 ``operation units'' \\spad{->} 0.25 \\indent{15} exponentiation = 4 units ,{} function calls = 10 units.")) (|systemSizeIF| (((|Float|) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{systemSizeIF(ode)} returns the intensity value of the size of the system of ODEs. 20 equations corresponds to the neutral value. It returns a value in the range [0,1].")) (|stiffnessAndStabilityOfODEIF| (((|Record| (|:| |stiffnessFactor| (|Float|)) (|:| |stabilityFactor| (|Float|))) (|Record| (|:| |xinit| (|DoubleFloat|)) (|:| |xend| (|DoubleFloat|)) (|:| |fn| (|Vector| (|Expression| (|DoubleFloat|)))) (|:| |yinit| (|List| (|DoubleFloat|))) (|:| |intvals| (|List| (|DoubleFloat|))) (|:| |g| (|Expression| (|DoubleFloat|))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{stiffnessAndStabilityOfODEIF(ode)} calculates the intensity values of stiffness of a system of first-order differential equations (by evaluating the maximum difference in the real parts of the negative eigenvalues of the jacobian of the system for which O(10) equates to mildly stiff wheras stiffness ratios of O(10^6) are not uncommon) and whether the system is likely to show any oscillations (identified by the closeness to the imaginary axis of the complex eigenvalues of the jacobian). \\blankline It returns two values in the range [0,1].")) (|stiffnessAndStabilityFactor| (((|Record| (|:| |stiffnessFactor| (|Float|)) (|:| |stabilityFactor| (|Float|))) (|Matrix| (|Expression| (|DoubleFloat|)))) "\\spad{stiffnessAndStabilityFactor(me)} calculates the stability and stiffness factor of a system of first-order differential equations (by evaluating the maximum difference in the real parts of the negative eigenvalues of the jacobian of the system for which O(10) equates to mildly stiff wheras stiffness ratios of O(10^6) are not uncommon) and whether the system is likely to show any oscillations (identified by the closeness to the imaginary axis of the complex eigenvalues of the jacobian).")) (|eval| (((|Matrix| (|Expression| (|DoubleFloat|))) (|Matrix| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|)) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{eval(mat,symbols,values)} evaluates a multivariable matrix at given \\spad{values} for each of a list of variables")) (|jacobian| (((|Matrix| (|Expression| (|DoubleFloat|))) (|Vector| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|))) "\\spad{jacobian(v,w)} is a local function to make a jacobian matrix")) (|sparsityIF| (((|Float|) (|Matrix| (|Expression| (|DoubleFloat|)))) "\\spad{sparsityIF(m)} calculates the sparsity of a jacobian matrix")) (|combineFeatureCompatibility| (((|Float|) (|Float|) (|List| (|Float|))) "\\spad{combineFeatureCompatibility(C1,L)} is for interacting attributes") (((|Float|) (|Float|) (|Float|)) "\\spad{combineFeatureCompatibility(C1,C2)} is for interacting attributes"))) NIL NIL (-199) -((|constructor| (NIL "\\axiomType{d02bbfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02BBF,{} a ODE routine which uses an Runge-Kutta method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02BBF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) +((|constructor| (NIL "\\axiomType{d02bbfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02BBF, a ODE routine which uses an Runge-Kutta method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02BBF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) NIL NIL (-200) -((|constructor| (NIL "\\axiomType{d02bhfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02BHF,{} a ODE routine which uses an Runge-Kutta method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02BHF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) +((|constructor| (NIL "\\axiomType{d02bhfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02BHF, a ODE routine which uses an Runge-Kutta method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02BHF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) NIL NIL (-201) -((|constructor| (NIL "\\axiomType{d02cjfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02CJF,{} a ODE routine which uses an Adams-Moulton-Bashworth method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02CJF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) +((|constructor| (NIL "\\axiomType{d02cjfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02CJF, a ODE routine which uses an Adams-Moulton-Bashworth method to solve a system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02CJF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) NIL NIL (-202) -((|constructor| (NIL "\\axiomType{d02ejfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02EJF,{} a ODE routine which uses a backward differentiation formulae method to handle a stiff system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02EJF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) +((|constructor| (NIL "\\axiomType{d02ejfAnnaType} is a domain of \\axiomType{OrdinaryDifferentialEquationsInitialValueProblemSolverCategory} for the NAG routine D02EJF, a ODE routine which uses a backward differentiation formulae method to handle a stiff system of differential equations. The function \\axiomFun{measure} measures the usefulness of the routine D02EJF for the given problem. The function \\axiomFun{ODESolve} performs the integration by using \\axiomType{NagOrdinaryDifferentialEquationsPackage}."))) NIL NIL (-203) -((|constructor| (NIL "\\axiom{d03AgentsPackage} contains a set of computational agents for use with Partial Differential Equation solvers.")) (|elliptic?| (((|Boolean|) (|Record| (|:| |pde| (|List| (|Expression| (|DoubleFloat|)))) (|:| |constraints| (|List| (|Record| (|:| |start| (|DoubleFloat|)) (|:| |finish| (|DoubleFloat|)) (|:| |grid| (|NonNegativeInteger|)) (|:| |boundaryType| (|Integer|)) (|:| |dStart| (|Matrix| (|DoubleFloat|))) (|:| |dFinish| (|Matrix| (|DoubleFloat|)))))) (|:| |f| (|List| (|List| (|Expression| (|DoubleFloat|))))) (|:| |st| (|String|)) (|:| |tol| (|DoubleFloat|)))) "\\spad{elliptic?(r)} \\undocumented{}")) (|central?| (((|Boolean|) (|DoubleFloat|) (|DoubleFloat|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{central?(f,{}g,{}l)} \\undocumented{}")) (|subscriptedVariables| (((|Expression| (|DoubleFloat|)) (|Expression| (|DoubleFloat|))) "\\spad{subscriptedVariables(e)} \\undocumented{}")) (|varList| (((|List| (|Symbol|)) (|Symbol|) (|NonNegativeInteger|)) "\\spad{varList(s,{}n)} \\undocumented{}"))) +((|constructor| (NIL "\\axiom{d03AgentsPackage} contains a set of computational agents for use with Partial Differential Equation solvers.")) (|elliptic?| (((|Boolean|) (|Record| (|:| |pde| (|List| (|Expression| (|DoubleFloat|)))) (|:| |constraints| (|List| (|Record| (|:| |start| (|DoubleFloat|)) (|:| |finish| (|DoubleFloat|)) (|:| |grid| (|NonNegativeInteger|)) (|:| |boundaryType| (|Integer|)) (|:| |dStart| (|Matrix| (|DoubleFloat|))) (|:| |dFinish| (|Matrix| (|DoubleFloat|)))))) (|:| |f| (|List| (|List| (|Expression| (|DoubleFloat|))))) (|:| |st| (|String|)) (|:| |tol| (|DoubleFloat|)))) "\\spad{elliptic?(r)} \\undocumented{}")) (|central?| (((|Boolean|) (|DoubleFloat|) (|DoubleFloat|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{central?(f,g,l)} \\undocumented{}")) (|subscriptedVariables| (((|Expression| (|DoubleFloat|)) (|Expression| (|DoubleFloat|))) "\\spad{subscriptedVariables(e)} \\undocumented{}")) (|varList| (((|List| (|Symbol|)) (|Symbol|) (|NonNegativeInteger|)) "\\spad{varList(s,n)} \\undocumented{}"))) NIL NIL (-204) @@ -753,355 +753,355 @@ NIL NIL NIL (-206 S) -((|constructor| (NIL "This domain implements a simple view of a database whose fields are indexed by symbols")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce(l)} makes a database out of a list")) (- (($ $ $) "\\spad{db1-db2} returns the difference of databases \\spad{db1} and \\spad{db2} \\spadignore{i.e.} consisting of elements in \\spad{db1} but not in \\spad{db2}")) (+ (($ $ $) "\\spad{db1+db2} returns the merge of databases \\spad{db1} and \\spad{db2}")) (|fullDisplay| (((|Void|) $ (|PositiveInteger|) (|PositiveInteger|)) "\\spad{fullDisplay(db,{}start,{}end )} prints full details of entries in the range \\axiom{\\spad{start}..end} in \\axiom{\\spad{db}}.") (((|Void|) $) "\\spad{fullDisplay(db)} prints full details of each entry in \\axiom{\\spad{db}}.") (((|Void|) $) "\\spad{fullDisplay(x)} displays \\spad{x} in detail")) (|display| (((|Void|) $) "\\spad{display(db)} prints a summary line for each entry in \\axiom{\\spad{db}}.") (((|Void|) $) "\\spad{display(x)} displays \\spad{x} in some form")) (|elt| (((|DataList| (|String|)) $ (|Symbol|)) "\\spad{elt(db,{}s)} returns the \\axiom{\\spad{s}} field of each element of \\axiom{\\spad{db}}.") (($ $ (|QueryEquation|)) "\\spad{elt(db,{}q)} returns all elements of \\axiom{\\spad{db}} which satisfy \\axiom{\\spad{q}}.") (((|String|) $ (|Symbol|)) "\\spad{elt(x,{}s)} returns an element of \\spad{x} indexed by \\spad{s}"))) +((|constructor| (NIL "This domain implements a simple view of a database whose fields are indexed by symbols")) (|coerce| (($ (|List| |#1|)) "\\spad{coerce(l)} makes a database out of a list")) (- (($ $ $) "\\spad{db1-db2} returns the difference of databases \\spad{db1} and \\spad{db2} \\spadignore{i.e.} consisting of elements in \\spad{db1} but not in \\spad{db2}")) (+ (($ $ $) "\\spad{db1+db2} returns the merge of databases \\spad{db1} and \\spad{db2}")) (|fullDisplay| (((|Void|) $ (|PositiveInteger|) (|PositiveInteger|)) "\\spad{fullDisplay(db,start,end \\spad{)}} prints full details of entries in the range \\axiom{start..end} in \\axiom{db}.") (((|Void|) $) "\\spad{fullDisplay(db)} prints full details of each entry in \\axiom{db}.") (((|Void|) $) "\\spad{fullDisplay(x)} displays \\spad{x} in detail")) (|display| (((|Void|) $) "\\spad{display(db)} prints a summary line for each entry in \\axiom{db}.") (((|Void|) $) "\\spad{display(x)} displays \\spad{x} in some form")) (|elt| (((|DataList| (|String|)) $ (|Symbol|)) "\\spad{elt(db,s)} returns the \\axiom{s} field of each element of \\axiom{db}.") (($ $ (|QueryEquation|)) "\\spad{elt(db,q)} returns all elements of \\axiom{db} which satisfy \\axiom{q}.") (((|String|) $ (|Symbol|)) "\\spad{elt(x,s)} returns an element of \\spad{x} indexed by \\spad{s}"))) NIL NIL -(-207 -1564 UP UPUP R) -((|constructor| (NIL "This package provides functions for computing the residues of a function on an algebraic curve.")) (|doubleResultant| ((|#2| |#4| (|Mapping| |#2| |#2|)) "\\spad{doubleResultant(f,{} ')} returns \\spad{p}(\\spad{x}) whose roots are rational multiples of the residues of \\spad{f} at all its finite poles. Argument ' is the derivation to use."))) +(-207 -1647 UP UPUP R) +((|constructor| (NIL "This package provides functions for computing the residues of a function on an algebraic curve.")) (|doubleResultant| ((|#2| |#4| (|Mapping| |#2| |#2|)) "\\spad{doubleResultant(f, \\spad{')}} returns p(x) whose roots are rational multiples of the residues of \\spad{f} at all its finite poles. Argument ' is the derivation to use."))) NIL NIL -(-208 -1564 FP) -((|constructor| (NIL "Package for the factorization of a univariate polynomial with coefficients in a finite field. The algorithm used is the \"distinct degree\" algorithm of Cantor-Zassenhaus,{} modified to use trace instead of the norm and a table for computing Frobenius as suggested by Naudin and Quitte .")) (|irreducible?| (((|Boolean|) |#2|) "\\spad{irreducible?(p)} tests whether the polynomial \\spad{p} is irreducible.")) (|tracePowMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{tracePowMod(u,{}k,{}v)} produces the sum of \\spad{u**(q**i)} for \\spad{i} running and \\spad{q=} size \\spad{F}")) (|trace2PowMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{trace2PowMod(u,{}k,{}v)} produces the sum of u**(2**i) for \\spad{i} running from 1 to \\spad{k} all computed modulo the polynomial \\spad{v}.")) (|exptMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{exptMod(u,{}k,{}v)} raises the polynomial \\spad{u} to the \\spad{k}th power modulo the polynomial \\spad{v}.")) (|separateFactors| (((|List| |#2|) (|List| (|Record| (|:| |deg| (|NonNegativeInteger|)) (|:| |prod| |#2|)))) "\\spad{separateFactors(lfact)} takes the list produced by separateDegrees and produces the complete list of factors.")) (|separateDegrees| (((|List| (|Record| (|:| |deg| (|NonNegativeInteger|)) (|:| |prod| |#2|))) |#2|) "\\spad{separateDegrees(p)} splits the square free polynomial \\spad{p} into factors each of which is a product of irreducibles of the same degree.")) (|distdfact| (((|Record| (|:| |cont| |#1|) (|:| |factors| (|List| (|Record| (|:| |irr| |#2|) (|:| |pow| (|Integer|)))))) |#2| (|Boolean|)) "\\spad{distdfact(p,{}sqfrflag)} produces the complete factorization of the polynomial \\spad{p} returning an internal data structure. If argument \\spad{sqfrflag} is \\spad{true},{} the polynomial is assumed square free.")) (|factorSquareFree| (((|Factored| |#2|) |#2|) "\\spad{factorSquareFree(p)} produces the complete factorization of the square free polynomial \\spad{p}.")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} produces the complete factorization of the polynomial \\spad{p}."))) +(-208 -1647 FP) +((|constructor| (NIL "Package for the factorization of a univariate polynomial with coefficients in a finite field. The algorithm used is the \"distinct degree\" algorithm of Cantor-Zassenhaus, modified to use trace instead of the norm and a table for computing Frobenius as suggested by Naudin and Quitte .")) (|irreducible?| (((|Boolean|) |#2|) "\\spad{irreducible?(p)} tests whether the polynomial \\spad{p} is irreducible.")) (|tracePowMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{tracePowMod(u,k,v)} produces the sum of \\spad{u**(q**i)} for \\spad{i} running and \\spad{q=} size \\spad{F}")) (|trace2PowMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{trace2PowMod(u,k,v)} produces the sum of u**(2**i) for \\spad{i} running from 1 to \\spad{k} all computed modulo the polynomial \\spad{v.}")) (|exptMod| ((|#2| |#2| (|NonNegativeInteger|) |#2|) "\\spad{exptMod(u,k,v)} raises the polynomial \\spad{u} to the \\spad{k}th power modulo the polynomial \\spad{v.}")) (|separateFactors| (((|List| |#2|) (|List| (|Record| (|:| |deg| (|NonNegativeInteger|)) (|:| |prod| |#2|)))) "\\spad{separateFactors(lfact)} takes the list produced by separateDegrees and produces the complete list of factors.")) (|separateDegrees| (((|List| (|Record| (|:| |deg| (|NonNegativeInteger|)) (|:| |prod| |#2|))) |#2|) "\\spad{separateDegrees(p)} splits the square free polynomial \\spad{p} into factors each of which is a product of irreducibles of the same degree.")) (|distdfact| (((|Record| (|:| |cont| |#1|) (|:| |factors| (|List| (|Record| (|:| |irr| |#2|) (|:| |pow| (|Integer|)))))) |#2| (|Boolean|)) "\\spad{distdfact(p,sqfrflag)} produces the complete factorization of the polynomial \\spad{p} returning an internal data structure. If argument \\spad{sqfrflag} is true, the polynomial is assumed square free.")) (|factorSquareFree| (((|Factored| |#2|) |#2|) "\\spad{factorSquareFree(p)} produces the complete factorization of the square free polynomial \\spad{p.}")) (|factor| (((|Factored| |#2|) |#2|) "\\spad{factor(p)} produces the complete factorization of the polynomial \\spad{p.}"))) NIL NIL (-209) ((|constructor| (NIL "This domain allows rational numbers to be presented as repeating decimal expansions.")) (|decimal| (($ (|Fraction| (|Integer|))) "\\spad{decimal(r)} converts a rational number to a decimal expansion.")) (|fractionPart| (((|Fraction| (|Integer|)) $) "\\spad{fractionPart(d)} returns the fractional part of a decimal expansion.")) (|coerce| (((|RadixExpansion| 10) $) "\\spad{coerce(d)} converts a decimal expansion to a radix expansion with base 10.") (((|Fraction| (|Integer|)) $) "\\spad{coerce(d)} converts a decimal expansion to a rational number."))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| (-569) (QUOTE (-905))) (|HasCategory| (-569) (LIST (QUOTE -1038) (QUOTE (-1163)))) (|HasCategory| (-569) (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-151))) (|HasCategory| (-569) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-569) (QUOTE (-1022))) (|HasCategory| (-569) (QUOTE (-816))) (|HasCategory| (-569) (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-1137))) (|HasCategory| (-569) (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| (-569) (QUOTE (-226))) (|HasCategory| (-569) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-569) (LIST (QUOTE -524) (QUOTE (-1163)) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -304) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -282) (QUOTE (-569)) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-302))) (|HasCategory| (-569) (QUOTE (-551))) (|HasCategory| (-569) (QUOTE (-843))) (-2232 (|HasCategory| (-569) (QUOTE (-816))) (|HasCategory| (-569) (QUOTE (-843)))) (|HasCategory| (-569) (LIST (QUOTE -631) (QUOTE (-569)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-905)))) (|HasCategory| (-569) (QUOTE (-149))))) -(-210 R -1564) -((|constructor| (NIL "\\spadtype{ElementaryFunctionDefiniteIntegration} provides functions to compute definite integrals of elementary functions.")) (|innerint| (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|Symbol|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{innerint(f,{} x,{} a,{} b,{} ignore?)} should be local but conditional")) (|integrate| (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|SegmentBinding| (|OrderedCompletion| |#2|)) (|String|)) "\\spad{integrate(f,{} x = a..b,{} \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters),{} then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|SegmentBinding| (|OrderedCompletion| |#2|))) "\\spad{integrate(f,{} x = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b}."))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| (-569) (QUOTE (-906))) (|HasCategory| (-569) (LIST (QUOTE -1039) (QUOTE (-1165)))) (|HasCategory| (-569) (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-151))) (|HasCategory| (-569) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-569) (QUOTE (-1023))) (|HasCategory| (-569) (QUOTE (-817))) (|HasCategory| (-569) (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-1139))) (|HasCategory| (-569) (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| (-569) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| (-569) (QUOTE (-226))) (|HasCategory| (-569) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-569) (LIST (QUOTE -524) (QUOTE (-1165)) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -304) (QUOTE (-569)))) (|HasCategory| (-569) (LIST (QUOTE -282) (QUOTE (-569)) (QUOTE (-569)))) (|HasCategory| (-569) (QUOTE (-302))) (|HasCategory| (-569) (QUOTE (-551))) (|HasCategory| (-569) (QUOTE (-844))) (-1929 (|HasCategory| (-569) (QUOTE (-817))) (|HasCategory| (-569) (QUOTE (-844)))) (|HasCategory| (-569) (LIST (QUOTE -631) (QUOTE (-569)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-569) (QUOTE (-906)))) (|HasCategory| (-569) (QUOTE (-149))))) +(-210 R -1647) +((|constructor| (NIL "\\spadtype{ElementaryFunctionDefiniteIntegration} provides functions to compute definite integrals of elementary functions.")) (|innerint| (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|Symbol|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{innerint(f, \\spad{x,} a, \\spad{b,} ignore?)} should be local but conditional")) (|integrate| (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|SegmentBinding| (|OrderedCompletion| |#2|)) (|String|)) "\\spad{integrate(f, \\spad{x} = a..b, \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters), then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| |#2|)) (|:| |f2| (|List| (|OrderedCompletion| |#2|))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) |#2| (|SegmentBinding| (|OrderedCompletion| |#2|))) "\\spad{integrate(f, \\spad{x} = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b.}"))) NIL NIL (-211 R) -((|constructor| (NIL "Definite integration of rational functions. \\spadtype{RationalFunctionDefiniteIntegration} provides functions to compute definite integrals of rational functions.")) (|integrate| (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Fraction| (|Polynomial| |#1|)))) (|String|)) "\\spad{integrate(f,{} x = a..b,{} \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters),{} then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Fraction| (|Polynomial| |#1|))))) "\\spad{integrate(f,{} x = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b}.") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Expression| |#1|))) (|String|)) "\\spad{integrate(f,{} x = a..b,{} \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters),{} then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Expression| |#1|)))) "\\spad{integrate(f,{} x = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b}. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b}."))) +((|constructor| (NIL "Definite integration of rational functions. \\spadtype{RationalFunctionDefiniteIntegration} provides functions to compute definite integrals of rational functions.")) (|integrate| (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Fraction| (|Polynomial| |#1|)))) (|String|)) "\\spad{integrate(f, \\spad{x} = a..b, \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters), then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Fraction| (|Polynomial| |#1|))))) "\\spad{integrate(f, \\spad{x} = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b.}") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Expression| |#1|))) (|String|)) "\\spad{integrate(f, \\spad{x} = a..b, \"noPole\")} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} If it is not possible to check whether \\spad{f} has a pole for \\spad{x} between a and \\spad{b} (because of parameters), then this function will assume that \\spad{f} has no such pole. Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b} or if the last argument is not \"noPole\".") (((|Union| (|:| |f1| (|OrderedCompletion| (|Expression| |#1|))) (|:| |f2| (|List| (|OrderedCompletion| (|Expression| |#1|)))) (|:| |fail| "failed") (|:| |pole| "potentialPole")) (|Fraction| (|Polynomial| |#1|)) (|SegmentBinding| (|OrderedCompletion| (|Expression| |#1|)))) "\\spad{integrate(f, \\spad{x} = a..b)} returns the integral of \\spad{f(x)dx} from a to \\spad{b.} Error: if \\spad{f} has a pole for \\spad{x} between a and \\spad{b.}"))) NIL NIL (-212 R1 R2) -((|constructor| (NIL "This package has no description")) (|expand| (((|List| (|Expression| |#2|)) (|Expression| |#2|) (|PositiveInteger|)) "\\spad{expand(f,{}n)} \\undocumented{}")) (|reduce| (((|Record| (|:| |pol| (|SparseUnivariatePolynomial| |#1|)) (|:| |deg| (|PositiveInteger|))) (|SparseUnivariatePolynomial| |#1|)) "\\spad{reduce(p)} \\undocumented{}"))) +((|constructor| (NIL "This package has no description")) (|expand| (((|List| (|Expression| |#2|)) (|Expression| |#2|) (|PositiveInteger|)) "\\spad{expand(f,n)} \\undocumented{}")) (|reduce| (((|Record| (|:| |pol| (|SparseUnivariatePolynomial| |#1|)) (|:| |deg| (|PositiveInteger|))) (|SparseUnivariatePolynomial| |#1|)) "\\spad{reduce(p)} \\undocumented{}"))) NIL NIL (-213 S) -((|constructor| (NIL "Linked list implementation of a Dequeue")) (|member?| (((|Boolean|) |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} member?(3,{}a)")) (|members| (((|List| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} members a")) (|parts| (((|List| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} parts a")) (|#| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} \\#a")) (|count| (((|NonNegativeInteger|) |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} count(4,{}a)") (((|NonNegativeInteger|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} count(\\spad{x+}->(\\spad{x>2}),{}a)")) (|any?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} any?(\\spad{x+}->(\\spad{x=4}),{}a)")) (|every?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} every?(\\spad{x+}->(\\spad{x=4}),{}a)")) (~= (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} b:=copy a \\spad{X} (a~=b)")) (= (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} b:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} (a=b)@Boolean")) (|coerce| (((|OutputForm|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} coerce a")) (|hash| (((|SingleInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} hash a")) (|latex| (((|String|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} latex a")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} map!(\\spad{x+}-\\spad{>x+10},{}a) \\spad{X} a")) (|top!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} top! a \\spad{X} a")) (|reverse!| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} reverse! a \\spad{X} a")) (|push!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} push! a \\spad{X} a")) (|pop!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} pop! a \\spad{X} a")) (|insertTop!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} insertTop! a \\spad{X} a")) (|insertBottom!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} insertBottom! a \\spad{X} a")) (|extractTop!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} extractTop! a \\spad{X} a")) (|extractBottom!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} extractBottom! a \\spad{X} a")) (|bottom!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} bottom! a \\spad{X} a")) (|top| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} top a")) (|height| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} height a")) (|depth| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} depth a")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} map(\\spad{x+}-\\spad{>x+10},{}a) \\spad{X} a")) (|eq?| (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} b:=copy a \\spad{X} eq?(a,{}\\spad{b})")) (|copy| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} copy a")) (|sample| (($) "\\blankline \\spad{X} sample()\\$Dequeue(INT)")) (|empty| (($) "\\blankline \\spad{X} b:=empty()\\$(Dequeue INT)")) (|empty?| (((|Boolean|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} empty? a")) (|bag| (($ (|List| |#1|)) "\\blankline \\spad{X} bag([1,{}2,{}3,{}4,{}5])\\$Dequeue(INT)")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} size?(a,{}5)")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} more?(a,{}9)")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} less?(a,{}9)")) (|length| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} length a")) (|rotate!| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} rotate! a")) (|back| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} back a")) (|front| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} front a")) (|inspect| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} inspect a")) (|insert!| (($ |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} insert! (8,{}a) \\spad{X} a")) (|enqueue!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} enqueue! (9,{}a) \\spad{X} a")) (|extract!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} extract! a \\spad{X} a")) (|dequeue!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5] \\spad{X} dequeue! a \\spad{X} a")) (|dequeue| (($) "\\blankline \\spad{X} a:Dequeue INT:= dequeue ()") (($ (|List| |#1|)) "\\indented{1}{dequeue([\\spad{x},{}\\spad{y},{}...,{}\\spad{z}]) creates a dequeue with first (top or front)} \\indented{1}{element \\spad{x},{} second element \\spad{y},{}...,{}and last (bottom or back) element \\spad{z}.} \\blankline \\spad{E} g:Dequeue INT:= dequeue [1,{}2,{}3,{}4,{}5]"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "Linked list implementation of a Dequeue")) (|member?| (((|Boolean|) |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} member?(3,a)")) (|members| (((|List| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} members a")) (|parts| (((|List| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} parts a")) (|#| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} \\#a")) (|count| (((|NonNegativeInteger|) |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} count(4,a)") (((|NonNegativeInteger|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} count(x+->(x>2),a)")) (|any?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} any?(x+->(x=4),a)")) (|every?| (((|Boolean|) (|Mapping| (|Boolean|) |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} every?(x+->(x=4),a)")) (~= (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} b:=copy a \\spad{X} (a~=b)")) (= (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} b:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} (a=b)@Boolean")) (|coerce| (((|OutputForm|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} coerce a")) (|hash| (((|SingleInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} hash a")) (|latex| (((|String|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} latex a")) (|map!| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} map!(x+->x+10,a) \\spad{X} a")) (|top!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} top! a \\spad{X} a")) (|reverse!| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} reverse! a \\spad{X} a")) (|push!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} push! a \\spad{X} a")) (|pop!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} pop! a \\spad{X} a")) (|insertTop!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} insertTop! a \\spad{X} a")) (|insertBottom!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} insertBottom! a \\spad{X} a")) (|extractTop!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} extractTop! a \\spad{X} a")) (|extractBottom!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} extractBottom! a \\spad{X} a")) (|bottom!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} bottom! a \\spad{X} a")) (|top| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} top a")) (|height| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} height a")) (|depth| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} depth a")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} map(x+->x+10,a) \\spad{X} a")) (|eq?| (((|Boolean|) $ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} b:=copy a \\spad{X} eq?(a,b)")) (|copy| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} copy a")) (|sample| (($) "\\blankline \\spad{X} sample()$Dequeue(INT)")) (|empty| (($) "\\blankline \\spad{X} b:=empty()$(Dequeue INT)")) (|empty?| (((|Boolean|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} empty? a")) (|bag| (($ (|List| |#1|)) "\\blankline \\spad{X} bag([1,2,3,4,5])$Dequeue(INT)")) (|size?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} size?(a,5)")) (|more?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} more?(a,9)")) (|less?| (((|Boolean|) $ (|NonNegativeInteger|)) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} less?(a,9)")) (|length| (((|NonNegativeInteger|) $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} length a")) (|rotate!| (($ $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} rotate! a")) (|back| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} back a")) (|front| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} front a")) (|inspect| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} inspect a")) (|insert!| (($ |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} insert! (8,a) \\spad{X} a")) (|enqueue!| ((|#1| |#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} enqueue! (9,a) \\spad{X} a")) (|extract!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} extract! a \\spad{X} a")) (|dequeue!| ((|#1| $) "\\blankline \\spad{X} a:Dequeue INT:= dequeue [1,2,3,4,5] \\spad{X} dequeue! a \\spad{X} a")) (|dequeue| (($) "\\blankline \\spad{X} a:Dequeue INT:= dequeue \\spad{()}") (($ (|List| |#1|)) "\\indented{1}{dequeue([x,y,...,z]) creates a dequeue with first (top or front)} \\indented{1}{element \\spad{x,} second element y,...,and last (bottom or back) element \\spad{z.}} \\blankline \\spad{E} g:Dequeue INT:= dequeue [1,2,3,4,5]"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-214 |CoefRing| |listIndVar|) -((|constructor| (NIL "The deRham complex of Euclidean space,{} that is,{} the class of differential forms of arbitary degree over a coefficient ring. See Flanders,{} Harley,{} Differential Forms,{} With Applications to the Physical Sciences,{} New York,{} Academic Press,{} 1963.")) (|exteriorDifferential| (($ $) "\\spad{exteriorDifferential(df)} returns the exterior derivative (gradient,{} curl,{} divergence,{} ...) of the differential form \\spad{df}.")) (|totalDifferential| (($ (|Expression| |#1|)) "\\spad{totalDifferential(x)} returns the total differential (gradient) form for element \\spad{x}.")) (|map| (($ (|Mapping| (|Expression| |#1|) (|Expression| |#1|)) $) "\\spad{map(f,{}df)} replaces each coefficient \\spad{x} of differential form \\spad{df} by \\spad{f(x)}.")) (|degree| (((|Integer|) $) "\\spad{degree(df)} returns the homogeneous degree of differential form \\spad{df}.")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(df)} tests if differential form \\spad{df} is a 0-form,{} \\spadignore{i.e.} if degree(\\spad{df}) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(df)} tests if all of the terms of differential form \\spad{df} have the same degree.")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th basis term for a differential form.")) (|coefficient| (((|Expression| |#1|) $ $) "\\spad{coefficient(df,{}u)},{} where \\spad{df} is a differential form,{} returns the coefficient of \\spad{df} containing the basis term \\spad{u} if such a term exists,{} and 0 otherwise.")) (|reductum| (($ $) "\\spad{reductum(df)},{} where \\spad{df} is a differential form,{} returns \\spad{df} minus the leading term of \\spad{df} if \\spad{df} has two or more terms,{} and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(df)} returns the leading basis term of differential form \\spad{df}.")) (|leadingCoefficient| (((|Expression| |#1|) $) "\\spad{leadingCoefficient(df)} returns the leading coefficient of differential form \\spad{df}."))) -((-4532 . T)) +((|constructor| (NIL "The deRham complex of Euclidean space, that is, the class of differential forms of arbitary degree over a coefficient ring. See Flanders, Harley, Differential Forms, With Applications to the Physical Sciences, New York, Academic Press, 1963.")) (|exteriorDifferential| (($ $) "\\spad{exteriorDifferential(df)} returns the exterior derivative (gradient, curl, divergence, ...) of the differential form \\spad{df.}")) (|totalDifferential| (($ (|Expression| |#1|)) "\\spad{totalDifferential(x)} returns the total differential (gradient) form for element \\spad{x.}")) (|map| (($ (|Mapping| (|Expression| |#1|) (|Expression| |#1|)) $) "\\spad{map(f,df)} replaces each coefficient \\spad{x} of differential form \\spad{df} by \\spad{f(x)}.")) (|degree| (((|Integer|) $) "\\spad{degree(df)} returns the homogeneous degree of differential form \\spad{df.}")) (|retractable?| (((|Boolean|) $) "\\spad{retractable?(df)} tests if differential form \\spad{df} is a 0-form, \\spadignore{i.e.} if degree(df) = 0.")) (|homogeneous?| (((|Boolean|) $) "\\spad{homogeneous?(df)} tests if all of the terms of differential form \\spad{df} have the same degree.")) (|generator| (($ (|NonNegativeInteger|)) "\\spad{generator(n)} returns the \\spad{n}th basis term for a differential form.")) (|coefficient| (((|Expression| |#1|) $ $) "\\spad{coefficient(df,u)}, where \\spad{df} is a differential form, returns the coefficient of \\spad{df} containing the basis term \\spad{u} if such a term exists, and 0 otherwise.")) (|reductum| (($ $) "\\spad{reductum(df)}, where \\spad{df} is a differential form, returns \\spad{df} minus the leading term of \\spad{df} if \\spad{df} has two or more terms, and 0 otherwise.")) (|leadingBasisTerm| (($ $) "\\spad{leadingBasisTerm(df)} returns the leading basis term of differential form \\spad{df.}")) (|leadingCoefficient| (((|Expression| |#1|) $) "\\spad{leadingCoefficient(df)} returns the leading coefficient of differential form \\spad{df.}"))) +((-4568 . T)) NIL -(-215 R -1564) -((|constructor| (NIL "\\spadtype{DefiniteIntegrationTools} provides common tools used by the definite integration of both rational and elementary functions.")) (|checkForZero| (((|Union| (|Boolean|) "failed") (|SparseUnivariatePolynomial| |#2|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p,{} a,{} b,{} incl?)} is \\spad{true} if \\spad{p} has a zero between a and \\spad{b},{} \\spad{false} otherwise,{} \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is \\spad{true},{} exclusive otherwise.") (((|Union| (|Boolean|) "failed") (|Polynomial| |#1|) (|Symbol|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p,{} x,{} a,{} b,{} incl?)} is \\spad{true} if \\spad{p} has a zero for \\spad{x} between a and \\spad{b},{} \\spad{false} otherwise,{} \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is \\spad{true},{} exclusive otherwise.")) (|computeInt| (((|Union| (|OrderedCompletion| |#2|) "failed") (|Kernel| |#2|) |#2| (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{computeInt(x,{} g,{} a,{} b,{} eval?)} returns the integral of \\spad{f} for \\spad{x} between a and \\spad{b},{} assuming that \\spad{g} is an indefinite integral of \\spad{f} and \\spad{f} has no pole between a and \\spad{b}. If \\spad{eval?} is \\spad{true},{} then \\spad{g} can be evaluated safely at \\spad{a} and \\spad{b},{} provided that they are finite values. Otherwise,{} limits must be computed.")) (|ignore?| (((|Boolean|) (|String|)) "\\spad{ignore?(s)} is \\spad{true} if \\spad{s} is the string that tells the integrator to assume that the function has no pole in the integration interval."))) +(-215 R -1647) +((|constructor| (NIL "\\spadtype{DefiniteIntegrationTools} provides common tools used by the definite integration of both rational and elementary functions.")) (|checkForZero| (((|Union| (|Boolean|) "failed") (|SparseUnivariatePolynomial| |#2|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p, a, \\spad{b,} incl?)} is \\spad{true} if \\spad{p} has a zero between a and \\spad{b,} \\spad{false} otherwise, \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is true, exclusive otherwise.") (((|Union| (|Boolean|) "failed") (|Polynomial| |#1|) (|Symbol|) (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{checkForZero(p, \\spad{x,} a, \\spad{b,} incl?)} is \\spad{true} if \\spad{p} has a zero for \\spad{x} between a and \\spad{b,} \\spad{false} otherwise, \"failed\" if this cannot be determined. Check for a and \\spad{b} inclusive if incl? is true, exclusive otherwise.")) (|computeInt| (((|Union| (|OrderedCompletion| |#2|) "failed") (|Kernel| |#2|) |#2| (|OrderedCompletion| |#2|) (|OrderedCompletion| |#2|) (|Boolean|)) "\\spad{computeInt(x, \\spad{g,} a, \\spad{b,} eval?)} returns the integral of \\spad{f} for \\spad{x} between a and \\spad{b,} assuming that \\spad{g} is an indefinite integral of \\spad{f} and \\spad{f} has no pole between a and \\spad{b.} If \\spad{eval?} is true, then \\spad{g} can be evaluated safely at \\spad{a} and \\spad{b}, provided that they are finite values. Otherwise, limits must be computed.")) (|ignore?| (((|Boolean|) (|String|)) "\\spad{ignore?(s)} is \\spad{true} if \\spad{s} is the string that tells the integrator to assume that the function has no pole in the integration interval."))) NIL NIL (-216) -((|constructor| (NIL "\\spadtype{DoubleFloat} is intended to make accessible hardware floating point arithmetic in Axiom,{} either native double precision,{} or IEEE. On most machines,{} there will be hardware support for the arithmetic operations: \\spad{++} +,{} *,{} / and possibly also the sqrt operation. The operations exp,{} log,{} sin,{} cos,{} atan are normally coded in software based on minimax polynomial/rational approximations. \\blankline Some general comments about the accuracy of the operations: the operations +,{} *,{} / and sqrt are expected to be fully accurate. The operations exp,{} log,{} sin,{} cos and atan are not expected to be fully accurate. In particular,{} sin and cos will lose all precision for large arguments. \\blankline The Float domain provides an alternative to the DoubleFloat domain. It provides an arbitrary precision model of floating point arithmetic. This means that accuracy problems like those above are eliminated by increasing the working precision where necessary. \\spadtype{Float} provides some special functions such as erf,{} the error function in addition to the elementary functions. The disadvantage of Float is that it is much more expensive than small floats when the latter can be used.")) (|integerDecode| (((|List| (|Integer|)) $) "\\indented{1}{integerDecode(\\spad{x}) returns the multiple values of the\\space{2}common} \\indented{1}{lisp integer-decode-float function.} \\indented{1}{See Steele,{} ISBN 0-13-152414-3 \\spad{p354}. This function can be used} \\indented{1}{to ensure that the results are bit-exact and do not depend on} \\indented{1}{the binary-to-decimal conversions.} \\blankline \\spad{X} a:DFLOAT:=-1.0/3.0 \\spad{X} integerDecode a")) (|machineFraction| (((|Fraction| (|Integer|)) $) "\\indented{1}{machineFraction(\\spad{x}) returns a bit-exact fraction of the machine} \\indented{1}{floating point number using the common lisp integer-decode-float} \\indented{1}{function. See Steele,{} ISBN 0-13-152414-3 \\spad{p354}} \\indented{1}{This function can be used to print results which do not depend} \\indented{1}{on binary-to-decimal conversions} \\blankline \\spad{X} a:DFLOAT:=-1.0/3.0 \\spad{X} machineFraction a")) (|rationalApproximation| (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{rationalApproximation(f,{} n,{} b)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< b**(-n)} (that is,{} \\spad{|(r-f)/f| < b**(-n)}).") (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|)) "\\spad{rationalApproximation(f,{} n)} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< 10**(-n)}.")) (|doubleFloatFormat| (((|String|) (|String|)) "change the output format for doublefloats using lisp format strings")) (|Beta| (($ $ $) "\\spad{Beta(x,{}y)} is \\spad{Gamma(x) * Gamma(y)/Gamma(x+y)}.")) (|Gamma| (($ $) "\\spad{Gamma(x)} is the Euler Gamma function.")) (|atan| (($ $ $) "\\spad{atan(x,{}y)} computes the arc tangent from \\spad{x} with phase \\spad{y}.")) (|log10| (($ $) "\\spad{log10(x)} computes the logarithm with base 10 for \\spad{x}.")) (|log2| (($ $) "\\spad{log2(x)} computes the logarithm with base 2 for \\spad{x}.")) (|hash| (((|Integer|) $) "\\spad{hash(x)} returns the hash key for \\spad{x}")) (|exp1| (($) "\\spad{exp1()} returns the natural log base \\spad{2.718281828...}.")) (** (($ $ $) "\\spad{x ** y} returns the \\spad{y}th power of \\spad{x} (equal to \\spad{exp(y log x)}).")) (/ (($ $ (|Integer|)) "\\spad{x / i} computes the division from \\spad{x} by an integer \\spad{i}."))) -((-2994 . T) (-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "\\spadtype{DoubleFloat} is intended to make accessible hardware floating point arithmetic in Axiom, either native double precision, or IEEE. On most machines, there will be hardware support for the arithmetic operations: \\spad{++} \\spad{+,} \\spad{*,} / and possibly also the sqrt operation. The operations exp, log, sin, cos, atan are normally coded in software based on minimax polynomial/rational approximations. \\blankline Some general comments about the accuracy of the operations: the operations \\spad{+,} \\spad{*,} / and sqrt are expected to be fully accurate. The operations exp, log, sin, cos and atan are not expected to be fully accurate. In particular, sin and cos will lose all precision for large arguments. \\blankline The Float domain provides an alternative to the DoubleFloat domain. It provides an arbitrary precision model of floating point arithmetic. This means that accuracy problems like those above are eliminated by increasing the working precision where necessary. \\spadtype{Float} provides some special functions such as erf, the error function in addition to the elementary functions. The disadvantage of Float is that it is much more expensive than small floats when the latter can be used.")) (|integerDecode| (((|List| (|Integer|)) $) "\\indented{1}{integerDecode(x) returns the multiple values of the\\space{2}common} \\indented{1}{lisp integer-decode-float function.} \\indented{1}{See Steele, ISBN 0-13-152414-3 p354. This function can be used} \\indented{1}{to ensure that the results are bit-exact and do not depend on} \\indented{1}{the binary-to-decimal conversions.} \\blankline \\spad{X} \\spad{a:DFLOAT:=-1.0/3.0} \\spad{X} integerDecode a")) (|machineFraction| (((|Fraction| (|Integer|)) $) "\\indented{1}{machineFraction(x) returns a bit-exact fraction of the machine} \\indented{1}{floating point number using the common lisp integer-decode-float} \\indented{1}{function. See Steele, ISBN 0-13-152414-3 p354} \\indented{1}{This function can be used to print results which do not depend} \\indented{1}{on binary-to-decimal conversions} \\blankline \\spad{X} \\spad{a:DFLOAT:=-1.0/3.0} \\spad{X} machineFraction a")) (|rationalApproximation| (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, \\spad{n,} \\spad{b)}} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< b**(-n)} (that is, \\spad{|(r-f)/f| < b**(-n)}).") (((|Fraction| (|Integer|)) $ (|NonNegativeInteger|)) "\\spad{rationalApproximation(f, \\spad{n)}} computes a rational approximation \\spad{r} to \\spad{f} with relative error \\spad{< 10**(-n)}.")) (|doubleFloatFormat| (((|String|) (|String|)) "change the output format for doublefloats using lisp format strings")) (|Beta| (($ $ $) "\\spad{Beta(x,y)} is \\spad{Gamma(x) * Gamma(y)/Gamma(x+y)}.")) (|Gamma| (($ $) "\\spad{Gamma(x)} is the Euler Gamma function.")) (|atan| (($ $ $) "\\spad{atan(x,y)} computes the arc tangent from \\spad{x} with phase \\spad{y.}")) (|log10| (($ $) "\\spad{log10(x)} computes the logarithm with base 10 for \\spad{x.}")) (|log2| (($ $) "\\spad{log2(x)} computes the logarithm with base 2 for \\spad{x.}")) (|hash| (((|Integer|) $) "\\spad{hash(x)} returns the hash key for \\spad{x}")) (|exp1| (($) "\\spad{exp1()} returns the natural log base \\spad{2.718281828...}.")) (** (($ $ $) "\\spad{x \\spad{**} \\spad{y}} returns the \\spad{y}th power of \\spad{x} (equal to \\spad{exp(y log x)}).")) (/ (($ $ (|Integer|)) "\\spad{x / i} computes the division from \\spad{x} by an integer i."))) +((-4334 . T) (-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-217) -((|constructor| (NIL "This is a low-level domain which implements matrices (two dimensional arrays) of double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|) (|Integer|)) "\\indented{1}{qnew(\\spad{n},{} \\spad{m}) creates a new uninitialized \\spad{n} by \\spad{m} matrix.} \\blankline \\spad{X} t1:DFMAT:=qnew(3,{}4)"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| (-216) (QUOTE (-1091))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1091)))) (|HasCategory| (-216) (QUOTE (-302))) (|HasCategory| (-216) (QUOTE (-559))) (|HasAttribute| (-216) (QUOTE (-4537 "*"))) (|HasCategory| (-216) (QUOTE (-173))) (|HasCategory| (-216) (QUOTE (-366)))) +((|constructor| (NIL "This is a low-level domain which implements matrices (two dimensional arrays) of double precision floating point numbers. Indexing is 0 based, there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|) (|Integer|)) "\\indented{1}{qnew(n, \\spad{m)} creates a new uninitialized \\spad{n} by \\spad{m} matrix.} \\blankline \\spad{X} t1:DFMAT:=qnew(3,4)"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| (-216) (QUOTE (-1093))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1093)))) (|HasCategory| (-216) (QUOTE (-302))) (|HasCategory| (-216) (QUOTE (-559))) (|HasAttribute| (-216) (QUOTE (-4573 "*"))) (|HasCategory| (-216) (QUOTE (-173))) (|HasCategory| (-216) (QUOTE (-366)))) (-218) -((|constructor| (NIL "This package provides special functions for double precision real and complex floating point.")) (|fresnelC| (((|Float|) (|Float|)) "\\indented{1}{fresnelC(\\spad{f}) denotes the Fresnel integral \\spad{C}} \\blankline \\spad{X} fresnelC(1.5)")) (|fresnelS| (((|Float|) (|Float|)) "\\indented{1}{fresnelS(\\spad{f}) denotes the Fresnel integral \\spad{S}} \\blankline \\spad{X} fresnelS(1.5)")) (|hypergeometric0F1| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{hypergeometric0F1(c,{}z)} is the hypergeometric function \\spad{0F1(; c; z)}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{hypergeometric0F1(c,{}z)} is the hypergeometric function \\spad{0F1(; c; z)}.")) (|airyBi| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyBi(x)} is the Airy function \\spad{\\spad{Bi}(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{\\spad{Bi}''(x) - x * \\spad{Bi}(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyBi(x)} is the Airy function \\spad{\\spad{Bi}(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{\\spad{Bi}''(x) - x * \\spad{Bi}(x) = 0}.}")) (|airyAi| (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyAi(x)} is the Airy function \\spad{\\spad{Ai}(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{\\spad{Ai}''(x) - x * \\spad{Ai}(x) = 0}.}") (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyAi(x)} is the Airy function \\spad{\\spad{Ai}(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{\\spad{Ai}''(x) - x * \\spad{Ai}(x) = 0}.}")) (|besselK| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselK(v,{}x)} is the modified Bessel function of the second kind,{} \\spad{K(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{K(v,{}x) = \\%pi/2*(I(-v,{}x) - I(v,{}x))/sin(v*\\%\\spad{pi})}} so is not valid for integer values of \\spad{v}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselK(v,{}x)} is the modified Bessel function of the second kind,{} \\spad{K(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{K(v,{}x) = \\%pi/2*(I(-v,{}x) - I(v,{}x))/sin(v*\\%\\spad{pi})}.} so is not valid for integer values of \\spad{v}.")) (|besselI| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselI(v,{}x)} is the modified Bessel function of the first kind,{} \\spad{I(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselI(v,{}x)} is the modified Bessel function of the first kind,{} \\spad{I(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) - (x^2+v^2)w(x) = 0}.}")) (|besselY| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselY(v,{}x)} is the Bessel function of the second kind,{} \\spad{Y(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{Y(v,{}x) = (J(v,{}x) cos(v*\\%\\spad{pi}) - J(-v,{}x))/sin(v*\\%\\spad{pi})}} so is not valid for integer values of \\spad{v}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselY(v,{}x)} is the Bessel function of the second kind,{} \\spad{Y(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{Y(v,{}x) = (J(v,{}x) cos(v*\\%\\spad{pi}) - J(-v,{}x))/sin(v*\\%\\spad{pi})}} so is not valid for integer values of \\spad{v}.")) (|besselJ| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselJ(v,{}x)} is the Bessel function of the first kind,{} \\spad{J(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselJ(v,{}x)} is the Bessel function of the first kind,{} \\spad{J(v,{}x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + x w'(x) + (x^2-v^2)w(x) = 0}.}")) (|polygamma| (((|Complex| (|DoubleFloat|)) (|NonNegativeInteger|) (|Complex| (|DoubleFloat|))) "\\spad{polygamma(n,{} x)} is the \\spad{n}-th derivative of \\spad{digamma(x)}.") (((|DoubleFloat|) (|NonNegativeInteger|) (|DoubleFloat|)) "\\spad{polygamma(n,{} x)} is the \\spad{n}-th derivative of \\spad{digamma(x)}.")) (|digamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{digamma(x)} is the function,{} \\spad{psi(x)},{} defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{digamma(x)} is the function,{} \\spad{psi(x)},{} defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}")) (|logGamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.")) (|Beta| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Beta(x,{} y)} is the Euler beta function,{} \\spad{B(x,{}y)},{} defined by \\indented{2}{\\spad{Beta(x,{}y) = integrate(t^(x-1)*(1-t)^(y-1),{} t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,{}y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{Beta(x,{} y)} is the Euler beta function,{} \\spad{B(x,{}y)},{} defined by \\indented{2}{\\spad{Beta(x,{}y) = integrate(t^(x-1)*(1-t)^(y-1),{} t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,{}y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}")) (|Ei6| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei6} is the first approximation of \\spad{Ei} where the result is \\spad{x*}\\%e^-x*Ei(\\spad{x}) from 32 to infinity (preserves digits)")) (|Ei5| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei5} is the first approximation of \\spad{Ei} where the result is \\spad{x*}\\%e^-x*Ei(\\spad{x}) from 12 to 32 (preserves digits)")) (|Ei4| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei4} is the first approximation of \\spad{Ei} where the result is \\spad{x*}\\%e^-x*Ei(\\spad{x}) from 4 to 12 (preserves digits)")) (|Ei3| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei3} is the first approximation of \\spad{Ei} where the result is (\\spad{Ei}(\\spad{x})-log \\spad{|x|} - gamma)\\spad{/x} from \\spad{-4} to 4 (preserves digits)")) (|Ei2| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei2} is the first approximation of \\spad{Ei} where the result is \\spad{x*}\\%e^-x*Ei(\\spad{x}) from \\spad{-10} to \\spad{-4} (preserves digits)")) (|Ei1| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei1} is the first approximation of \\spad{Ei} where the result is \\spad{x*}\\%e^-x*Ei(\\spad{x}) from -infinity to \\spad{-10} (preserves digits)")) (|Ei| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei} is the Exponential Integral function This is computed using a 6 part piecewise approximation. DoubleFloat can only preserve about 16 digits but the Chebyshev approximation used can give 30 digits.")) (|En| (((|OnePointCompletion| (|DoubleFloat|)) (|Integer|) (|DoubleFloat|)) "\\spad{En(n,{}x)} is the \\spad{n}th Exponential Integral Function")) (E1 (((|OnePointCompletion| (|DoubleFloat|)) (|DoubleFloat|)) "\\spad{E1(x)} is the Exponential Integral function The current implementation is a piecewise approximation involving one poly from \\spad{-4}..4 and a second poly for \\spad{x} > 4")) (|Gamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Gamma(x)} is the Euler gamma function,{} \\spad{Gamma(x)},{} defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t),{} t=0..\\%infinity)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{Gamma(x)} is the Euler gamma function,{} \\spad{Gamma(x)},{} defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t),{} t=0..\\%infinity)}.}"))) +((|constructor| (NIL "This package provides special functions for double precision real and complex floating point.")) (|fresnelC| (((|Float|) (|Float|)) "\\indented{1}{fresnelC(f) denotes the Fresnel integral \\spad{C}} \\blankline \\spad{X} fresnelC(1.5)")) (|fresnelS| (((|Float|) (|Float|)) "\\indented{1}{fresnelS(f) denotes the Fresnel integral \\spad{S}} \\blankline \\spad{X} fresnelS(1.5)")) (|hypergeometric0F1| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{hypergeometric0F1(c,z)} is the hypergeometric function \\spad{0F1(; \\spad{c;} z)}.") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{hypergeometric0F1(c,z)} is the hypergeometric function \\spad{0F1(; \\spad{c;} z)}.")) (|airyBi| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyBi(x)} is the Airy function \\spad{Bi(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Bi''(x) - \\spad{x} * Bi(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyBi(x)} is the Airy function \\spad{Bi(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Bi''(x) - \\spad{x} * Bi(x) = 0}.}")) (|airyAi| (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{airyAi(x)} is the Airy function \\spad{Ai(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Ai''(x) - \\spad{x} * Ai(x) = 0}.}") (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{airyAi(x)} is the Airy function \\spad{Ai(x)}. This function satisfies the differential equation: \\indented{2}{\\spad{Ai''(x) - \\spad{x} * Ai(x) = 0}.}")) (|besselK| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselK(v,x)} is the modified Bessel function of the second kind, \\spad{K(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) - (x^2+v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{K(v,x) = \\%pi/2*(I(-v,x) - I(v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselK(v,x)} is the modified Bessel function of the second kind, \\spad{K(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) - (x^2+v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{K(v,x) = \\%pi/2*(I(-v,x) - I(v,x))/sin(v*\\%pi)}.} so is not valid for integer values of \\spad{v.}")) (|besselI| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselI(v,x)} is the modified Bessel function of the first kind, \\spad{I(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) - (x^2+v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselI(v,x)} is the modified Bessel function of the first kind, \\spad{I(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) - (x^2+v^2)w(x) = 0}.}")) (|besselY| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselY(v,x)} is the Bessel function of the second kind, \\spad{Y(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) + (x^2-v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{Y(v,x) = (J(v,x) cos(v*\\%pi) - J(-v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselY(v,x)} is the Bessel function of the second kind, \\spad{Y(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) + (x^2-v^2)w(x) = 0}.} Note that the default implementation uses the relation \\indented{2}{\\spad{Y(v,x) = (J(v,x) cos(v*\\%pi) - J(-v,x))/sin(v*\\%pi)}} so is not valid for integer values of \\spad{v.}")) (|besselJ| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{besselJ(v,x)} is the Bessel function of the first kind, \\spad{J(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) + (x^2-v^2)w(x) = 0}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{besselJ(v,x)} is the Bessel function of the first kind, \\spad{J(v,x)}. This function satisfies the differential equation: \\indented{2}{\\spad{x^2 w''(x) + \\spad{x} w'(x) + (x^2-v^2)w(x) = 0}.}")) (|polygamma| (((|Complex| (|DoubleFloat|)) (|NonNegativeInteger|) (|Complex| (|DoubleFloat|))) "\\spad{polygamma(n, \\spad{x)}} is the \\spad{n}-th derivative of \\spad{digamma(x)}.") (((|DoubleFloat|) (|NonNegativeInteger|) (|DoubleFloat|)) "\\spad{polygamma(n, \\spad{x)}} is the \\spad{n}-th derivative of \\spad{digamma(x)}.")) (|digamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{digamma(x)} is the function, \\spad{psi(x)}, defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{digamma(x)} is the function, \\spad{psi(x)}, defined by \\indented{2}{\\spad{psi(x) = Gamma'(x)/Gamma(x)}.}")) (|logGamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{logGamma(x)} is the natural log of \\spad{Gamma(x)}. This can often be computed even if \\spad{Gamma(x)} cannot.")) (|Beta| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Beta(x, \\spad{y)}} is the Euler beta function, \\spad{B(x,y)}, defined by \\indented{2}{\\spad{Beta(x,y) = integrate(t^(x-1)*(1-t)^(y-1), t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}") (((|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) "\\spad{Beta(x, \\spad{y)}} is the Euler beta function, \\spad{B(x,y)}, defined by \\indented{2}{\\spad{Beta(x,y) = integrate(t^(x-1)*(1-t)^(y-1), t=0..1)}.} This is related to \\spad{Gamma(x)} by \\indented{2}{\\spad{Beta(x,y) = Gamma(x)*Gamma(y) / Gamma(x + y)}.}")) (|Ei6| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei6} is the first approximation of \\spad{Ei} where the result is x*\\%e^-x*Ei(x) from 32 to infinity (preserves digits)")) (|Ei5| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei5} is the first approximation of \\spad{Ei} where the result is x*\\%e^-x*Ei(x) from 12 to 32 (preserves digits)")) (|Ei4| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei4} is the first approximation of \\spad{Ei} where the result is x*\\%e^-x*Ei(x) from 4 to 12 (preserves digits)")) (|Ei3| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei3} is the first approximation of \\spad{Ei} where the result is (Ei(x)-log \\spad{|x|} - gamma)/x from \\spad{-4} to 4 (preserves digits)")) (|Ei2| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei2} is the first approximation of \\spad{Ei} where the result is x*\\%e^-x*Ei(x) from \\spad{-10} to \\spad{-4} (preserves digits)")) (|Ei1| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei1} is the first approximation of \\spad{Ei} where the result is x*\\%e^-x*Ei(x) from -infinity to \\spad{-10} (preserves digits)")) (|Ei| (((|OnePointCompletion| (|DoubleFloat|)) (|OnePointCompletion| (|DoubleFloat|))) "\\spad{Ei} is the Exponential Integral function This is computed using a 6 part piecewise approximation. DoubleFloat can only preserve about 16 digits but the Chebyshev approximation used can give 30 digits.")) (|En| (((|OnePointCompletion| (|DoubleFloat|)) (|Integer|) (|DoubleFloat|)) "\\spad{En(n,x)} is the \\spad{n}th Exponential Integral Function")) (E1 (((|OnePointCompletion| (|DoubleFloat|)) (|DoubleFloat|)) "\\spad{E1(x)} is the Exponential Integral function The current implementation is a piecewise approximation involving one poly from \\spad{-4..4} and a second poly for \\spad{x} > 4")) (|Gamma| (((|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) "\\spad{Gamma(x)} is the Euler gamma function, \\spad{Gamma(x)}, defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t), t=0..\\%infinity)}.}") (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{Gamma(x)} is the Euler gamma function, \\spad{Gamma(x)}, defined by \\indented{2}{\\spad{Gamma(x) = integrate(t^(x-1)*exp(-t), t=0..\\%infinity)}.}"))) NIL NIL (-219) -((|constructor| (NIL "This is a low-level domain which implements vectors (one dimensional arrays) of double precision floating point numbers. Indexing is 0 based,{} there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|)) "\\indented{1}{qnew(\\spad{n}) creates a new uninitialized vector of length \\spad{n}.} \\blankline \\spad{X} t1:DFVEC:=qnew(7)"))) -((-4536 . T) (-4535 . T)) -((|HasCategory| (-216) (QUOTE (-1091))) (|HasCategory| (-216) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-216) (QUOTE (-843))) (-2232 (|HasCategory| (-216) (QUOTE (-843))) (|HasCategory| (-216) (QUOTE (-1091)))) (|HasCategory| (-569) (QUOTE (-843))) (|HasCategory| (-216) (QUOTE (-25))) (|HasCategory| (-216) (QUOTE (-23))) (|HasCategory| (-216) (QUOTE (-21))) (|HasCategory| (-216) (QUOTE (-717))) (|HasCategory| (-216) (QUOTE (-1048))) (-12 (|HasCategory| (-216) (QUOTE (-1003))) (|HasCategory| (-216) (QUOTE (-1048)))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-843)))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1091)))))) +((|constructor| (NIL "This is a low-level domain which implements vectors (one dimensional arrays) of double precision floating point numbers. Indexing is 0 based, there is no bound checking (unless provided by lower level).")) (|qnew| (($ (|Integer|)) "\\indented{1}{qnew(n) creates a new uninitialized vector of length \\spad{n.}} \\blankline \\spad{X} t1:DFVEC:=qnew(7)"))) +((-4572 . T) (-4571 . T)) +((|HasCategory| (-216) (QUOTE (-1093))) (|HasCategory| (-216) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-216) (QUOTE (-844))) (-1929 (|HasCategory| (-216) (QUOTE (-844))) (|HasCategory| (-216) (QUOTE (-1093)))) (|HasCategory| (-569) (QUOTE (-844))) (|HasCategory| (-216) (QUOTE (-25))) (|HasCategory| (-216) (QUOTE (-23))) (|HasCategory| (-216) (QUOTE (-21))) (|HasCategory| (-216) (QUOTE (-718))) (|HasCategory| (-216) (QUOTE (-1049))) (-12 (|HasCategory| (-216) (QUOTE (-1004))) (|HasCategory| (-216) (QUOTE (-1049)))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-844)))) (-12 (|HasCategory| (-216) (LIST (QUOTE -304) (QUOTE (-216)))) (|HasCategory| (-216) (QUOTE (-1093)))))) (-220 R) -((|constructor| (NIL "4x4 Matrices for coordinate transformations\\spad{\\br} This package contains functions to create 4x4 matrices useful for rotating and transforming coordinate systems. These matrices are useful for graphics and robotics. (Reference: Robot Manipulators Richard Paul MIT Press 1981) \\blankline A Denavit-Hartenberg Matrix is a 4x4 Matrix of the form:\\spad{\\br} \\tab{5}\\spad{nx ox ax px}\\spad{\\br} \\tab{5}\\spad{ny oy ay py}\\spad{\\br} \\tab{5}\\spad{nz oz az pz}\\spad{\\br} \\tab{5}\\spad{0 0 0 1}\\spad{\\br} (\\spad{n},{} \\spad{o},{} and a are the direction cosines)")) (|translate| (($ |#1| |#1| |#1|) "\\spad{translate(x,{}y,{}z)} returns a dhmatrix for translation by \\spad{x},{} \\spad{y},{} and \\spad{z}")) (|scale| (($ |#1| |#1| |#1|) "\\spad{scale(sx,{}sy,{}sz)} returns a dhmatrix for scaling in the \\spad{x},{} \\spad{y} and \\spad{z} directions")) (|rotatez| (($ |#1|) "\\spad{rotatez(r)} returns a dhmatrix for rotation about axis \\spad{z} for \\spad{r} degrees")) (|rotatey| (($ |#1|) "\\spad{rotatey(r)} returns a dhmatrix for rotation about axis \\spad{y} for \\spad{r} degrees")) (|rotatex| (($ |#1|) "\\spad{rotatex(r)} returns a dhmatrix for rotation about axis \\spad{x} for \\spad{r} degrees")) (|identity| (($) "\\spad{identity()} create the identity dhmatrix")) (* (((|Point| |#1|) $ (|Point| |#1|)) "\\spad{t*p} applies the dhmatrix \\spad{t} to point \\spad{p}"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-559))) (|HasAttribute| |#1| (QUOTE (-4537 "*"))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366)))) +((|constructor| (NIL "4x4 Matrices for coordinate transformations\\br This package contains functions to create 4x4 matrices useful for rotating and transforming coordinate systems. These matrices are useful for graphics and robotics. (Reference: Robot Manipulators Richard Paul MIT Press 1981) \\blankline A Denavit-Hartenberg Matrix is a 4x4 Matrix of the form:\\br \\tab{5}\\spad{nx ox ax px}\\br \\tab{5}\\spad{ny oy ay py}\\br \\tab{5}\\spad{nz oz az pz}\\br \\tab{5}\\spad{0 0 0 1}\\br \\spad{(n,} o, and a are the direction cosines)")) (|translate| (($ |#1| |#1| |#1|) "\\spad{translate(x,y,z)} returns a dhmatrix for translation by \\spad{x,} \\spad{y,} and \\spad{z}")) (|scale| (($ |#1| |#1| |#1|) "\\spad{scale(sx,sy,sz)} returns a dhmatrix for scaling in the \\spad{x,} \\spad{y} and \\spad{z} directions")) (|rotatez| (($ |#1|) "\\spad{rotatez(r)} returns a dhmatrix for rotation about axis \\spad{z} for \\spad{r} degrees")) (|rotatey| (($ |#1|) "\\spad{rotatey(r)} returns a dhmatrix for rotation about axis \\spad{y} for \\spad{r} degrees")) (|rotatex| (($ |#1|) "\\spad{rotatex(r)} returns a dhmatrix for rotation about axis \\spad{x} for \\spad{r} degrees")) (|identity| (($) "\\spad{identity()} create the identity dhmatrix")) (* (((|Point| |#1|) $ (|Point| |#1|)) "\\spad{t*p} applies the dhmatrix \\spad{t} to point \\spad{p}"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))) (|HasCategory| |#1| (QUOTE (-302))) (|HasCategory| |#1| (QUOTE (-559))) (|HasAttribute| |#1| (QUOTE (-4573 "*"))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366)))) (-221 A S) -((|constructor| (NIL "A dictionary is an aggregate in which entries can be inserted,{} searched for and removed. Duplicates are thrown away on insertion. This category models the usual notion of dictionary which involves large amounts of data where copying is impractical. Principal operations are thus destructive (non-copying) ones."))) +((|constructor| (NIL "A dictionary is an aggregate in which entries can be inserted, searched for and removed. Duplicates are thrown away on insertion. This category models the usual notion of dictionary which involves large amounts of data where copying is impractical. Principal operations are thus destructive (non-copying) ones."))) NIL NIL (-222 S) -((|constructor| (NIL "A dictionary is an aggregate in which entries can be inserted,{} searched for and removed. Duplicates are thrown away on insertion. This category models the usual notion of dictionary which involves large amounts of data where copying is impractical. Principal operations are thus destructive (non-copying) ones."))) -((-4536 . T) (-2982 . T)) +((|constructor| (NIL "A dictionary is an aggregate in which entries can be inserted, searched for and removed. Duplicates are thrown away on insertion. This category models the usual notion of dictionary which involves large amounts of data where copying is impractical. Principal operations are thus destructive (non-copying) ones."))) +((-4572 . T) (-4317 . T)) NIL (-223 S R) -((|constructor| (NIL "Differential extensions of a ring \\spad{R}. Given a differentiation on \\spad{R},{} extend it to a differentiation on \\%.")) (D (($ $ (|Mapping| |#2| |#2|) (|NonNegativeInteger|)) "\\spad{D(x,{} deriv,{} n)} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R}.") (($ $ (|Mapping| |#2| |#2|)) "\\spad{D(x,{} deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R}.")) (|differentiate| (($ $ (|Mapping| |#2| |#2|) (|NonNegativeInteger|)) "\\spad{differentiate(x,{} deriv,{} n)} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R}.") (($ $ (|Mapping| |#2| |#2|)) "\\spad{differentiate(x,{} deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R}."))) +((|constructor| (NIL "Differential extensions of a ring \\spad{R.} Given a differentiation on \\spad{R,} extend it to a differentiation on \\spad{%.}")) (D (($ $ (|Mapping| |#2| |#2|) (|NonNegativeInteger|)) "\\spad{D(x, deriv, \\spad{n)}} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R.}") (($ $ (|Mapping| |#2| |#2|)) "\\spad{D(x, deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R.}")) (|differentiate| (($ $ (|Mapping| |#2| |#2|) (|NonNegativeInteger|)) "\\spad{differentiate(x, deriv, \\spad{n)}} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R.}") (($ $ (|Mapping| |#2| |#2|)) "\\spad{differentiate(x, deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R.}"))) NIL -((|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-226)))) +((|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-226)))) (-224 R) -((|constructor| (NIL "Differential extensions of a ring \\spad{R}. Given a differentiation on \\spad{R},{} extend it to a differentiation on \\%.")) (D (($ $ (|Mapping| |#1| |#1|) (|NonNegativeInteger|)) "\\spad{D(x,{} deriv,{} n)} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R}.") (($ $ (|Mapping| |#1| |#1|)) "\\spad{D(x,{} deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R}.")) (|differentiate| (($ $ (|Mapping| |#1| |#1|) (|NonNegativeInteger|)) "\\spad{differentiate(x,{} deriv,{} n)} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R}.") (($ $ (|Mapping| |#1| |#1|)) "\\spad{differentiate(x,{} deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R}."))) -((-4532 . T)) +((|constructor| (NIL "Differential extensions of a ring \\spad{R.} Given a differentiation on \\spad{R,} extend it to a differentiation on \\spad{%.}")) (D (($ $ (|Mapping| |#1| |#1|) (|NonNegativeInteger|)) "\\spad{D(x, deriv, \\spad{n)}} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R.}") (($ $ (|Mapping| |#1| |#1|)) "\\spad{D(x, deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R.}")) (|differentiate| (($ $ (|Mapping| |#1| |#1|) (|NonNegativeInteger|)) "\\spad{differentiate(x, deriv, \\spad{n)}} differentiate \\spad{x} \\spad{n} times using a derivation which extends \\spad{deriv} on \\spad{R.}") (($ $ (|Mapping| |#1| |#1|)) "\\spad{differentiate(x, deriv)} differentiates \\spad{x} extending the derivation deriv on \\spad{R.}"))) +((-4568 . T)) NIL (-225 S) -((|constructor| (NIL "An ordinary differential ring,{} that is,{} a ring with an operation \\spadfun{differentiate}. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\\spad{\\br} \\tab{5}\\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}")) (D (($ $ (|NonNegativeInteger|)) "\\spad{D(x,{} n)} returns the \\spad{n}-th derivative of \\spad{x}.") (($ $) "\\spad{D(x)} returns the derivative of \\spad{x}. This function is a simple differential operator where no variable needs to be specified.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(x,{} n)} returns the \\spad{n}-th derivative of \\spad{x}.") (($ $) "\\spad{differentiate(x)} returns the derivative of \\spad{x}. This function is a simple differential operator where no variable needs to be specified."))) +((|constructor| (NIL "An ordinary differential ring, that is, a ring with an operation \\spadfun{differentiate}. \\blankline Axioms\\br \\tab{5}\\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\\br \\tab{5}\\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}")) (D (($ $ (|NonNegativeInteger|)) "\\spad{D(x, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{x.}") (($ $) "\\spad{D(x)} returns the derivative of \\spad{x.} This function is a simple differential operator where no variable needs to be specified.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(x, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{x.}") (($ $) "\\spad{differentiate(x)} returns the derivative of \\spad{x.} This function is a simple differential operator where no variable needs to be specified."))) NIL NIL (-226) -((|constructor| (NIL "An ordinary differential ring,{} that is,{} a ring with an operation \\spadfun{differentiate}. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\\spad{\\br} \\tab{5}\\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}")) (D (($ $ (|NonNegativeInteger|)) "\\spad{D(x,{} n)} returns the \\spad{n}-th derivative of \\spad{x}.") (($ $) "\\spad{D(x)} returns the derivative of \\spad{x}. This function is a simple differential operator where no variable needs to be specified.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(x,{} n)} returns the \\spad{n}-th derivative of \\spad{x}.") (($ $) "\\spad{differentiate(x)} returns the derivative of \\spad{x}. This function is a simple differential operator where no variable needs to be specified."))) -((-4532 . T)) +((|constructor| (NIL "An ordinary differential ring, that is, a ring with an operation \\spadfun{differentiate}. \\blankline Axioms\\br \\tab{5}\\spad{differentiate(x+y) = differentiate(x)+differentiate(y)}\\br \\tab{5}\\spad{differentiate(x*y) = x*differentiate(y) + differentiate(x)*y}")) (D (($ $ (|NonNegativeInteger|)) "\\spad{D(x, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{x.}") (($ $) "\\spad{D(x)} returns the derivative of \\spad{x.} This function is a simple differential operator where no variable needs to be specified.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(x, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{x.}") (($ $) "\\spad{differentiate(x)} returns the derivative of \\spad{x.} This function is a simple differential operator where no variable needs to be specified."))) +((-4568 . T)) NIL (-227 A S) -((|constructor| (NIL "This category is a collection of operations common to both categories \\spadtype{Dictionary} and \\spadtype{MultiDictionary}")) (|select!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select!(p,{}d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is not \\spad{true}.")) (|remove!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove!(p,{}d)} destructively changes dictionary \\spad{d} by removeing all entries \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}.") (($ |#2| $) "\\spad{remove!(x,{}d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{y} such that \\axiom{\\spad{y} = \\spad{x}}.")) (|dictionary| (($ (|List| |#2|)) "\\spad{dictionary([x,{}y,{}...,{}z])} creates a dictionary consisting of entries \\axiom{\\spad{x},{}\\spad{y},{}...,{}\\spad{z}}.") (($) "\\spad{dictionary()}\\$\\spad{D} creates an empty dictionary of type \\spad{D}."))) +((|constructor| (NIL "This category is a collection of operations common to both categories \\spadtype{Dictionary} and \\spadtype{MultiDictionary}")) (|select!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select!(p,d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{x} such that \\axiom{p(x)} is not true.")) (|remove!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove!(p,d)} destructively changes dictionary \\spad{d} by removeing all entries \\spad{x} such that \\axiom{p(x)} is true.") (($ |#2| $) "\\spad{remove!(x,d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{y} such that \\axiom{y = \\spad{x}.}")) (|dictionary| (($ (|List| |#2|)) "\\spad{dictionary([x,y,...,z])} creates a dictionary consisting of entries \\axiom{x,y,...,z}.") (($) "\\spad{dictionary()}$D creates an empty dictionary of type \\spad{D.}"))) NIL -((|HasAttribute| |#1| (QUOTE -4535))) +((|HasAttribute| |#1| (QUOTE -4571))) (-228 S) -((|constructor| (NIL "This category is a collection of operations common to both categories \\spadtype{Dictionary} and \\spadtype{MultiDictionary}")) (|select!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select!(p,{}d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is not \\spad{true}.")) (|remove!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove!(p,{}d)} destructively changes dictionary \\spad{d} by removeing all entries \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}.") (($ |#1| $) "\\spad{remove!(x,{}d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{y} such that \\axiom{\\spad{y} = \\spad{x}}.")) (|dictionary| (($ (|List| |#1|)) "\\spad{dictionary([x,{}y,{}...,{}z])} creates a dictionary consisting of entries \\axiom{\\spad{x},{}\\spad{y},{}...,{}\\spad{z}}.") (($) "\\spad{dictionary()}\\$\\spad{D} creates an empty dictionary of type \\spad{D}."))) -((-4536 . T) (-2982 . T)) +((|constructor| (NIL "This category is a collection of operations common to both categories \\spadtype{Dictionary} and \\spadtype{MultiDictionary}")) (|select!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select!(p,d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{x} such that \\axiom{p(x)} is not true.")) (|remove!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove!(p,d)} destructively changes dictionary \\spad{d} by removeing all entries \\spad{x} such that \\axiom{p(x)} is true.") (($ |#1| $) "\\spad{remove!(x,d)} destructively changes dictionary \\spad{d} by removing all entries \\spad{y} such that \\axiom{y = \\spad{x}.}")) (|dictionary| (($ (|List| |#1|)) "\\spad{dictionary([x,y,...,z])} creates a dictionary consisting of entries \\axiom{x,y,...,z}.") (($) "\\spad{dictionary()}$D creates an empty dictionary of type \\spad{D.}"))) +((-4572 . T) (-4317 . T)) NIL (-229) -((|constructor| (NIL "Any solution of a homogeneous linear Diophantine equation can be represented as a sum of minimal solutions,{} which form a \"basis\" (a minimal solution cannot be represented as a nontrivial sum of solutions) in the case of an inhomogeneous linear Diophantine equation,{} each solution is the sum of a inhomogeneous solution and any number of homogeneous solutions therefore,{} it suffices to compute two sets:\\spad{\\br} \\tab{5}1. all minimal inhomogeneous solutions\\spad{\\br} \\tab{5}2. all minimal homogeneous solutions\\spad{\\br} the algorithm implemented is a completion procedure,{} which enumerates all solutions in a recursive depth-first-search it can be seen as finding monotone paths in a graph for more details see Reference")) (|dioSolve| (((|Record| (|:| |varOrder| (|List| (|Symbol|))) (|:| |inhom| (|Union| (|List| (|Vector| (|NonNegativeInteger|))) "failed")) (|:| |hom| (|List| (|Vector| (|NonNegativeInteger|))))) (|Equation| (|Polynomial| (|Integer|)))) "\\spad{dioSolve(u)} computes a basis of all minimal solutions for linear homogeneous Diophantine equation \\spad{u},{} then all minimal solutions of inhomogeneous equation"))) +((|constructor| (NIL "Any solution of a homogeneous linear Diophantine equation can be represented as a sum of minimal solutions, which form a \"basis\" (a minimal solution cannot be represented as a nontrivial sum of solutions) in the case of an inhomogeneous linear Diophantine equation, each solution is the sum of a inhomogeneous solution and any number of homogeneous solutions therefore, it suffices to compute two sets:\\br \\tab{5}1. all minimal inhomogeneous solutions\\br \\tab{5}2. all minimal homogeneous solutions\\br the algorithm implemented is a completion procedure, which enumerates all solutions in a recursive depth-first-search it can be seen as finding monotone paths in a graph for more details see Reference")) (|dioSolve| (((|Record| (|:| |varOrder| (|List| (|Symbol|))) (|:| |inhom| (|Union| (|List| (|Vector| (|NonNegativeInteger|))) "failed")) (|:| |hom| (|List| (|Vector| (|NonNegativeInteger|))))) (|Equation| (|Polynomial| (|Integer|)))) "\\spad{dioSolve(u)} computes a basis of all minimal solutions for linear homogeneous Diophantine equation u, then all minimal solutions of inhomogeneous equation"))) NIL NIL -(-230 S -4391 R) -((|constructor| (NIL "This category represents a finite cartesian product of a given type. Many categorical properties are preserved under this construction.")) (|dot| ((|#3| $ $) "\\spad{dot(x,{}y)} computes the inner product of the vectors \\spad{x} and \\spad{y}.")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#3|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim.")) (|finiteAggregate| ((|attribute|) "attribute to indicate an aggregate of finite size"))) +(-230 S -4360 R) +((|constructor| (NIL "This category represents a finite cartesian product of a given type. Many categorical properties are preserved under this construction.")) (|dot| ((|#3| $ $) "\\spad{dot(x,y)} computes the inner product of the vectors \\spad{x} and \\spad{y.}")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#3|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim.")) (|finiteAggregate| ((|attribute|) "attribute to indicate an aggregate of finite size"))) NIL -((|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-789))) (|HasCategory| |#3| (QUOTE (-841))) (|HasAttribute| |#3| (QUOTE -4532)) (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-371))) (|HasCategory| |#3| (QUOTE (-717))) (|HasCategory| |#3| (QUOTE (-138))) (|HasCategory| |#3| (QUOTE (-25))) (|HasCategory| |#3| (QUOTE (-1048))) (|HasCategory| |#3| (QUOTE (-1091)))) -(-231 -4391 R) -((|constructor| (NIL "This category represents a finite cartesian product of a given type. Many categorical properties are preserved under this construction.")) (|dot| ((|#2| $ $) "\\spad{dot(x,{}y)} computes the inner product of the vectors \\spad{x} and \\spad{y}.")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#2|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim.")) (|finiteAggregate| ((|attribute|) "attribute to indicate an aggregate of finite size"))) -((-4529 |has| |#2| (-1048)) (-4530 |has| |#2| (-1048)) (-4532 |has| |#2| (-6 -4532)) ((-4537 "*") |has| |#2| (-173)) (-4535 . T) (-2982 . T)) +((|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-790))) (|HasCategory| |#3| (QUOTE (-842))) (|HasAttribute| |#3| (QUOTE -4568)) (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-371))) (|HasCategory| |#3| (QUOTE (-718))) (|HasCategory| |#3| (QUOTE (-138))) (|HasCategory| |#3| (QUOTE (-25))) (|HasCategory| |#3| (QUOTE (-1049))) (|HasCategory| |#3| (QUOTE (-1093)))) +(-231 -4360 R) +((|constructor| (NIL "This category represents a finite cartesian product of a given type. Many categorical properties are preserved under this construction.")) (|dot| ((|#2| $ $) "\\spad{dot(x,y)} computes the inner product of the vectors \\spad{x} and \\spad{y.}")) (|unitVector| (($ (|PositiveInteger|)) "\\spad{unitVector(n)} produces a vector with 1 in position \\spad{n} and zero elsewhere.")) (|directProduct| (($ (|Vector| |#2|)) "\\spad{directProduct(v)} converts the vector \\spad{v} to become a direct product. Error: if the length of \\spad{v} is different from dim.")) (|finiteAggregate| ((|attribute|) "attribute to indicate an aggregate of finite size"))) +((-4565 |has| |#2| (-1049)) (-4566 |has| |#2| (-1049)) (-4568 |has| |#2| (-6 -4568)) ((-4573 "*") |has| |#2| (-173)) (-4571 . T) (-4317 . T)) NIL -(-232 -4391 A B) -((|constructor| (NIL "This package provides operations which all take as arguments direct products of elements of some type \\spad{A} and functions from \\spad{A} to another type \\spad{B}. The operations all iterate over their vector argument and either return a value of type \\spad{B} or a direct product over \\spad{B}.")) (|map| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2|) (|DirectProduct| |#1| |#2|)) "\\spad{map(f,{} v)} applies the function \\spad{f} to every element of the vector \\spad{v} producing a new vector containing the values.")) (|reduce| ((|#3| (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{reduce(func,{}vec,{}ident)} combines the elements in \\spad{vec} using the binary function \\spad{func}. Argument \\spad{ident} is returned if the vector is empty.")) (|scan| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{scan(func,{}vec,{}ident)} creates a new vector whose elements are the result of applying reduce to the binary function \\spad{func},{} increasing initial subsequences of the vector \\spad{vec},{} and the element \\spad{ident}."))) +(-232 -4360 A B) +((|constructor| (NIL "This package provides operations which all take as arguments direct products of elements of some type \\spad{A} and functions from \\spad{A} to another type \\spad{B.} The operations all iterate over their vector argument and either return a value of type \\spad{B} or a direct product over \\spad{B.}")) (|map| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2|) (|DirectProduct| |#1| |#2|)) "\\spad{map(f, \\spad{v)}} applies the function \\spad{f} to every element of the vector \\spad{v} producing a new vector containing the values.")) (|reduce| ((|#3| (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{reduce(func,vec,ident)} combines the elements in \\spad{vec} using the binary function func. Argument \\spad{ident} is returned if the vector is empty.")) (|scan| (((|DirectProduct| |#1| |#3|) (|Mapping| |#3| |#2| |#3|) (|DirectProduct| |#1| |#2|) |#3|) "\\spad{scan(func,vec,ident)} creates a new vector whose elements are the result of applying reduce to the binary function func, increasing initial subsequences of the vector vec, and the element ident."))) NIL NIL -(-233 -4391 R) +(-233 -4360 R) ((|constructor| (NIL "This type represents the finite direct or cartesian product of an underlying component type. This contrasts with simple vectors in that the members can be viewed as having constant length. Thus many categorical properties can by lifted from the underlying component type. Component extraction operations are provided but no updating operations. Thus new direct product elements can either be created by converting vector elements using the \\spadfun{directProduct} function or by taking appropriate linear combinations of basis vectors provided by the \\spad{unitVector} operation."))) -((-4529 |has| |#2| (-1048)) (-4530 |has| |#2| (-1048)) (-4532 |has| |#2| (-6 -4532)) ((-4537 "*") |has| |#2| (-173)) (-4535 . T)) -((|HasCategory| |#2| (QUOTE (-1091))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1048))) (|HasCategory| |#2| (QUOTE (-789))) (|HasCategory| |#2| (QUOTE (-841))) (-2232 (|HasCategory| |#2| (QUOTE (-789))) (|HasCategory| |#2| (QUOTE (-841)))) (|HasCategory| |#2| (QUOTE (-717))) (|HasCategory| |#2| (QUOTE (-173))) (-2232 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1048)))) (-2232 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-366)))) (-2232 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-1048)))) (|HasCategory| |#2| (QUOTE (-371))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-226))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1048)))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-1048)))) (|HasCategory| (-569) (QUOTE (-843))) (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1091)))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1091)))) (|HasAttribute| |#2| (QUOTE -4532)) (|HasCategory| |#2| (QUOTE (-138))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1048)))) (|HasCategory| |#2| (QUOTE (-25))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-25))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-371))) (|HasCategory| |#2| (QUOTE (-717))) (|HasCategory| |#2| (QUOTE (-789))) (|HasCategory| |#2| (QUOTE (-841))) (|HasCategory| |#2| (QUOTE (-1048))) (|HasCategory| |#2| (QUOTE (-1091)))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (QUOTE (-25))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1048)))) (-2232 (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-717)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-789)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-841)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1091))))) (-2232 (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-717)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-789)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-841)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1091))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (LIST (QUOTE -896) (QUOTE (-1163))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-717)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-789)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-841)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1048)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1091)))))) +((-4565 |has| |#2| (-1049)) (-4566 |has| |#2| (-1049)) (-4568 |has| |#2| (-6 -4568)) ((-4573 "*") |has| |#2| (-173)) (-4571 . T)) +((|HasCategory| |#2| (QUOTE (-1093))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1049))) (|HasCategory| |#2| (QUOTE (-790))) (|HasCategory| |#2| (QUOTE (-842))) (-1929 (|HasCategory| |#2| (QUOTE (-790))) (|HasCategory| |#2| (QUOTE (-842)))) (|HasCategory| |#2| (QUOTE (-718))) (|HasCategory| |#2| (QUOTE (-173))) (-1929 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1049)))) (-1929 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-366)))) (-1929 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-1049)))) (|HasCategory| |#2| (QUOTE (-371))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-226))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1049)))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-1049)))) (|HasCategory| (-569) (QUOTE (-844))) (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1093)))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1093)))) (|HasAttribute| |#2| (QUOTE -4568)) (|HasCategory| |#2| (QUOTE (-138))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1049)))) (|HasCategory| |#2| (QUOTE (-25))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-25))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-371))) (|HasCategory| |#2| (QUOTE (-718))) (|HasCategory| |#2| (QUOTE (-790))) (|HasCategory| |#2| (QUOTE (-842))) (|HasCategory| |#2| (QUOTE (-1049))) (|HasCategory| |#2| (QUOTE (-1093)))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (QUOTE (-25))) (|HasCategory| |#2| (QUOTE (-138))) (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-226))) (|HasCategory| |#2| (QUOTE (-366))) (|HasCategory| |#2| (QUOTE (-1049)))) (-1929 (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-718)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-790)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-842)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-1093))))) (-1929 (-12 (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-718)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-790)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-842)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-1093))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (LIST (QUOTE -897) (QUOTE (-1165))))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-25)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-138)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-173)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-226)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-366)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-371)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-718)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-790)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-842)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1049)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1093)))))) (-234 |Coef|) -((|constructor| (NIL "DirichletRing is the ring of arithmetical functions with Dirichlet convolution as multiplication")) (|additive?| (((|Boolean|) $ (|PositiveInteger|)) "\\spad{additive?(a,{} n)} returns \\spad{true} if the first \\spad{n} coefficients of a are additive")) (|multiplicative?| (((|Boolean|) $ (|PositiveInteger|)) "\\spad{multiplicative?(a,{} n)} returns \\spad{true} if the first \\spad{n} coefficients of a are multiplicative")) (|zeta| (($) "\\spad{zeta()} returns the function which is constantly one"))) -((-4530 |has| |#1| (-173)) (-4529 |has| |#1| (-173)) ((-4537 "*") |has| |#1| (-173)) (-4528 |has| |#1| (-173)) (-4532 . T)) +((|constructor| (NIL "DirichletRing is the ring of arithmetical functions with Dirichlet convolution as multiplication")) (|additive?| (((|Boolean|) $ (|PositiveInteger|)) "\\spad{additive?(a, \\spad{n)}} returns \\spad{true} if the first \\spad{n} coefficients of a are additive")) (|multiplicative?| (((|Boolean|) $ (|PositiveInteger|)) "\\spad{multiplicative?(a, \\spad{n)}} returns \\spad{true} if the first \\spad{n} coefficients of a are multiplicative")) (|zeta| (($) "\\spad{zeta()} returns the function which is constantly one"))) +((-4566 |has| |#1| (-173)) (-4565 |has| |#1| (-173)) ((-4573 "*") |has| |#1| (-173)) (-4564 |has| |#1| (-173)) (-4568 . T)) ((|HasCategory| |#1| (QUOTE (-173)))) (-235) -((|constructor| (NIL "DisplayPackage allows one to print strings in a nice manner,{} including highlighting substrings.")) (|sayLength| (((|Integer|) (|List| (|String|))) "\\spad{sayLength(l)} returns the length of a list of strings \\spad{l} as an integer.") (((|Integer|) (|String|)) "\\spad{sayLength(s)} returns the length of a string \\spad{s} as an integer.")) (|say| (((|Void|) (|List| (|String|))) "\\spad{say(l)} sends a list of strings \\spad{l} to output.") (((|Void|) (|String|)) "\\spad{say(s)} sends a string \\spad{s} to output.")) (|center| (((|List| (|String|)) (|List| (|String|)) (|Integer|) (|String|)) "\\spad{center(l,{}i,{}s)} takes a list of strings \\spad{l},{} and centers them within a list of strings which is \\spad{i} characters long,{} in which the remaining spaces are filled with strings composed of as many repetitions as possible of the last string parameter \\spad{s}.") (((|String|) (|String|) (|Integer|) (|String|)) "\\spad{center(s,{}i,{}s)} takes the first string \\spad{s},{} and centers it within a string of length \\spad{i},{} in which the other elements of the string are composed of as many replications as possible of the second indicated string,{} \\spad{s} which must have a length greater than that of an empty string.")) (|copies| (((|String|) (|Integer|) (|String|)) "\\spad{copies(i,{}s)} will take a string \\spad{s} and create a new string composed of \\spad{i} copies of \\spad{s}.")) (|newLine| (((|String|)) "\\spad{newLine()} sends a new line command to output.")) (|bright| (((|List| (|String|)) (|List| (|String|))) "\\spad{bright(l)} sets the font property of a list of strings,{} \\spad{l},{} to bold-face type.") (((|List| (|String|)) (|String|)) "\\spad{bright(s)} sets the font property of the string \\spad{s} to bold-face type."))) +((|constructor| (NIL "DisplayPackage allows one to print strings in a nice manner, including highlighting substrings.")) (|sayLength| (((|Integer|) (|List| (|String|))) "\\spad{sayLength(l)} returns the length of a list of strings \\spad{l} as an integer.") (((|Integer|) (|String|)) "\\spad{sayLength(s)} returns the length of a string \\spad{s} as an integer.")) (|say| (((|Void|) (|List| (|String|))) "\\spad{say(l)} sends a list of strings \\spad{l} to output.") (((|Void|) (|String|)) "\\spad{say(s)} sends a string \\spad{s} to output.")) (|center| (((|List| (|String|)) (|List| (|String|)) (|Integer|) (|String|)) "\\spad{center(l,i,s)} takes a list of strings \\spad{l,} and centers them within a list of strings which is \\spad{i} characters long, in which the remaining spaces are filled with strings composed of as many repetitions as possible of the last string parameter \\spad{s.}") (((|String|) (|String|) (|Integer|) (|String|)) "\\spad{center(s,i,s)} takes the first string \\spad{s,} and centers it within a string of length i, in which the other elements of the string are composed of as many replications as possible of the second indicated string, \\spad{s} which must have a length greater than that of an empty string.")) (|copies| (((|String|) (|Integer|) (|String|)) "\\spad{copies(i,s)} will take a string \\spad{s} and create a new string composed of \\spad{i} copies of \\spad{s.}")) (|newLine| (((|String|)) "\\spad{newLine()} sends a new line command to output.")) (|bright| (((|List| (|String|)) (|List| (|String|))) "\\spad{bright(l)} sets the font property of a list of strings, \\spad{l,} to bold-face type.") (((|List| (|String|)) (|String|)) "\\spad{bright(s)} sets the font property of the string \\spad{s} to bold-face type."))) NIL NIL (-236 S) -((|constructor| (NIL "This category exports the function for domains")) (|divOfPole| (($ $) "\\spad{divOfPole(d)} returns the negative part of \\spad{d}.")) (|divOfZero| (($ $) "\\spad{divOfZero(d)} returns the positive part of \\spad{d}.")) (|suppOfPole| (((|List| |#1|) $) "suppOfZero(\\spad{d}) returns the elements of the support of \\spad{d} that have a negative coefficient.")) (|suppOfZero| (((|List| |#1|) $) "\\spad{suppOfZero(d)} returns the elements of the support of \\spad{d} that have a positive coefficient.")) (|supp| (((|List| |#1|) $) "\\spad{supp(d)} returns the support of the divisor \\spad{d}.")) (|effective?| (((|Boolean|) $) "\\spad{effective?(d)} returns \\spad{true} if \\spad{d} \\spad{>=} 0.")) (|concat| (($ $ $) "\\spad{concat(a,{}b)} concats the divisor a and \\spad{b} without collecting the duplicative points.")) (|collect| (($ $) "\\spad{collect collects} the duplicative points in the divisor.")) (|split| (((|List| $) $) "\\spad{split(d)} splits the divisor \\spad{d}. For example,{} split( 2 \\spad{p1} + 3p2 ) returns the list [ 2 \\spad{p1},{} 3 \\spad{p2} ].")) (|degree| (((|Integer|) $) "\\spad{degree(d)} returns the degree of the divisor \\spad{d}"))) -((-4530 . T) (-4529 . T)) +((|constructor| (NIL "This category exports the function for domains")) (|divOfPole| (($ $) "\\spad{divOfPole(d)} returns the negative part of \\spad{d.}")) (|divOfZero| (($ $) "\\spad{divOfZero(d)} returns the positive part of \\spad{d.}")) (|suppOfPole| (((|List| |#1|) $) "suppOfZero(d) returns the elements of the support of \\spad{d} that have a negative coefficient.")) (|suppOfZero| (((|List| |#1|) $) "\\spad{suppOfZero(d)} returns the elements of the support of \\spad{d} that have a positive coefficient.")) (|supp| (((|List| |#1|) $) "\\spad{supp(d)} returns the support of the divisor \\spad{d.}")) (|effective?| (((|Boolean|) $) "\\spad{effective?(d)} returns \\spad{true} if \\spad{d} \\spad{>=} 0.")) (|concat| (($ $ $) "\\spad{concat(a,b)} concats the divisor a and \\spad{b} without collecting the duplicative points.")) (|collect| (($ $) "\\spad{collect collects} the duplicative points in the divisor.")) (|split| (((|List| $) $) "\\spad{split(d)} splits the divisor \\spad{d.} For example, split( 2 \\spad{p1} + 3p2 ) returns the list [ 2 \\spad{p1,} 3 \\spad{p2} \\spad{].}")) (|degree| (((|Integer|) $) "\\spad{degree(d)} returns the degree of the divisor \\spad{d}"))) +((-4566 . T) (-4565 . T)) NIL (-237 S) ((|constructor| (NIL "The following is part of the PAFF package"))) -((-4530 . T) (-4529 . T)) -((|HasCategory| (-569) (QUOTE (-788)))) +((-4566 . T) (-4565 . T)) +((|HasCategory| (-569) (QUOTE (-789)))) (-238 S) -((|constructor| (NIL "A division ring (sometimes called a skew field),{} \\spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.")) (|inv| (($ $) "\\spad{inv x} returns the multiplicative inverse of \\spad{x}. Error: if \\spad{x} is 0.")) (^ (($ $ (|Integer|)) "\\spad{x^n} returns \\spad{x} raised to the integer power \\spad{n}.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}."))) +((|constructor| (NIL "A division ring (sometimes called a skew field), \\spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.")) (|inv| (($ $) "\\spad{inv \\spad{x}} returns the multiplicative inverse of \\spad{x.} Error: if \\spad{x} is 0.")) (^ (($ $ (|Integer|)) "\\spad{x^n} returns \\spad{x} raised to the integer power \\spad{n.}")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n.}"))) NIL NIL (-239) -((|constructor| (NIL "A division ring (sometimes called a skew field),{} \\spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.")) (|inv| (($ $) "\\spad{inv x} returns the multiplicative inverse of \\spad{x}. Error: if \\spad{x} is 0.")) (^ (($ $ (|Integer|)) "\\spad{x^n} returns \\spad{x} raised to the integer power \\spad{n}.")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n}."))) -((-4528 . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "A division ring (sometimes called a skew field), \\spadignore{i.e.} a not necessarily commutative ring where all non-zero elements have multiplicative inverses.")) (|inv| (($ $) "\\spad{inv \\spad{x}} returns the multiplicative inverse of \\spad{x.} Error: if \\spad{x} is 0.")) (^ (($ $ (|Integer|)) "\\spad{x^n} returns \\spad{x} raised to the integer power \\spad{n.}")) (** (($ $ (|Integer|)) "\\spad{x**n} returns \\spad{x} raised to the integer power \\spad{n.}"))) +((-4564 . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-240 S) -((|constructor| (NIL "A doubly-linked aggregate serves as a model for a doubly-linked list,{} that is,{} a list which can has links to both next and previous nodes and thus can be efficiently traversed in both directions.")) (|setnext!| (($ $ $) "\\spad{setnext!(u,{}v)} destructively sets the next node of doubly-linked aggregate \\spad{u} to \\spad{v},{} returning \\spad{v}.")) (|setprevious!| (($ $ $) "\\spad{setprevious!(u,{}v)} destructively sets the previous node of doubly-linked aggregate \\spad{u} to \\spad{v},{} returning \\spad{v}.")) (|concat!| (($ $ $) "\\spad{concat!(u,{}v)} destructively concatenates doubly-linked aggregate \\spad{v} to the end of doubly-linked aggregate \\spad{u}.")) (|next| (($ $) "\\spad{next(l)} returns the doubly-linked aggregate beginning with its next element. Error: if \\spad{l} has no next element. Note that \\axiom{next(\\spad{l}) = rest(\\spad{l})} and \\axiom{previous(next(\\spad{l})) = \\spad{l}}.")) (|previous| (($ $) "\\spad{previous(l)} returns the doubly-link list beginning with its previous element. Error: if \\spad{l} has no previous element. Note that \\axiom{next(previous(\\spad{l})) = \\spad{l}}.")) (|tail| (($ $) "\\spad{tail(l)} returns the doubly-linked aggregate \\spad{l} starting at its second element. Error: if \\spad{l} is empty.")) (|head| (($ $) "\\spad{head(l)} returns the first element of a doubly-linked aggregate \\spad{l}. Error: if \\spad{l} is empty.")) (|last| ((|#1| $) "\\spad{last(l)} returns the last element of a doubly-linked aggregate \\spad{l}. Error: if \\spad{l} is empty."))) -((-2982 . T)) +((|constructor| (NIL "A doubly-linked aggregate serves as a model for a doubly-linked list, that is, a list which can has links to both next and previous nodes and thus can be efficiently traversed in both directions.")) (|setnext!| (($ $ $) "\\spad{setnext!(u,v)} destructively sets the next node of doubly-linked aggregate \\spad{u} to \\spad{v,} returning \\spad{v.}")) (|setprevious!| (($ $ $) "\\spad{setprevious!(u,v)} destructively sets the previous node of doubly-linked aggregate \\spad{u} to \\spad{v,} returning \\spad{v.}")) (|concat!| (($ $ $) "\\spad{concat!(u,v)} destructively concatenates doubly-linked aggregate \\spad{v} to the end of doubly-linked aggregate u.")) (|next| (($ $) "\\spad{next(l)} returns the doubly-linked aggregate beginning with its next element. Error: if \\spad{l} has no next element. Note that \\axiom{next(l) = rest(l)} and \\axiom{previous(next(l)) = \\spad{l}.}")) (|previous| (($ $) "\\spad{previous(l)} returns the doubly-link list beginning with its previous element. Error: if \\spad{l} has no previous element. Note that \\axiom{next(previous(l)) = \\spad{l}.}")) (|tail| (($ $) "\\spad{tail(l)} returns the doubly-linked aggregate \\spad{l} starting at its second element. Error: if \\spad{l} is empty.")) (|head| (($ $) "\\spad{head(l)} returns the first element of a doubly-linked aggregate \\spad{l.} Error: if \\spad{l} is empty.")) (|last| ((|#1| $) "\\spad{last(l)} returns the last element of a doubly-linked aggregate \\spad{l.} Error: if \\spad{l} is empty."))) +((-4317 . T)) NIL (-241 S) -((|constructor| (NIL "This domain provides some nice functions on lists")) (|elt| (((|NonNegativeInteger|) $ "count") "\\axiom{\\spad{l}.\"count\"} returns the number of elements in \\axiom{\\spad{l}}.") (($ $ "sort") "\\axiom{\\spad{l}.sort} returns \\axiom{\\spad{l}} with elements sorted. Note: \\axiom{\\spad{l}.sort = sort(\\spad{l})}") (($ $ "unique") "\\axiom{\\spad{l}.unique} returns \\axiom{\\spad{l}} with duplicates removed. Note: \\axiom{\\spad{l}.unique = removeDuplicates(\\spad{l})}.")) (|datalist| (($ (|List| |#1|)) "\\spad{datalist(l)} creates a datalist from \\spad{l}")) (|coerce| (((|List| |#1|) $) "\\spad{coerce(x)} returns the list of elements in \\spad{x}") (($ (|List| |#1|)) "\\spad{coerce(l)} creates a datalist from \\spad{l}"))) -((-4536 . T) (-4535 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-843))) (-2232 (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#1| (QUOTE (-1091)))) (|HasCategory| (-569) (QUOTE (-843))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-843)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))))) +((|constructor| (NIL "This domain provides some nice functions on lists")) (|elt| (((|NonNegativeInteger|) $ "count") "\\axiom{l.\"count\"} returns the number of elements in \\axiom{l}.") (($ $ "sort") "\\axiom{l.sort} returns \\axiom{l} with elements sorted. Note: \\axiom{l.sort = sort(l)}") (($ $ "unique") "\\axiom{l.unique} returns \\axiom{l} with duplicates removed. Note: \\axiom{l.unique = removeDuplicates(l)}.")) (|datalist| (($ (|List| |#1|)) "\\spad{datalist(l)} creates a datalist from \\spad{l}")) (|coerce| (((|List| |#1|) $) "\\spad{coerce(x)} returns the list of elements in \\spad{x}") (($ (|List| |#1|)) "\\spad{coerce(l)} creates a datalist from \\spad{l}"))) +((-4572 . T) (-4571 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#1| (QUOTE (-844))) (-1929 (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#1| (QUOTE (-1093)))) (|HasCategory| (-569) (QUOTE (-844))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-844)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))))) (-242 M) -((|constructor| (NIL "DiscreteLogarithmPackage implements help functions for discrete logarithms in monoids using small cyclic groups.")) (|shanksDiscLogAlgorithm| (((|Union| (|NonNegativeInteger|) "failed") |#1| |#1| (|NonNegativeInteger|)) "\\spad{shanksDiscLogAlgorithm(b,{}a,{}p)} computes \\spad{s} with \\spad{b**s = a} for assuming that \\spad{a} and \\spad{b} are elements in a 'small' cyclic group of order \\spad{p} by Shank\\spad{'s} algorithm. Note that this is a subroutine of the function \\spadfun{discreteLog}.")) (** ((|#1| |#1| (|Integer|)) "\\spad{x ** n} returns \\spad{x} raised to the integer power \\spad{n}"))) +((|constructor| (NIL "DiscreteLogarithmPackage implements help functions for discrete logarithms in monoids using small cyclic groups.")) (|shanksDiscLogAlgorithm| (((|Union| (|NonNegativeInteger|) "failed") |#1| |#1| (|NonNegativeInteger|)) "\\spad{shanksDiscLogAlgorithm(b,a,p)} computes \\spad{s} with \\spad{b**s = a} for assuming that \\spad{a} and \\spad{b} are elements in a 'small' cyclic group of order \\spad{p} by Shank's algorithm. Note that this is a subroutine of the function \\spadfun{discreteLog}.")) (** ((|#1| |#1| (|Integer|)) "\\spad{x \\spad{**} \\spad{n}} returns \\spad{x} raised to the integer power \\spad{n}"))) NIL NIL (-243 |vl| R) -((|constructor| (NIL "This type supports distributed multivariate polynomials whose variables are from a user specified list of symbols. The coefficient ring may be non commutative,{} but the variables are assumed to commute. The term ordering is lexicographic specified by the variable list parameter with the most significant variable first in the list.")) (|reorder| (($ $ (|List| (|Integer|))) "\\spad{reorder(p,{} perm)} applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial"))) -(((-4537 "*") |has| |#2| (-173)) (-4528 |has| |#2| (-559)) (-4533 |has| |#2| (-6 -4533)) (-4530 . T) (-4529 . T) (-4532 . T)) -((|HasCategory| |#2| (QUOTE (-905))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-173))) (-2232 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-559)))) (-12 (|HasCategory| (-853 |#1|) (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| |#2| (LIST (QUOTE -882) (QUOTE (-382))))) (-12 (|HasCategory| (-853 |#1|) (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -882) (QUOTE (-569))))) (-12 (|HasCategory| (-853 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| |#2| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382)))))) (-12 (|HasCategory| (-853 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569)))))) (-12 (|HasCategory| (-853 |#1|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542))))) (|HasCategory| |#2| (QUOTE (-843))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-151))) (|HasCategory| |#2| (QUOTE (-149))) (|HasCategory| |#2| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-366))) (-2232 (|HasCategory| |#2| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (|HasAttribute| |#2| (QUOTE -4533)) (|HasCategory| |#2| (QUOTE (-454))) (-2232 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-905)))) (-2232 (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-905)))) (-2232 (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-905)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-905)))) (|HasCategory| |#2| (QUOTE (-149))))) +((|constructor| (NIL "This type supports distributed multivariate polynomials whose variables are from a user specified list of symbols. The coefficient ring may be non commutative, but the variables are assumed to commute. The term ordering is lexicographic specified by the variable list parameter with the most significant variable first in the list.")) (|reorder| (($ $ (|List| (|Integer|))) "\\spad{reorder(p, perm)} applies the permutation perm to the variables in a polynomial and returns the new correctly ordered polynomial"))) +(((-4573 "*") |has| |#2| (-173)) (-4564 |has| |#2| (-559)) (-4569 |has| |#2| (-6 -4569)) (-4566 . T) (-4565 . T) (-4568 . T)) +((|HasCategory| |#2| (QUOTE (-906))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-173))) (-1929 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-559)))) (-12 (|HasCategory| (-854 |#1|) (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| |#2| (LIST (QUOTE -883) (QUOTE (-382))))) (-12 (|HasCategory| (-854 |#1|) (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -883) (QUOTE (-569))))) (-12 (|HasCategory| (-854 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| |#2| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382)))))) (-12 (|HasCategory| (-854 |#1|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569)))))) (-12 (|HasCategory| (-854 |#1|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#2| (LIST (QUOTE -610) (QUOTE (-542))))) (|HasCategory| |#2| (QUOTE (-844))) (|HasCategory| |#2| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#2| (QUOTE (-151))) (|HasCategory| |#2| (QUOTE (-149))) (|HasCategory| |#2| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (QUOTE (-366))) (-1929 (|HasCategory| |#2| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#2| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (|HasAttribute| |#2| (QUOTE -4569)) (|HasCategory| |#2| (QUOTE (-454))) (-1929 (|HasCategory| |#2| (QUOTE (-173))) (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-906)))) (-1929 (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-559))) (|HasCategory| |#2| (QUOTE (-906)))) (-1929 (|HasCategory| |#2| (QUOTE (-454))) (|HasCategory| |#2| (QUOTE (-906)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#2| (QUOTE (-906)))) (|HasCategory| |#2| (QUOTE (-149))))) (-244 |n| R M S) ((|constructor| (NIL "This constructor provides a direct product type with a left matrix-module view."))) -((-4532 -2232 (-2206 (|has| |#4| (-1048)) (|has| |#4| (-226))) (-2206 (|has| |#4| (-1048)) (|has| |#4| (-896 (-1163)))) (|has| |#4| (-6 -4532)) (-2206 (|has| |#4| (-1048)) (|has| |#4| (-631 (-569))))) (-4529 |has| |#4| (-1048)) (-4530 |has| |#4| (-1048)) ((-4537 "*") |has| |#4| (-173)) (-4535 . T)) -((|HasCategory| |#4| (QUOTE (-366))) (|HasCategory| |#4| (QUOTE (-1048))) (|HasCategory| |#4| (QUOTE (-789))) (|HasCategory| |#4| (QUOTE (-841))) (-2232 (|HasCategory| |#4| (QUOTE (-789))) (|HasCategory| |#4| (QUOTE (-841)))) (|HasCategory| |#4| (QUOTE (-717))) (|HasCategory| |#4| (QUOTE (-173))) (-2232 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-366))) (|HasCategory| |#4| (QUOTE (-1048)))) (-2232 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-366)))) (-2232 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-1048)))) (|HasCategory| |#4| (QUOTE (-371))) (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (QUOTE (-226))) (-2232 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1048)))) (|HasCategory| |#4| (QUOTE (-1091))) (|HasCategory| (-569) (QUOTE (-843))) (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1048)))) (-2232 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1048)))) (|HasCategory| |#4| (QUOTE (-717)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-717)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-789)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-841)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1091))))) (-2232 (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1091)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-717)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-789)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-841)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1091))))) (-2232 (|HasAttribute| |#4| (QUOTE -4532)) (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1048))))) (|HasCategory| |#4| (QUOTE (-138))) (|HasCategory| |#4| (QUOTE (-25))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (LIST (QUOTE -896) (QUOTE (-1163))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-717)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-789)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-841)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1048)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1091)))))) +((-4568 -1929 (-3993 (|has| |#4| (-1049)) (|has| |#4| (-226))) (-3993 (|has| |#4| (-1049)) (|has| |#4| (-897 (-1165)))) (|has| |#4| (-6 -4568)) (-3993 (|has| |#4| (-1049)) (|has| |#4| (-631 (-569))))) (-4565 |has| |#4| (-1049)) (-4566 |has| |#4| (-1049)) ((-4573 "*") |has| |#4| (-173)) (-4571 . T)) +((|HasCategory| |#4| (QUOTE (-366))) (|HasCategory| |#4| (QUOTE (-1049))) (|HasCategory| |#4| (QUOTE (-790))) (|HasCategory| |#4| (QUOTE (-842))) (-1929 (|HasCategory| |#4| (QUOTE (-790))) (|HasCategory| |#4| (QUOTE (-842)))) (|HasCategory| |#4| (QUOTE (-718))) (|HasCategory| |#4| (QUOTE (-173))) (-1929 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-366))) (|HasCategory| |#4| (QUOTE (-1049)))) (-1929 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-366)))) (-1929 (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-1049)))) (|HasCategory| |#4| (QUOTE (-371))) (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (QUOTE (-226))) (-1929 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (QUOTE (-173))) (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1049)))) (|HasCategory| |#4| (QUOTE (-1093))) (|HasCategory| (-569) (QUOTE (-844))) (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1049)))) (-1929 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1049)))) (|HasCategory| |#4| (QUOTE (-718)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-718)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-790)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-842)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1093))))) (-1929 (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1093)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-718)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-790)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-842)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#4| (QUOTE (-1093))))) (-1929 (|HasAttribute| |#4| (QUOTE -4568)) (-12 (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (QUOTE (-226))) (|HasCategory| |#4| (QUOTE (-1049))))) (|HasCategory| |#4| (QUOTE (-138))) (|HasCategory| |#4| (QUOTE (-25))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (LIST (QUOTE -897) (QUOTE (-1165))))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-173)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-226)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-366)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-371)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-718)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-790)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-842)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1049)))) (-12 (|HasCategory| |#4| (LIST (QUOTE -304) (|devaluate| |#4|))) (|HasCategory| |#4| (QUOTE (-1093)))))) (-245 |n| R S) -((|constructor| (NIL "This constructor provides a direct product of \\spad{R}-modules with an \\spad{R}-module view."))) -((-4532 -2232 (-2206 (|has| |#3| (-1048)) (|has| |#3| (-226))) (-2206 (|has| |#3| (-1048)) (|has| |#3| (-896 (-1163)))) (|has| |#3| (-6 -4532)) (-2206 (|has| |#3| (-1048)) (|has| |#3| (-631 (-569))))) (-4529 |has| |#3| (-1048)) (-4530 |has| |#3| (-1048)) ((-4537 "*") |has| |#3| (-173)) (-4535 . T)) -((|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-1048))) (|HasCategory| |#3| (QUOTE (-789))) (|HasCategory| |#3| (QUOTE (-841))) (-2232 (|HasCategory| |#3| (QUOTE (-789))) (|HasCategory| |#3| (QUOTE (-841)))) (|HasCategory| |#3| (QUOTE (-717))) (|HasCategory| |#3| (QUOTE (-173))) (-2232 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-1048)))) (-2232 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-366)))) (-2232 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-1048)))) (|HasCategory| |#3| (QUOTE (-371))) (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (QUOTE (-226))) (-2232 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1048)))) (|HasCategory| |#3| (QUOTE (-1091))) (|HasCategory| (-569) (QUOTE (-843))) (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1048)))) (-2232 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1048)))) (|HasCategory| |#3| (QUOTE (-717)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-717)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-789)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-841)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1091))))) (-2232 (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1091)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-717)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-789)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-841)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1091))))) (-2232 (|HasAttribute| |#3| (QUOTE -4532)) (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1048))))) (|HasCategory| |#3| (QUOTE (-138))) (|HasCategory| |#3| (QUOTE (-25))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1091)))) (-2232 (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (LIST (QUOTE -896) (QUOTE (-1163))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-717)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-789)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-841)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1048)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1091)))))) +((|constructor| (NIL "This constructor provides a direct product of R-modules with an R-module view."))) +((-4568 -1929 (-3993 (|has| |#3| (-1049)) (|has| |#3| (-226))) (-3993 (|has| |#3| (-1049)) (|has| |#3| (-897 (-1165)))) (|has| |#3| (-6 -4568)) (-3993 (|has| |#3| (-1049)) (|has| |#3| (-631 (-569))))) (-4565 |has| |#3| (-1049)) (-4566 |has| |#3| (-1049)) ((-4573 "*") |has| |#3| (-173)) (-4571 . T)) +((|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-1049))) (|HasCategory| |#3| (QUOTE (-790))) (|HasCategory| |#3| (QUOTE (-842))) (-1929 (|HasCategory| |#3| (QUOTE (-790))) (|HasCategory| |#3| (QUOTE (-842)))) (|HasCategory| |#3| (QUOTE (-718))) (|HasCategory| |#3| (QUOTE (-173))) (-1929 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-366))) (|HasCategory| |#3| (QUOTE (-1049)))) (-1929 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-366)))) (-1929 (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-1049)))) (|HasCategory| |#3| (QUOTE (-371))) (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (QUOTE (-226))) (-1929 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (QUOTE (-173))) (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1049)))) (|HasCategory| |#3| (QUOTE (-1093))) (|HasCategory| (-569) (QUOTE (-844))) (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1049)))) (-1929 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1049)))) (|HasCategory| |#3| (QUOTE (-718)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-718)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-790)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-842)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1093))))) (-1929 (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1093)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-718)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-790)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-842)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#3| (QUOTE (-1093))))) (-1929 (|HasAttribute| |#3| (QUOTE -4568)) (-12 (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (QUOTE (-226))) (|HasCategory| |#3| (QUOTE (-1049))))) (|HasCategory| |#3| (QUOTE (-138))) (|HasCategory| |#3| (QUOTE (-25))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1093)))) (-1929 (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (LIST (QUOTE -631) (QUOTE (-569))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (LIST (QUOTE -897) (QUOTE (-1165))))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-173)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-226)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-366)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-371)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-718)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-790)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-842)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1049)))) (-12 (|HasCategory| |#3| (LIST (QUOTE -304) (|devaluate| |#3|))) (|HasCategory| |#3| (QUOTE (-1093)))))) (-246 A R S V E) -((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition,{} it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader},{} \\spadfun{initial},{} \\spadfun{separant},{} \\spadfun{differentialVariables},{} and \\spadfun{isobaric?}. Furthermore,{} if the ground ring is a differential ring,{} then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor,{} one needs to provide a ground ring \\spad{R},{} an ordered set \\spad{S} of differential indeterminates,{} a ranking \\spad{V} on the set of derivatives of the differential indeterminates,{} and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates.")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#4| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note that an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight,{} and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#3|) "\\spad{weight(p,{} s)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p}.")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#3|) "\\spad{weights(p,{} s)} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p}.")) (|degree| (((|NonNegativeInteger|) $ |#3|) "\\spad{degree(p,{} s)} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p},{} which is the maximum number of differentiations of a differential indeterminate,{} among all those appearing in \\spad{p}.") (((|NonNegativeInteger|) $ |#3|) "\\spad{order(p,{}s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s}.")) (|differentialVariables| (((|List| |#3|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p}.")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring,{} in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} \\spad{:=} makeVariable(\\spad{p}). Note that In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#3|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate,{} in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} :=makeVariable(\\spad{s}). Note that In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored."))) +((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition, it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader}, \\spadfun{initial}, \\spadfun{separant}, \\spadfun{differentialVariables}, and \\spadfun{isobaric?}. Furthermore, if the ground ring is a differential ring, then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor, one needs to provide a ground ring \\spad{R,} an ordered set \\spad{S} of differential indeterminates, a ranking \\spad{V} on the set of derivatives of the differential indeterminates, and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates.")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#4| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note that an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight, and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#3|) "\\spad{weight(p, \\spad{s)}} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p.}")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#3|) "\\spad{weights(p, \\spad{s)}} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p.}")) (|degree| (((|NonNegativeInteger|) $ |#3|) "\\spad{degree(p, \\spad{s)}} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p,} which is the maximum number of differentiations of a differential indeterminate, among all those appearing in \\spad{p.}") (((|NonNegativeInteger|) $ |#3|) "\\spad{order(p,s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s.}")) (|differentialVariables| (((|List| |#3|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p.}")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring, in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z.n} where \\spad{z} \\spad{:=} makeVariable(p). Note that In the interpreter, \\spad{z} is given as an internal map, which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#3|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate, in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z.n} where \\spad{z} :=makeVariable(s). Note that In the interpreter, \\spad{z} is given as an internal map, which may be ignored."))) NIL ((|HasCategory| |#2| (QUOTE (-226)))) (-247 R S V E) -((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition,{} it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader},{} \\spadfun{initial},{} \\spadfun{separant},{} \\spadfun{differentialVariables},{} and \\spadfun{isobaric?}. Furthermore,{} if the ground ring is a differential ring,{} then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor,{} one needs to provide a ground ring \\spad{R},{} an ordered set \\spad{S} of differential indeterminates,{} a ranking \\spad{V} on the set of derivatives of the differential indeterminates,{} and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates.")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#3| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note that an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight,{} and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#2|) "\\spad{weight(p,{} s)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p}.")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#2|) "\\spad{weights(p,{} s)} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p}.")) (|degree| (((|NonNegativeInteger|) $ |#2|) "\\spad{degree(p,{} s)} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p},{} which is the maximum number of differentiations of a differential indeterminate,{} among all those appearing in \\spad{p}.") (((|NonNegativeInteger|) $ |#2|) "\\spad{order(p,{}s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s}.")) (|differentialVariables| (((|List| |#2|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p}.")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring,{} in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} \\spad{:=} makeVariable(\\spad{p}). Note that In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#2|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate,{} in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z}.\\spad{n} where \\spad{z} :=makeVariable(\\spad{s}). Note that In the interpreter,{} \\spad{z} is given as an internal map,{} which may be ignored."))) -(((-4537 "*") |has| |#1| (-173)) (-4528 |has| |#1| (-559)) (-4533 |has| |#1| (-6 -4533)) (-4530 . T) (-4529 . T) (-4532 . T)) +((|constructor| (NIL "\\spadtype{DifferentialPolynomialCategory} is a category constructor specifying basic functions in an ordinary differential polynomial ring with a given ordered set of differential indeterminates. In addition, it implements defaults for the basic functions. The functions \\spadfun{order} and \\spadfun{weight} are extended from the set of derivatives of differential indeterminates to the set of differential polynomials. Other operations provided on differential polynomials are \\spadfun{leader}, \\spadfun{initial}, \\spadfun{separant}, \\spadfun{differentialVariables}, and \\spadfun{isobaric?}. Furthermore, if the ground ring is a differential ring, then evaluation (substitution of differential indeterminates by elements of the ground ring or by differential polynomials) is provided by \\spadfun{eval}. A convenient way of referencing derivatives is provided by the functions \\spadfun{makeVariable}. \\blankline To construct a domain using this constructor, one needs to provide a ground ring \\spad{R,} an ordered set \\spad{S} of differential indeterminates, a ranking \\spad{V} on the set of derivatives of the differential indeterminates, and a set \\spad{E} of exponents in bijection with the set of differential monomials in the given differential indeterminates.")) (|separant| (($ $) "\\spad{separant(p)} returns the partial derivative of the differential polynomial \\spad{p} with respect to its leader.")) (|initial| (($ $) "\\spad{initial(p)} returns the leading coefficient when the differential polynomial \\spad{p} is written as a univariate polynomial in its leader.")) (|leader| ((|#3| $) "\\spad{leader(p)} returns the derivative of the highest rank appearing in the differential polynomial \\spad{p} Note that an error occurs if \\spad{p} is in the ground ring.")) (|isobaric?| (((|Boolean|) $) "\\spad{isobaric?(p)} returns \\spad{true} if every differential monomial appearing in the differential polynomial \\spad{p} has same weight, and returns \\spad{false} otherwise.")) (|weight| (((|NonNegativeInteger|) $ |#2|) "\\spad{weight(p, \\spad{s)}} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|NonNegativeInteger|) $) "\\spad{weight(p)} returns the maximum weight of all differential monomials appearing in the differential polynomial \\spad{p.}")) (|weights| (((|List| (|NonNegativeInteger|)) $ |#2|) "\\spad{weights(p, \\spad{s)}} returns a list of weights of differential monomials appearing in the differential polynomial \\spad{p} when \\spad{p} is viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.") (((|List| (|NonNegativeInteger|)) $) "\\spad{weights(p)} returns a list of weights of differential monomials appearing in differential polynomial \\spad{p.}")) (|degree| (((|NonNegativeInteger|) $ |#2|) "\\spad{degree(p, \\spad{s)}} returns the maximum degree of the differential polynomial \\spad{p} viewed as a differential polynomial in the differential indeterminate \\spad{s} alone.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(p)} returns the order of the differential polynomial \\spad{p,} which is the maximum number of differentiations of a differential indeterminate, among all those appearing in \\spad{p.}") (((|NonNegativeInteger|) $ |#2|) "\\spad{order(p,s)} returns the order of the differential polynomial \\spad{p} in differential indeterminate \\spad{s.}")) (|differentialVariables| (((|List| |#2|) $) "\\spad{differentialVariables(p)} returns a list of differential indeterminates occurring in a differential polynomial \\spad{p.}")) (|makeVariable| (((|Mapping| $ (|NonNegativeInteger|)) $) "\\spad{makeVariable(p)} views \\spad{p} as an element of a differential ring, in such a way that the \\spad{n}-th derivative of \\spad{p} may be simply referenced as \\spad{z.n} where \\spad{z} \\spad{:=} makeVariable(p). Note that In the interpreter, \\spad{z} is given as an internal map, which may be ignored.") (((|Mapping| $ (|NonNegativeInteger|)) |#2|) "\\spad{makeVariable(s)} views \\spad{s} as a differential indeterminate, in such a way that the \\spad{n}-th derivative of \\spad{s} may be simply referenced as \\spad{z.n} where \\spad{z} :=makeVariable(s). Note that In the interpreter, \\spad{z} is given as an internal map, which may be ignored."))) +(((-4573 "*") |has| |#1| (-173)) (-4564 |has| |#1| (-559)) (-4569 |has| |#1| (-6 -4569)) (-4566 . T) (-4565 . T) (-4568 . T)) NIL (-248 S) -((|constructor| (NIL "A dequeue is a doubly ended stack,{} that is,{} a bag where first items inserted are the first items extracted,{} at either the front or the back end of the data structure.")) (|reverse!| (($ $) "\\spad{reverse!(d)} destructively replaces \\spad{d} by its reverse dequeue,{} \\spadignore{i.e.} the top (front) element is now the bottom (back) element,{} and so on.")) (|extractBottom!| ((|#1| $) "\\spad{extractBottom!(d)} destructively extracts the bottom (back) element from the dequeue \\spad{d}. Error: if \\spad{d} is empty.")) (|extractTop!| ((|#1| $) "\\spad{extractTop!(d)} destructively extracts the top (front) element from the dequeue \\spad{d}. Error: if \\spad{d} is empty.")) (|insertBottom!| ((|#1| |#1| $) "\\spad{insertBottom!(x,{}d)} destructively inserts \\spad{x} into the dequeue \\spad{d} at the bottom (back) of the dequeue.")) (|insertTop!| ((|#1| |#1| $) "\\spad{insertTop!(x,{}d)} destructively inserts \\spad{x} into the dequeue \\spad{d},{} that is,{} at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue,{} and so on.")) (|bottom!| ((|#1| $) "\\spad{bottom!(d)} returns the element at the bottom (back) of the dequeue.")) (|top!| ((|#1| $) "\\spad{top!(d)} returns the element at the top (front) of the dequeue.")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(d)} returns the number of elements in dequeue \\spad{d}. Note that \\axiom{height(\\spad{d}) = \\# \\spad{d}}.")) (|dequeue| (($ (|List| |#1|)) "\\spad{dequeue([x,{}y,{}...,{}z])} creates a dequeue with first (top or front) element \\spad{x},{} second element \\spad{y},{}...,{}and last (bottom or back) element \\spad{z}.") (($) "\\spad{dequeue()}\\$\\spad{D} creates an empty dequeue of type \\spad{D}."))) -((-4535 . T) (-4536 . T) (-2982 . T)) +((|constructor| (NIL "A dequeue is a doubly ended stack, that is, a bag where first items inserted are the first items extracted, at either the front or the back end of the data structure.")) (|reverse!| (($ $) "\\spad{reverse!(d)} destructively replaces \\spad{d} by its reverse dequeue, \\spadignore{i.e.} the top (front) element is now the bottom (back) element, and so on.")) (|extractBottom!| ((|#1| $) "\\spad{extractBottom!(d)} destructively extracts the bottom (back) element from the dequeue \\spad{d.} Error: if \\spad{d} is empty.")) (|extractTop!| ((|#1| $) "\\spad{extractTop!(d)} destructively extracts the top (front) element from the dequeue \\spad{d.} Error: if \\spad{d} is empty.")) (|insertBottom!| ((|#1| |#1| $) "\\spad{insertBottom!(x,d)} destructively inserts \\spad{x} into the dequeue \\spad{d} at the bottom (back) of the dequeue.")) (|insertTop!| ((|#1| |#1| $) "\\spad{insertTop!(x,d)} destructively inserts \\spad{x} into the dequeue \\spad{d,} that is, at the top (front) of the dequeue. The element previously at the top of the dequeue becomes the second in the dequeue, and so on.")) (|bottom!| ((|#1| $) "\\spad{bottom!(d)} returns the element at the bottom (back) of the dequeue.")) (|top!| ((|#1| $) "\\spad{top!(d)} returns the element at the top (front) of the dequeue.")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(d)} returns the number of elements in dequeue \\spad{d.} Note that \\axiom{height(d) = \\# \\spad{d}.}")) (|dequeue| (($ (|List| |#1|)) "\\spad{dequeue([x,y,...,z])} creates a dequeue with first (top or front) element \\spad{x,} second element y,...,and last (bottom or back) element \\spad{z.}") (($) "\\spad{dequeue()}$D creates an empty dequeue of type \\spad{D.}"))) +((-4571 . T) (-4572 . T) (-4317 . T)) NIL (-249) -((|constructor| (NIL "TopLevelDrawFunctionsForCompiledFunctions provides top level functions for drawing graphics of expressions.")) (|recolor| (((|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{recolor()},{} uninteresting to top level user; exported in order to compile package.")) (|makeObject| (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(surface(f,{}g,{}h),{}a..b,{}c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(surface(f,{}g,{}h),{}a..b,{}c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(f,{}a..b,{}c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{f(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f,{}a..b,{}c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{f(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(f,{}a..b,{}c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f,{}a..b,{}c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)},{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{makeObject(sp,{}curve(f,{}g,{}h),{}a..b)} returns the space \\spad{sp} of the domain \\spadtype{ThreeSpace} with the addition of the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f,{}g,{}h),{}a..b,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{makeObject(sp,{}curve(f,{}g,{}h),{}a..b)} returns the space \\spad{sp} of the domain \\spadtype{ThreeSpace} with the addition of the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f,{}g,{}h),{}a..b,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.")) (|draw| (((|ThreeDimensionalViewport|) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(surface(f,{}g,{}h),{}a..b,{}c..d)} draws the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}.") (((|ThreeDimensionalViewport|) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(surface(f,{}g,{}h),{}a..b,{}c..d)} draws the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(f,{}a..b,{}c..d)} draws the graph of the parametric surface \\spad{f(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)} The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,{}a..b,{}c..d)} draws the graph of the parametric surface \\spad{f(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(f,{}a..b,{}c..d)} draws the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}.") (((|ThreeDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,{}a..b,{}c..d,{}l)} draws the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}. and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{draw(f,{}a..b,{}l)} draws the graph of the parametric curve \\spad{f} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,{}a..b,{}l)} draws the graph of the parametric curve \\spad{f} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{draw(curve(f,{}g,{}h),{}a..b,{}l)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f,{}g,{}h),{}a..b,{}l)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t),{} z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{draw(curve(f,{}g),{}a..b)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f,{}g),{}a..b,{}l)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{draw(f,{}a..b)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}.") (((|TwoDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,{}a..b,{}l)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied."))) +((|constructor| (NIL "TopLevelDrawFunctionsForCompiledFunctions provides top level functions for drawing graphics of expressions.")) (|recolor| (((|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{recolor()}, uninteresting to top level user; exported in order to compile package.")) (|makeObject| (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(surface(f,g,h),a..b,c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(surface(f,g,h),a..b,c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(f,a..b,c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{f(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f,a..b,c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{f(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{makeObject(f,a..b,c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f,a..b,c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{makeObject(sp,curve(f,g,h),a..b)} returns the space \\spad{sp} of the domain \\spadtype{ThreeSpace} with the addition of the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|ThreeSpace| (|DoubleFloat|)) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f,g,h),a..b,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{makeObject(sp,curve(f,g,h),a..b)} returns the space \\spad{sp} of the domain \\spadtype{ThreeSpace} with the addition of the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f,g,h),a..b,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.")) (|draw| (((|ThreeDimensionalViewport|) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(surface(f,g,h),a..b,c..d)} draws the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}.") (((|ThreeDimensionalViewport|) (|ParametricSurface| (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(surface(f,g,h),a..b,c..d)} draws the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(f,a..b,c..d)} draws the graph of the parametric surface \\spad{f(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)} The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,a..b,c..d)} draws the graph of the parametric surface \\spad{f(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|))) "\\spad{draw(f,a..b,c..d)} draws the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}.") (((|ThreeDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,a..b,c..d,l)} draws the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}. and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{draw(f,a..b,l)} draws the graph of the parametric curve \\spad{f} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|ThreeDimensionalViewport|) (|Mapping| (|Point| (|DoubleFloat|)) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,a..b,l)} draws the graph of the parametric curve \\spad{f} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{draw(curve(f,g,h),a..b,l)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f,g,h),a..b,l)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t), \\spad{z} = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|))) "\\spad{draw(curve(f,g),a..b)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f,g),a..b,l)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|))) "\\spad{draw(f,a..b)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}.") (((|TwoDimensionalViewport|) (|Mapping| (|DoubleFloat|) (|DoubleFloat|)) (|Segment| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f,a..b,l)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied."))) NIL NIL (-250 R |Ex|) -((|constructor| (NIL "TopLevelDrawFunctionsForAlgebraicCurves provides top level functions for drawing non-singular algebraic curves.")) (|draw| (((|TwoDimensionalViewport|) (|Equation| |#2|) (|Symbol|) (|Symbol|) (|List| (|DrawOption|))) "\\spad{draw(f(x,{}y) = g(x,{}y),{}x,{}y,{}l)} draws the graph of a polynomial equation. The list \\spad{l} of draw options must specify a region in the plane in which the curve is to sketched."))) +((|constructor| (NIL "TopLevelDrawFunctionsForAlgebraicCurves provides top level functions for drawing non-singular algebraic curves.")) (|draw| (((|TwoDimensionalViewport|) (|Equation| |#2|) (|Symbol|) (|Symbol|) (|List| (|DrawOption|))) "\\spad{draw(f(x,y) = g(x,y),x,y,l)} draws the graph of a polynomial equation. The list \\spad{l} of draw options must specify a region in the plane in which the curve is to sketched."))) NIL NIL (-251) -((|constructor| (NIL "\\axiomType{DrawComplex} provides some facilities for drawing complex functions.")) (|setClipValue| (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{setClipValue(x)} sets to \\spad{x} the maximum value to plot when drawing complex functions. Returns \\spad{x}.")) (|setImagSteps| (((|Integer|) (|Integer|)) "\\spad{setImagSteps(i)} sets to \\spad{i} the number of steps to use in the imaginary direction when drawing complex functions. Returns \\spad{i}.")) (|setRealSteps| (((|Integer|) (|Integer|)) "\\spad{setRealSteps(i)} sets to \\spad{i} the number of steps to use in the real direction when drawing complex functions. Returns \\spad{i}.")) (|drawComplexVectorField| (((|ThreeDimensionalViewport|) (|Mapping| (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) (|Segment| (|DoubleFloat|)) (|Segment| (|DoubleFloat|))) "\\spad{drawComplexVectorField(f,{}rRange,{}iRange)} draws a complex vector field using arrows on the \\spad{x--y} plane. These vector fields should be viewed from the top by pressing the \"XY\" translate button on the 3-\\spad{d} viewport control panel. Sample call: \\indented{3}{\\spad{f z == sin z}} \\indented{3}{\\spad{drawComplexVectorField(f,{} -2..2,{} -2..2)}} Parameter descriptions: \\indented{2}{\\spad{f} : the function to draw} \\indented{2}{\\spad{rRange} : the range of the real values} \\indented{2}{\\spad{iRange} : the range of the imaginary values} Call the functions \\axiomFunFrom{setRealSteps}{DrawComplex} and \\axiomFunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction.")) (|drawComplex| (((|ThreeDimensionalViewport|) (|Mapping| (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) (|Segment| (|DoubleFloat|)) (|Segment| (|DoubleFloat|)) (|Boolean|)) "\\spad{drawComplex(f,{}rRange,{}iRange,{}arrows?)} draws a complex function as a height field. It uses the complex norm as the height and the complex argument as the color. It will optionally draw arrows on the surface indicating the direction of the complex value. Sample call: \\indented{2}{\\spad{f z == exp(1/z)}} \\indented{2}{\\spad{drawComplex(f,{} 0.3..3,{} 0..2*\\%\\spad{pi},{} false)}} Parameter descriptions: \\indented{2}{\\spad{f:}\\space{2}the function to draw} \\indented{2}{\\spad{rRange} : the range of the real values} \\indented{2}{\\spad{iRange} : the range of imaginary values} \\indented{2}{\\spad{arrows?} : a flag indicating whether to draw the phase arrows for \\spad{f}} Call the functions \\axiomFunFrom{setRealSteps}{DrawComplex} and \\axiomFunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction."))) +((|constructor| (NIL "\\axiomType{DrawComplex} provides some facilities for drawing complex functions.")) (|setClipValue| (((|DoubleFloat|) (|DoubleFloat|)) "\\spad{setClipValue(x)} sets to \\spad{x} the maximum value to plot when drawing complex functions. Returns \\spad{x.}")) (|setImagSteps| (((|Integer|) (|Integer|)) "\\spad{setImagSteps(i)} sets to \\spad{i} the number of steps to use in the imaginary direction when drawing complex functions. Returns i.")) (|setRealSteps| (((|Integer|) (|Integer|)) "\\spad{setRealSteps(i)} sets to \\spad{i} the number of steps to use in the real direction when drawing complex functions. Returns i.")) (|drawComplexVectorField| (((|ThreeDimensionalViewport|) (|Mapping| (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) (|Segment| (|DoubleFloat|)) (|Segment| (|DoubleFloat|))) "\\spad{drawComplexVectorField(f,rRange,iRange)} draws a complex vector field using arrows on the \\spad{x--y} plane. These vector fields should be viewed from the top by pressing the \"XY\" translate button on the 3-d viewport control panel. Sample call: \\indented{3}{\\spad{f \\spad{z} \\spad{==} sin \\spad{z}}} \\indented{3}{\\spad{drawComplexVectorField(f, -2..2, -2..2)}} Parameter descriptions: \\indented{2}{f : the function to draw} \\indented{2}{rRange : the range of the real values} \\indented{2}{iRange : the range of the imaginary values} Call the functions \\axiomFunFrom{setRealSteps}{DrawComplex} and \\axiomFunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction.")) (|drawComplex| (((|ThreeDimensionalViewport|) (|Mapping| (|Complex| (|DoubleFloat|)) (|Complex| (|DoubleFloat|))) (|Segment| (|DoubleFloat|)) (|Segment| (|DoubleFloat|)) (|Boolean|)) "\\spad{drawComplex(f,rRange,iRange,arrows?)} draws a complex function as a height field. It uses the complex norm as the height and the complex argument as the color. It will optionally draw arrows on the surface indicating the direction of the complex value. Sample call: \\indented{2}{\\spad{f \\spad{z} \\spad{==} exp(1/z)}} \\indented{2}{\\spad{drawComplex(f, 0.3..3, 0..2*%pi, false)}} Parameter descriptions: \\indented{2}{f:\\space{2}the function to draw} \\indented{2}{rRange : the range of the real values} \\indented{2}{iRange : the range of imaginary values} \\indented{2}{arrows? : a flag indicating whether to draw the phase arrows for \\spad{f}} Call the functions \\axiomFunFrom{setRealSteps}{DrawComplex} and \\axiomFunFrom{setImagSteps}{DrawComplex} to change the number of steps used in each direction."))) NIL NIL (-252 R) -((|constructor| (NIL "Hack for the draw interface. DrawNumericHack provides a \"coercion\" from something of the form \\spad{x = a..b} where \\spad{a} and \\spad{b} are formal expressions to a binding of the form \\spad{x = c..d} where \\spad{c} and \\spad{d} are the numerical values of \\spad{a} and \\spad{b}. This \"coercion\" fails if \\spad{a} and \\spad{b} contains symbolic variables,{} but is meant for expressions involving \\%\\spad{pi}. Note that this package is meant for internal use only.")) (|coerce| (((|SegmentBinding| (|Float|)) (|SegmentBinding| (|Expression| |#1|))) "\\spad{coerce(x = a..b)} returns \\spad{x = c..d} where \\spad{c} and \\spad{d} are the numerical values of \\spad{a} and \\spad{b}."))) +((|constructor| (NIL "Hack for the draw interface. DrawNumericHack provides a \"coercion\" from something of the form \\spad{x = a..b} where \\spad{a} and \\spad{b} are formal expressions to a binding of the form \\spad{x = c..d} where \\spad{c} and \\spad{d} are the numerical values of \\spad{a} and \\spad{b.} This \"coercion\" fails if \\spad{a} and \\spad{b} contains symbolic variables, but is meant for expressions involving \\%pi. Note that this package is meant for internal use only.")) (|coerce| (((|SegmentBinding| (|Float|)) (|SegmentBinding| (|Expression| |#1|))) "\\spad{coerce(x = a..b)} returns \\spad{x = c..d} where \\spad{c} and \\spad{d} are the numerical values of \\spad{a} and \\spad{b.}"))) NIL NIL (-253 |Ex|) -((|constructor| (NIL "TopLevelDrawFunctions provides top level functions for drawing graphics of expressions.")) (|makeObject| (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{makeObject(surface(f(u,{}v),{}g(u,{}v),{}h(u,{}v)),{}u = a..b,{}v = c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{h(t)} is the default title.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(surface(f(u,{}v),{}g(u,{}v),{}h(u,{}v)),{}u = a..b,{}v = c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{h(t)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{makeObject(f(x,{}y),{}x = a..b,{}y = c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{f(x,{}y)} appears as the default title.") (((|ThreeSpace| (|DoubleFloat|)) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f(x,{}y),{}x = a..b,{}y = c..d,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{f(x,{}y)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{makeObject(curve(f(t),{}g(t),{}h(t)),{}t = a..b)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)},{} \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{h(t)} is the default title.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f(t),{}g(t),{}h(t)),{}t = a..b,{}l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)},{} \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{h(t)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.")) (|draw| (((|ThreeDimensionalViewport|) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{draw(surface(f(u,{}v),{}g(u,{}v),{}h(u,{}v)),{}u = a..b,{}v = c..d)} draws the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{h(t)} is the default title.") (((|ThreeDimensionalViewport|) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(surface(f(u,{}v),{}g(u,{}v),{}h(u,{}v)),{}u = a..b,{}v = c..d,{}l)} draws the graph of the parametric surface \\spad{x = f(u,{}v)},{} \\spad{y = g(u,{}v)},{} \\spad{z = h(u,{}v)} as \\spad{u} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{v} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{h(t)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{draw(f(x,{}y),{}x = a..b,{}y = c..d)} draws the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{f(x,{}y)} appears in the title bar.") (((|ThreeDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f(x,{}y),{}x = a..b,{}y = c..d,{}l)} draws the graph of \\spad{z = f(x,{}y)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)} and \\spad{y} ranges from \\spad{min(c,{}d)} to \\spad{max(c,{}d)}; \\spad{f(x,{}y)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{draw(curve(f(t),{}g(t),{}h(t)),{}t = a..b)} draws the graph of the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)},{} \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{h(t)} is the default title.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f(t),{}g(t),{}h(t)),{}t = a..b,{}l)} draws the graph of the parametric curve \\spad{x = f(t)},{} \\spad{y = g(t)},{} \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{h(t)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{draw(curve(f(t),{}g(t)),{}t = a..b)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{(f(t),{}g(t))} appears in the title bar.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f(t),{}g(t)),{}t = a..b,{}l)} draws the graph of the parametric curve \\spad{x = f(t),{} y = g(t)} as \\spad{t} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{(f(t),{}g(t))} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) |#1| (|SegmentBinding| (|Float|))) "\\spad{draw(f(x),{}x = a..b)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{f(x)} appears in the title bar.") (((|TwoDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f(x),{}x = a..b,{}l)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,{}b)} to \\spad{max(a,{}b)}; \\spad{f(x)} is the default title,{} and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied."))) +((|constructor| (NIL "TopLevelDrawFunctions provides top level functions for drawing graphics of expressions.")) (|makeObject| (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{makeObject(surface(f(u,v),g(u,v),h(u,v)),u = a..b,v = c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{h(t)} is the default title.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(surface(f(u,v),g(u,v),h(u,v)),u = a..b,v = c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{h(t)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{makeObject(f(x,y),x = a..b,y = c..d)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{f(x,y)} appears as the default title.") (((|ThreeSpace| (|DoubleFloat|)) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(f(x,y),x = a..b,y = c..d,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{f(x,y)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{makeObject(curve(f(t),g(t),h(t)),t = a..b)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t)}, \\spad{y = g(t)}, \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{h(t)} is the default title.") (((|ThreeSpace| (|DoubleFloat|)) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{makeObject(curve(f(t),g(t),h(t)),t = a..b,l)} returns a space of the domain \\spadtype{ThreeSpace} which contains the graph of the parametric curve \\spad{x = f(t)}, \\spad{y = g(t)}, \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{h(t)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.")) (|draw| (((|ThreeDimensionalViewport|) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{draw(surface(f(u,v),g(u,v),h(u,v)),u = a..b,v = c..d)} draws the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{h(t)} is the default title.") (((|ThreeDimensionalViewport|) (|ParametricSurface| |#1|) (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(surface(f(u,v),g(u,v),h(u,v)),u = a..b,v = c..d,l)} draws the graph of the parametric surface \\spad{x = f(u,v)}, \\spad{y = g(u,v)}, \\spad{z = h(u,v)} as \\spad{u} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{v} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{h(t)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|))) "\\spad{draw(f(x,y),x = a..b,y = c..d)} draws the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{f(x,y)} appears in the title bar.") (((|ThreeDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f(x,y),x = a..b,y = c..d,l)} draws the graph of \\spad{z = f(x,y)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)} and \\spad{y} ranges from \\spad{min(c,d)} to \\spad{max(c,d)}; \\spad{f(x,y)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{draw(curve(f(t),g(t),h(t)),t = a..b)} draws the graph of the parametric curve \\spad{x = f(t)}, \\spad{y = g(t)}, \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{h(t)} is the default title.") (((|ThreeDimensionalViewport|) (|ParametricSpaceCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f(t),g(t),h(t)),t = a..b,l)} draws the graph of the parametric curve \\spad{x = f(t)}, \\spad{y = g(t)}, \\spad{z = h(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{h(t)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| |#1|) (|SegmentBinding| (|Float|))) "\\spad{draw(curve(f(t),g(t)),t = a..b)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{(f(t),g(t))} appears in the title bar.") (((|TwoDimensionalViewport|) (|ParametricPlaneCurve| |#1|) (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(curve(f(t),g(t)),t = a..b,l)} draws the graph of the parametric curve \\spad{x = f(t), \\spad{y} = g(t)} as \\spad{t} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{(f(t),g(t))} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) |#1| (|SegmentBinding| (|Float|))) "\\spad{draw(f(x),x = a..b)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{f(x)} appears in the title bar.") (((|TwoDimensionalViewport|) |#1| (|SegmentBinding| (|Float|)) (|List| (|DrawOption|))) "\\spad{draw(f(x),x = a..b,l)} draws the graph of \\spad{y = f(x)} as \\spad{x} ranges from \\spad{min(a,b)} to \\spad{max(a,b)}; \\spad{f(x)} is the default title, and the options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied."))) NIL NIL (-254) -((|constructor| (NIL "TopLevelDrawFunctionsForPoints provides top level functions for drawing curves and surfaces described by sets of points.")) (|draw| (((|ThreeDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{draw(lx,{}ly,{}lz,{}l)} draws the surface constructed by projecting the values in the \\axiom{\\spad{lz}} list onto the rectangular grid formed by the The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|))) "\\spad{draw(lx,{}ly,{}lz)} draws the surface constructed by projecting the values in the \\axiom{\\spad{lz}} list onto the rectangular grid formed by the \\axiom{\\spad{lx} \\spad{x} \\spad{ly}}.") (((|TwoDimensionalViewport|) (|List| (|Point| (|DoubleFloat|))) (|List| (|DrawOption|))) "\\spad{draw(lp,{}l)} plots the curve constructed from the list of points \\spad{lp}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|List| (|Point| (|DoubleFloat|)))) "\\spad{draw(lp)} plots the curve constructed from the list of points \\spad{lp}.") (((|TwoDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{draw(lx,{}ly,{}l)} plots the curve constructed of points (\\spad{x},{}\\spad{y}) for \\spad{x} in \\spad{lx} for \\spad{y} in \\spad{ly}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|))) "\\spad{draw(lx,{}ly)} plots the curve constructed of points (\\spad{x},{}\\spad{y}) for \\spad{x} in \\spad{lx} for \\spad{y} in \\spad{ly}."))) +((|constructor| (NIL "TopLevelDrawFunctionsForPoints provides top level functions for drawing curves and surfaces described by sets of points.")) (|draw| (((|ThreeDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{draw(lx,ly,lz,l)} draws the surface constructed by projecting the values in the \\axiom{lz} list onto the rectangular grid formed by the The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|ThreeDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|))) "\\spad{draw(lx,ly,lz)} draws the surface constructed by projecting the values in the \\axiom{lz} list onto the rectangular grid formed by the \\axiom{lx \\spad{x} ly}.") (((|TwoDimensionalViewport|) (|List| (|Point| (|DoubleFloat|))) (|List| (|DrawOption|))) "\\spad{draw(lp,l)} plots the curve constructed from the list of points \\spad{lp.} The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|List| (|Point| (|DoubleFloat|)))) "\\spad{draw(lp)} plots the curve constructed from the list of points \\spad{lp.}") (((|TwoDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{draw(lx,ly,l)} plots the curve constructed of points (x,y) for \\spad{x} in \\spad{lx} for \\spad{y} in \\spad{ly}. The options contained in the list \\spad{l} of the domain \\spad{DrawOption} are applied.") (((|TwoDimensionalViewport|) (|List| (|DoubleFloat|)) (|List| (|DoubleFloat|))) "\\spad{draw(lx,ly)} plots the curve constructed of points (x,y) for \\spad{x} in \\spad{lx} for \\spad{y} in \\spad{ly}."))) NIL NIL (-255) -((|constructor| (NIL "This package has no description")) (|units| (((|List| (|Float|)) (|List| (|DrawOption|)) (|List| (|Float|))) "\\spad{units(l,{}u)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{unit}. If the option does not exist the value,{} \\spad{u} is returned.")) (|coord| (((|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|))) (|List| (|DrawOption|)) (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coord(l,{}p)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{coord}. If the option does not exist the value,{} \\spad{p} is returned.")) (|tubeRadius| (((|Float|) (|List| (|DrawOption|)) (|Float|)) "\\spad{tubeRadius(l,{}n)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{tubeRadius}. If the option does not exist the value,{} \\spad{n} is returned.")) (|tubePoints| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{tubePoints(l,{}n)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{tubePoints}. If the option does not exist the value,{} \\spad{n} is returned.")) (|space| (((|ThreeSpace| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{space(l)} takes a list of draw options,{} \\spad{l},{} and checks to see if it contains the option \\spad{space}. If the the option doesn\\spad{'t} exist,{} then an empty space is returned.")) (|var2Steps| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{var2Steps(l,{}n)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{var2Steps}. If the option does not exist the value,{} \\spad{n} is returned.")) (|var1Steps| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{var1Steps(l,{}n)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{var1Steps}. If the option does not exist the value,{} \\spad{n} is returned.")) (|ranges| (((|List| (|Segment| (|Float|))) (|List| (|DrawOption|)) (|List| (|Segment| (|Float|)))) "\\spad{ranges(l,{}r)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{ranges}. If the option does not exist the value,{} \\spad{r} is returned.")) (|curveColorPalette| (((|Palette|) (|List| (|DrawOption|)) (|Palette|)) "\\spad{curveColorPalette(l,{}p)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{curveColorPalette}. If the option does not exist the value,{} \\spad{p} is returned.")) (|pointColorPalette| (((|Palette|) (|List| (|DrawOption|)) (|Palette|)) "\\spad{pointColorPalette(l,{}p)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{pointColorPalette}. If the option does not exist the value,{} \\spad{p} is returned.")) (|toScale| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{toScale(l,{}b)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{toScale}. If the option does not exist the value,{} \\spad{b} is returned.")) (|style| (((|String|) (|List| (|DrawOption|)) (|String|)) "\\spad{style(l,{}s)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{style}. If the option does not exist the value,{} \\spad{s} is returned.")) (|title| (((|String|) (|List| (|DrawOption|)) (|String|)) "\\spad{title(l,{}s)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{title}. If the option does not exist the value,{} \\spad{s} is returned.")) (|viewpoint| (((|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|))) (|List| (|DrawOption|)) (|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)))) "\\spad{viewpoint(l,{}ls)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{viewpoint}. IF the option does not exist,{} the value \\spad{ls} is returned.")) (|clipBoolean| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{clipBoolean(l,{}b)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{clipBoolean}. If the option does not exist the value,{} \\spad{b} is returned.")) (|adaptive| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{adaptive(l,{}b)} takes the list of draw options,{} \\spad{l},{} and checks the list to see if it contains the option \\spad{adaptive}. If the option does not exist the value,{} \\spad{b} is returned."))) +((|constructor| (NIL "This package has no description")) (|units| (((|List| (|Float|)) (|List| (|DrawOption|)) (|List| (|Float|))) "\\spad{units(l,u)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{unit}. If the option does not exist the value, \\spad{u} is returned.")) (|coord| (((|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|))) (|List| (|DrawOption|)) (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coord(l,p)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{coord}. If the option does not exist the value, \\spad{p} is returned.")) (|tubeRadius| (((|Float|) (|List| (|DrawOption|)) (|Float|)) "\\spad{tubeRadius(l,n)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{tubeRadius}. If the option does not exist the value, \\spad{n} is returned.")) (|tubePoints| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{tubePoints(l,n)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{tubePoints}. If the option does not exist the value, \\spad{n} is returned.")) (|space| (((|ThreeSpace| (|DoubleFloat|)) (|List| (|DrawOption|))) "\\spad{space(l)} takes a list of draw options, \\spad{l,} and checks to see if it contains the option \\spad{space}. If the the option doesn't exist, then an empty space is returned.")) (|var2Steps| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{var2Steps(l,n)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{var2Steps}. If the option does not exist the value, \\spad{n} is returned.")) (|var1Steps| (((|PositiveInteger|) (|List| (|DrawOption|)) (|PositiveInteger|)) "\\spad{var1Steps(l,n)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{var1Steps}. If the option does not exist the value, \\spad{n} is returned.")) (|ranges| (((|List| (|Segment| (|Float|))) (|List| (|DrawOption|)) (|List| (|Segment| (|Float|)))) "\\spad{ranges(l,r)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{ranges}. If the option does not exist the value, \\spad{r} is returned.")) (|curveColorPalette| (((|Palette|) (|List| (|DrawOption|)) (|Palette|)) "\\spad{curveColorPalette(l,p)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{curveColorPalette}. If the option does not exist the value, \\spad{p} is returned.")) (|pointColorPalette| (((|Palette|) (|List| (|DrawOption|)) (|Palette|)) "\\spad{pointColorPalette(l,p)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{pointColorPalette}. If the option does not exist the value, \\spad{p} is returned.")) (|toScale| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{toScale(l,b)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{toScale}. If the option does not exist the value, \\spad{b} is returned.")) (|style| (((|String|) (|List| (|DrawOption|)) (|String|)) "\\spad{style(l,s)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{style}. If the option does not exist the value, \\spad{s} is returned.")) (|title| (((|String|) (|List| (|DrawOption|)) (|String|)) "\\spad{title(l,s)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{title}. If the option does not exist the value, \\spad{s} is returned.")) (|viewpoint| (((|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|))) (|List| (|DrawOption|)) (|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)))) "\\spad{viewpoint(l,ls)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{viewpoint}. IF the option does not exist, the value \\spad{ls} is returned.")) (|clipBoolean| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{clipBoolean(l,b)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{clipBoolean}. If the option does not exist the value, \\spad{b} is returned.")) (|adaptive| (((|Boolean|) (|List| (|DrawOption|)) (|Boolean|)) "\\spad{adaptive(l,b)} takes the list of draw options, \\spad{l,} and checks the list to see if it contains the option \\spad{adaptive}. If the option does not exist the value, \\spad{b} is returned."))) NIL NIL (-256 S) -((|constructor| (NIL "This package has no description")) (|option| (((|Union| |#1| "failed") (|List| (|DrawOption|)) (|Symbol|)) "\\spad{option(l,{}s)} determines whether the indicated drawing option,{} \\spad{s},{} is contained in the list of drawing options,{} \\spad{l},{} which is defined by the draw command."))) +((|constructor| (NIL "This package has no description")) (|option| (((|Union| |#1| "failed") (|List| (|DrawOption|)) (|Symbol|)) "\\spad{option(l,s)} determines whether the indicated drawing option, \\spad{s,} is contained in the list of drawing options, \\spad{l,} which is defined by the draw command."))) NIL NIL (-257) -((|constructor| (NIL "DrawOption allows the user to specify defaults for the creation and rendering of plots.")) (|option?| (((|Boolean|) (|List| $) (|Symbol|)) "\\spad{option?()} is not to be used at the top level; option? internally returns \\spad{true} for drawing options which are indicated in a draw command,{} or \\spad{false} for those which are not.")) (|option| (((|Union| (|Any|) "failed") (|List| $) (|Symbol|)) "\\spad{option()} is not to be used at the top level; option determines internally which drawing options are indicated in a draw command.")) (|unit| (($ (|List| (|Float|))) "\\spad{unit(lf)} will mark off the units according to the indicated list \\spad{lf}. This option is expressed in the form \\spad{unit == [f1,{}f2]}.")) (|coord| (($ (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coord(p)} specifies a change of coordinates of point \\spad{p}. This option is expressed in the form \\spad{coord == p}.")) (|tubePoints| (($ (|PositiveInteger|)) "\\spad{tubePoints(n)} specifies the number of points,{} \\spad{n},{} defining the circle which creates the tube around a 3D curve,{} the default is 6. This option is expressed in the form \\spad{tubePoints == n}.")) (|var2Steps| (($ (|PositiveInteger|)) "\\spad{var2Steps(n)} indicates the number of subdivisions,{} \\spad{n},{} of the second range variable. This option is expressed in the form \\spad{var2Steps == n}.")) (|var1Steps| (($ (|PositiveInteger|)) "\\spad{var1Steps(n)} indicates the number of subdivisions,{} \\spad{n},{} of the first range variable. This option is expressed in the form \\spad{var1Steps == n}.")) (|space| (($ (|ThreeSpace| (|DoubleFloat|))) "\\spad{space specifies} the space into which we will draw. If none is given then a new space is created.")) (|ranges| (($ (|List| (|Segment| (|Float|)))) "\\spad{ranges(l)} provides a list of user-specified ranges \\spad{l}. This option is expressed in the form \\spad{ranges == l}.")) (|range| (($ (|List| (|Segment| (|Fraction| (|Integer|))))) "\\spad{range([i])} provides a user-specified range \\spad{i}. This option is expressed in the form \\spad{range == [i]}.") (($ (|List| (|Segment| (|Float|)))) "\\spad{range([l])} provides a user-specified range \\spad{l}. This option is expressed in the form \\spad{range == [l]}.")) (|tubeRadius| (($ (|Float|)) "\\spad{tubeRadius(r)} specifies a radius,{} \\spad{r},{} for a tube plot around a 3D curve; is expressed in the form \\spad{tubeRadius == 4}.")) (|colorFunction| (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(x,{}y,{}z))} specifies the color for three dimensional plots as a function of \\spad{x},{} \\spad{y},{} and \\spad{z} coordinates. This option is expressed in the form \\spad{colorFunction == f(x,{}y,{}z)}.") (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(u,{}v))} specifies the color for three dimensional plots as a function based upon the two parametric variables. This option is expressed in the form \\spad{colorFunction == f(u,{}v)}.") (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(z))} specifies the color based upon the \\spad{z}-component of three dimensional plots. This option is expressed in the form \\spad{colorFunction == f(z)}.")) (|curveColor| (($ (|Palette|)) "\\spad{curveColor(p)} specifies a color index for 2D graph curves from the spadcolors palette \\spad{p}. This option is expressed in the form \\spad{curveColor ==p}.") (($ (|Float|)) "\\spad{curveColor(v)} specifies a color,{} \\spad{v},{} for 2D graph curves. This option is expressed in the form \\spad{curveColor == v}.")) (|pointColor| (($ (|Palette|)) "\\spad{pointColor(p)} specifies a color index for 2D graph points from the spadcolors palette \\spad{p}. This option is expressed in the form \\spad{pointColor == p}.") (($ (|Float|)) "\\spad{pointColor(v)} specifies a color,{} \\spad{v},{} for 2D graph points. This option is expressed in the form \\spad{pointColor == v}.")) (|coordinates| (($ (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coordinates(p)} specifies a change of coordinate systems of point \\spad{p}. This option is expressed in the form \\spad{coordinates == p}.")) (|toScale| (($ (|Boolean|)) "\\spad{toScale(b)} specifies whether or not a plot is to be drawn to scale; if \\spad{b} is \\spad{true} it is drawn to scale,{} if \\spad{b} is \\spad{false} it is not. This option is expressed in the form \\spad{toScale == b}.")) (|style| (($ (|String|)) "\\spad{style(s)} specifies the drawing style in which the graph will be plotted by the indicated string \\spad{s}. This option is expressed in the form \\spad{style == s}.")) (|title| (($ (|String|)) "\\spad{title(s)} specifies a title for a plot by the indicated string \\spad{s}. This option is expressed in the form \\spad{title == s}.")) (|viewpoint| (($ (|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)))) "\\spad{viewpoint(vp)} creates a viewpoint data structure corresponding to the list of values. The values are interpreted as [theta,{} phi,{} scale,{} scaleX,{} scaleY,{} scaleZ,{} deltaX,{} deltaY]. This option is expressed in the form \\spad{viewpoint == ls}.")) (|clip| (($ (|List| (|Segment| (|Float|)))) "\\spad{clip([l])} provides ranges for user-defined clipping as specified in the list \\spad{l}. This option is expressed in the form \\spad{clip == [l]}.") (($ (|Boolean|)) "\\spad{clip(b)} turns 2D clipping on if \\spad{b} is \\spad{true},{} or off if \\spad{b} is \\spad{false}. This option is expressed in the form \\spad{clip == b}.")) (|adaptive| (($ (|Boolean|)) "\\spad{adaptive(b)} turns adaptive 2D plotting on if \\spad{b} is \\spad{true},{} or off if \\spad{b} is \\spad{false}. This option is expressed in the form \\spad{adaptive == b}."))) +((|constructor| (NIL "DrawOption allows the user to specify defaults for the creation and rendering of plots.")) (|option?| (((|Boolean|) (|List| $) (|Symbol|)) "\\spad{option?()} is not to be used at the top level; option? internally returns \\spad{true} for drawing options which are indicated in a draw command, or \\spad{false} for those which are not.")) (|option| (((|Union| (|Any|) "failed") (|List| $) (|Symbol|)) "\\spad{option()} is not to be used at the top level; option determines internally which drawing options are indicated in a draw command.")) (|unit| (($ (|List| (|Float|))) "\\spad{unit(lf)} will mark off the units according to the indicated list \\spad{lf.} This option is expressed in the form \\spad{unit \\spad{==} [f1,f2]}.")) (|coord| (($ (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coord(p)} specifies a change of coordinates of point \\spad{p.} This option is expressed in the form \\spad{coord \\spad{==} \\spad{p}.}")) (|tubePoints| (($ (|PositiveInteger|)) "\\spad{tubePoints(n)} specifies the number of points, \\spad{n,} defining the circle which creates the tube around a 3D curve, the default is 6. This option is expressed in the form \\spad{tubePoints \\spad{==} \\spad{n}.}")) (|var2Steps| (($ (|PositiveInteger|)) "\\spad{var2Steps(n)} indicates the number of subdivisions, \\spad{n,} of the second range variable. This option is expressed in the form \\spad{var2Steps \\spad{==} \\spad{n}.}")) (|var1Steps| (($ (|PositiveInteger|)) "\\spad{var1Steps(n)} indicates the number of subdivisions, \\spad{n,} of the first range variable. This option is expressed in the form \\spad{var1Steps \\spad{==} \\spad{n}.}")) (|space| (($ (|ThreeSpace| (|DoubleFloat|))) "\\spad{space specifies} the space into which we will draw. If none is given then a new space is created.")) (|ranges| (($ (|List| (|Segment| (|Float|)))) "\\spad{ranges(l)} provides a list of user-specified ranges \\spad{l.} This option is expressed in the form \\spad{ranges \\spad{==} \\spad{l}.}")) (|range| (($ (|List| (|Segment| (|Fraction| (|Integer|))))) "\\spad{range([i])} provides a user-specified range i. This option is expressed in the form \\spad{range \\spad{==} [i]}.") (($ (|List| (|Segment| (|Float|)))) "\\spad{range([l])} provides a user-specified range \\spad{l.} This option is expressed in the form \\spad{range \\spad{==} [l]}.")) (|tubeRadius| (($ (|Float|)) "\\spad{tubeRadius(r)} specifies a radius, \\spad{r,} for a tube plot around a 3D curve; is expressed in the form \\spad{tubeRadius \\spad{==} 4}.")) (|colorFunction| (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(x,y,z))} specifies the color for three dimensional plots as a function of \\spad{x,} \\spad{y,} and \\spad{z} coordinates. This option is expressed in the form \\spad{colorFunction \\spad{==} f(x,y,z)}.") (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(u,v))} specifies the color for three dimensional plots as a function based upon the two parametric variables. This option is expressed in the form \\spad{colorFunction \\spad{==} f(u,v)}.") (($ (|Mapping| (|DoubleFloat|) (|DoubleFloat|))) "\\spad{colorFunction(f(z))} specifies the color based upon the z-component of three dimensional plots. This option is expressed in the form \\spad{colorFunction \\spad{==} f(z)}.")) (|curveColor| (($ (|Palette|)) "\\spad{curveColor(p)} specifies a color index for 2D graph curves from the spadcolors palette \\spad{p.} This option is expressed in the form \\spad{curveColor ==p}.") (($ (|Float|)) "\\spad{curveColor(v)} specifies a color, \\spad{v,} for 2D graph curves. This option is expressed in the form \\spad{curveColor \\spad{==} \\spad{v}.}")) (|pointColor| (($ (|Palette|)) "\\spad{pointColor(p)} specifies a color index for 2D graph points from the spadcolors palette \\spad{p.} This option is expressed in the form \\spad{pointColor \\spad{==} \\spad{p}.}") (($ (|Float|)) "\\spad{pointColor(v)} specifies a color, \\spad{v,} for 2D graph points. This option is expressed in the form \\spad{pointColor \\spad{==} \\spad{v}.}")) (|coordinates| (($ (|Mapping| (|Point| (|DoubleFloat|)) (|Point| (|DoubleFloat|)))) "\\spad{coordinates(p)} specifies a change of coordinate systems of point \\spad{p.} This option is expressed in the form \\spad{coordinates \\spad{==} \\spad{p}.}")) (|toScale| (($ (|Boolean|)) "\\spad{toScale(b)} specifies whether or not a plot is to be drawn to scale; if \\spad{b} is \\spad{true} it is drawn to scale, if \\spad{b} is \\spad{false} it is not. This option is expressed in the form \\spad{toScale \\spad{==} \\spad{b}.}")) (|style| (($ (|String|)) "\\spad{style(s)} specifies the drawing style in which the graph will be plotted by the indicated string \\spad{s.} This option is expressed in the form \\spad{style \\spad{==} \\spad{s}.}")) (|title| (($ (|String|)) "\\spad{title(s)} specifies a title for a plot by the indicated string \\spad{s.} This option is expressed in the form \\spad{title \\spad{==} \\spad{s}.}")) (|viewpoint| (($ (|Record| (|:| |theta| (|DoubleFloat|)) (|:| |phi| (|DoubleFloat|)) (|:| |scale| (|DoubleFloat|)) (|:| |scaleX| (|DoubleFloat|)) (|:| |scaleY| (|DoubleFloat|)) (|:| |scaleZ| (|DoubleFloat|)) (|:| |deltaX| (|DoubleFloat|)) (|:| |deltaY| (|DoubleFloat|)))) "\\spad{viewpoint(vp)} creates a viewpoint data structure corresponding to the list of values. The values are interpreted as [theta, phi, scale, scaleX, scaleY, scaleZ, deltaX, deltaY]. This option is expressed in the form \\spad{viewpoint \\spad{==} ls}.")) (|clip| (($ (|List| (|Segment| (|Float|)))) "\\spad{clip([l])} provides ranges for user-defined clipping as specified in the list \\spad{l.} This option is expressed in the form \\spad{clip \\spad{==} [l]}.") (($ (|Boolean|)) "\\spad{clip(b)} turns 2D clipping on if \\spad{b} is true, or off if \\spad{b} is false. This option is expressed in the form \\spad{clip \\spad{==} \\spad{b}.}")) (|adaptive| (($ (|Boolean|)) "\\spad{adaptive(b)} turns adaptive 2D plotting on if \\spad{b} is true, or off if \\spad{b} is false. This option is expressed in the form \\spad{adaptive \\spad{==} \\spad{b}.}"))) NIL NIL (-258 R S V) ((|constructor| (NIL "\\spadtype{DifferentialSparseMultivariatePolynomial} implements an ordinary differential polynomial ring by combining a domain belonging to the category \\spadtype{DifferentialVariableCategory} with the domain \\spadtype{SparseMultivariatePolynomial}."))) -(((-4537 "*") |has| |#1| (-173)) (-4528 |has| |#1| (-559)) (-4533 |has| |#1| (-6 -4533)) (-4530 . T) (-4529 . T) (-4532 . T)) -((|HasCategory| |#1| (QUOTE (-905))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-173))) (-2232 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-559)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| |#3| (LIST (QUOTE -882) (QUOTE (-382))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -882) (QUOTE (-569))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| |#3| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382)))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| |#3| (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569)))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#3| (LIST (QUOTE -610) (QUOTE (-542))))) (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-226))) (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-366))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1038) (LIST (QUOTE -410) (QUOTE (-569)))))) (|HasAttribute| |#1| (QUOTE -4533)) (|HasCategory| |#1| (QUOTE (-454))) (-2232 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-905)))) (-2232 (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-905)))) (-2232 (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-905)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-905)))) (|HasCategory| |#1| (QUOTE (-149))))) +(((-4573 "*") |has| |#1| (-173)) (-4564 |has| |#1| (-559)) (-4569 |has| |#1| (-6 -4569)) (-4566 . T) (-4565 . T) (-4568 . T)) +((|HasCategory| |#1| (QUOTE (-906))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-173))) (-1929 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-559)))) (-12 (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| |#3| (LIST (QUOTE -883) (QUOTE (-382))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| |#3| (LIST (QUOTE -883) (QUOTE (-569))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| |#3| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382)))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| |#3| (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569)))))) (-12 (|HasCategory| |#1| (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| |#3| (LIST (QUOTE -610) (QUOTE (-542))))) (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#1| (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-151))) (|HasCategory| |#1| (QUOTE (-149))) (|HasCategory| |#1| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#1| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (QUOTE (-226))) (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-366))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -43) (LIST (QUOTE -410) (QUOTE (-569))))) (|HasCategory| |#1| (LIST (QUOTE -1039) (LIST (QUOTE -410) (QUOTE (-569)))))) (|HasAttribute| |#1| (QUOTE -4569)) (|HasCategory| |#1| (QUOTE (-454))) (-1929 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-906)))) (-1929 (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-906)))) (-1929 (|HasCategory| |#1| (QUOTE (-454))) (|HasCategory| |#1| (QUOTE (-906)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| |#1| (QUOTE (-906)))) (|HasCategory| |#1| (QUOTE (-149))))) (-259 S) -((|constructor| (NIL "This category is part of the PAFF package")) (|tree| (($ (|List| |#1|)) "\\spad{tree(l)} creates a chain tree from the list \\spad{l}") (($ |#1|) "\\spad{tree(nd)} creates a tree with value \\spad{nd},{} and no children") (($ |#1| (|List| $)) "\\spad{tree(nd,{}ls)} creates a tree with value \\spad{nd},{} and children \\spad{ls}."))) -((-4535 . T) (-4536 . T) (-2982 . T)) +((|constructor| (NIL "This category is part of the PAFF package")) (|tree| (($ (|List| |#1|)) "\\spad{tree(l)} creates a chain tree from the list \\spad{l}") (($ |#1|) "\\spad{tree(nd)} creates a tree with value \\spad{nd,} and no children") (($ |#1| (|List| $)) "\\spad{tree(nd,ls)} creates a tree with value \\spad{nd,} and children \\spad{ls.}"))) +((-4571 . T) (-4572 . T) (-4317 . T)) NIL (-260 S) -((|constructor| (NIL "This category is part of the PAFF package")) (|fullOutput| (((|Boolean|)) "\\spad{fullOutput returns} the value of the flag set by fullOutput(\\spad{b}).") (((|Boolean|) (|Boolean|)) "\\spad{fullOutput(b)} sets a flag such that when \\spad{true},{} a coerce to OutputForm yields the full output of \\spad{tr},{} otherwise encode(\\spad{tr}) is output (see encode function). The default is \\spad{false}.")) (|fullOut| (((|OutputForm|) $) "\\spad{fullOut(tr)} yields a full output of \\spad{tr} (see function fullOutput).")) (|encode| (((|String|) $) "\\spad{encode(t)} returns a string indicating the \"shape\" of the tree"))) -((-4535 . T) (-4536 . T)) -((|HasCategory| |#1| (QUOTE (-1091))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "This category is part of the PAFF package")) (|fullOutput| (((|Boolean|)) "\\spad{fullOutput returns} the value of the flag set by fullOutput(b).") (((|Boolean|) (|Boolean|)) "\\spad{fullOutput(b)} sets a flag such that when true, a coerce to OutputForm yields the full output of \\spad{tr,} otherwise encode(tr) is output (see encode function). The default is false.")) (|fullOut| (((|OutputForm|) $) "\\spad{fullOut(tr)} yields a full output of \\spad{tr} (see function fullOutput).")) (|encode| (((|String|) $) "\\spad{encode(t)} returns a string indicating the \"shape\" of the tree"))) +((-4571 . T) (-4572 . T)) +((|HasCategory| |#1| (QUOTE (-1093))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093))))) (-261 K |symb| |PolyRing| E |ProjPt| PCS |Plc| DIVISOR |InfClsPoint| |DesTree| BLMET) -((|constructor| (NIL "\\indented{1}{The following is all the categories,{} domains and package} used for the desingularisation be means of monoidal transformation (Blowing-up)")) (|genusTreeNeg| (((|Integer|) (|NonNegativeInteger|) (|List| |#10|)) "\\spad{genusTreeNeg(n,{}listOfTrees)} computes the \"genus\" of a curve that may be not absolutly irreducible,{} where \\spad{n} is the degree of a polynomial pol defining the curve and \\spad{listOfTrees} is all the desingularisation trees at all singular points on the curve defined by pol. A \"negative\" genus means that the curve is reducible \\spad{!!}.")) (|genusTree| (((|NonNegativeInteger|) (|NonNegativeInteger|) (|List| |#10|)) "\\spad{genusTree(n,{}listOfTrees)} computes the genus of a curve,{} where \\spad{n} is the degree of a polynomial pol defining the curve and \\spad{listOfTrees} is all the desingularisation trees at all singular points on the curve defined by pol.")) (|genusNeg| (((|Integer|) |#3|) "\\spad{genusNeg(pol)} computes the \"genus\" of a curve that may be not absolutly irreducible. A \"negative\" genus means that the curve is reducible \\spad{!!}.")) (|genus| (((|NonNegativeInteger|) |#3|) "\\spad{genus(pol)} computes the genus of the curve defined by \\spad{pol}.")) (|initializeParamOfPlaces| (((|Void|) |#10| (|List| |#3|)) "initParLocLeaves(\\spad{tr},{}listOfFnc) initialize the local parametrization at places corresponding to the leaves of \\spad{tr} according to the given list of functions in listOfFnc.") (((|Void|) |#10|) "initParLocLeaves(\\spad{tr}) initialize the local parametrization at places corresponding to the leaves of \\spad{tr}.")) (|initParLocLeaves| (((|Void|) |#10|) "\\spad{initParLocLeaves(tr)} initialize the local parametrization at simple points corresponding to the leaves of \\spad{tr}.")) (|fullParamInit| (((|Void|) |#10|) "\\spad{fullParamInit(tr)} initialize the local parametrization at all places (leaves of \\spad{tr}),{} computes the local exceptional divisor at each infinytly close points in the tree. This function is equivalent to the following called: initParLocLeaves(\\spad{tr}) initializeParamOfPlaces(\\spad{tr}) blowUpWithExcpDiv(\\spad{tr})")) (|desingTree| (((|List| |#10|) |#3|) "\\spad{desingTree(pol)} returns all the desingularisation trees of all singular points on the curve defined by \\spad{pol}.")) (|desingTreeAtPoint| ((|#10| |#5| |#3|) "\\spad{desingTreeAtPoint(pt,{}pol)} computes the desingularisation tree at the point \\spad{pt} on the curve defined by \\spad{pol}. This function recursively compute the tree.")) (|adjunctionDivisor| ((|#8| |#10|) "\\spad{adjunctionDivisor(tr)} compute the local adjunction divisor of a desingularisation tree \\spad{tr} of a singular point.")) (|divisorAtDesingTree| ((|#8| |#3| |#10|) "\\spad{divisorAtDesingTree(f,{}tr)} computes the local divisor of \\spad{f} at a desingularisation tree \\spad{tr} of a singular point."))) +((|constructor| (NIL "\\indented{1}{The following is all the categories, domains and package} used for the desingularisation be means of monoidal transformation (Blowing-up)")) (|genusTreeNeg| (((|Integer|) (|NonNegativeInteger|) (|List| |#10|)) "\\spad{genusTreeNeg(n,listOfTrees)} computes the \"genus\" of a curve that may be not absolutly irreducible, where \\spad{n} is the degree of a polynomial pol defining the curve and \\spad{listOfTrees} is all the desingularisation trees at all singular points on the curve defined by pol. A \"negative\" genus means that the curve is reducible \\spad{!!.}")) (|genusTree| (((|NonNegativeInteger|) (|NonNegativeInteger|) (|List| |#10|)) "\\spad{genusTree(n,listOfTrees)} computes the genus of a curve, where \\spad{n} is the degree of a polynomial pol defining the curve and \\spad{listOfTrees} is all the desingularisation trees at all singular points on the curve defined by pol.")) (|genusNeg| (((|Integer|) |#3|) "\\spad{genusNeg(pol)} computes the \"genus\" of a curve that may be not absolutly irreducible. A \"negative\" genus means that the curve is reducible \\spad{!!.}")) (|genus| (((|NonNegativeInteger|) |#3|) "\\spad{genus(pol)} computes the genus of the curve defined by pol.")) (|initializeParamOfPlaces| (((|Void|) |#10| (|List| |#3|)) "initParLocLeaves(tr,listOfFnc) initialize the local parametrization at places corresponding to the leaves of \\spad{tr} according to the given list of functions in listOfFnc.") (((|Void|) |#10|) "initParLocLeaves(tr) initialize the local parametrization at places corresponding to the leaves of \\spad{tr.}")) (|initParLocLeaves| (((|Void|) |#10|) "\\spad{initParLocLeaves(tr)} initialize the local parametrization at simple points corresponding to the leaves of \\spad{tr.}")) (|fullParamInit| (((|Void|) |#10|) "\\spad{fullParamInit(tr)} initialize the local parametrization at all places (leaves of tr), computes the local exceptional divisor at each infinytly close points in the tree. This function is equivalent to the following called: initParLocLeaves(tr) initializeParamOfPlaces(tr) blowUpWithExcpDiv(tr)")) (|desingTree| (((|List| |#10|) |#3|) "\\spad{desingTree(pol)} returns all the desingularisation trees of all singular points on the curve defined by pol.")) (|desingTreeAtPoint| ((|#10| |#5| |#3|) "\\spad{desingTreeAtPoint(pt,pol)} computes the desingularisation tree at the point \\spad{pt} on the curve defined by pol. This function recursively compute the tree.")) (|adjunctionDivisor| ((|#8| |#10|) "\\spad{adjunctionDivisor(tr)} compute the local adjunction divisor of a desingularisation tree \\spad{tr} of a singular point.")) (|divisorAtDesingTree| ((|#8| |#3| |#10|) "\\spad{divisorAtDesingTree(f,tr)} computes the local divisor of \\spad{f} at a desingularisation tree \\spad{tr} of a singular point."))) NIL NIL (-262 A S) -((|constructor| (NIL "\\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If \\spad{x},{}...,{}\\spad{y} is an ordered set of differential indeterminates,{} and the prime notation is used for differentiation,{} then the set of derivatives (including zero-th order) of the differential indeterminates is \\spad{x},{}\\spad{x'},{}\\spad{x''},{}...,{} \\spad{y},{}\\spad{y'},{}\\spad{y''},{}... (Note that in the interpreter,{} the \\spad{n}-th derivative of \\spad{y} is displayed as \\spad{y} with a subscript \\spad{n}.) This set is viewed as a set of algebraic indeterminates,{} totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \\blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives,{} and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates,{} just as one associates a domain in the category \\spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \\spadfun{<}. For example,{} one may define one derivative to be less than another by lexicographically comparing first the \\spadfun{order},{} then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \\blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates,{} Very often,{} a grading is the first step in ordering the set of monomials. For differential polynomial domains,{} this constructor provides a function \\spadfun{weight},{} which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example,{} one may define the weight of a derivative to be simply its \\spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials,{} providing a graded ring structure.")) (|coerce| (($ |#2|) "\\spad{coerce(s)} returns \\spad{s},{} viewed as the zero-th order derivative of \\spad{s}.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(v,{} n)} returns the \\spad{n}-th derivative of \\spad{v}.") (($ $) "\\spad{differentiate(v)} returns the derivative of \\spad{v}.")) (|weight| (((|NonNegativeInteger|) $) "\\spad{weight(v)} returns the weight of the derivative \\spad{v}.")) (|variable| ((|#2| $) "\\spad{variable(v)} returns \\spad{s} if \\spad{v} is any derivative of the differential indeterminate \\spad{s}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(v)} returns \\spad{n} if \\spad{v} is the \\spad{n}-th derivative of any differential indeterminate.")) (|makeVariable| (($ |#2| (|NonNegativeInteger|)) "\\spad{makeVariable(s,{} n)} returns the \\spad{n}-th derivative of a differential indeterminate \\spad{s} as an algebraic indeterminate."))) +((|constructor| (NIL "\\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If x,...,y is an ordered set of differential indeterminates, and the prime notation is used for differentiation, then the set of derivatives (including zero-th order) of the differential indeterminates is x,\\spad{x'},\\spad{x''},..., y,\\spad{y'},\\spad{y''},... (Note that in the interpreter, the \\spad{n}-th derivative of \\spad{y} is displayed as \\spad{y} with a subscript \\spad{n.)} This set is viewed as a set of algebraic indeterminates, totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \\blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives, and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates, just as one associates a domain in the category \\spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \\spadfun{<}. For example, one may define one derivative to be less than another by lexicographically comparing first the \\spadfun{order}, then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \\blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates, Very often, a grading is the first step in ordering the set of monomials. For differential polynomial domains, this constructor provides a function \\spadfun{weight}, which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example, one may define the weight of a derivative to be simply its \\spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials, providing a graded ring structure.")) (|coerce| (($ |#2|) "\\spad{coerce(s)} returns \\spad{s,} viewed as the zero-th order derivative of \\spad{s.}")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(v, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{v.}") (($ $) "\\spad{differentiate(v)} returns the derivative of \\spad{v.}")) (|weight| (((|NonNegativeInteger|) $) "\\spad{weight(v)} returns the weight of the derivative \\spad{v.}")) (|variable| ((|#2| $) "\\spad{variable(v)} returns \\spad{s} if \\spad{v} is any derivative of the differential indeterminate \\spad{s.}")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(v)} returns \\spad{n} if \\spad{v} is the \\spad{n}-th derivative of any differential indeterminate.")) (|makeVariable| (($ |#2| (|NonNegativeInteger|)) "\\spad{makeVariable(s, \\spad{n)}} returns the \\spad{n}-th derivative of a differential indeterminate \\spad{s} as an algebraic indeterminate."))) NIL NIL (-263 S) -((|constructor| (NIL "\\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If \\spad{x},{}...,{}\\spad{y} is an ordered set of differential indeterminates,{} and the prime notation is used for differentiation,{} then the set of derivatives (including zero-th order) of the differential indeterminates is \\spad{x},{}\\spad{x'},{}\\spad{x''},{}...,{} \\spad{y},{}\\spad{y'},{}\\spad{y''},{}... (Note that in the interpreter,{} the \\spad{n}-th derivative of \\spad{y} is displayed as \\spad{y} with a subscript \\spad{n}.) This set is viewed as a set of algebraic indeterminates,{} totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \\blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives,{} and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates,{} just as one associates a domain in the category \\spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \\spadfun{<}. For example,{} one may define one derivative to be less than another by lexicographically comparing first the \\spadfun{order},{} then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \\blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates,{} Very often,{} a grading is the first step in ordering the set of monomials. For differential polynomial domains,{} this constructor provides a function \\spadfun{weight},{} which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example,{} one may define the weight of a derivative to be simply its \\spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials,{} providing a graded ring structure.")) (|coerce| (($ |#1|) "\\spad{coerce(s)} returns \\spad{s},{} viewed as the zero-th order derivative of \\spad{s}.")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(v,{} n)} returns the \\spad{n}-th derivative of \\spad{v}.") (($ $) "\\spad{differentiate(v)} returns the derivative of \\spad{v}.")) (|weight| (((|NonNegativeInteger|) $) "\\spad{weight(v)} returns the weight of the derivative \\spad{v}.")) (|variable| ((|#1| $) "\\spad{variable(v)} returns \\spad{s} if \\spad{v} is any derivative of the differential indeterminate \\spad{s}.")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(v)} returns \\spad{n} if \\spad{v} is the \\spad{n}-th derivative of any differential indeterminate.")) (|makeVariable| (($ |#1| (|NonNegativeInteger|)) "\\spad{makeVariable(s,{} n)} returns the \\spad{n}-th derivative of a differential indeterminate \\spad{s} as an algebraic indeterminate."))) +((|constructor| (NIL "\\spadtype{DifferentialVariableCategory} constructs the set of derivatives of a given set of (ordinary) differential indeterminates. If x,...,y is an ordered set of differential indeterminates, and the prime notation is used for differentiation, then the set of derivatives (including zero-th order) of the differential indeterminates is x,\\spad{x'},\\spad{x''},..., y,\\spad{y'},\\spad{y''},... (Note that in the interpreter, the \\spad{n}-th derivative of \\spad{y} is displayed as \\spad{y} with a subscript \\spad{n.)} This set is viewed as a set of algebraic indeterminates, totally ordered in a way compatible with differentiation and the given order on the differential indeterminates. Such a total order is called a ranking of the differential indeterminates. \\blankline A domain in this category is needed to construct a differential polynomial domain. Differential polynomials are ordered by a ranking on the derivatives, and by an order (extending the ranking) on on the set of differential monomials. One may thus associate a domain in this category with a ranking of the differential indeterminates, just as one associates a domain in the category \\spadtype{OrderedAbelianMonoidSup} with an ordering of the set of monomials in a set of algebraic indeterminates. The ranking is specified through the binary relation \\spadfun{<}. For example, one may define one derivative to be less than another by lexicographically comparing first the \\spadfun{order}, then the given order of the differential indeterminates appearing in the derivatives. This is the default implementation. \\blankline The notion of weight generalizes that of degree. A polynomial domain may be made into a graded ring if a weight function is given on the set of indeterminates, Very often, a grading is the first step in ordering the set of monomials. For differential polynomial domains, this constructor provides a function \\spadfun{weight}, which allows the assignment of a non-negative number to each derivative of a differential indeterminate. For example, one may define the weight of a derivative to be simply its \\spadfun{order} (this is the default assignment). This weight function can then be extended to the set of all differential polynomials, providing a graded ring structure.")) (|coerce| (($ |#1|) "\\spad{coerce(s)} returns \\spad{s,} viewed as the zero-th order derivative of \\spad{s.}")) (|differentiate| (($ $ (|NonNegativeInteger|)) "\\spad{differentiate(v, \\spad{n)}} returns the \\spad{n}-th derivative of \\spad{v.}") (($ $) "\\spad{differentiate(v)} returns the derivative of \\spad{v.}")) (|weight| (((|NonNegativeInteger|) $) "\\spad{weight(v)} returns the weight of the derivative \\spad{v.}")) (|variable| ((|#1| $) "\\spad{variable(v)} returns \\spad{s} if \\spad{v} is any derivative of the differential indeterminate \\spad{s.}")) (|order| (((|NonNegativeInteger|) $) "\\spad{order(v)} returns \\spad{n} if \\spad{v} is the \\spad{n}-th derivative of any differential indeterminate.")) (|makeVariable| (($ |#1| (|NonNegativeInteger|)) "\\spad{makeVariable(s, \\spad{n)}} returns the \\spad{n}-th derivative of a differential indeterminate \\spad{s} as an algebraic indeterminate."))) NIL NIL (-264) -((|constructor| (NIL "\\axiomType{e04AgentsPackage} is a package of numerical agents to be used to investigate attributes of an input function so as to decide the \\axiomFun{measure} of an appropriate numerical optimization routine.")) (|optAttributes| (((|List| (|String|)) (|Union| (|:| |noa| (|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|)))))) (|:| |lsa| (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))))) "\\spad{optAttributes(o)} is a function for supplying a list of attributes of an optimization problem.")) (|expenseOfEvaluation| (((|Float|) (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))) "\\spad{expenseOfEvaluation(o)} returns the intensity value of the cost of evaluating the input set of functions. This is in terms of the number of ``operational units\\spad{''}. It returns a value in the range [0,{}1].")) (|changeNameToObjf| (((|Result|) (|Symbol|) (|Result|)) "\\spad{changeNameToObjf(s,{}r)} changes the name of item \\axiom{\\spad{s}} in \\axiom{\\spad{r}} to objf.")) (|varList| (((|List| (|Symbol|)) (|Expression| (|DoubleFloat|)) (|NonNegativeInteger|)) "\\spad{varList(e,{}n)} returns a list of \\axiom{\\spad{n}} indexed variables with name as in \\axiom{\\spad{e}}.")) (|variables| (((|List| (|Symbol|)) (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))) "\\spad{variables(args)} returns the list of variables in \\axiom{\\spad{args}.\\spad{lfn}}")) (|quadratic?| (((|Boolean|) (|Expression| (|DoubleFloat|))) "\\spad{quadratic?(e)} tests if \\axiom{\\spad{e}} is a quadratic function.")) (|nonLinearPart| (((|List| (|Expression| (|DoubleFloat|))) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{nonLinearPart(l)} returns the list of non-linear functions of \\spad{l}.")) (|linearPart| (((|List| (|Expression| (|DoubleFloat|))) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{linearPart(l)} returns the list of linear functions of \\axiom{\\spad{l}}.")) (|linearMatrix| (((|Matrix| (|DoubleFloat|)) (|List| (|Expression| (|DoubleFloat|))) (|NonNegativeInteger|)) "\\spad{linearMatrix(l,{}n)} returns a matrix of coefficients of the linear functions in \\axiom{\\spad{l}}. If \\spad{l} is empty,{} the matrix has at least one row.")) (|linear?| (((|Boolean|) (|Expression| (|DoubleFloat|))) "\\spad{linear?(e)} tests if \\axiom{\\spad{e}} is a linear function.") (((|Boolean|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{linear?(l)} returns \\spad{true} if all the bounds \\spad{l} are either linear or simple.")) (|simpleBounds?| (((|Boolean|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{simpleBounds?(l)} returns \\spad{true} if the list of expressions \\spad{l} are simple.")) (|splitLinear| (((|Expression| (|DoubleFloat|)) (|Expression| (|DoubleFloat|))) "\\spad{splitLinear(f)} splits the linear part from an expression which it returns.")) (|sumOfSquares| (((|Union| (|Expression| (|DoubleFloat|)) "failed") (|Expression| (|DoubleFloat|))) "\\spad{sumOfSquares(f)} returns either an expression for which the square is the original function of \"failed\".")) (|sortConstraints| (((|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|))))) (|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|)))))) "\\spad{sortConstraints(args)} uses a simple bubblesort on the list of constraints using the degree of the expression on which to sort. Of course,{} it must match the bounds to the constraints.")) (|finiteBound| (((|List| (|DoubleFloat|)) (|List| (|OrderedCompletion| (|DoubleFloat|))) (|DoubleFloat|)) "\\spad{finiteBound(l,{}b)} repaces all instances of an infinite entry in \\axiom{\\spad{l}} by a finite entry \\axiom{\\spad{b}} or \\axiom{\\spad{-b}}."))) +((|constructor| (NIL "\\axiomType{e04AgentsPackage} is a package of numerical agents to be used to investigate attributes of an input function so as to decide the \\axiomFun{measure} of an appropriate numerical optimization routine.")) (|optAttributes| (((|List| (|String|)) (|Union| (|:| |noa| (|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|)))))) (|:| |lsa| (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))))) "\\spad{optAttributes(o)} is a function for supplying a list of attributes of an optimization problem.")) (|expenseOfEvaluation| (((|Float|) (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))) "\\spad{expenseOfEvaluation(o)} returns the intensity value of the cost of evaluating the input set of functions. This is in terms of the number of ``operational units''. It returns a value in the range [0,1].")) (|changeNameToObjf| (((|Result|) (|Symbol|) (|Result|)) "\\spad{changeNameToObjf(s,r)} changes the name of item \\axiom{s} in \\axiom{r} to objf.")) (|varList| (((|List| (|Symbol|)) (|Expression| (|DoubleFloat|)) (|NonNegativeInteger|)) "\\spad{varList(e,n)} returns a list of \\axiom{n} indexed variables with name as in \\axiom{e}.")) (|variables| (((|List| (|Symbol|)) (|Record| (|:| |lfn| (|List| (|Expression| (|DoubleFloat|)))) (|:| |init| (|List| (|DoubleFloat|))))) "\\spad{variables(args)} returns the list of variables in \\axiom{args.lfn}")) (|quadratic?| (((|Boolean|) (|Expression| (|DoubleFloat|))) "\\spad{quadratic?(e)} tests if \\axiom{e} is a quadratic function.")) (|nonLinearPart| (((|List| (|Expression| (|DoubleFloat|))) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{nonLinearPart(l)} returns the list of non-linear functions of \\spad{l.}")) (|linearPart| (((|List| (|Expression| (|DoubleFloat|))) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{linearPart(l)} returns the list of linear functions of \\axiom{l}.")) (|linearMatrix| (((|Matrix| (|DoubleFloat|)) (|List| (|Expression| (|DoubleFloat|))) (|NonNegativeInteger|)) "\\spad{linearMatrix(l,n)} returns a matrix of coefficients of the linear functions in \\axiom{l}. If \\spad{l} is empty, the matrix has at least one row.")) (|linear?| (((|Boolean|) (|Expression| (|DoubleFloat|))) "\\spad{linear?(e)} tests if \\axiom{e} is a linear function.") (((|Boolean|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{linear?(l)} returns \\spad{true} if all the bounds \\spad{l} are either linear or simple.")) (|simpleBounds?| (((|Boolean|) (|List| (|Expression| (|DoubleFloat|)))) "\\spad{simpleBounds?(l)} returns \\spad{true} if the list of expressions \\spad{l} are simple.")) (|splitLinear| (((|Expression| (|DoubleFloat|)) (|Expression| (|DoubleFloat|))) "\\spad{splitLinear(f)} splits the linear part from an expression which it returns.")) (|sumOfSquares| (((|Union| (|Expression| (|DoubleFloat|)) "failed") (|Expression| (|DoubleFloat|))) "\\spad{sumOfSquares(f)} returns either an expression for which the square is the original function of \"failed\".")) (|sortConstraints| (((|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|))))) (|Record| (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |init| (|List| (|DoubleFloat|))) (|:| |lb| (|List| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |cf| (|List| (|Expression| (|DoubleFloat|)))) (|:| |ub| (|List| (|OrderedCompletion| (|DoubleFloat|)))))) "\\spad{sortConstraints(args)} uses a simple bubblesort on the list of constraints using the degree of the expression on which to sort. Of course, it must match the bounds to the constraints.")) (|finiteBound| (((|List| (|DoubleFloat|)) (|List| (|OrderedCompletion| (|DoubleFloat|))) (|DoubleFloat|)) "\\spad{finiteBound(l,b)} repaces all instances of an infinite entry in \\axiom{l} by a finite entry \\axiom{b} or \\axiom{-b}."))) NIL NIL (-265) -((|constructor| (NIL "\\axiomType{e04dgfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04DGF,{} a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04DGF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04dgfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04DGF, a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04DGF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-266) -((|constructor| (NIL "\\axiomType{e04fdfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04FDF,{} a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04FDF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04fdfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04FDF, a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04FDF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-267) -((|constructor| (NIL "\\axiomType{e04gcfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04GCF,{} a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04GCF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04gcfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04GCF, a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04GCF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-268) -((|constructor| (NIL "\\axiomType{e04jafAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04JAF,{} a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04JAF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04jafAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04JAF, a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04JAF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-269) -((|constructor| (NIL "\\axiomType{e04mbfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04MBF,{} an optimization routine for Linear functions. The function \\axiomFun{measure} measures the usefulness of the routine E04MBF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04mbfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04MBF, an optimization routine for Linear functions. The function \\axiomFun{measure} measures the usefulness of the routine E04MBF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-270) -((|constructor| (NIL "\\axiomType{e04nafAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04NAF,{} an optimization routine for Quadratic functions. The function \\axiomFun{measure} measures the usefulness of the routine E04NAF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04nafAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04NAF, an optimization routine for Quadratic functions. The function \\axiomFun{measure} measures the usefulness of the routine E04NAF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-271) -((|constructor| (NIL "\\axiomType{e04ucfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04UCF,{} a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04UCF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) +((|constructor| (NIL "\\axiomType{e04ucfAnnaType} is a domain of \\axiomType{NumericalOptimization} for the NAG routine E04UCF, a general optimization routine which can handle some singularities in the input function. The function \\axiomFun{measure} measures the usefulness of the routine E04UCF for the given problem. The function \\axiomFun{numericalOptimization} performs the optimization by using \\axiomType{NagOptimisationPackage}."))) NIL NIL (-272) -((|constructor| (NIL "A domain used in the construction of the exterior algebra on a set \\spad{X} over a ring \\spad{R}. This domain represents the set of all ordered subsets of the set \\spad{X},{} assumed to be in correspondance with {1,{}2,{}3,{} ...}. The ordered subsets are themselves ordered lexicographically and are in bijective correspondance with an ordered basis of the exterior algebra. In this domain we are dealing strictly with the exponents of basis elements which can only be 0 or 1. \\blankline The multiplicative identity element of the exterior algebra corresponds to the empty subset of \\spad{X}. A coerce from List Integer to an ordered basis element is provided to allow the convenient input of expressions. Another exported function forgets the ordered structure and simply returns the list corresponding to an ordered subset.")) (|Nul| (($ (|NonNegativeInteger|)) "\\spad{Nul()} gives the basis element 1 for the algebra generated by \\spad{n} generators.")) (|exponents| (((|List| (|Integer|)) $) "\\spad{exponents(x)} converts a domain element into a list of zeros and ones corresponding to the exponents in the basis element that \\spad{x} represents.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(x)} gives the numbers of 1\\spad{'s} in \\spad{x},{} \\spadignore{i.e.} the number of non-zero exponents in the basis element that \\spad{x} represents.")) (|coerce| (($ (|List| (|Integer|))) "\\spad{coerce(l)} converts a list of 0\\spad{'s} and 1\\spad{'s} into a basis element,{} where 1 (respectively 0) designates that the variable of the corresponding index of \\spad{l} is (respectively,{} is not) present. Error: if an element of \\spad{l} is not 0 or 1."))) +((|constructor| (NIL "A domain used in the construction of the exterior algebra on a set \\spad{X} over a ring \\spad{R.} This domain represents the set of all ordered subsets of the set \\spad{X,} assumed to be in correspondance with {1,2,3, ...}. The ordered subsets are themselves ordered lexicographically and are in bijective correspondance with an ordered basis of the exterior algebra. In this domain we are dealing strictly with the exponents of basis elements which can only be 0 or 1. \\blankline The multiplicative identity element of the exterior algebra corresponds to the empty subset of \\spad{X.} A coerce from List Integer to an ordered basis element is provided to allow the convenient input of expressions. Another exported function forgets the ordered structure and simply returns the list corresponding to an ordered subset.")) (|Nul| (($ (|NonNegativeInteger|)) "\\spad{Nul()} gives the basis element 1 for the algebra generated by \\spad{n} generators.")) (|exponents| (((|List| (|Integer|)) $) "\\spad{exponents(x)} converts a domain element into a list of zeros and ones corresponding to the exponents in the basis element that \\spad{x} represents.")) (|degree| (((|NonNegativeInteger|) $) "\\spad{degree(x)} gives the numbers of 1's in \\spad{x,} \\spadignore{i.e.} the number of non-zero exponents in the basis element that \\spad{x} represents.")) (|coerce| (($ (|List| (|Integer|))) "\\spad{coerce(l)} converts a list of 0's and 1's into a basis element, where 1 (respectively 0) designates that the variable of the corresponding index of \\spad{l} is (respectively, is not) present. Error: if an element of \\spad{l} is not 0 or 1."))) NIL NIL -(-273 R -1564) -((|constructor| (NIL "Provides elementary functions over an integral domain.")) (|localReal?| (((|Boolean|) |#2|) "\\spad{localReal?(x)} should be local but conditional")) (|specialTrigs| (((|Union| |#2| "failed") |#2| (|List| (|Record| (|:| |func| |#2|) (|:| |pole| (|Boolean|))))) "\\spad{specialTrigs(x,{}l)} should be local but conditional")) (|iiacsch| ((|#2| |#2|) "\\spad{iiacsch(x)} should be local but conditional")) (|iiasech| ((|#2| |#2|) "\\spad{iiasech(x)} should be local but conditional")) (|iiacoth| ((|#2| |#2|) "\\spad{iiacoth(x)} should be local but conditional")) (|iiatanh| ((|#2| |#2|) "\\spad{iiatanh(x)} should be local but conditional")) (|iiacosh| ((|#2| |#2|) "\\spad{iiacosh(x)} should be local but conditional")) (|iiasinh| ((|#2| |#2|) "\\spad{iiasinh(x)} should be local but conditional")) (|iicsch| ((|#2| |#2|) "\\spad{iicsch(x)} should be local but conditional")) (|iisech| ((|#2| |#2|) "\\spad{iisech(x)} should be local but conditional")) (|iicoth| ((|#2| |#2|) "\\spad{iicoth(x)} should be local but conditional")) (|iitanh| ((|#2| |#2|) "\\spad{iitanh(x)} should be local but conditional")) (|iicosh| ((|#2| |#2|) "\\spad{iicosh(x)} should be local but conditional")) (|iisinh| ((|#2| |#2|) "\\spad{iisinh(x)} should be local but conditional")) (|iiacsc| ((|#2| |#2|) "\\spad{iiacsc(x)} should be local but conditional")) (|iiasec| ((|#2| |#2|) "\\spad{iiasec(x)} should be local but conditional")) (|iiacot| ((|#2| |#2|) "\\spad{iiacot(x)} should be local but conditional")) (|iiatan| ((|#2| |#2|) "\\spad{iiatan(x)} should be local but conditional")) (|iiacos| ((|#2| |#2|) "\\spad{iiacos(x)} should be local but conditional")) (|iiasin| ((|#2| |#2|) "\\spad{iiasin(x)} should be local but conditional")) (|iicsc| ((|#2| |#2|) "\\spad{iicsc(x)} should be local but conditional")) (|iisec| ((|#2| |#2|) "\\spad{iisec(x)} should be local but conditional")) (|iicot| ((|#2| |#2|) "\\spad{iicot(x)} should be local but conditional")) (|iitan| ((|#2| |#2|) "\\spad{iitan(x)} should be local but conditional")) (|iicos| ((|#2| |#2|) "\\spad{iicos(x)} should be local but conditional")) (|iisin| ((|#2| |#2|) "\\spad{iisin(x)} should be local but conditional")) (|iilog| ((|#2| |#2|) "\\spad{iilog(x)} should be local but conditional")) (|iiexp| ((|#2| |#2|) "\\spad{iiexp(x)} should be local but conditional")) (|iisqrt3| ((|#2|) "\\spad{iisqrt3()} should be local but conditional")) (|iisqrt2| ((|#2|) "\\spad{iisqrt2()} should be local but conditional")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(p)} returns an elementary operator with the same symbol as \\spad{p}")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(p)} returns \\spad{true} if operator \\spad{p} is elementary")) (|pi| ((|#2|) "\\spad{\\spad{pi}()} returns the \\spad{pi} operator")) (|acsch| ((|#2| |#2|) "\\spad{acsch(x)} applies the inverse hyperbolic cosecant operator to \\spad{x}")) (|asech| ((|#2| |#2|) "\\spad{asech(x)} applies the inverse hyperbolic secant operator to \\spad{x}")) (|acoth| ((|#2| |#2|) "\\spad{acoth(x)} applies the inverse hyperbolic cotangent operator to \\spad{x}")) (|atanh| ((|#2| |#2|) "\\spad{atanh(x)} applies the inverse hyperbolic tangent operator to \\spad{x}")) (|acosh| ((|#2| |#2|) "\\spad{acosh(x)} applies the inverse hyperbolic cosine operator to \\spad{x}")) (|asinh| ((|#2| |#2|) "\\spad{asinh(x)} applies the inverse hyperbolic sine operator to \\spad{x}")) (|csch| ((|#2| |#2|) "\\spad{csch(x)} applies the hyperbolic cosecant operator to \\spad{x}")) (|sech| ((|#2| |#2|) "\\spad{sech(x)} applies the hyperbolic secant operator to \\spad{x}")) (|coth| ((|#2| |#2|) "\\spad{coth(x)} applies the hyperbolic cotangent operator to \\spad{x}")) (|tanh| ((|#2| |#2|) "\\spad{tanh(x)} applies the hyperbolic tangent operator to \\spad{x}")) (|cosh| ((|#2| |#2|) "\\spad{cosh(x)} applies the hyperbolic cosine operator to \\spad{x}")) (|sinh| ((|#2| |#2|) "\\spad{sinh(x)} applies the hyperbolic sine operator to \\spad{x}")) (|acsc| ((|#2| |#2|) "\\spad{acsc(x)} applies the inverse cosecant operator to \\spad{x}")) (|asec| ((|#2| |#2|) "\\spad{asec(x)} applies the inverse secant operator to \\spad{x}")) (|acot| ((|#2| |#2|) "\\spad{acot(x)} applies the inverse cotangent operator to \\spad{x}")) (|atan| ((|#2| |#2|) "\\spad{atan(x)} applies the inverse tangent operator to \\spad{x}")) (|acos| ((|#2| |#2|) "\\spad{acos(x)} applies the inverse cosine operator to \\spad{x}")) (|asin| ((|#2| |#2|) "\\spad{asin(x)} applies the inverse sine operator to \\spad{x}")) (|csc| ((|#2| |#2|) "\\spad{csc(x)} applies the cosecant operator to \\spad{x}")) (|sec| ((|#2| |#2|) "\\spad{sec(x)} applies the secant operator to \\spad{x}")) (|cot| ((|#2| |#2|) "\\spad{cot(x)} applies the cotangent operator to \\spad{x}")) (|tan| ((|#2| |#2|) "\\spad{tan(x)} applies the tangent operator to \\spad{x}")) (|cos| ((|#2| |#2|) "\\spad{cos(x)} applies the cosine operator to \\spad{x}")) (|sin| ((|#2| |#2|) "\\spad{sin(x)} applies the sine operator to \\spad{x}")) (|log| ((|#2| |#2|) "\\spad{log(x)} applies the logarithm operator to \\spad{x}")) (|exp| ((|#2| |#2|) "\\spad{exp(x)} applies the exponential operator to \\spad{x}"))) +(-273 R -1647) +((|constructor| (NIL "Provides elementary functions over an integral domain.")) (|localReal?| (((|Boolean|) |#2|) "\\spad{localReal?(x)} should be local but conditional")) (|specialTrigs| (((|Union| |#2| "failed") |#2| (|List| (|Record| (|:| |func| |#2|) (|:| |pole| (|Boolean|))))) "\\spad{specialTrigs(x,l)} should be local but conditional")) (|iiacsch| ((|#2| |#2|) "\\spad{iiacsch(x)} should be local but conditional")) (|iiasech| ((|#2| |#2|) "\\spad{iiasech(x)} should be local but conditional")) (|iiacoth| ((|#2| |#2|) "\\spad{iiacoth(x)} should be local but conditional")) (|iiatanh| ((|#2| |#2|) "\\spad{iiatanh(x)} should be local but conditional")) (|iiacosh| ((|#2| |#2|) "\\spad{iiacosh(x)} should be local but conditional")) (|iiasinh| ((|#2| |#2|) "\\spad{iiasinh(x)} should be local but conditional")) (|iicsch| ((|#2| |#2|) "\\spad{iicsch(x)} should be local but conditional")) (|iisech| ((|#2| |#2|) "\\spad{iisech(x)} should be local but conditional")) (|iicoth| ((|#2| |#2|) "\\spad{iicoth(x)} should be local but conditional")) (|iitanh| ((|#2| |#2|) "\\spad{iitanh(x)} should be local but conditional")) (|iicosh| ((|#2| |#2|) "\\spad{iicosh(x)} should be local but conditional")) (|iisinh| ((|#2| |#2|) "\\spad{iisinh(x)} should be local but conditional")) (|iiacsc| ((|#2| |#2|) "\\spad{iiacsc(x)} should be local but conditional")) (|iiasec| ((|#2| |#2|) "\\spad{iiasec(x)} should be local but conditional")) (|iiacot| ((|#2| |#2|) "\\spad{iiacot(x)} should be local but conditional")) (|iiatan| ((|#2| |#2|) "\\spad{iiatan(x)} should be local but conditional")) (|iiacos| ((|#2| |#2|) "\\spad{iiacos(x)} should be local but conditional")) (|iiasin| ((|#2| |#2|) "\\spad{iiasin(x)} should be local but conditional")) (|iicsc| ((|#2| |#2|) "\\spad{iicsc(x)} should be local but conditional")) (|iisec| ((|#2| |#2|) "\\spad{iisec(x)} should be local but conditional")) (|iicot| ((|#2| |#2|) "\\spad{iicot(x)} should be local but conditional")) (|iitan| ((|#2| |#2|) "\\spad{iitan(x)} should be local but conditional")) (|iicos| ((|#2| |#2|) "\\spad{iicos(x)} should be local but conditional")) (|iisin| ((|#2| |#2|) "\\spad{iisin(x)} should be local but conditional")) (|iilog| ((|#2| |#2|) "\\spad{iilog(x)} should be local but conditional")) (|iiexp| ((|#2| |#2|) "\\spad{iiexp(x)} should be local but conditional")) (|iisqrt3| ((|#2|) "\\spad{iisqrt3()} should be local but conditional")) (|iisqrt2| ((|#2|) "\\spad{iisqrt2()} should be local but conditional")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(p)} returns an elementary operator with the same symbol as \\spad{p}")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(p)} returns \\spad{true} if operator \\spad{p} is elementary")) (|pi| ((|#2|) "\\spad{pi()} returns the \\spad{pi} operator")) (|acsch| ((|#2| |#2|) "\\spad{acsch(x)} applies the inverse hyperbolic cosecant operator to \\spad{x}")) (|asech| ((|#2| |#2|) "\\spad{asech(x)} applies the inverse hyperbolic secant operator to \\spad{x}")) (|acoth| ((|#2| |#2|) "\\spad{acoth(x)} applies the inverse hyperbolic cotangent operator to \\spad{x}")) (|atanh| ((|#2| |#2|) "\\spad{atanh(x)} applies the inverse hyperbolic tangent operator to \\spad{x}")) (|acosh| ((|#2| |#2|) "\\spad{acosh(x)} applies the inverse hyperbolic cosine operator to \\spad{x}")) (|asinh| ((|#2| |#2|) "\\spad{asinh(x)} applies the inverse hyperbolic sine operator to \\spad{x}")) (|csch| ((|#2| |#2|) "\\spad{csch(x)} applies the hyperbolic cosecant operator to \\spad{x}")) (|sech| ((|#2| |#2|) "\\spad{sech(x)} applies the hyperbolic secant operator to \\spad{x}")) (|coth| ((|#2| |#2|) "\\spad{coth(x)} applies the hyperbolic cotangent operator to \\spad{x}")) (|tanh| ((|#2| |#2|) "\\spad{tanh(x)} applies the hyperbolic tangent operator to \\spad{x}")) (|cosh| ((|#2| |#2|) "\\spad{cosh(x)} applies the hyperbolic cosine operator to \\spad{x}")) (|sinh| ((|#2| |#2|) "\\spad{sinh(x)} applies the hyperbolic sine operator to \\spad{x}")) (|acsc| ((|#2| |#2|) "\\spad{acsc(x)} applies the inverse cosecant operator to \\spad{x}")) (|asec| ((|#2| |#2|) "\\spad{asec(x)} applies the inverse secant operator to \\spad{x}")) (|acot| ((|#2| |#2|) "\\spad{acot(x)} applies the inverse cotangent operator to \\spad{x}")) (|atan| ((|#2| |#2|) "\\spad{atan(x)} applies the inverse tangent operator to \\spad{x}")) (|acos| ((|#2| |#2|) "\\spad{acos(x)} applies the inverse cosine operator to \\spad{x}")) (|asin| ((|#2| |#2|) "\\spad{asin(x)} applies the inverse sine operator to \\spad{x}")) (|csc| ((|#2| |#2|) "\\spad{csc(x)} applies the cosecant operator to \\spad{x}")) (|sec| ((|#2| |#2|) "\\spad{sec(x)} applies the secant operator to \\spad{x}")) (|cot| ((|#2| |#2|) "\\spad{cot(x)} applies the cotangent operator to \\spad{x}")) (|tan| ((|#2| |#2|) "\\spad{tan(x)} applies the tangent operator to \\spad{x}")) (|cos| ((|#2| |#2|) "\\spad{cos(x)} applies the cosine operator to \\spad{x}")) (|sin| ((|#2| |#2|) "\\spad{sin(x)} applies the sine operator to \\spad{x}")) (|log| ((|#2| |#2|) "\\spad{log(x)} applies the logarithm operator to \\spad{x}")) (|exp| ((|#2| |#2|) "\\spad{exp(x)} applies the exponential operator to \\spad{x}"))) NIL NIL -(-274 R -1564) -((|constructor| (NIL "ElementaryFunctionStructurePackage provides functions to test the algebraic independence of various elementary functions,{} using the Risch structure theorem (real and complex versions). It also provides transformations on elementary functions which are not considered simplifications.")) (|tanQ| ((|#2| (|Fraction| (|Integer|)) |#2|) "\\spad{tanQ(q,{}a)} is a local function with a conditional implementation.")) (|rootNormalize| ((|#2| |#2| (|Kernel| |#2|)) "\\spad{rootNormalize(f,{} k)} returns \\spad{f} rewriting either \\spad{k} which must be an \\spad{n}th-root in terms of radicals already in \\spad{f},{} or some radicals in \\spad{f} in terms of \\spad{k}.")) (|validExponential| (((|Union| |#2| "failed") (|List| (|Kernel| |#2|)) |#2| (|Symbol|)) "\\spad{validExponential([k1,{}...,{}kn],{}f,{}x)} returns \\spad{g} if \\spad{exp(f)=g} and \\spad{g} involves only \\spad{k1...kn},{} and \"failed\" otherwise.")) (|realElementary| ((|#2| |#2| (|Symbol|)) "\\spad{realElementary(f,{}x)} rewrites the kernels of \\spad{f} involving \\spad{x} in terms of the 4 fundamental real transcendental elementary functions: \\spad{log,{} exp,{} tan,{} atan}.") ((|#2| |#2|) "\\spad{realElementary(f)} rewrites \\spad{f} in terms of the 4 fundamental real transcendental elementary functions: \\spad{log,{} exp,{} tan,{} atan}.")) (|rischNormalize| (((|Record| (|:| |func| |#2|) (|:| |kers| (|List| (|Kernel| |#2|))) (|:| |vals| (|List| |#2|))) |#2| (|Symbol|)) "\\spad{rischNormalize(f,{} x)} returns \\spad{[g,{} [k1,{}...,{}kn],{} [h1,{}...,{}hn]]} such that \\spad{g = normalize(f,{} x)} and each \\spad{\\spad{ki}} was rewritten as \\spad{\\spad{hi}} during the normalization.")) (|normalize| ((|#2| |#2| (|Symbol|)) "\\spad{normalize(f,{} x)} rewrites \\spad{f} using the least possible number of real algebraically independent kernels involving \\spad{x}.") ((|#2| |#2|) "\\spad{normalize(f)} rewrites \\spad{f} using the least possible number of real algebraically independent kernels."))) +(-274 R -1647) +((|constructor| (NIL "ElementaryFunctionStructurePackage provides functions to test the algebraic independence of various elementary functions, using the Risch structure theorem (real and complex versions). It also provides transformations on elementary functions which are not considered simplifications.")) (|tanQ| ((|#2| (|Fraction| (|Integer|)) |#2|) "\\spad{tanQ(q,a)} is a local function with a conditional implementation.")) (|rootNormalize| ((|#2| |#2| (|Kernel| |#2|)) "\\spad{rootNormalize(f, \\spad{k)}} returns \\spad{f} rewriting either \\spad{k} which must be an nth-root in terms of radicals already in \\spad{f}, or some radicals in \\spad{f} in terms of \\spad{k}.")) (|validExponential| (((|Union| |#2| "failed") (|List| (|Kernel| |#2|)) |#2| (|Symbol|)) "\\spad{validExponential([k1,...,kn],f,x)} returns \\spad{g} if \\spad{exp(f)=g} and \\spad{g} involves only \\spad{k1...kn}, and \"failed\" otherwise.")) (|realElementary| ((|#2| |#2| (|Symbol|)) "\\spad{realElementary(f,x)} rewrites the kernels of \\spad{f} involving \\spad{x} in terms of the 4 fundamental real transcendental elementary functions: \\spad{log, exp, tan, atan}.") ((|#2| |#2|) "\\spad{realElementary(f)} rewrites \\spad{f} in terms of the 4 fundamental real transcendental elementary functions: \\spad{log, exp, tan, atan}.")) (|rischNormalize| (((|Record| (|:| |func| |#2|) (|:| |kers| (|List| (|Kernel| |#2|))) (|:| |vals| (|List| |#2|))) |#2| (|Symbol|)) "\\spad{rischNormalize(f, \\spad{x)}} returns \\spad{[g, [k1,...,kn], [h1,...,hn]]} such that \\spad{g = normalize(f, \\spad{x)}} and each \\spad{ki} was rewritten as \\spad{hi} during the normalization.")) (|normalize| ((|#2| |#2| (|Symbol|)) "\\spad{normalize(f, \\spad{x)}} rewrites \\spad{f} using the least possible number of real algebraically independent kernels involving \\spad{x}.") ((|#2| |#2|) "\\spad{normalize(f)} rewrites \\spad{f} using the least possible number of real algebraically independent kernels."))) NIL NIL (-275 |Coef| UTS ULS) -((|constructor| (NIL "This package provides elementary functions on any Laurent series domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return \"failed\" when this is not possible.")) (|acsch| ((|#3| |#3|) "\\spad{acsch(z)} returns the inverse hyperbolic cosecant of Laurent series \\spad{z}.")) (|asech| ((|#3| |#3|) "\\spad{asech(z)} returns the inverse hyperbolic secant of Laurent series \\spad{z}.")) (|acoth| ((|#3| |#3|) "\\spad{acoth(z)} returns the inverse hyperbolic cotangent of Laurent series \\spad{z}.")) (|atanh| ((|#3| |#3|) "\\spad{atanh(z)} returns the inverse hyperbolic tangent of Laurent series \\spad{z}.")) (|acosh| ((|#3| |#3|) "\\spad{acosh(z)} returns the inverse hyperbolic cosine of Laurent series \\spad{z}.")) (|asinh| ((|#3| |#3|) "\\spad{asinh(z)} returns the inverse hyperbolic sine of Laurent series \\spad{z}.")) (|csch| ((|#3| |#3|) "\\spad{csch(z)} returns the hyperbolic cosecant of Laurent series \\spad{z}.")) (|sech| ((|#3| |#3|) "\\spad{sech(z)} returns the hyperbolic secant of Laurent series \\spad{z}.")) (|coth| ((|#3| |#3|) "\\spad{coth(z)} returns the hyperbolic cotangent of Laurent series \\spad{z}.")) (|tanh| ((|#3| |#3|) "\\spad{tanh(z)} returns the hyperbolic tangent of Laurent series \\spad{z}.")) (|cosh| ((|#3| |#3|) "\\spad{cosh(z)} returns the hyperbolic cosine of Laurent series \\spad{z}.")) (|sinh| ((|#3| |#3|) "\\spad{sinh(z)} returns the hyperbolic sine of Laurent series \\spad{z}.")) (|acsc| ((|#3| |#3|) "\\spad{acsc(z)} returns the arc-cosecant of Laurent series \\spad{z}.")) (|asec| ((|#3| |#3|) "\\spad{asec(z)} returns the arc-secant of Laurent series \\spad{z}.")) (|acot| ((|#3| |#3|) "\\spad{acot(z)} returns the arc-cotangent of Laurent series \\spad{z}.")) (|atan| ((|#3| |#3|) "\\spad{atan(z)} returns the arc-tangent of Laurent series \\spad{z}.")) (|acos| ((|#3| |#3|) "\\spad{acos(z)} returns the arc-cosine of Laurent series \\spad{z}.")) (|asin| ((|#3| |#3|) "\\spad{asin(z)} returns the arc-sine of Laurent series \\spad{z}.")) (|csc| ((|#3| |#3|) "\\spad{csc(z)} returns the cosecant of Laurent series \\spad{z}.")) (|sec| ((|#3| |#3|) "\\spad{sec(z)} returns the secant of Laurent series \\spad{z}.")) (|cot| ((|#3| |#3|) "\\spad{cot(z)} returns the cotangent of Laurent series \\spad{z}.")) (|tan| ((|#3| |#3|) "\\spad{tan(z)} returns the tangent of Laurent series \\spad{z}.")) (|cos| ((|#3| |#3|) "\\spad{cos(z)} returns the cosine of Laurent series \\spad{z}.")) (|sin| ((|#3| |#3|) "\\spad{sin(z)} returns the sine of Laurent series \\spad{z}.")) (|log| ((|#3| |#3|) "\\spad{log(z)} returns the logarithm of Laurent series \\spad{z}.")) (|exp| ((|#3| |#3|) "\\spad{exp(z)} returns the exponential of Laurent series \\spad{z}.")) (** ((|#3| |#3| (|Fraction| (|Integer|))) "\\spad{s ** r} raises a Laurent series \\spad{s} to a rational power \\spad{r}"))) +((|constructor| (NIL "This package provides elementary functions on any Laurent series domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return \"failed\" when this is not possible.")) (|acsch| ((|#3| |#3|) "\\spad{acsch(z)} returns the inverse hyperbolic cosecant of Laurent series \\spad{z.}")) (|asech| ((|#3| |#3|) "\\spad{asech(z)} returns the inverse hyperbolic secant of Laurent series \\spad{z.}")) (|acoth| ((|#3| |#3|) "\\spad{acoth(z)} returns the inverse hyperbolic cotangent of Laurent series \\spad{z.}")) (|atanh| ((|#3| |#3|) "\\spad{atanh(z)} returns the inverse hyperbolic tangent of Laurent series \\spad{z.}")) (|acosh| ((|#3| |#3|) "\\spad{acosh(z)} returns the inverse hyperbolic cosine of Laurent series \\spad{z.}")) (|asinh| ((|#3| |#3|) "\\spad{asinh(z)} returns the inverse hyperbolic sine of Laurent series \\spad{z.}")) (|csch| ((|#3| |#3|) "\\spad{csch(z)} returns the hyperbolic cosecant of Laurent series \\spad{z.}")) (|sech| ((|#3| |#3|) "\\spad{sech(z)} returns the hyperbolic secant of Laurent series \\spad{z.}")) (|coth| ((|#3| |#3|) "\\spad{coth(z)} returns the hyperbolic cotangent of Laurent series \\spad{z.}")) (|tanh| ((|#3| |#3|) "\\spad{tanh(z)} returns the hyperbolic tangent of Laurent series \\spad{z.}")) (|cosh| ((|#3| |#3|) "\\spad{cosh(z)} returns the hyperbolic cosine of Laurent series \\spad{z.}")) (|sinh| ((|#3| |#3|) "\\spad{sinh(z)} returns the hyperbolic sine of Laurent series \\spad{z.}")) (|acsc| ((|#3| |#3|) "\\spad{acsc(z)} returns the arc-cosecant of Laurent series \\spad{z.}")) (|asec| ((|#3| |#3|) "\\spad{asec(z)} returns the arc-secant of Laurent series \\spad{z.}")) (|acot| ((|#3| |#3|) "\\spad{acot(z)} returns the arc-cotangent of Laurent series \\spad{z.}")) (|atan| ((|#3| |#3|) "\\spad{atan(z)} returns the arc-tangent of Laurent series \\spad{z.}")) (|acos| ((|#3| |#3|) "\\spad{acos(z)} returns the arc-cosine of Laurent series \\spad{z.}")) (|asin| ((|#3| |#3|) "\\spad{asin(z)} returns the arc-sine of Laurent series \\spad{z.}")) (|csc| ((|#3| |#3|) "\\spad{csc(z)} returns the cosecant of Laurent series \\spad{z.}")) (|sec| ((|#3| |#3|) "\\spad{sec(z)} returns the secant of Laurent series \\spad{z.}")) (|cot| ((|#3| |#3|) "\\spad{cot(z)} returns the cotangent of Laurent series \\spad{z.}")) (|tan| ((|#3| |#3|) "\\spad{tan(z)} returns the tangent of Laurent series \\spad{z.}")) (|cos| ((|#3| |#3|) "\\spad{cos(z)} returns the cosine of Laurent series \\spad{z.}")) (|sin| ((|#3| |#3|) "\\spad{sin(z)} returns the sine of Laurent series \\spad{z.}")) (|log| ((|#3| |#3|) "\\spad{log(z)} returns the logarithm of Laurent series \\spad{z.}")) (|exp| ((|#3| |#3|) "\\spad{exp(z)} returns the exponential of Laurent series \\spad{z.}")) (** ((|#3| |#3| (|Fraction| (|Integer|))) "\\spad{s \\spad{**} \\spad{r}} raises a Laurent series \\spad{s} to a rational power \\spad{r}"))) NIL ((|HasCategory| |#1| (QUOTE (-366)))) (-276 |Coef| ULS UPXS EFULS) -((|constructor| (NIL "This package provides elementary functions on any Laurent series domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return \"failed\" when this is not possible.")) (|acsch| ((|#3| |#3|) "\\spad{acsch(z)} returns the inverse hyperbolic cosecant of a Puiseux series \\spad{z}.")) (|asech| ((|#3| |#3|) "\\spad{asech(z)} returns the inverse hyperbolic secant of a Puiseux series \\spad{z}.")) (|acoth| ((|#3| |#3|) "\\spad{acoth(z)} returns the inverse hyperbolic cotangent of a Puiseux series \\spad{z}.")) (|atanh| ((|#3| |#3|) "\\spad{atanh(z)} returns the inverse hyperbolic tangent of a Puiseux series \\spad{z}.")) (|acosh| ((|#3| |#3|) "\\spad{acosh(z)} returns the inverse hyperbolic cosine of a Puiseux series \\spad{z}.")) (|asinh| ((|#3| |#3|) "\\spad{asinh(z)} returns the inverse hyperbolic sine of a Puiseux series \\spad{z}.")) (|csch| ((|#3| |#3|) "\\spad{csch(z)} returns the hyperbolic cosecant of a Puiseux series \\spad{z}.")) (|sech| ((|#3| |#3|) "\\spad{sech(z)} returns the hyperbolic secant of a Puiseux series \\spad{z}.")) (|coth| ((|#3| |#3|) "\\spad{coth(z)} returns the hyperbolic cotangent of a Puiseux series \\spad{z}.")) (|tanh| ((|#3| |#3|) "\\spad{tanh(z)} returns the hyperbolic tangent of a Puiseux series \\spad{z}.")) (|cosh| ((|#3| |#3|) "\\spad{cosh(z)} returns the hyperbolic cosine of a Puiseux series \\spad{z}.")) (|sinh| ((|#3| |#3|) "\\spad{sinh(z)} returns the hyperbolic sine of a Puiseux series \\spad{z}.")) (|acsc| ((|#3| |#3|) "\\spad{acsc(z)} returns the arc-cosecant of a Puiseux series \\spad{z}.")) (|asec| ((|#3| |#3|) "\\spad{asec(z)} returns the arc-secant of a Puiseux series \\spad{z}.")) (|acot| ((|#3| |#3|) "\\spad{acot(z)} returns the arc-cotangent of a Puiseux series \\spad{z}.")) (|atan| ((|#3| |#3|) "\\spad{atan(z)} returns the arc-tangent of a Puiseux series \\spad{z}.")) (|acos| ((|#3| |#3|) "\\spad{acos(z)} returns the arc-cosine of a Puiseux series \\spad{z}.")) (|asin| ((|#3| |#3|) "\\spad{asin(z)} returns the arc-sine of a Puiseux series \\spad{z}.")) (|csc| ((|#3| |#3|) "\\spad{csc(z)} returns the cosecant of a Puiseux series \\spad{z}.")) (|sec| ((|#3| |#3|) "\\spad{sec(z)} returns the secant of a Puiseux series \\spad{z}.")) (|cot| ((|#3| |#3|) "\\spad{cot(z)} returns the cotangent of a Puiseux series \\spad{z}.")) (|tan| ((|#3| |#3|) "\\spad{tan(z)} returns the tangent of a Puiseux series \\spad{z}.")) (|cos| ((|#3| |#3|) "\\spad{cos(z)} returns the cosine of a Puiseux series \\spad{z}.")) (|sin| ((|#3| |#3|) "\\spad{sin(z)} returns the sine of a Puiseux series \\spad{z}.")) (|log| ((|#3| |#3|) "\\spad{log(z)} returns the logarithm of a Puiseux series \\spad{z}.")) (|exp| ((|#3| |#3|) "\\spad{exp(z)} returns the exponential of a Puiseux series \\spad{z}.")) (** ((|#3| |#3| (|Fraction| (|Integer|))) "\\spad{z ** r} raises a Puiseaux series \\spad{z} to a rational power \\spad{r}"))) +((|constructor| (NIL "This package provides elementary functions on any Laurent series domain over a field which was constructed from a Taylor series domain. These functions are implemented by calling the corresponding functions on the Taylor series domain. We also provide 'partial functions' which compute transcendental functions of Laurent series when possible and return \"failed\" when this is not possible.")) (|acsch| ((|#3| |#3|) "\\spad{acsch(z)} returns the inverse hyperbolic cosecant of a Puiseux series \\spad{z.}")) (|asech| ((|#3| |#3|) "\\spad{asech(z)} returns the inverse hyperbolic secant of a Puiseux series \\spad{z.}")) (|acoth| ((|#3| |#3|) "\\spad{acoth(z)} returns the inverse hyperbolic cotangent of a Puiseux series \\spad{z.}")) (|atanh| ((|#3| |#3|) "\\spad{atanh(z)} returns the inverse hyperbolic tangent of a Puiseux series \\spad{z.}")) (|acosh| ((|#3| |#3|) "\\spad{acosh(z)} returns the inverse hyperbolic cosine of a Puiseux series \\spad{z.}")) (|asinh| ((|#3| |#3|) "\\spad{asinh(z)} returns the inverse hyperbolic sine of a Puiseux series \\spad{z.}")) (|csch| ((|#3| |#3|) "\\spad{csch(z)} returns the hyperbolic cosecant of a Puiseux series \\spad{z.}")) (|sech| ((|#3| |#3|) "\\spad{sech(z)} returns the hyperbolic secant of a Puiseux series \\spad{z.}")) (|coth| ((|#3| |#3|) "\\spad{coth(z)} returns the hyperbolic cotangent of a Puiseux series \\spad{z.}")) (|tanh| ((|#3| |#3|) "\\spad{tanh(z)} returns the hyperbolic tangent of a Puiseux series \\spad{z.}")) (|cosh| ((|#3| |#3|) "\\spad{cosh(z)} returns the hyperbolic cosine of a Puiseux series \\spad{z.}")) (|sinh| ((|#3| |#3|) "\\spad{sinh(z)} returns the hyperbolic sine of a Puiseux series \\spad{z.}")) (|acsc| ((|#3| |#3|) "\\spad{acsc(z)} returns the arc-cosecant of a Puiseux series \\spad{z.}")) (|asec| ((|#3| |#3|) "\\spad{asec(z)} returns the arc-secant of a Puiseux series \\spad{z.}")) (|acot| ((|#3| |#3|) "\\spad{acot(z)} returns the arc-cotangent of a Puiseux series \\spad{z.}")) (|atan| ((|#3| |#3|) "\\spad{atan(z)} returns the arc-tangent of a Puiseux series \\spad{z.}")) (|acos| ((|#3| |#3|) "\\spad{acos(z)} returns the arc-cosine of a Puiseux series \\spad{z.}")) (|asin| ((|#3| |#3|) "\\spad{asin(z)} returns the arc-sine of a Puiseux series \\spad{z.}")) (|csc| ((|#3| |#3|) "\\spad{csc(z)} returns the cosecant of a Puiseux series \\spad{z.}")) (|sec| ((|#3| |#3|) "\\spad{sec(z)} returns the secant of a Puiseux series \\spad{z.}")) (|cot| ((|#3| |#3|) "\\spad{cot(z)} returns the cotangent of a Puiseux series \\spad{z.}")) (|tan| ((|#3| |#3|) "\\spad{tan(z)} returns the tangent of a Puiseux series \\spad{z.}")) (|cos| ((|#3| |#3|) "\\spad{cos(z)} returns the cosine of a Puiseux series \\spad{z.}")) (|sin| ((|#3| |#3|) "\\spad{sin(z)} returns the sine of a Puiseux series \\spad{z.}")) (|log| ((|#3| |#3|) "\\spad{log(z)} returns the logarithm of a Puiseux series \\spad{z.}")) (|exp| ((|#3| |#3|) "\\spad{exp(z)} returns the exponential of a Puiseux series \\spad{z.}")) (** ((|#3| |#3| (|Fraction| (|Integer|))) "\\spad{z \\spad{**} \\spad{r}} raises a Puiseaux series \\spad{z} to a rational power \\spad{r}"))) NIL ((|HasCategory| |#1| (QUOTE (-366)))) (-277 A S) -((|constructor| (NIL "An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists and streams which are represented by linked structures so as to make insertion,{} deletion,{} and concatenation efficient. However,{} access to elements of these extensible aggregates is generally slow since access is made from the end. See \\spadtype{FlexibleArray} for an exception.")) (|removeDuplicates!| (($ $) "\\spad{removeDuplicates!(u)} destructively removes duplicates from \\spad{u}.")) (|select!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select!(p,{}u)} destructively changes \\spad{u} by keeping only values \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})}.")) (|merge!| (($ $ $) "\\spad{merge!(u,{}v)} destructively merges \\spad{u} and \\spad{v} in ascending order.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $ $) "\\spad{merge!(p,{}u,{}v)} destructively merges \\spad{u} and \\spad{v} using predicate \\spad{p}.")) (|insert!| (($ $ $ (|Integer|)) "\\spad{insert!(v,{}u,{}i)} destructively inserts aggregate \\spad{v} into \\spad{u} at position \\spad{i}.") (($ |#2| $ (|Integer|)) "\\spad{insert!(x,{}u,{}i)} destructively inserts \\spad{x} into \\spad{u} at position \\spad{i}.")) (|remove!| (($ |#2| $) "\\spad{remove!(x,{}u)} destructively removes all values \\spad{x} from \\spad{u}.") (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove!(p,{}u)} destructively removes all elements \\spad{x} of \\spad{u} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}.")) (|delete!| (($ $ (|UniversalSegment| (|Integer|))) "\\spad{delete!(u,{}i..j)} destructively deletes elements \\spad{u}.\\spad{i} through \\spad{u}.\\spad{j}.") (($ $ (|Integer|)) "\\indented{1}{delete!(\\spad{u},{}\\spad{i}) destructively deletes the \\axiom{\\spad{i}}th element of \\spad{u}.} \\blankline \\spad{E} Data:=Record(age:Integer,{}gender:String) \\spad{E} a1:AssociationList(String,{}Data):=table() \\spad{E} \\spad{a1}.\"tim\":=[55,{}\"male\"]\\$Data \\spad{E} delete!(\\spad{a1},{}1)")) (|concat!| (($ $ $) "\\spad{concat!(u,{}v)} destructively appends \\spad{v} to the end of \\spad{u}. \\spad{v} is unchanged") (($ $ |#2|) "\\spad{concat!(u,{}x)} destructively adds element \\spad{x} to the end of \\spad{u}."))) +((|constructor| (NIL "An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists and streams which are represented by linked structures so as to make insertion, deletion, and concatenation efficient. However, access to elements of these extensible aggregates is generally slow since access is made from the end. See \\spadtype{FlexibleArray} for an exception.")) (|removeDuplicates!| (($ $) "\\spad{removeDuplicates!(u)} destructively removes duplicates from u.")) (|select!| (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{select!(p,u)} destructively changes \\spad{u} by keeping only values \\spad{x} such that \\axiom{p(x)}.")) (|merge!| (($ $ $) "\\spad{merge!(u,v)} destructively merges \\spad{u} and \\spad{v} in ascending order.") (($ (|Mapping| (|Boolean|) |#2| |#2|) $ $) "\\spad{merge!(p,u,v)} destructively merges \\spad{u} and \\spad{v} using predicate \\spad{p.}")) (|insert!| (($ $ $ (|Integer|)) "\\spad{insert!(v,u,i)} destructively inserts aggregate \\spad{v} into \\spad{u} at position i.") (($ |#2| $ (|Integer|)) "\\spad{insert!(x,u,i)} destructively inserts \\spad{x} into \\spad{u} at position i.")) (|remove!| (($ |#2| $) "\\spad{remove!(x,u)} destructively removes all values \\spad{x} from u.") (($ (|Mapping| (|Boolean|) |#2|) $) "\\spad{remove!(p,u)} destructively removes all elements \\spad{x} of \\spad{u} such that \\axiom{p(x)} is true.")) (|delete!| (($ $ (|UniversalSegment| (|Integer|))) "\\spad{delete!(u,i..j)} destructively deletes elements u.i through u.j.") (($ $ (|Integer|)) "\\indented{1}{delete!(u,i) destructively deletes the \\axiom{i}th element of u.} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data \\spad{E} delete!(a1,1)")) (|concat!| (($ $ $) "\\spad{concat!(u,v)} destructively appends \\spad{v} to the end of u. \\spad{v} is unchanged") (($ $ |#2|) "\\spad{concat!(u,x)} destructively adds element \\spad{x} to the end of u."))) NIL -((|HasCategory| |#2| (QUOTE (-843))) (|HasCategory| |#2| (QUOTE (-1091)))) +((|HasCategory| |#2| (QUOTE (-844))) (|HasCategory| |#2| (QUOTE (-1093)))) (-278 S) -((|constructor| (NIL "An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists and streams which are represented by linked structures so as to make insertion,{} deletion,{} and concatenation efficient. However,{} access to elements of these extensible aggregates is generally slow since access is made from the end. See \\spadtype{FlexibleArray} for an exception.")) (|removeDuplicates!| (($ $) "\\spad{removeDuplicates!(u)} destructively removes duplicates from \\spad{u}.")) (|select!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select!(p,{}u)} destructively changes \\spad{u} by keeping only values \\spad{x} such that \\axiom{\\spad{p}(\\spad{x})}.")) (|merge!| (($ $ $) "\\spad{merge!(u,{}v)} destructively merges \\spad{u} and \\spad{v} in ascending order.") (($ (|Mapping| (|Boolean|) |#1| |#1|) $ $) "\\spad{merge!(p,{}u,{}v)} destructively merges \\spad{u} and \\spad{v} using predicate \\spad{p}.")) (|insert!| (($ $ $ (|Integer|)) "\\spad{insert!(v,{}u,{}i)} destructively inserts aggregate \\spad{v} into \\spad{u} at position \\spad{i}.") (($ |#1| $ (|Integer|)) "\\spad{insert!(x,{}u,{}i)} destructively inserts \\spad{x} into \\spad{u} at position \\spad{i}.")) (|remove!| (($ |#1| $) "\\spad{remove!(x,{}u)} destructively removes all values \\spad{x} from \\spad{u}.") (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove!(p,{}u)} destructively removes all elements \\spad{x} of \\spad{u} such that \\axiom{\\spad{p}(\\spad{x})} is \\spad{true}.")) (|delete!| (($ $ (|UniversalSegment| (|Integer|))) "\\spad{delete!(u,{}i..j)} destructively deletes elements \\spad{u}.\\spad{i} through \\spad{u}.\\spad{j}.") (($ $ (|Integer|)) "\\indented{1}{delete!(\\spad{u},{}\\spad{i}) destructively deletes the \\axiom{\\spad{i}}th element of \\spad{u}.} \\blankline \\spad{E} Data:=Record(age:Integer,{}gender:String) \\spad{E} a1:AssociationList(String,{}Data):=table() \\spad{E} \\spad{a1}.\"tim\":=[55,{}\"male\"]\\$Data \\spad{E} delete!(\\spad{a1},{}1)")) (|concat!| (($ $ $) "\\spad{concat!(u,{}v)} destructively appends \\spad{v} to the end of \\spad{u}. \\spad{v} is unchanged") (($ $ |#1|) "\\spad{concat!(u,{}x)} destructively adds element \\spad{x} to the end of \\spad{u}."))) -((-4536 . T) (-2982 . T)) +((|constructor| (NIL "An extensible aggregate is one which allows insertion and deletion of entries. These aggregates are models of lists and streams which are represented by linked structures so as to make insertion, deletion, and concatenation efficient. However, access to elements of these extensible aggregates is generally slow since access is made from the end. See \\spadtype{FlexibleArray} for an exception.")) (|removeDuplicates!| (($ $) "\\spad{removeDuplicates!(u)} destructively removes duplicates from u.")) (|select!| (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{select!(p,u)} destructively changes \\spad{u} by keeping only values \\spad{x} such that \\axiom{p(x)}.")) (|merge!| (($ $ $) "\\spad{merge!(u,v)} destructively merges \\spad{u} and \\spad{v} in ascending order.") (($ (|Mapping| (|Boolean|) |#1| |#1|) $ $) "\\spad{merge!(p,u,v)} destructively merges \\spad{u} and \\spad{v} using predicate \\spad{p.}")) (|insert!| (($ $ $ (|Integer|)) "\\spad{insert!(v,u,i)} destructively inserts aggregate \\spad{v} into \\spad{u} at position i.") (($ |#1| $ (|Integer|)) "\\spad{insert!(x,u,i)} destructively inserts \\spad{x} into \\spad{u} at position i.")) (|remove!| (($ |#1| $) "\\spad{remove!(x,u)} destructively removes all values \\spad{x} from u.") (($ (|Mapping| (|Boolean|) |#1|) $) "\\spad{remove!(p,u)} destructively removes all elements \\spad{x} of \\spad{u} such that \\axiom{p(x)} is true.")) (|delete!| (($ $ (|UniversalSegment| (|Integer|))) "\\spad{delete!(u,i..j)} destructively deletes elements u.i through u.j.") (($ $ (|Integer|)) "\\indented{1}{delete!(u,i) destructively deletes the \\axiom{i}th element of u.} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data \\spad{E} delete!(a1,1)")) (|concat!| (($ $ $) "\\spad{concat!(u,v)} destructively appends \\spad{v} to the end of u. \\spad{v} is unchanged") (($ $ |#1|) "\\spad{concat!(u,x)} destructively adds element \\spad{x} to the end of u."))) +((-4572 . T) (-4317 . T)) NIL (-279 S) -((|constructor| (NIL "Category for the elementary functions.")) (** (($ $ $) "\\spad{x**y} returns \\spad{x} to the power \\spad{y}.")) (|exp| (($ $) "\\spad{exp(x)} returns \\%\\spad{e} to the power \\spad{x}.")) (|log| (($ $) "\\spad{log(x)} returns the natural logarithm of \\spad{x}."))) +((|constructor| (NIL "Category for the elementary functions.")) (** (($ $ $) "\\spad{x**y} returns \\spad{x} to the power \\spad{y.}")) (|exp| (($ $) "\\spad{exp(x)} returns \\%e to the power \\spad{x.}")) (|log| (($ $) "\\spad{log(x)} returns the natural logarithm of \\spad{x.}"))) NIL NIL (-280) -((|constructor| (NIL "Category for the elementary functions.")) (** (($ $ $) "\\spad{x**y} returns \\spad{x} to the power \\spad{y}.")) (|exp| (($ $) "\\spad{exp(x)} returns \\%\\spad{e} to the power \\spad{x}.")) (|log| (($ $) "\\spad{log(x)} returns the natural logarithm of \\spad{x}."))) +((|constructor| (NIL "Category for the elementary functions.")) (** (($ $ $) "\\spad{x**y} returns \\spad{x} to the power \\spad{y.}")) (|exp| (($ $) "\\spad{exp(x)} returns \\%e to the power \\spad{x.}")) (|log| (($ $) "\\spad{log(x)} returns the natural logarithm of \\spad{x.}"))) NIL NIL (-281 |Coef| UTS) -((|constructor| (NIL "The elliptic functions \\spad{sn},{} \\spad{sc} and \\spad{dn} are expanded as Taylor series.")) (|sncndn| (((|List| (|Stream| |#1|)) (|Stream| |#1|) |#1|) "\\spad{sncndn(s,{}c)} is used internally.")) (|dn| ((|#2| |#2| |#1|) "\\spad{dn(x,{}k)} expands the elliptic function \\spad{dn} as a Taylor \\indented{1}{series.}")) (|cn| ((|#2| |#2| |#1|) "\\spad{cn(x,{}k)} expands the elliptic function \\spad{cn} as a Taylor \\indented{1}{series.}")) (|sn| ((|#2| |#2| |#1|) "\\spad{sn(x,{}k)} expands the elliptic function \\spad{sn} as a Taylor \\indented{1}{series.}"))) +((|constructor| (NIL "The elliptic functions \\spad{sn,} \\spad{sc} and \\spad{dn} are expanded as Taylor series.")) (|sncndn| (((|List| (|Stream| |#1|)) (|Stream| |#1|) |#1|) "\\spad{sncndn(s,c)} is used internally.")) (|dn| ((|#2| |#2| |#1|) "\\spad{dn(x,k)} expands the elliptic function \\spad{dn} as a Taylor \\indented{1}{series.}")) (|cn| ((|#2| |#2| |#1|) "\\spad{cn(x,k)} expands the elliptic function \\spad{cn} as a Taylor \\indented{1}{series.}")) (|sn| ((|#2| |#2| |#1|) "\\spad{sn(x,k)} expands the elliptic function \\spad{sn} as a Taylor \\indented{1}{series.}"))) NIL NIL (-282 S |Index|) -((|constructor| (NIL "An eltable over domains \\spad{D} and \\spad{I} is a structure which can be viewed as a function from \\spad{D} to \\spad{I}. Examples of eltable structures range from data structures,{} \\spadignore{e.g.} those of type \\spadtype{List},{} to algebraic structures like \\spadtype{Polynomial}.")) (|elt| ((|#2| $ |#1|) "\\spad{elt(u,{}i)} (also written: \\spad{u} . \\spad{i}) returns the element of \\spad{u} indexed by \\spad{i}. Error: if \\spad{i} is not an index of \\spad{u}."))) +((|constructor| (NIL "An eltable over domains \\spad{D} and \\spad{I} is a structure which can be viewed as a function from \\spad{D} to I. Examples of eltable structures range from data structures, \\spadignore{e.g.} those of type \\spadtype{List}, to algebraic structures like \\spadtype{Polynomial}.")) (|elt| ((|#2| $ |#1|) "\\spad{elt(u,i)} (also written: \\spad{u} . i) returns the element of \\spad{u} indexed by i. Error: if \\spad{i} is not an index of u."))) NIL NIL (-283 S |Dom| |Im|) -((|constructor| (NIL "An eltable aggregate is one which can be viewed as a function. For example,{} the list \\axiom{[1,{}7,{}4]} can applied to 0,{}1,{} and 2 respectively will return the integers 1,{}7,{} and 4; thus this list may be viewed as mapping 0 to 1,{} 1 to 7 and 2 to 4. In general,{} an aggregate can map members of a domain Dom to an image domain Im.")) (|qsetelt!| ((|#3| $ |#2| |#3|) "\\spad{qsetelt!(u,{}x,{}y)} sets the image of \\axiom{\\spad{x}} to be \\axiom{\\spad{y}} under \\axiom{\\spad{u}},{} without checking that \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}}. If such a check is required use the function \\axiom{setelt}.")) (|setelt| ((|#3| $ |#2| |#3|) "\\spad{setelt(u,{}x,{}y)} sets the image of \\spad{x} to be \\spad{y} under \\spad{u},{} assuming \\spad{x} is in the domain of \\spad{u}. Error: if \\spad{x} is not in the domain of \\spad{u}.")) (|qelt| ((|#3| $ |#2|) "\\spad{qelt(u,{} x)} applies \\axiom{\\spad{u}} to \\axiom{\\spad{x}} without checking whether \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}}. If \\axiom{\\spad{x}} is not in the domain of \\axiom{\\spad{u}} a memory-access violation may occur. If a check on whether \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}} is required,{} use the function \\axiom{elt}.")) (|elt| ((|#3| $ |#2| |#3|) "\\spad{elt(u,{} x,{} y)} applies \\spad{u} to \\spad{x} if \\spad{x} is in the domain of \\spad{u},{} and returns \\spad{y} otherwise. For example,{} if \\spad{u} is a polynomial in \\axiom{\\spad{x}} over the rationals,{} \\axiom{elt(\\spad{u},{}\\spad{n},{}0)} may define the coefficient of \\axiom{\\spad{x}} to the power \\spad{n},{} returning 0 when \\spad{n} is out of range."))) +((|constructor| (NIL "An eltable aggregate is one which can be viewed as a function. For example, the list \\axiom{[1,7,4]} can applied to 0,1, and 2 respectively will return the integers 1,7, and 4; thus this list may be viewed as mapping 0 to 1, 1 to 7 and 2 to 4. In general, an aggregate can map members of a domain Dom to an image domain Im.")) (|qsetelt!| ((|#3| $ |#2| |#3|) "\\spad{qsetelt!(u,x,y)} sets the image of \\axiom{x} to be \\axiom{y} under \\axiom{u}, without checking that \\axiom{x} is in the domain of \\axiom{u}. If such a check is required use the function \\axiom{setelt}.")) (|setelt| ((|#3| $ |#2| |#3|) "\\spad{setelt(u,x,y)} sets the image of \\spad{x} to be \\spad{y} under u, assuming \\spad{x} is in the domain of u. Error: if \\spad{x} is not in the domain of u.")) (|qelt| ((|#3| $ |#2|) "\\spad{qelt(u, \\spad{x)}} applies \\axiom{u} to \\axiom{x} without checking whether \\axiom{x} is in the domain of \\axiom{u}. If \\axiom{x} is not in the domain of \\axiom{u} a memory-access violation may occur. If a check on whether \\axiom{x} is in the domain of \\axiom{u} is required, use the function \\axiom{elt}.")) (|elt| ((|#3| $ |#2| |#3|) "\\spad{elt(u, \\spad{x,} \\spad{y)}} applies \\spad{u} to \\spad{x} if \\spad{x} is in the domain of u, and returns \\spad{y} otherwise. For example, if \\spad{u} is a polynomial in \\axiom{x} over the rationals, \\axiom{elt(u,n,0)} may define the coefficient of \\axiom{x} to the power \\spad{n,} returning 0 when \\spad{n} is out of range."))) NIL -((|HasAttribute| |#1| (QUOTE -4536))) +((|HasAttribute| |#1| (QUOTE -4572))) (-284 |Dom| |Im|) -((|constructor| (NIL "An eltable aggregate is one which can be viewed as a function. For example,{} the list \\axiom{[1,{}7,{}4]} can applied to 0,{}1,{} and 2 respectively will return the integers 1,{}7,{} and 4; thus this list may be viewed as mapping 0 to 1,{} 1 to 7 and 2 to 4. In general,{} an aggregate can map members of a domain Dom to an image domain Im.")) (|qsetelt!| ((|#2| $ |#1| |#2|) "\\spad{qsetelt!(u,{}x,{}y)} sets the image of \\axiom{\\spad{x}} to be \\axiom{\\spad{y}} under \\axiom{\\spad{u}},{} without checking that \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}}. If such a check is required use the function \\axiom{setelt}.")) (|setelt| ((|#2| $ |#1| |#2|) "\\spad{setelt(u,{}x,{}y)} sets the image of \\spad{x} to be \\spad{y} under \\spad{u},{} assuming \\spad{x} is in the domain of \\spad{u}. Error: if \\spad{x} is not in the domain of \\spad{u}.")) (|qelt| ((|#2| $ |#1|) "\\spad{qelt(u,{} x)} applies \\axiom{\\spad{u}} to \\axiom{\\spad{x}} without checking whether \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}}. If \\axiom{\\spad{x}} is not in the domain of \\axiom{\\spad{u}} a memory-access violation may occur. If a check on whether \\axiom{\\spad{x}} is in the domain of \\axiom{\\spad{u}} is required,{} use the function \\axiom{elt}.")) (|elt| ((|#2| $ |#1| |#2|) "\\spad{elt(u,{} x,{} y)} applies \\spad{u} to \\spad{x} if \\spad{x} is in the domain of \\spad{u},{} and returns \\spad{y} otherwise. For example,{} if \\spad{u} is a polynomial in \\axiom{\\spad{x}} over the rationals,{} \\axiom{elt(\\spad{u},{}\\spad{n},{}0)} may define the coefficient of \\axiom{\\spad{x}} to the power \\spad{n},{} returning 0 when \\spad{n} is out of range."))) +((|constructor| (NIL "An eltable aggregate is one which can be viewed as a function. For example, the list \\axiom{[1,7,4]} can applied to 0,1, and 2 respectively will return the integers 1,7, and 4; thus this list may be viewed as mapping 0 to 1, 1 to 7 and 2 to 4. In general, an aggregate can map members of a domain Dom to an image domain Im.")) (|qsetelt!| ((|#2| $ |#1| |#2|) "\\spad{qsetelt!(u,x,y)} sets the image of \\axiom{x} to be \\axiom{y} under \\axiom{u}, without checking that \\axiom{x} is in the domain of \\axiom{u}. If such a check is required use the function \\axiom{setelt}.")) (|setelt| ((|#2| $ |#1| |#2|) "\\spad{setelt(u,x,y)} sets the image of \\spad{x} to be \\spad{y} under u, assuming \\spad{x} is in the domain of u. Error: if \\spad{x} is not in the domain of u.")) (|qelt| ((|#2| $ |#1|) "\\spad{qelt(u, \\spad{x)}} applies \\axiom{u} to \\axiom{x} without checking whether \\axiom{x} is in the domain of \\axiom{u}. If \\axiom{x} is not in the domain of \\axiom{u} a memory-access violation may occur. If a check on whether \\axiom{x} is in the domain of \\axiom{u} is required, use the function \\axiom{elt}.")) (|elt| ((|#2| $ |#1| |#2|) "\\spad{elt(u, \\spad{x,} \\spad{y)}} applies \\spad{u} to \\spad{x} if \\spad{x} is in the domain of u, and returns \\spad{y} otherwise. For example, if \\spad{u} is a polynomial in \\axiom{x} over the rationals, \\axiom{elt(u,n,0)} may define the coefficient of \\axiom{x} to the power \\spad{n,} returning 0 when \\spad{n} is out of range."))) NIL NIL -(-285 S R |Mod| -2461 -3288 |exactQuo|) -((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing},{} \\spadtype{ModularField}")) (|elt| ((|#2| $ |#2|) "\\spad{elt(x,{}r)} or \\spad{x}.\\spad{r} is not documented")) (|inv| (($ $) "\\spad{inv(x)} is not documented")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} is not documented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,{}y)} is not documented")) (|reduce| (($ |#2| |#3|) "\\spad{reduce(r,{}m)} is not documented")) (|coerce| ((|#2| $) "\\spad{coerce(x)} is not documented")) (|modulus| ((|#3| $) "\\spad{modulus(x)} is not documented"))) -((-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +(-285 S R |Mod| -2688 -2102 |exactQuo|) +((|constructor| (NIL "These domains are used for the factorization and gcds of univariate polynomials over the integers in order to work modulo different primes. See \\spadtype{ModularRing}, \\spadtype{ModularField}")) (|elt| ((|#2| $ |#2|) "\\spad{elt(x,r)} or \\spad{x.r} is not documented")) (|inv| (($ $) "\\spad{inv(x)} is not documented")) (|recip| (((|Union| $ "failed") $) "\\spad{recip(x)} is not documented")) (|exQuo| (((|Union| $ "failed") $ $) "\\spad{exQuo(x,y)} is not documented")) (|reduce| (($ |#2| |#3|) "\\spad{reduce(r,m)} is not documented")) (|coerce| ((|#2| $) "\\spad{coerce(x)} is not documented")) (|modulus| ((|#3| $) "\\spad{modulus(x)} is not documented"))) +((-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-286) -((|constructor| (NIL "Entire Rings (non-commutative Integral Domains),{} \\spadignore{i.e.} a ring not necessarily commutative which has no zero divisors. \\blankline Axioms\\spad{\\br} \\tab{5}\\spad{ab=0 => a=0 or b=0} \\spad{--} known as noZeroDivisors\\spad{\\br} \\tab{5}\\spad{not(1=0)}")) (|noZeroDivisors| ((|attribute|) "if a product is zero then one of the factors must be zero."))) -((-4528 . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "Entire Rings (non-commutative Integral Domains), \\spadignore{i.e.} a ring not necessarily commutative which has no zero divisors. \\blankline Axioms\\br \\tab{5}\\spad{ab=0 \\spad{=>} \\spad{a=0} or b=0} \\spad{--} known as noZeroDivisors\\br \\tab{5}\\spad{not(1=0)}")) (|noZeroDivisors| ((|attribute|) "if a product is zero then one of the factors must be zero."))) +((-4564 . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-287 R) -((|constructor| (NIL "This is a package for the exact computation of eigenvalues and eigenvectors. This package can be made to work for matrices with coefficients which are rational functions over a ring where we can factor polynomials. Rational eigenvalues are always explicitly computed while the non-rational ones are expressed in terms of their minimal polynomial.")) (|eigenvectors| (((|List| (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |eigmult| (|NonNegativeInteger|)) (|:| |eigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|))))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvectors(m)} returns the eigenvalues and eigenvectors for the matrix \\spad{m}. The rational eigenvalues and the correspondent eigenvectors are explicitely computed,{} while the non rational ones are given via their minimal polynomial and the corresponding eigenvectors are expressed in terms of a \"generic\" root of such a polynomial.")) (|generalizedEigenvectors| (((|List| (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |geneigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|))))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{generalizedEigenvectors(m)} returns the generalized eigenvectors of the matrix \\spad{m}.")) (|generalizedEigenvector| (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |eigmult| (|NonNegativeInteger|)) (|:| |eigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{generalizedEigenvector(eigen,{}m)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \\spad{eigen},{} as returned by the function eigenvectors.") (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|))) (|Matrix| (|Fraction| (|Polynomial| |#1|))) (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{generalizedEigenvector(alpha,{}m,{}k,{}g)} returns the generalized eigenvectors of the matrix relative to the eigenvalue \\spad{alpha}. The integers \\spad{k} and \\spad{g} are respectively the algebraic and the geometric multiplicity of tye eigenvalue \\spad{alpha}. \\spad{alpha} can be either rational or not. In the seconda case apha is the minimal polynomial of the eigenvalue.")) (|eigenvector| (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvector(eigval,{}m)} returns the eigenvectors belonging to the eigenvalue \\spad{eigval} for the matrix \\spad{m}.")) (|eigenvalues| (((|List| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvalues(m)} returns the eigenvalues of the matrix \\spad{m} which are expressible as rational functions over the rational numbers.")) (|characteristicPolynomial| (((|Polynomial| |#1|) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{characteristicPolynomial(m)} returns the characteristicPolynomial of the matrix \\spad{m} using a new generated symbol symbol as the main variable.") (((|Polynomial| |#1|) (|Matrix| (|Fraction| (|Polynomial| |#1|))) (|Symbol|)) "\\spad{characteristicPolynomial(m,{}var)} returns the characteristicPolynomial of the matrix \\spad{m} using the symbol \\spad{var} as the main variable."))) +((|constructor| (NIL "This is a package for the exact computation of eigenvalues and eigenvectors. This package can be made to work for matrices with coefficients which are rational functions over a ring where we can factor polynomials. Rational eigenvalues are always explicitly computed while the non-rational ones are expressed in terms of their minimal polynomial.")) (|eigenvectors| (((|List| (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |eigmult| (|NonNegativeInteger|)) (|:| |eigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|))))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvectors(m)} returns the eigenvalues and eigenvectors for the matrix \\spad{m.} The rational eigenvalues and the correspondent eigenvectors are explicitely computed, while the non rational ones are given via their minimal polynomial and the corresponding eigenvectors are expressed in terms of a \"generic\" root of such a polynomial.")) (|generalizedEigenvectors| (((|List| (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |geneigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|))))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{generalizedEigenvectors(m)} returns the generalized eigenvectors of the matrix \\spad{m.}")) (|generalizedEigenvector| (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Record| (|:| |eigval| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|:| |eigmult| (|NonNegativeInteger|)) (|:| |eigvec| (|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{generalizedEigenvector(eigen,m)} returns the generalized eigenvectors of the matrix relative to the eigenvalue eigen, as returned by the function eigenvectors.") (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|))) (|Matrix| (|Fraction| (|Polynomial| |#1|))) (|NonNegativeInteger|) (|NonNegativeInteger|)) "\\spad{generalizedEigenvector(alpha,m,k,g)} returns the generalized eigenvectors of the matrix relative to the eigenvalue alpha. The integers \\spad{k} and \\spad{g} are respectively the algebraic and the geometric multiplicity of tye eigenvalue alpha. \\spad{alpha} can be either rational or not. In the seconda case apha is the minimal polynomial of the eigenvalue.")) (|eigenvector| (((|List| (|Matrix| (|Fraction| (|Polynomial| |#1|)))) (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvector(eigval,m)} returns the eigenvectors belonging to the eigenvalue \\spad{eigval} for the matrix \\spad{m.}")) (|eigenvalues| (((|List| (|Union| (|Fraction| (|Polynomial| |#1|)) (|SuchThat| (|Symbol|) (|Polynomial| |#1|)))) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{eigenvalues(m)} returns the eigenvalues of the matrix \\spad{m} which are expressible as rational functions over the rational numbers.")) (|characteristicPolynomial| (((|Polynomial| |#1|) (|Matrix| (|Fraction| (|Polynomial| |#1|)))) "\\spad{characteristicPolynomial(m)} returns the characteristicPolynomial of the matrix \\spad{m} using a new generated symbol symbol as the main variable.") (((|Polynomial| |#1|) (|Matrix| (|Fraction| (|Polynomial| |#1|))) (|Symbol|)) "\\spad{characteristicPolynomial(m,var)} returns the characteristicPolynomial of the matrix \\spad{m} using the symbol \\spad{var} as the main variable."))) NIL NIL (-288 S R) -((|constructor| (NIL "This package provides operations for mapping the sides of equations.")) (|map| (((|Equation| |#2|) (|Mapping| |#2| |#1|) (|Equation| |#1|)) "\\spad{map(f,{}eq)} returns an equation where \\spad{f} is applied to the sides of \\spad{eq}"))) +((|constructor| (NIL "This package provides operations for mapping the sides of equations.")) (|map| (((|Equation| |#2|) (|Mapping| |#2| |#1|) (|Equation| |#1|)) "\\spad{map(f,eq)} returns an equation where \\spad{f} is applied to the sides of \\spad{eq}"))) NIL NIL (-289 S) -((|constructor| (NIL "Equations as mathematical objects. All properties of the basis domain,{} \\spadignore{e.g.} being an abelian group are carried over the equation domain,{} by performing the structural operations on the left and on the right hand side.")) (|subst| (($ $ $) "\\spad{subst(eq1,{}eq2)} substitutes \\spad{eq2} into both sides of \\spad{eq1} the \\spad{lhs} of \\spad{eq2} should be a kernel")) (|inv| (($ $) "\\spad{inv(x)} returns the multiplicative inverse of \\spad{x}.")) (/ (($ $ $) "\\spad{e1/e2} produces a new equation by dividing the left and right hand sides of equations \\spad{e1} and \\spad{e2}.")) (|factorAndSplit| (((|List| $) $) "\\spad{factorAndSplit(eq)} make the right hand side 0 and factors the new left hand side. Each factor is equated to 0 and put into the resulting list without repetitions.")) (|rightOne| (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side.") (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side,{} if possible.")) (|leftOne| (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side.") (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side,{} if possible.")) (* (($ $ |#1|) "\\spad{eqn*x} produces a new equation by multiplying both sides of equation eqn by \\spad{x}.") (($ |#1| $) "\\spad{x*eqn} produces a new equation by multiplying both sides of equation eqn by \\spad{x}.")) (- (($ $ |#1|) "\\spad{eqn-x} produces a new equation by subtracting \\spad{x} from both sides of equation eqn.") (($ |#1| $) "\\spad{x-eqn} produces a new equation by subtracting both sides of equation eqn from \\spad{x}.")) (|rightZero| (($ $) "\\spad{rightZero(eq)} subtracts the right hand side.")) (|leftZero| (($ $) "\\spad{leftZero(eq)} subtracts the left hand side.")) (+ (($ $ |#1|) "\\spad{eqn+x} produces a new equation by adding \\spad{x} to both sides of equation eqn.") (($ |#1| $) "\\spad{x+eqn} produces a new equation by adding \\spad{x} to both sides of equation eqn.")) (|eval| (($ $ (|List| $)) "\\spad{eval(eqn,{} [x1=v1,{} ... xn=vn])} replaces \\spad{xi} by \\spad{vi} in equation \\spad{eqn}.") (($ $ $) "\\spad{eval(eqn,{} x=f)} replaces \\spad{x} by \\spad{f} in equation \\spad{eqn}.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(f,{}eqn)} constructs a new equation by applying \\spad{f} to both sides of \\spad{eqn}.")) (|rhs| ((|#1| $) "\\spad{rhs(eqn)} returns the right hand side of equation \\spad{eqn}.")) (|lhs| ((|#1| $) "\\spad{lhs(eqn)} returns the left hand side of equation \\spad{eqn}.")) (|swap| (($ $) "\\spad{swap(eq)} interchanges left and right hand side of equation \\spad{eq}.")) (|equation| (($ |#1| |#1|) "\\spad{equation(a,{}b)} creates an equation.")) (= (($ |#1| |#1|) "\\spad{a=b} creates an equation."))) -((-4532 -2232 (|has| |#1| (-1048)) (|has| |#1| (-479))) (-4529 |has| |#1| (-1048)) (-4530 |has| |#1| (-1048))) -((|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1091))) (|HasCategory| |#1| (QUOTE (-1048))) (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-1048)))) (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1163)) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1091)))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-297))) (-2232 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-479)))) (-2232 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-1048)))) (|HasCategory| |#1| (QUOTE (-173))) (-2232 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1048)))) (-2232 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366)))) (|HasCategory| |#1| (QUOTE (-717))) (-2232 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-717)))) (|HasCategory| |#1| (QUOTE (-1103))) (-2232 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-717))) (|HasCategory| |#1| (QUOTE (-1103)))) (|HasCategory| |#1| (QUOTE (-21))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1048)))) (-2232 (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-717)))) (|HasCategory| |#1| (QUOTE (-25))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1048)))) (-2232 (|HasCategory| |#1| (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-717))) (|HasCategory| |#1| (QUOTE (-1048))) (|HasCategory| |#1| (QUOTE (-1103))) (|HasCategory| |#1| (QUOTE (-1091))))) +((|constructor| (NIL "Equations as mathematical objects. All properties of the basis domain, \\spadignore{e.g.} being an abelian group are carried over the equation domain, by performing the structural operations on the left and on the right hand side.")) (|subst| (($ $ $) "\\spad{subst(eq1,eq2)} substitutes \\spad{eq2} into both sides of \\spad{eq1} the \\spad{lhs} of \\spad{eq2} should be a kernel")) (|inv| (($ $) "\\spad{inv(x)} returns the multiplicative inverse of \\spad{x.}")) (/ (($ $ $) "\\spad{e1/e2} produces a new equation by dividing the left and right hand sides of equations \\spad{e1} and e2.")) (|factorAndSplit| (((|List| $) $) "\\spad{factorAndSplit(eq)} make the right hand side 0 and factors the new left hand side. Each factor is equated to 0 and put into the resulting list without repetitions.")) (|rightOne| (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side.") (((|Union| $ "failed") $) "\\spad{rightOne(eq)} divides by the right hand side, if possible.")) (|leftOne| (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side.") (((|Union| $ "failed") $) "\\spad{leftOne(eq)} divides by the left hand side, if possible.")) (* (($ $ |#1|) "\\spad{eqn*x} produces a new equation by multiplying both sides of equation eqn by \\spad{x.}") (($ |#1| $) "\\spad{x*eqn} produces a new equation by multiplying both sides of equation eqn by \\spad{x.}")) (- (($ $ |#1|) "\\spad{eqn-x} produces a new equation by subtracting \\spad{x} from both sides of equation eqn.") (($ |#1| $) "\\spad{x-eqn} produces a new equation by subtracting both sides of equation eqn from \\spad{x.}")) (|rightZero| (($ $) "\\spad{rightZero(eq)} subtracts the right hand side.")) (|leftZero| (($ $) "\\spad{leftZero(eq)} subtracts the left hand side.")) (+ (($ $ |#1|) "\\spad{eqn+x} produces a new equation by adding \\spad{x} to both sides of equation eqn.") (($ |#1| $) "\\spad{x+eqn} produces a new equation by adding \\spad{x} to both sides of equation eqn.")) (|eval| (($ $ (|List| $)) "\\spad{eval(eqn, [x1=v1, \\spad{...} xn=vn])} replaces \\spad{xi} by \\spad{vi} in equation eqn.") (($ $ $) "\\spad{eval(eqn, x=f)} replaces \\spad{x} by \\spad{f} in equation eqn.")) (|map| (($ (|Mapping| |#1| |#1|) $) "\\spad{map(f,eqn)} constructs a new equation by applying \\spad{f} to both sides of eqn.")) (|rhs| ((|#1| $) "\\spad{rhs(eqn)} returns the right hand side of equation eqn.")) (|lhs| ((|#1| $) "\\spad{lhs(eqn)} returns the left hand side of equation eqn.")) (|swap| (($ $) "\\spad{swap(eq)} interchanges left and right hand side of equation eq.")) (|equation| (($ |#1| |#1|) "\\spad{equation(a,b)} creates an equation.")) (= (($ |#1| |#1|) "\\spad{a=b} creates an equation."))) +((-4568 -1929 (|has| |#1| (-1049)) (|has| |#1| (-479))) (-4565 |has| |#1| (-1049)) (-4566 |has| |#1| (-1049))) +((|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1093))) (|HasCategory| |#1| (QUOTE (-1049))) (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-1049)))) (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (LIST (QUOTE -524) (QUOTE (-1165)) (|devaluate| |#1|))) (-12 (|HasCategory| |#1| (LIST (QUOTE -304) (|devaluate| |#1|))) (|HasCategory| |#1| (QUOTE (-1093)))) (|HasCategory| |#1| (QUOTE (-559))) (|HasCategory| |#1| (QUOTE (-297))) (-1929 (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-479)))) (-1929 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-1049)))) (|HasCategory| |#1| (QUOTE (-173))) (-1929 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1049)))) (-1929 (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366)))) (|HasCategory| |#1| (QUOTE (-718))) (-1929 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-718)))) (|HasCategory| |#1| (QUOTE (-1105))) (-1929 (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-718))) (|HasCategory| |#1| (QUOTE (-1105)))) (|HasCategory| |#1| (QUOTE (-21))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1049)))) (-1929 (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-718)))) (|HasCategory| |#1| (QUOTE (-25))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-1049)))) (-1929 (|HasCategory| |#1| (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| |#1| (QUOTE (-21))) (|HasCategory| |#1| (QUOTE (-25))) (|HasCategory| |#1| (QUOTE (-173))) (|HasCategory| |#1| (QUOTE (-366))) (|HasCategory| |#1| (QUOTE (-479))) (|HasCategory| |#1| (QUOTE (-718))) (|HasCategory| |#1| (QUOTE (-1049))) (|HasCategory| |#1| (QUOTE (-1105))) (|HasCategory| |#1| (QUOTE (-1093))))) (-290 |Key| |Entry|) ((|constructor| (NIL "This domain provides tables where the keys are compared using \\spadfun{eq?}. Thus keys are considered equal only if they are the same instance of a structure."))) -((-4535 . T) (-4536 . T)) -((|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091))) (-12 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -2335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3782) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091)))) (|HasCategory| |#1| (QUOTE (-843))) (|HasCategory| |#2| (QUOTE (-1091))) (-2232 (|HasCategory| (-2 (|:| -2335 |#1|) (|:| -3782 |#2|)) (QUOTE (-1091))) (|HasCategory| |#2| (QUOTE (-1091)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1091))))) +((-4571 . T) (-4572 . T)) +((|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093))) (-12 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (LIST (QUOTE -304) (LIST (QUOTE -2) (LIST (QUOTE |:|) (QUOTE -3335) (|devaluate| |#1|)) (LIST (QUOTE |:|) (QUOTE -3175) (|devaluate| |#2|))))) (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093)))) (|HasCategory| |#1| (QUOTE (-844))) (|HasCategory| |#2| (QUOTE (-1093))) (-1929 (|HasCategory| (-2 (|:| -3335 |#1|) (|:| -3175 |#2|)) (QUOTE (-1093))) (|HasCategory| |#2| (QUOTE (-1093)))) (-12 (|HasCategory| |#2| (LIST (QUOTE -304) (|devaluate| |#2|))) (|HasCategory| |#2| (QUOTE (-1093))))) (-291) -((|constructor| (NIL "ErrorFunctions implements error functions callable from the system interpreter. Typically,{} these functions would be called in user functions. The simple forms of the functions take one argument which is either a string (an error message) or a list of strings which all together make up a message. The list can contain formatting codes (see below). The more sophisticated versions takes two arguments where the first argument is the name of the function from which the error was invoked and the second argument is either a string or a list of strings,{} as above. When you use the one argument version in an interpreter function,{} the system will automatically insert the name of the function as the new first argument. Thus in the user interpreter function\\spad{\\br} \\tab{5}\\spad{f x == if x < 0 then error \"negative argument\" else x}\\spad{\\br} the call to error will actually be of the form\\spad{\\br} \\tab{5}\\spad{error(\"f\",{}\"negative argument\")}\\spad{\\br} because the interpreter will have created a new first argument. \\blankline Formatting codes: error messages may contain the following formatting codes (they should either start or end a string or else have blanks around them):\\spad{\\br} \\spad{\\%l}\\tab{6}start a new line\\spad{\\br} \\spad{\\%b}\\tab{6}start printing in a bold font (where available)\\spad{\\br} \\spad{\\%d}\\tab{6}stop printing in a bold font (where available)\\spad{\\br} \\spad{\\%ceon}\\tab{3}start centering message lines\\spad{\\br} \\spad{\\%ceoff}\\tab{2}stop centering message lines\\spad{\\br} \\spad{\\%rjon}\\tab{3}start displaying lines \"ragged left\"\\spad{\\br} \\spad{\\%rjoff}\\tab{2}stop displaying lines \"ragged left\"\\spad{\\br} \\spad{\\%i}\\tab{6}indent following lines 3 additional spaces\\spad{\\br} \\spad{\\%u}\\tab{6}unindent following lines 3 additional spaces\\spad{\\br} \\spad{\\%xN}\\tab{5}insert \\spad{N} blanks (eg,{} \\spad{\\%x10} inserts 10 blanks) \\blankline")) (|error| (((|Exit|) (|String|) (|List| (|String|))) "\\spad{error(nam,{}lmsg)} displays error messages \\spad{lmsg} preceded by a message containing the name \\spad{nam} of the function in which the error is contained.") (((|Exit|) (|String|) (|String|)) "\\spad{error(nam,{}msg)} displays error message \\spad{msg} preceded by a message containing the name \\spad{nam} of the function in which the error is contained.") (((|Exit|) (|List| (|String|))) "\\spad{error(lmsg)} displays error message \\spad{lmsg} and terminates.") (((|Exit|) (|String|)) "\\spad{error(msg)} displays error message \\spad{msg} and terminates."))) +((|constructor| (NIL "ErrorFunctions implements error functions callable from the system interpreter. Typically, these functions would be called in user functions. The simple forms of the functions take one argument which is either a string (an error message) or a list of strings which all together make up a message. The list can contain formatting codes (see below). The more sophisticated versions takes two arguments where the first argument is the name of the function from which the error was invoked and the second argument is either a string or a list of strings, as above. When you use the one argument version in an interpreter function, the system will automatically insert the name of the function as the new first argument. Thus in the user interpreter function\\br \\tab{5}\\spad{f \\spad{x} \\spad{==} if \\spad{x} < 0 then error \"negative argument\" else x}\\br the call to error will actually be of the form\\br \\tab{5}\\spad{error(\"f\",\"negative argument\")}\\br because the interpreter will have created a new first argument. \\blankline Formatting codes: error messages may contain the following formatting codes (they should either start or end a string or else have blanks around them):\\br \\spad{\\%l}\\tab{6}start a new line\\br \\spad{\\%b}\\tab{6}start printing in a bold font (where available)\\br \\spad{\\%d}\\tab{6}stop printing in a bold font (where available)\\br \\spad{\\%ceon}\\tab{3}start centering message lines\\br \\spad{\\%ceoff}\\tab{2}stop centering message lines\\br \\spad{\\%rjon}\\tab{3}start displaying lines \"ragged left\"\\br \\spad{\\%rjoff}\\tab{2}stop displaying lines \"ragged left\"\\br \\spad{\\%i}\\tab{6}indent following lines 3 additional spaces\\br \\spad{\\%u}\\tab{6}unindent following lines 3 additional spaces\\br \\spad{\\%xN}\\tab{5}insert \\spad{N} blanks (eg, \\spad{\\%x10} inserts 10 blanks) \\blankline")) (|error| (((|Exit|) (|String|) (|List| (|String|))) "\\spad{error(nam,lmsg)} displays error messages \\spad{lmsg} preceded by a message containing the name \\spad{nam} of the function in which the error is contained.") (((|Exit|) (|String|) (|String|)) "\\spad{error(nam,msg)} displays error message \\spad{msg} preceded by a message containing the name \\spad{nam} of the function in which the error is contained.") (((|Exit|) (|List| (|String|))) "\\spad{error(lmsg)} displays error message \\spad{lmsg} and terminates.") (((|Exit|) (|String|)) "\\spad{error(msg)} displays error message \\spad{msg} and terminates."))) NIL NIL -(-292 -1564 S) -((|constructor| (NIL "This package allows a map from any expression space into any object to be lifted to a kernel over the expression set,{} using a given property of the operator of the kernel.")) (|map| ((|#2| (|Mapping| |#2| |#1|) (|String|) (|Kernel| |#1|)) "\\spad{map(f,{} p,{} k)} uses the property \\spad{p} of the operator of \\spad{k},{} in order to lift \\spad{f} and apply it to \\spad{k}."))) +(-292 -1647 S) +((|constructor| (NIL "This package allows a map from any expression space into any object to be lifted to a kernel over the expression set, using a given property of the operator of the kernel.")) (|map| ((|#2| (|Mapping| |#2| |#1|) (|String|) (|Kernel| |#1|)) "\\spad{map(f, \\spad{p,} \\spad{k)}} uses the property \\spad{p} of the operator of \\spad{k,} in order to lift \\spad{f} and apply it to \\spad{k.}"))) NIL NIL -(-293 E -1564) -((|constructor| (NIL "This package allows a mapping \\spad{E} \\spad{->} \\spad{F} to be lifted to a kernel over \\spad{E}; This lifting can fail if the operator of the kernel cannot be applied in \\spad{F}; Do not use this package with \\spad{E} = \\spad{F},{} since this may drop some properties of the operators.")) (|map| ((|#2| (|Mapping| |#2| |#1|) (|Kernel| |#1|)) "\\spad{map(f,{} k)} returns \\spad{g = op(f(a1),{}...,{}f(an))} where \\spad{k = op(a1,{}...,{}an)}."))) +(-293 E -1647) +((|constructor| (NIL "This package allows a mapping \\spad{E} \\spad{->} \\spad{F} to be lifted to a kernel over E; This lifting can fail if the operator of the kernel cannot be applied in \\spad{F;} Do not use this package with \\spad{E} = \\spad{F,} since this may drop some properties of the operators.")) (|map| ((|#2| (|Mapping| |#2| |#1|) (|Kernel| |#1|)) "\\spad{map(f, \\spad{k)}} returns \\spad{g = op(f(a1),...,f(an))} where \\spad{k = op(a1,...,an)}."))) NIL NIL (-294 A B) @@ -1109,51 +1109,51 @@ NIL NIL NIL (-295) -((|constructor| (NIL "ExpertSystemContinuityPackage is a package of functions for the use of domains belonging to the category \\axiomType{NumericalIntegration}.")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a Stream of \\axiomType{DoubleFloat} to \\axiomType{List}(\\axiomType{String})")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a List of \\axiomType{DoubleFloat} to \\axiomType{List}(\\axiomType{String})")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|polynomialZeros| (((|List| (|DoubleFloat|)) (|Polynomial| (|Fraction| (|Integer|))) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{polynomialZeros(fn,{}var,{}range)} calculates the real zeros of the polynomial which are contained in the given interval. It returns a list of points (\\axiomType{Doublefloat}) for which the univariate polynomial \\spad{fn} is zero.")) (|singularitiesOf| (((|Stream| (|DoubleFloat|)) (|Vector| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{singularitiesOf(v,{}vars,{}range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{v} will most likely produce an error. This includes those points which evaluate to 0/0.") (((|Stream| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{singularitiesOf(e,{}vars,{}range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{e} will most likely produce an error. This includes those points which evaluate to 0/0.")) (|zerosOf| (((|Stream| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{zerosOf(e,{}vars,{}range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{e} will most likely produce an error.")) (|problemPoints| (((|List| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{problemPoints(f,{}var,{}range)} returns a list of possible problem points by looking at the zeros of the denominator of the function \\spad{f} if it can be retracted to \\axiomType{Polynomial(DoubleFloat)}.")) (|functionIsFracPolynomial?| (((|Boolean|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsFracPolynomial?(args)} tests whether the function can be retracted to \\axiomType{Fraction(Polynomial(DoubleFloat))}")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(u)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\axiom{\\spad{u}}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(u)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\axiom{\\spad{u}}"))) +((|constructor| (NIL "ExpertSystemContinuityPackage is a package of functions for the use of domains belonging to the category \\axiomType{NumericalIntegration}.")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a Stream of \\axiomType{DoubleFloat} to \\axiomType{List}(\\axiomType{String})")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a List of \\axiomType{DoubleFloat} to \\axiomType{List}(\\axiomType{String})")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|polynomialZeros| (((|List| (|DoubleFloat|)) (|Polynomial| (|Fraction| (|Integer|))) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{polynomialZeros(fn,var,range)} calculates the real zeros of the polynomial which are contained in the given interval. It returns a list of points (\\axiomType{Doublefloat}) for which the univariate polynomial \\spad{fn} is zero.")) (|singularitiesOf| (((|Stream| (|DoubleFloat|)) (|Vector| (|Expression| (|DoubleFloat|))) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{singularitiesOf(v,vars,range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{v} will most likely produce an error. This includes those points which evaluate to 0/0.") (((|Stream| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{singularitiesOf(e,vars,range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{e} will most likely produce an error. This includes those points which evaluate to 0/0.")) (|zerosOf| (((|Stream| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|List| (|Symbol|)) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{zerosOf(e,vars,range)} returns a list of points (\\axiomType{Doublefloat}) at which a NAG fortran version of \\spad{e} will most likely produce an error.")) (|problemPoints| (((|List| (|DoubleFloat|)) (|Expression| (|DoubleFloat|)) (|Symbol|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{problemPoints(f,var,range)} returns a list of possible problem points by looking at the zeros of the denominator of the function \\spad{f} if it can be retracted to \\axiomType{Polynomial(DoubleFloat)}.")) (|functionIsFracPolynomial?| (((|Boolean|) (|Record| (|:| |var| (|Symbol|)) (|:| |fn| (|Expression| (|DoubleFloat|))) (|:| |range| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|:| |abserr| (|DoubleFloat|)) (|:| |relerr| (|DoubleFloat|)))) "\\spad{functionIsFracPolynomial?(args)} tests whether the function can be retracted to \\axiomType{Fraction(Polynomial(DoubleFloat))}")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(u)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\axiom{u}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(u)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\axiom{u}"))) NIL NIL (-296 S) -((|constructor| (NIL "An expression space is a set which is closed under certain operators.")) (|odd?| (((|Boolean|) $) "\\spad{odd? x} is \\spad{true} if \\spad{x} is an odd integer.")) (|even?| (((|Boolean|) $) "\\spad{even? x} is \\spad{true} if \\spad{x} is an even integer.")) (|definingPolynomial| (($ $) "\\spad{definingPolynomial(x)} returns an expression \\spad{p} such that \\spad{p(x) = 0}.")) (|minPoly| (((|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{minPoly(k)} returns \\spad{p} such that \\spad{p(k) = 0}.")) (|eval| (($ $ (|BasicOperator|) (|Mapping| $ $)) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|BasicOperator|) (|Mapping| $ (|List| $))) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a1,{}..,{}am)} in \\spad{x} by \\spad{f(a1,{}..,{}am)} for any \\spad{a1},{}...,{}\\spad{am}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a1,{}...,{}an)} in \\spad{x} by \\spad{\\spad{fi}(a1,{}...,{}an)} for any \\spad{a1},{}...,{}\\spad{an}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ $))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a)} in \\spad{x} by \\spad{\\spad{fi}(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ $)) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ (|List| $))) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a1,{}..,{}am)} in \\spad{x} by \\spad{f(a1,{}..,{}am)} for any \\spad{a1},{}...,{}\\spad{am}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a1,{}...,{}an)} in \\spad{x} by \\spad{\\spad{fi}(a1,{}...,{}an)} for any \\spad{a1},{}...,{}\\spad{an}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ $))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a)} in \\spad{x} by \\spad{\\spad{fi}(a)} for any \\spad{a}.")) (|freeOf?| (((|Boolean|) $ (|Symbol|)) "\\spad{freeOf?(x,{} s)} tests if \\spad{x} does not contain any operator whose name is \\spad{s}.") (((|Boolean|) $ $) "\\spad{freeOf?(x,{} y)} tests if \\spad{x} does not contain any occurrence of \\spad{y},{} where \\spad{y} is a single kernel.")) (|map| (($ (|Mapping| $ $) (|Kernel| $)) "\\spad{map(f,{} k)} returns \\spad{op(f(x1),{}...,{}f(xn))} where \\spad{k = op(x1,{}...,{}xn)}.")) (|kernel| (($ (|BasicOperator|) (|List| $)) "\\spad{kernel(op,{} [f1,{}...,{}fn])} constructs \\spad{op(f1,{}...,{}fn)} without evaluating it.") (($ (|BasicOperator|) $) "\\spad{kernel(op,{} x)} constructs \\spad{op}(\\spad{x}) without evaluating it.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(x,{} s)} tests if \\spad{x} is a kernel and is the name of its operator is \\spad{s}.") (((|Boolean|) $ (|BasicOperator|)) "\\spad{is?(x,{} op)} tests if \\spad{x} is a kernel and is its operator is op.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} tests if \\% accepts \\spad{op} as applicable to its elements.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\%.")) (|operators| (((|List| (|BasicOperator|)) $) "\\spad{operators(f)} returns all the basic operators appearing in \\spad{f},{} no matter what their levels are.")) (|tower| (((|List| (|Kernel| $)) $) "\\spad{tower(f)} returns all the kernels appearing in \\spad{f},{} no matter what their levels are.")) (|kernels| (((|List| (|Kernel| $)) $) "\\spad{kernels(f)} returns the list of all the top-level kernels appearing in \\spad{f},{} but not the ones appearing in the arguments of the top-level kernels.")) (|mainKernel| (((|Union| (|Kernel| $) "failed") $) "\\spad{mainKernel(f)} returns a kernel of \\spad{f} with maximum nesting level,{} or if \\spad{f} has no kernels (\\spadignore{i.e.} \\spad{f} is a constant).")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(f)} returns the highest nesting level appearing in \\spad{f}. Constants have height 0. Symbols have height 1. For any operator op and expressions \\spad{f1},{}...,{}\\spad{fn},{} \\spad{op(f1,{}...,{}fn)} has height equal to \\spad{1 + max(height(f1),{}...,{}height(fn))}.")) (|distribute| (($ $ $) "\\spad{distribute(f,{} g)} expands all the kernels in \\spad{f} that contain \\spad{g} in their arguments and that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or a \\spadfunFrom{paren}{ExpressionSpace} expression.") (($ $) "\\spad{distribute(f)} expands all the kernels in \\spad{f} that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or \\spadfunFrom{paren}{ExpressionSpace} expression.")) (|paren| (($ (|List| $)) "\\spad{paren([f1,{}...,{}fn])} returns \\spad{(f1,{}...,{}fn)}. This prevents the \\spad{fi} from being evaluated when operators are applied to them,{} and makes them applicable to a unary operator. For example,{} \\spad{atan(paren [x,{} 2])} returns the formal kernel \\spad{atan((x,{} 2))}.") (($ $) "\\spad{paren(f)} returns (\\spad{f}). This prevents \\spad{f} from being evaluated when operators are applied to it. For example,{} \\spad{log(1)} returns 0,{} but \\spad{log(paren 1)} returns the formal kernel log((1)).")) (|box| (($ (|List| $)) "\\spad{box([f1,{}...,{}fn])} returns \\spad{(f1,{}...,{}fn)} with a 'box' around them that prevents the \\spad{fi} from being evaluated when operators are applied to them,{} and makes them applicable to a unary operator. For example,{} \\spad{atan(box [x,{} 2])} returns the formal kernel \\spad{atan(x,{} 2)}.") (($ $) "\\spad{box(f)} returns \\spad{f} with a 'box' around it that prevents \\spad{f} from being evaluated when operators are applied to it. For example,{} \\spad{log(1)} returns 0,{} but \\spad{log(box 1)} returns the formal kernel log(1).")) (|subst| (($ $ (|List| (|Kernel| $)) (|List| $)) "\\spad{subst(f,{} [k1...,{}kn],{} [g1,{}...,{}gn])} replaces the kernels \\spad{k1},{}...,{}\\spad{kn} by \\spad{g1},{}...,{}\\spad{gn} formally in \\spad{f}.") (($ $ (|List| (|Equation| $))) "\\spad{subst(f,{} [k1 = g1,{}...,{}kn = gn])} replaces the kernels \\spad{k1},{}...,{}\\spad{kn} by \\spad{g1},{}...,{}\\spad{gn} formally in \\spad{f}.") (($ $ (|Equation| $)) "\\spad{subst(f,{} k = g)} replaces the kernel \\spad{k} by \\spad{g} formally in \\spad{f}.")) (|elt| (($ (|BasicOperator|) (|List| $)) "\\spad{elt(op,{}[x1,{}...,{}xn])} or \\spad{op}([\\spad{x1},{}...,{}\\spad{xn}]) applies the \\spad{n}-ary operator \\spad{op} to \\spad{x1},{}...,{}\\spad{xn}.") (($ (|BasicOperator|) $ $ $ $) "\\spad{elt(op,{}x,{}y,{}z,{}t)} or \\spad{op}(\\spad{x},{} \\spad{y},{} \\spad{z},{} \\spad{t}) applies the 4-ary operator \\spad{op} to \\spad{x},{} \\spad{y},{} \\spad{z} and \\spad{t}.") (($ (|BasicOperator|) $ $ $) "\\spad{elt(op,{}x,{}y,{}z)} or \\spad{op}(\\spad{x},{} \\spad{y},{} \\spad{z}) applies the ternary operator \\spad{op} to \\spad{x},{} \\spad{y} and \\spad{z}.") (($ (|BasicOperator|) $ $) "\\spad{elt(op,{}x,{}y)} or \\spad{op}(\\spad{x},{} \\spad{y}) applies the binary operator \\spad{op} to \\spad{x} and \\spad{y}.") (($ (|BasicOperator|) $) "\\spad{elt(op,{}x)} or \\spad{op}(\\spad{x}) applies the unary operator \\spad{op} to \\spad{x}."))) +((|constructor| (NIL "An expression space is a set which is closed under certain operators.")) (|odd?| (((|Boolean|) $) "\\spad{odd? \\spad{x}} is \\spad{true} if \\spad{x} is an odd integer.")) (|even?| (((|Boolean|) $) "\\spad{even? \\spad{x}} is \\spad{true} if \\spad{x} is an even integer.")) (|definingPolynomial| (($ $) "\\spad{definingPolynomial(x)} returns an expression \\spad{p} such that \\spad{p(x) = 0}.")) (|minPoly| (((|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{minPoly(k)} returns \\spad{p} such that \\spad{p(k) = 0}.")) (|eval| (($ $ (|BasicOperator|) (|Mapping| $ $)) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|BasicOperator|) (|Mapping| $ (|List| $))) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a1,..,am)} in \\spad{x} by \\spad{f(a1,..,am)} for any \\spad{a1},...,\\spad{am}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a1,...,an)} in \\spad{x} by \\spad{fi(a1,...,an)} for any \\spad{a1},...,\\spad{an}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ $))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a)} in \\spad{x} by \\spad{fi(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ $)) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ (|List| $))) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a1,..,am)} in \\spad{x} by \\spad{f(a1,..,am)} for any \\spad{a1},...,\\spad{am}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a1,...,an)} in \\spad{x} by \\spad{fi(a1,...,an)} for any \\spad{a1},...,\\spad{an}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ $))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a)} in \\spad{x} by \\spad{fi(a)} for any \\spad{a}.")) (|freeOf?| (((|Boolean|) $ (|Symbol|)) "\\spad{freeOf?(x, \\spad{s)}} tests if \\spad{x} does not contain any operator whose name is \\spad{s.}") (((|Boolean|) $ $) "\\spad{freeOf?(x, \\spad{y)}} tests if \\spad{x} does not contain any occurrence of \\spad{y,} where \\spad{y} is a single kernel.")) (|map| (($ (|Mapping| $ $) (|Kernel| $)) "\\spad{map(f, \\spad{k)}} returns \\spad{op(f(x1),...,f(xn))} where \\spad{k = op(x1,...,xn)}.")) (|kernel| (($ (|BasicOperator|) (|List| $)) "\\spad{kernel(op, [f1,...,fn])} constructs \\spad{op(f1,...,fn)} without evaluating it.") (($ (|BasicOperator|) $) "\\spad{kernel(op, \\spad{x)}} constructs op(x) without evaluating it.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(x, \\spad{s)}} tests if \\spad{x} is a kernel and is the name of its operator is \\spad{s.}") (((|Boolean|) $ (|BasicOperator|)) "\\spad{is?(x, op)} tests if \\spad{x} is a kernel and is its operator is op.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} tests if \\% accepts \\spad{op} as applicable to its elements.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\spad{%.}")) (|operators| (((|List| (|BasicOperator|)) $) "\\spad{operators(f)} returns all the basic operators appearing in \\spad{f,} no matter what their levels are.")) (|tower| (((|List| (|Kernel| $)) $) "\\spad{tower(f)} returns all the kernels appearing in \\spad{f,} no matter what their levels are.")) (|kernels| (((|List| (|Kernel| $)) $) "\\spad{kernels(f)} returns the list of all the top-level kernels appearing in \\spad{f,} but not the ones appearing in the arguments of the top-level kernels.")) (|mainKernel| (((|Union| (|Kernel| $) "failed") $) "\\spad{mainKernel(f)} returns a kernel of \\spad{f} with maximum nesting level, or if \\spad{f} has no kernels (\\spadignore{i.e.} \\spad{f} is a constant).")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(f)} returns the highest nesting level appearing in \\spad{f.} Constants have height 0. Symbols have height 1. For any operator op and expressions f1,...,fn, \\spad{op(f1,...,fn)} has height equal to \\spad{1 + max(height(f1),...,height(fn))}.")) (|distribute| (($ $ $) "\\spad{distribute(f, \\spad{g)}} expands all the kernels in \\spad{f} that contain \\spad{g} in their arguments and that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or a \\spadfunFrom{paren}{ExpressionSpace} expression.") (($ $) "\\spad{distribute(f)} expands all the kernels in \\spad{f} that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or \\spadfunFrom{paren}{ExpressionSpace} expression.")) (|paren| (($ (|List| $)) "\\spad{paren([f1,...,fn])} returns \\spad{(f1,...,fn)}. This prevents the \\spad{fi} from being evaluated when operators are applied to them, and makes them applicable to a unary operator. For example, \\spad{atan(paren \\spad{[x,} 2])} returns the formal kernel \\spad{atan((x, 2))}.") (($ $) "\\spad{paren(f)} returns (f). This prevents \\spad{f} from being evaluated when operators are applied to it. For example, \\spad{log(1)} returns 0, but \\spad{log(paren 1)} returns the formal kernel log((1)).")) (|box| (($ (|List| $)) "\\spad{box([f1,...,fn])} returns \\spad{(f1,...,fn)} with a 'box' around them that prevents the \\spad{fi} from being evaluated when operators are applied to them, and makes them applicable to a unary operator. For example, \\spad{atan(box \\spad{[x,} 2])} returns the formal kernel \\spad{atan(x, 2)}.") (($ $) "\\spad{box(f)} returns \\spad{f} with a 'box' around it that prevents \\spad{f} from being evaluated when operators are applied to it. For example, \\spad{log(1)} returns 0, but \\spad{log(box 1)} returns the formal kernel log(1).")) (|subst| (($ $ (|List| (|Kernel| $)) (|List| $)) "\\spad{subst(f, [k1...,kn], [g1,...,gn])} replaces the kernels k1,...,kn by g1,...,gn formally in \\spad{f.}") (($ $ (|List| (|Equation| $))) "\\spad{subst(f, \\spad{[k1} = g1,...,kn = gn])} replaces the kernels k1,...,kn by g1,...,gn formally in \\spad{f.}") (($ $ (|Equation| $)) "\\spad{subst(f, \\spad{k} = \\spad{g)}} replaces the kernel \\spad{k} by \\spad{g} formally in \\spad{f.}")) (|elt| (($ (|BasicOperator|) (|List| $)) "\\spad{elt(op,[x1,...,xn])} or op([x1,...,xn]) applies the n-ary operator \\spad{op} to x1,...,xn.") (($ (|BasicOperator|) $ $ $ $) "\\spad{elt(op,x,y,z,t)} or op(x, \\spad{y,} \\spad{z,} \\spad{t)} applies the 4-ary operator \\spad{op} to \\spad{x,} \\spad{y,} \\spad{z} and \\spad{t.}") (($ (|BasicOperator|) $ $ $) "\\spad{elt(op,x,y,z)} or op(x, \\spad{y,} \\spad{z)} applies the ternary operator \\spad{op} to \\spad{x,} \\spad{y} and \\spad{z.}") (($ (|BasicOperator|) $ $) "\\spad{elt(op,x,y)} or op(x, \\spad{y)} applies the binary operator \\spad{op} to \\spad{x} and \\spad{y.}") (($ (|BasicOperator|) $) "\\spad{elt(op,x)} or op(x) applies the unary operator \\spad{op} to \\spad{x.}"))) NIL -((|HasCategory| |#1| (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-1048)))) +((|HasCategory| |#1| (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| |#1| (QUOTE (-1049)))) (-297) -((|constructor| (NIL "An expression space is a set which is closed under certain operators.")) (|odd?| (((|Boolean|) $) "\\spad{odd? x} is \\spad{true} if \\spad{x} is an odd integer.")) (|even?| (((|Boolean|) $) "\\spad{even? x} is \\spad{true} if \\spad{x} is an even integer.")) (|definingPolynomial| (($ $) "\\spad{definingPolynomial(x)} returns an expression \\spad{p} such that \\spad{p(x) = 0}.")) (|minPoly| (((|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{minPoly(k)} returns \\spad{p} such that \\spad{p(k) = 0}.")) (|eval| (($ $ (|BasicOperator|) (|Mapping| $ $)) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|BasicOperator|) (|Mapping| $ (|List| $))) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a1,{}..,{}am)} in \\spad{x} by \\spad{f(a1,{}..,{}am)} for any \\spad{a1},{}...,{}\\spad{am}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a1,{}...,{}an)} in \\spad{x} by \\spad{\\spad{fi}(a1,{}...,{}an)} for any \\spad{a1},{}...,{}\\spad{an}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ $))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a)} in \\spad{x} by \\spad{\\spad{fi}(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ $)) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ (|List| $))) "\\spad{eval(x,{} s,{} f)} replaces every \\spad{s(a1,{}..,{}am)} in \\spad{x} by \\spad{f(a1,{}..,{}am)} for any \\spad{a1},{}...,{}\\spad{am}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a1,{}...,{}an)} in \\spad{x} by \\spad{\\spad{fi}(a1,{}...,{}an)} for any \\spad{a1},{}...,{}\\spad{an}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ $))) "\\spad{eval(x,{} [s1,{}...,{}sm],{} [f1,{}...,{}fm])} replaces every \\spad{\\spad{si}(a)} in \\spad{x} by \\spad{\\spad{fi}(a)} for any \\spad{a}.")) (|freeOf?| (((|Boolean|) $ (|Symbol|)) "\\spad{freeOf?(x,{} s)} tests if \\spad{x} does not contain any operator whose name is \\spad{s}.") (((|Boolean|) $ $) "\\spad{freeOf?(x,{} y)} tests if \\spad{x} does not contain any occurrence of \\spad{y},{} where \\spad{y} is a single kernel.")) (|map| (($ (|Mapping| $ $) (|Kernel| $)) "\\spad{map(f,{} k)} returns \\spad{op(f(x1),{}...,{}f(xn))} where \\spad{k = op(x1,{}...,{}xn)}.")) (|kernel| (($ (|BasicOperator|) (|List| $)) "\\spad{kernel(op,{} [f1,{}...,{}fn])} constructs \\spad{op(f1,{}...,{}fn)} without evaluating it.") (($ (|BasicOperator|) $) "\\spad{kernel(op,{} x)} constructs \\spad{op}(\\spad{x}) without evaluating it.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(x,{} s)} tests if \\spad{x} is a kernel and is the name of its operator is \\spad{s}.") (((|Boolean|) $ (|BasicOperator|)) "\\spad{is?(x,{} op)} tests if \\spad{x} is a kernel and is its operator is op.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} tests if \\% accepts \\spad{op} as applicable to its elements.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\%.")) (|operators| (((|List| (|BasicOperator|)) $) "\\spad{operators(f)} returns all the basic operators appearing in \\spad{f},{} no matter what their levels are.")) (|tower| (((|List| (|Kernel| $)) $) "\\spad{tower(f)} returns all the kernels appearing in \\spad{f},{} no matter what their levels are.")) (|kernels| (((|List| (|Kernel| $)) $) "\\spad{kernels(f)} returns the list of all the top-level kernels appearing in \\spad{f},{} but not the ones appearing in the arguments of the top-level kernels.")) (|mainKernel| (((|Union| (|Kernel| $) "failed") $) "\\spad{mainKernel(f)} returns a kernel of \\spad{f} with maximum nesting level,{} or if \\spad{f} has no kernels (\\spadignore{i.e.} \\spad{f} is a constant).")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(f)} returns the highest nesting level appearing in \\spad{f}. Constants have height 0. Symbols have height 1. For any operator op and expressions \\spad{f1},{}...,{}\\spad{fn},{} \\spad{op(f1,{}...,{}fn)} has height equal to \\spad{1 + max(height(f1),{}...,{}height(fn))}.")) (|distribute| (($ $ $) "\\spad{distribute(f,{} g)} expands all the kernels in \\spad{f} that contain \\spad{g} in their arguments and that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or a \\spadfunFrom{paren}{ExpressionSpace} expression.") (($ $) "\\spad{distribute(f)} expands all the kernels in \\spad{f} that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or \\spadfunFrom{paren}{ExpressionSpace} expression.")) (|paren| (($ (|List| $)) "\\spad{paren([f1,{}...,{}fn])} returns \\spad{(f1,{}...,{}fn)}. This prevents the \\spad{fi} from being evaluated when operators are applied to them,{} and makes them applicable to a unary operator. For example,{} \\spad{atan(paren [x,{} 2])} returns the formal kernel \\spad{atan((x,{} 2))}.") (($ $) "\\spad{paren(f)} returns (\\spad{f}). This prevents \\spad{f} from being evaluated when operators are applied to it. For example,{} \\spad{log(1)} returns 0,{} but \\spad{log(paren 1)} returns the formal kernel log((1)).")) (|box| (($ (|List| $)) "\\spad{box([f1,{}...,{}fn])} returns \\spad{(f1,{}...,{}fn)} with a 'box' around them that prevents the \\spad{fi} from being evaluated when operators are applied to them,{} and makes them applicable to a unary operator. For example,{} \\spad{atan(box [x,{} 2])} returns the formal kernel \\spad{atan(x,{} 2)}.") (($ $) "\\spad{box(f)} returns \\spad{f} with a 'box' around it that prevents \\spad{f} from being evaluated when operators are applied to it. For example,{} \\spad{log(1)} returns 0,{} but \\spad{log(box 1)} returns the formal kernel log(1).")) (|subst| (($ $ (|List| (|Kernel| $)) (|List| $)) "\\spad{subst(f,{} [k1...,{}kn],{} [g1,{}...,{}gn])} replaces the kernels \\spad{k1},{}...,{}\\spad{kn} by \\spad{g1},{}...,{}\\spad{gn} formally in \\spad{f}.") (($ $ (|List| (|Equation| $))) "\\spad{subst(f,{} [k1 = g1,{}...,{}kn = gn])} replaces the kernels \\spad{k1},{}...,{}\\spad{kn} by \\spad{g1},{}...,{}\\spad{gn} formally in \\spad{f}.") (($ $ (|Equation| $)) "\\spad{subst(f,{} k = g)} replaces the kernel \\spad{k} by \\spad{g} formally in \\spad{f}.")) (|elt| (($ (|BasicOperator|) (|List| $)) "\\spad{elt(op,{}[x1,{}...,{}xn])} or \\spad{op}([\\spad{x1},{}...,{}\\spad{xn}]) applies the \\spad{n}-ary operator \\spad{op} to \\spad{x1},{}...,{}\\spad{xn}.") (($ (|BasicOperator|) $ $ $ $) "\\spad{elt(op,{}x,{}y,{}z,{}t)} or \\spad{op}(\\spad{x},{} \\spad{y},{} \\spad{z},{} \\spad{t}) applies the 4-ary operator \\spad{op} to \\spad{x},{} \\spad{y},{} \\spad{z} and \\spad{t}.") (($ (|BasicOperator|) $ $ $) "\\spad{elt(op,{}x,{}y,{}z)} or \\spad{op}(\\spad{x},{} \\spad{y},{} \\spad{z}) applies the ternary operator \\spad{op} to \\spad{x},{} \\spad{y} and \\spad{z}.") (($ (|BasicOperator|) $ $) "\\spad{elt(op,{}x,{}y)} or \\spad{op}(\\spad{x},{} \\spad{y}) applies the binary operator \\spad{op} to \\spad{x} and \\spad{y}.") (($ (|BasicOperator|) $) "\\spad{elt(op,{}x)} or \\spad{op}(\\spad{x}) applies the unary operator \\spad{op} to \\spad{x}."))) +((|constructor| (NIL "An expression space is a set which is closed under certain operators.")) (|odd?| (((|Boolean|) $) "\\spad{odd? \\spad{x}} is \\spad{true} if \\spad{x} is an odd integer.")) (|even?| (((|Boolean|) $) "\\spad{even? \\spad{x}} is \\spad{true} if \\spad{x} is an even integer.")) (|definingPolynomial| (($ $) "\\spad{definingPolynomial(x)} returns an expression \\spad{p} such that \\spad{p(x) = 0}.")) (|minPoly| (((|SparseUnivariatePolynomial| $) (|Kernel| $)) "\\spad{minPoly(k)} returns \\spad{p} such that \\spad{p(k) = 0}.")) (|eval| (($ $ (|BasicOperator|) (|Mapping| $ $)) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|BasicOperator|) (|Mapping| $ (|List| $))) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a1,..,am)} in \\spad{x} by \\spad{f(a1,..,am)} for any \\spad{a1},...,\\spad{am}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a1,...,an)} in \\spad{x} by \\spad{fi(a1,...,an)} for any \\spad{a1},...,\\spad{an}.") (($ $ (|List| (|BasicOperator|)) (|List| (|Mapping| $ $))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a)} in \\spad{x} by \\spad{fi(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ $)) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a)} in \\spad{x} by \\spad{f(a)} for any \\spad{a}.") (($ $ (|Symbol|) (|Mapping| $ (|List| $))) "\\spad{eval(x, \\spad{s,} \\spad{f)}} replaces every \\spad{s(a1,..,am)} in \\spad{x} by \\spad{f(a1,..,am)} for any \\spad{a1},...,\\spad{am}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ (|List| $)))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a1,...,an)} in \\spad{x} by \\spad{fi(a1,...,an)} for any \\spad{a1},...,\\spad{an}.") (($ $ (|List| (|Symbol|)) (|List| (|Mapping| $ $))) "\\spad{eval(x, [s1,...,sm], [f1,...,fm])} replaces every \\spad{si(a)} in \\spad{x} by \\spad{fi(a)} for any \\spad{a}.")) (|freeOf?| (((|Boolean|) $ (|Symbol|)) "\\spad{freeOf?(x, \\spad{s)}} tests if \\spad{x} does not contain any operator whose name is \\spad{s.}") (((|Boolean|) $ $) "\\spad{freeOf?(x, \\spad{y)}} tests if \\spad{x} does not contain any occurrence of \\spad{y,} where \\spad{y} is a single kernel.")) (|map| (($ (|Mapping| $ $) (|Kernel| $)) "\\spad{map(f, \\spad{k)}} returns \\spad{op(f(x1),...,f(xn))} where \\spad{k = op(x1,...,xn)}.")) (|kernel| (($ (|BasicOperator|) (|List| $)) "\\spad{kernel(op, [f1,...,fn])} constructs \\spad{op(f1,...,fn)} without evaluating it.") (($ (|BasicOperator|) $) "\\spad{kernel(op, \\spad{x)}} constructs op(x) without evaluating it.")) (|is?| (((|Boolean|) $ (|Symbol|)) "\\spad{is?(x, \\spad{s)}} tests if \\spad{x} is a kernel and is the name of its operator is \\spad{s.}") (((|Boolean|) $ (|BasicOperator|)) "\\spad{is?(x, op)} tests if \\spad{x} is a kernel and is its operator is op.")) (|belong?| (((|Boolean|) (|BasicOperator|)) "\\spad{belong?(op)} tests if \\% accepts \\spad{op} as applicable to its elements.")) (|operator| (((|BasicOperator|) (|BasicOperator|)) "\\spad{operator(op)} returns a copy of \\spad{op} with the domain-dependent properties appropriate for \\spad{%.}")) (|operators| (((|List| (|BasicOperator|)) $) "\\spad{operators(f)} returns all the basic operators appearing in \\spad{f,} no matter what their levels are.")) (|tower| (((|List| (|Kernel| $)) $) "\\spad{tower(f)} returns all the kernels appearing in \\spad{f,} no matter what their levels are.")) (|kernels| (((|List| (|Kernel| $)) $) "\\spad{kernels(f)} returns the list of all the top-level kernels appearing in \\spad{f,} but not the ones appearing in the arguments of the top-level kernels.")) (|mainKernel| (((|Union| (|Kernel| $) "failed") $) "\\spad{mainKernel(f)} returns a kernel of \\spad{f} with maximum nesting level, or if \\spad{f} has no kernels (\\spadignore{i.e.} \\spad{f} is a constant).")) (|height| (((|NonNegativeInteger|) $) "\\spad{height(f)} returns the highest nesting level appearing in \\spad{f.} Constants have height 0. Symbols have height 1. For any operator op and expressions f1,...,fn, \\spad{op(f1,...,fn)} has height equal to \\spad{1 + max(height(f1),...,height(fn))}.")) (|distribute| (($ $ $) "\\spad{distribute(f, \\spad{g)}} expands all the kernels in \\spad{f} that contain \\spad{g} in their arguments and that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or a \\spadfunFrom{paren}{ExpressionSpace} expression.") (($ $) "\\spad{distribute(f)} expands all the kernels in \\spad{f} that are formally enclosed by a \\spadfunFrom{box}{ExpressionSpace} or \\spadfunFrom{paren}{ExpressionSpace} expression.")) (|paren| (($ (|List| $)) "\\spad{paren([f1,...,fn])} returns \\spad{(f1,...,fn)}. This prevents the \\spad{fi} from being evaluated when operators are applied to them, and makes them applicable to a unary operator. For example, \\spad{atan(paren \\spad{[x,} 2])} returns the formal kernel \\spad{atan((x, 2))}.") (($ $) "\\spad{paren(f)} returns (f). This prevents \\spad{f} from being evaluated when operators are applied to it. For example, \\spad{log(1)} returns 0, but \\spad{log(paren 1)} returns the formal kernel log((1)).")) (|box| (($ (|List| $)) "\\spad{box([f1,...,fn])} returns \\spad{(f1,...,fn)} with a 'box' around them that prevents the \\spad{fi} from being evaluated when operators are applied to them, and makes them applicable to a unary operator. For example, \\spad{atan(box \\spad{[x,} 2])} returns the formal kernel \\spad{atan(x, 2)}.") (($ $) "\\spad{box(f)} returns \\spad{f} with a 'box' around it that prevents \\spad{f} from being evaluated when operators are applied to it. For example, \\spad{log(1)} returns 0, but \\spad{log(box 1)} returns the formal kernel log(1).")) (|subst| (($ $ (|List| (|Kernel| $)) (|List| $)) "\\spad{subst(f, [k1...,kn], [g1,...,gn])} replaces the kernels k1,...,kn by g1,...,gn formally in \\spad{f.}") (($ $ (|List| (|Equation| $))) "\\spad{subst(f, \\spad{[k1} = g1,...,kn = gn])} replaces the kernels k1,...,kn by g1,...,gn formally in \\spad{f.}") (($ $ (|Equation| $)) "\\spad{subst(f, \\spad{k} = \\spad{g)}} replaces the kernel \\spad{k} by \\spad{g} formally in \\spad{f.}")) (|elt| (($ (|BasicOperator|) (|List| $)) "\\spad{elt(op,[x1,...,xn])} or op([x1,...,xn]) applies the n-ary operator \\spad{op} to x1,...,xn.") (($ (|BasicOperator|) $ $ $ $) "\\spad{elt(op,x,y,z,t)} or op(x, \\spad{y,} \\spad{z,} \\spad{t)} applies the 4-ary operator \\spad{op} to \\spad{x,} \\spad{y,} \\spad{z} and \\spad{t.}") (($ (|BasicOperator|) $ $ $) "\\spad{elt(op,x,y,z)} or op(x, \\spad{y,} \\spad{z)} applies the ternary operator \\spad{op} to \\spad{x,} \\spad{y} and \\spad{z.}") (($ (|BasicOperator|) $ $) "\\spad{elt(op,x,y)} or op(x, \\spad{y)} applies the binary operator \\spad{op} to \\spad{x} and \\spad{y.}") (($ (|BasicOperator|) $) "\\spad{elt(op,x)} or op(x) applies the unary operator \\spad{op} to \\spad{x.}"))) NIL NIL (-298 R1) -((|constructor| (NIL "\\axiom{\\spad{ExpertSystemToolsPackage1}} contains some useful functions for use by the computational agents of Ordinary Differential Equation solvers.")) (|neglist| (((|List| |#1|) (|List| |#1|)) "\\spad{neglist(l)} returns only the negative elements of the list \\spad{l}"))) +((|constructor| (NIL "\\axiom{ExpertSystemToolsPackage1} contains some useful functions for use by the computational agents of Ordinary Differential Equation solvers.")) (|neglist| (((|List| |#1|) (|List| |#1|)) "\\spad{neglist(l)} returns only the negative elements of the list \\spad{l}"))) NIL NIL (-299 R1 R2) -((|constructor| (NIL "\\axiom{\\spad{ExpertSystemToolsPackage2}} contains some useful functions for use by the computational agents of Ordinary Differential Equation solvers.")) (|map| (((|Matrix| |#2|) (|Mapping| |#2| |#1|) (|Matrix| |#1|)) "\\spad{map(f,{}m)} applies a mapping \\spad{f:R1} \\spad{->} \\spad{R2} onto a matrix \\spad{m} in \\spad{R1} returning a matrix in \\spad{R2}"))) +((|constructor| (NIL "\\axiom{ExpertSystemToolsPackage2} contains some useful functions for use by the computational agents of Ordinary Differential Equation solvers.")) (|map| (((|Matrix| |#2|) (|Mapping| |#2| |#1|) (|Matrix| |#1|)) "\\spad{map(f,m)} applies a mapping \\spad{f:R1} \\spad{->} \\spad{R2} onto a matrix \\spad{m} in \\spad{R1} returning a matrix in \\spad{R2}"))) NIL NIL (-300) -((|constructor| (NIL "\\axiom{ExpertSystemToolsPackage} contains some useful functions for use by the computational agents of numerical solvers.")) (|mat| (((|Matrix| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|NonNegativeInteger|)) "\\spad{mat(a,{}n)} constructs a one-dimensional matrix of a.")) (|fi2df| (((|DoubleFloat|) (|Fraction| (|Integer|))) "\\spad{fi2df(f)} coerces a \\axiomType{Fraction Integer} to \\axiomType{DoubleFloat}")) (|df2ef| (((|Expression| (|Float|)) (|DoubleFloat|)) "\\spad{df2ef(a)} coerces a \\axiomType{DoubleFloat} to \\axiomType{Expression Float}")) (|pdf2df| (((|DoubleFloat|) (|Polynomial| (|DoubleFloat|))) "\\spad{pdf2df(p)} coerces a \\axiomType{Polynomial DoubleFloat} to \\axiomType{DoubleFloat}. It is an error if \\axiom{\\spad{p}} is not retractable to DoubleFloat.")) (|pdf2ef| (((|Expression| (|Float|)) (|Polynomial| (|DoubleFloat|))) "\\spad{pdf2ef(p)} coerces a \\axiomType{Polynomial DoubleFloat} to \\axiomType{Expression Float}")) (|iflist2Result| (((|Result|) (|Record| (|:| |stiffness| (|Float|)) (|:| |stability| (|Float|)) (|:| |expense| (|Float|)) (|:| |accuracy| (|Float|)) (|:| |intermediateResults| (|Float|)))) "\\spad{iflist2Result(m)} converts a attributes record into a \\axiomType{Result}")) (|att2Result| (((|Result|) (|Record| (|:| |endPointContinuity| (|Union| (|:| |continuous| "Continuous at the end points") (|:| |lowerSingular| "There is a singularity at the lower end point") (|:| |upperSingular| "There is a singularity at the upper end point") (|:| |bothSingular| "There are singularities at both end points") (|:| |notEvaluated| "End point continuity not yet evaluated"))) (|:| |singularitiesStream| (|Union| (|:| |str| (|Stream| (|DoubleFloat|))) (|:| |notEvaluated| "Internal singularities not yet evaluated"))) (|:| |range| (|Union| (|:| |finite| "The range is finite") (|:| |lowerInfinite| "The bottom of range is infinite") (|:| |upperInfinite| "The top of range is infinite") (|:| |bothInfinite| "Both top and bottom points are infinite") (|:| |notEvaluated| "Range not yet evaluated"))))) "\\spad{att2Result(m)} converts a attributes record into a \\axiomType{Result}")) (|measure2Result| (((|Result|) (|Record| (|:| |measure| (|Float|)) (|:| |name| (|String|)) (|:| |explanations| (|List| (|String|))) (|:| |extra| (|Result|)))) "\\spad{measure2Result(m)} converts a measure record into a \\axiomType{Result}") (((|Result|) (|Record| (|:| |measure| (|Float|)) (|:| |name| (|String|)) (|:| |explanations| (|List| (|String|))))) "\\spad{measure2Result(m)} converts a measure record into a \\axiomType{Result}")) (|outputMeasure| (((|String|) (|Float|)) "\\spad{outputMeasure(n)} rounds \\spad{n} to 3 decimal places and outputs it as a string")) (|concat| (((|Result|) (|List| (|Result|))) "\\spad{concat(l)} concatenates a list of aggregates of type \\axiomType{Result}") (((|Result|) (|Result|) (|Result|)) "\\spad{concat(a,{}b)} adds two aggregates of type \\axiomType{Result}.")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(u)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\spad{u}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(u)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\spad{u}")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a \\axiomType{Stream DoubleFloat} to \\axiomType{String}")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a \\axiomType{List DoubleFloat} to \\axiomType{List String}")) (|f2st| (((|String|) (|Float|)) "\\spad{f2st(n)} coerces a \\axiomType{Float} to \\axiomType{String}")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|in?| (((|Boolean|) (|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{in?(p,{}range)} tests whether point \\spad{p} is internal to the \\spad{range} \\spad{range}")) (|vedf2vef| (((|Vector| (|Expression| (|Float|))) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{vedf2vef(v)} maps \\axiomType{Vector Expression DoubleFloat} to \\axiomType{Vector Expression Float}")) (|edf2ef| (((|Expression| (|Float|)) (|Expression| (|DoubleFloat|))) "\\spad{edf2ef(e)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{Expression Float}")) (|ldf2vmf| (((|Vector| (|MachineFloat|)) (|List| (|DoubleFloat|))) "\\spad{ldf2vmf(l)} coerces a \\axiomType{List DoubleFloat} to \\axiomType{List MachineFloat}")) (|df2mf| (((|MachineFloat|) (|DoubleFloat|)) "\\spad{df2mf(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{MachineFloat}")) (|dflist| (((|List| (|DoubleFloat|)) (|List| (|Record| (|:| |left| (|Fraction| (|Integer|))) (|:| |right| (|Fraction| (|Integer|)))))) "\\spad{dflist(l)} returns a list of \\axiomType{DoubleFloat} equivalents of list \\spad{l}")) (|dfRange| (((|Segment| (|OrderedCompletion| (|DoubleFloat|))) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{dfRange(r)} converts a range including \\inputbitmap{\\htbmdir{}/plusminus.bitmap} \\infty to \\axiomType{DoubleFloat} equavalents.")) (|edf2efi| (((|Expression| (|Fraction| (|Integer|))) (|Expression| (|DoubleFloat|))) "\\spad{edf2efi(e)} coerces \\axiomType{Expression DoubleFloat} into \\axiomType{Expression Fraction Integer}")) (|numberOfOperations| (((|Record| (|:| |additions| (|Integer|)) (|:| |multiplications| (|Integer|)) (|:| |exponentiations| (|Integer|)) (|:| |functionCalls| (|Integer|))) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{numberOfOperations(ode)} counts additions,{} multiplications,{} exponentiations and function calls in the input set of expressions.")) (|expenseOfEvaluation| (((|Float|) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{expenseOfEvaluation(o)} gives an approximation of the cost of evaluating a list of expressions in terms of the number of basic operations. < 0.3 inexpensive ; 0.5 neutral ; > 0.7 very expensive 400 `operation units' \\spad{->} 0.75 200 `operation units' \\spad{->} 0.5 83 `operation units' \\spad{->} 0.25 \\spad{**} = 4 units ,{} function calls = 10 units.")) (|isQuotient| (((|Union| (|Expression| (|DoubleFloat|)) "failed") (|Expression| (|DoubleFloat|))) "\\spad{isQuotient(expr)} returns the quotient part of the input expression or \\spad{\"failed\"} if the expression is not of that form.")) (|edf2df| (((|DoubleFloat|) (|Expression| (|DoubleFloat|))) "\\spad{edf2df(n)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{DoubleFloat} It is an error if \\spad{n} is not coercible to DoubleFloat")) (|edf2fi| (((|Fraction| (|Integer|)) (|Expression| (|DoubleFloat|))) "\\spad{edf2fi(n)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{Fraction Integer} It is an error if \\spad{n} is not coercible to Fraction Integer")) (|df2fi| (((|Fraction| (|Integer|)) (|DoubleFloat|)) "\\spad{df2fi(n)} is a function to convert a \\axiomType{DoubleFloat} to a \\axiomType{Fraction Integer}")) (|convert| (((|List| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|List| (|Segment| (|OrderedCompletion| (|Float|))))) "\\spad{convert(l)} is a function to convert a \\axiomType{Segment OrderedCompletion Float} to a \\axiomType{Segment OrderedCompletion DoubleFloat}")) (|socf2socdf| (((|Segment| (|OrderedCompletion| (|DoubleFloat|))) (|Segment| (|OrderedCompletion| (|Float|)))) "\\spad{socf2socdf(a)} is a function to convert a \\axiomType{Segment OrderedCompletion Float} to a \\axiomType{Segment OrderedCompletion DoubleFloat}")) (|ocf2ocdf| (((|OrderedCompletion| (|DoubleFloat|)) (|OrderedCompletion| (|Float|))) "\\spad{ocf2ocdf(a)} is a function to convert an \\axiomType{OrderedCompletion Float} to an \\axiomType{OrderedCompletion DoubleFloat}")) (|ef2edf| (((|Expression| (|DoubleFloat|)) (|Expression| (|Float|))) "\\spad{ef2edf(f)} is a function to convert an \\axiomType{Expression Float} to an \\axiomType{Expression DoubleFloat}")) (|f2df| (((|DoubleFloat|) (|Float|)) "\\spad{f2df(f)} is a function to convert a \\axiomType{Float} to a \\axiomType{DoubleFloat}"))) +((|constructor| (NIL "\\axiom{ExpertSystemToolsPackage} contains some useful functions for use by the computational agents of numerical solvers.")) (|mat| (((|Matrix| (|DoubleFloat|)) (|List| (|DoubleFloat|)) (|NonNegativeInteger|)) "\\spad{mat(a,n)} constructs a one-dimensional matrix of a.")) (|fi2df| (((|DoubleFloat|) (|Fraction| (|Integer|))) "\\spad{fi2df(f)} coerces a \\axiomType{Fraction Integer} to \\axiomType{DoubleFloat}")) (|df2ef| (((|Expression| (|Float|)) (|DoubleFloat|)) "\\spad{df2ef(a)} coerces a \\axiomType{DoubleFloat} to \\axiomType{Expression Float}")) (|pdf2df| (((|DoubleFloat|) (|Polynomial| (|DoubleFloat|))) "\\spad{pdf2df(p)} coerces a \\axiomType{Polynomial DoubleFloat} to \\axiomType{DoubleFloat}. It is an error if \\axiom{p} is not retractable to DoubleFloat.")) (|pdf2ef| (((|Expression| (|Float|)) (|Polynomial| (|DoubleFloat|))) "\\spad{pdf2ef(p)} coerces a \\axiomType{Polynomial DoubleFloat} to \\axiomType{Expression Float}")) (|iflist2Result| (((|Result|) (|Record| (|:| |stiffness| (|Float|)) (|:| |stability| (|Float|)) (|:| |expense| (|Float|)) (|:| |accuracy| (|Float|)) (|:| |intermediateResults| (|Float|)))) "\\spad{iflist2Result(m)} converts a attributes record into a \\axiomType{Result}")) (|att2Result| (((|Result|) (|Record| (|:| |endPointContinuity| (|Union| (|:| |continuous| "Continuous at the end points") (|:| |lowerSingular| "There is a singularity at the lower end point") (|:| |upperSingular| "There is a singularity at the upper end point") (|:| |bothSingular| "There are singularities at both end points") (|:| |notEvaluated| "End point continuity not yet evaluated"))) (|:| |singularitiesStream| (|Union| (|:| |str| (|Stream| (|DoubleFloat|))) (|:| |notEvaluated| "Internal singularities not yet evaluated"))) (|:| |range| (|Union| (|:| |finite| "The range is finite") (|:| |lowerInfinite| "The bottom of range is infinite") (|:| |upperInfinite| "The top of range is infinite") (|:| |bothInfinite| "Both top and bottom points are infinite") (|:| |notEvaluated| "Range not yet evaluated"))))) "\\spad{att2Result(m)} converts a attributes record into a \\axiomType{Result}")) (|measure2Result| (((|Result|) (|Record| (|:| |measure| (|Float|)) (|:| |name| (|String|)) (|:| |explanations| (|List| (|String|))) (|:| |extra| (|Result|)))) "\\spad{measure2Result(m)} converts a measure record into a \\axiomType{Result}") (((|Result|) (|Record| (|:| |measure| (|Float|)) (|:| |name| (|String|)) (|:| |explanations| (|List| (|String|))))) "\\spad{measure2Result(m)} converts a measure record into a \\axiomType{Result}")) (|outputMeasure| (((|String|) (|Float|)) "\\spad{outputMeasure(n)} rounds \\spad{n} to 3 decimal places and outputs it as a string")) (|concat| (((|Result|) (|List| (|Result|))) "\\spad{concat(l)} concatenates a list of aggregates of type \\axiomType{Result}") (((|Result|) (|Result|) (|Result|)) "\\spad{concat(a,b)} adds two aggregates of type \\axiomType{Result}.")) (|gethi| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{gethi(u)} gets the \\axiomType{DoubleFloat} equivalent of the second endpoint of the range \\spad{u}")) (|getlo| (((|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{getlo(u)} gets the \\axiomType{DoubleFloat} equivalent of the first endpoint of the range \\spad{u}")) (|sdf2lst| (((|List| (|String|)) (|Stream| (|DoubleFloat|))) "\\spad{sdf2lst(ln)} coerces a \\axiomType{Stream DoubleFloat} to \\axiomType{String}")) (|ldf2lst| (((|List| (|String|)) (|List| (|DoubleFloat|))) "\\spad{ldf2lst(ln)} coerces a \\axiomType{List DoubleFloat} to \\axiomType{List String}")) (|f2st| (((|String|) (|Float|)) "\\spad{f2st(n)} coerces a \\axiomType{Float} to \\axiomType{String}")) (|df2st| (((|String|) (|DoubleFloat|)) "\\spad{df2st(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{String}")) (|in?| (((|Boolean|) (|DoubleFloat|) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{in?(p,range)} tests whether point \\spad{p} is internal to the \\spad{range} \\spad{range}")) (|vedf2vef| (((|Vector| (|Expression| (|Float|))) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{vedf2vef(v)} maps \\axiomType{Vector Expression DoubleFloat} to \\axiomType{Vector Expression Float}")) (|edf2ef| (((|Expression| (|Float|)) (|Expression| (|DoubleFloat|))) "\\spad{edf2ef(e)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{Expression Float}")) (|ldf2vmf| (((|Vector| (|MachineFloat|)) (|List| (|DoubleFloat|))) "\\spad{ldf2vmf(l)} coerces a \\axiomType{List DoubleFloat} to \\axiomType{List MachineFloat}")) (|df2mf| (((|MachineFloat|) (|DoubleFloat|)) "\\spad{df2mf(n)} coerces a \\axiomType{DoubleFloat} to \\axiomType{MachineFloat}")) (|dflist| (((|List| (|DoubleFloat|)) (|List| (|Record| (|:| |left| (|Fraction| (|Integer|))) (|:| |right| (|Fraction| (|Integer|)))))) "\\spad{dflist(l)} returns a list of \\axiomType{DoubleFloat} equivalents of list \\spad{l}")) (|dfRange| (((|Segment| (|OrderedCompletion| (|DoubleFloat|))) (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) "\\spad{dfRange(r)} converts a range including \\inputbitmap{\\htbmdir{}/plusminus.bitmap} \\infty to \\axiomType{DoubleFloat} equavalents.")) (|edf2efi| (((|Expression| (|Fraction| (|Integer|))) (|Expression| (|DoubleFloat|))) "\\spad{edf2efi(e)} coerces \\axiomType{Expression DoubleFloat} into \\axiomType{Expression Fraction Integer}")) (|numberOfOperations| (((|Record| (|:| |additions| (|Integer|)) (|:| |multiplications| (|Integer|)) (|:| |exponentiations| (|Integer|)) (|:| |functionCalls| (|Integer|))) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{numberOfOperations(ode)} counts additions, multiplications, exponentiations and function calls in the input set of expressions.")) (|expenseOfEvaluation| (((|Float|) (|Vector| (|Expression| (|DoubleFloat|)))) "\\spad{expenseOfEvaluation(o)} gives an approximation of the cost of evaluating a list of expressions in terms of the number of basic operations. < 0.3 inexpensive ; 0.5 neutral ; > 0.7 very expensive 400 `operation units' \\spad{->} 0.75 200 `operation units' \\spad{->} 0.5 83 `operation units' \\spad{->} 0.25 \\spad{**} = 4 units ,{} function calls = 10 units.")) (|isQuotient| (((|Union| (|Expression| (|DoubleFloat|)) "failed") (|Expression| (|DoubleFloat|))) "\\spad{isQuotient(expr)} returns the quotient part of the input expression or \\spad{\"failed\"} if the expression is not of that form.")) (|edf2df| (((|DoubleFloat|) (|Expression| (|DoubleFloat|))) "\\spad{edf2df(n)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{DoubleFloat} It is an error if \\spad{n} is not coercible to DoubleFloat")) (|edf2fi| (((|Fraction| (|Integer|)) (|Expression| (|DoubleFloat|))) "\\spad{edf2fi(n)} maps \\axiomType{Expression DoubleFloat} to \\axiomType{Fraction Integer} It is an error if \\spad{n} is not coercible to Fraction Integer")) (|df2fi| (((|Fraction| (|Integer|)) (|DoubleFloat|)) "\\spad{df2fi(n)} is a function to convert a \\axiomType{DoubleFloat} to a \\axiomType{Fraction Integer}")) (|convert| (((|List| (|Segment| (|OrderedCompletion| (|DoubleFloat|)))) (|List| (|Segment| (|OrderedCompletion| (|Float|))))) "\\spad{convert(l)} is a function to convert a \\axiomType{Segment OrderedCompletion Float} to a \\axiomType{Segment OrderedCompletion DoubleFloat}")) (|socf2socdf| (((|Segment| (|OrderedCompletion| (|DoubleFloat|))) (|Segment| (|OrderedCompletion| (|Float|)))) "\\spad{socf2socdf(a)} is a function to convert a \\axiomType{Segment OrderedCompletion Float} to a \\axiomType{Segment OrderedCompletion DoubleFloat}")) (|ocf2ocdf| (((|OrderedCompletion| (|DoubleFloat|)) (|OrderedCompletion| (|Float|))) "\\spad{ocf2ocdf(a)} is a function to convert an \\axiomType{OrderedCompletion Float} to an \\axiomType{OrderedCompletion DoubleFloat}")) (|ef2edf| (((|Expression| (|DoubleFloat|)) (|Expression| (|Float|))) "\\spad{ef2edf(f)} is a function to convert an \\axiomType{Expression Float} to an \\axiomType{Expression DoubleFloat}")) (|f2df| (((|DoubleFloat|) (|Float|)) "\\spad{f2df(f)} is a function to convert a \\axiomType{Float} to a \\axiomType{DoubleFloat}"))) NIL NIL (-301 S) -((|constructor| (NIL "A constructive euclidean domain,{} \\spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\\spadfun{euclideanSize}) than the divisor. \\blankline Conditional attributes\\spad{\\br} \\tab{5}multiplicativeValuation\\tab{5}Size(a*b)=Size(a)*Size(\\spad{b})\\spad{\\br} \\tab{5}additiveValuation\\tab{11}Size(a*b)=Size(a)+Size(\\spad{b})")) (|multiEuclidean| (((|Union| (|List| $) "failed") (|List| $) $) "\\spad{multiEuclidean([f1,{}...,{}fn],{}z)} returns a list of coefficients \\spad{[a1,{} ...,{} an]} such that \\spad{ z / prod \\spad{fi} = sum aj/fj}. If no such list of coefficients exists,{} \"failed\" is returned.")) (|extendedEuclidean| (((|Union| (|Record| (|:| |coef1| $) (|:| |coef2| $)) "failed") $ $ $) "\\spad{extendedEuclidean(x,{}y,{}z)} either returns a record rec where \\spad{rec.coef1*x+rec.coef2*y=z} or returns \"failed\" if \\spad{z} cannot be expressed as a linear combination of \\spad{x} and \\spad{y}.") (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{extendedEuclidean(x,{}y)} returns a record rec where \\spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a \\spad{gcd} of \\spad{x} and \\spad{y}. The \\spad{gcd} is unique only up to associates if \\spadatt{canonicalUnitNormal} is not asserted. \\spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.")) (|rem| (($ $ $) "\\spad{x rem y} is the same as \\spad{divide(x,{}y).remainder}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|quo| (($ $ $) "\\spad{x quo y} is the same as \\spad{divide(x,{}y).quotient}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|divide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{divide(x,{}y)} divides \\spad{x} by \\spad{y} producing a record containing a \\spad{quotient} and \\spad{remainder},{} where the remainder is smaller (see \\spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \\spad{y}.")) (|euclideanSize| (((|NonNegativeInteger|) $) "\\spad{euclideanSize(x)} returns the euclidean size of the element \\spad{x}. Error: if \\spad{x} is zero.")) (|sizeLess?| (((|Boolean|) $ $) "\\spad{sizeLess?(x,{}y)} tests whether \\spad{x} is strictly smaller than \\spad{y} with respect to the \\spadfunFrom{euclideanSize}{EuclideanDomain}."))) +((|constructor| (NIL "A constructive euclidean domain, \\spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\\spadfun{euclideanSize}) than the divisor. \\blankline Conditional attributes\\br \\tab{5}multiplicativeValuation\\tab{5}Size(a*b)=Size(a)*Size(b)\\br \\tab{5}additiveValuation\\tab{11}Size(a*b)=Size(a)+Size(b)")) (|multiEuclidean| (((|Union| (|List| $) "failed") (|List| $) $) "\\spad{multiEuclidean([f1,...,fn],z)} returns a list of coefficients \\spad{[a1, ..., an]} such that \\spad{ \\spad{z} / prod \\spad{fi} = sum aj/fj}. If no such list of coefficients exists, \"failed\" is returned.")) (|extendedEuclidean| (((|Union| (|Record| (|:| |coef1| $) (|:| |coef2| $)) "failed") $ $ $) "\\spad{extendedEuclidean(x,y,z)} either returns a record rec where \\spad{rec.coef1*x+rec.coef2*y=z} or returns \"failed\" if \\spad{z} cannot be expressed as a linear combination of \\spad{x} and \\spad{y.}") (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{extendedEuclidean(x,y)} returns a record rec where \\spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a \\spad{gcd} of \\spad{x} and \\spad{y.} The \\spad{gcd} is unique only up to associates if \\spadatt{canonicalUnitNormal} is not asserted. \\spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.")) (|rem| (($ $ $) "\\spad{x rem \\spad{y}} is the same as \\spad{divide(x,y).remainder}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|quo| (($ $ $) "\\spad{x quo \\spad{y}} is the same as \\spad{divide(x,y).quotient}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|divide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{divide(x,y)} divides \\spad{x} by \\spad{y} producing a record containing a \\spad{quotient} and \\spad{remainder}, where the remainder is smaller (see \\spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \\spad{y.}")) (|euclideanSize| (((|NonNegativeInteger|) $) "\\spad{euclideanSize(x)} returns the euclidean size of the element \\spad{x.} Error: if \\spad{x} is zero.")) (|sizeLess?| (((|Boolean|) $ $) "\\spad{sizeLess?(x,y)} tests whether \\spad{x} is strictly smaller than \\spad{y} with respect to the \\spadfunFrom{euclideanSize}{EuclideanDomain}."))) NIL NIL (-302) -((|constructor| (NIL "A constructive euclidean domain,{} \\spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\\spadfun{euclideanSize}) than the divisor. \\blankline Conditional attributes\\spad{\\br} \\tab{5}multiplicativeValuation\\tab{5}Size(a*b)=Size(a)*Size(\\spad{b})\\spad{\\br} \\tab{5}additiveValuation\\tab{11}Size(a*b)=Size(a)+Size(\\spad{b})")) (|multiEuclidean| (((|Union| (|List| $) "failed") (|List| $) $) "\\spad{multiEuclidean([f1,{}...,{}fn],{}z)} returns a list of coefficients \\spad{[a1,{} ...,{} an]} such that \\spad{ z / prod \\spad{fi} = sum aj/fj}. If no such list of coefficients exists,{} \"failed\" is returned.")) (|extendedEuclidean| (((|Union| (|Record| (|:| |coef1| $) (|:| |coef2| $)) "failed") $ $ $) "\\spad{extendedEuclidean(x,{}y,{}z)} either returns a record rec where \\spad{rec.coef1*x+rec.coef2*y=z} or returns \"failed\" if \\spad{z} cannot be expressed as a linear combination of \\spad{x} and \\spad{y}.") (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{extendedEuclidean(x,{}y)} returns a record rec where \\spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a \\spad{gcd} of \\spad{x} and \\spad{y}. The \\spad{gcd} is unique only up to associates if \\spadatt{canonicalUnitNormal} is not asserted. \\spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.")) (|rem| (($ $ $) "\\spad{x rem y} is the same as \\spad{divide(x,{}y).remainder}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|quo| (($ $ $) "\\spad{x quo y} is the same as \\spad{divide(x,{}y).quotient}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|divide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{divide(x,{}y)} divides \\spad{x} by \\spad{y} producing a record containing a \\spad{quotient} and \\spad{remainder},{} where the remainder is smaller (see \\spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \\spad{y}.")) (|euclideanSize| (((|NonNegativeInteger|) $) "\\spad{euclideanSize(x)} returns the euclidean size of the element \\spad{x}. Error: if \\spad{x} is zero.")) (|sizeLess?| (((|Boolean|) $ $) "\\spad{sizeLess?(x,{}y)} tests whether \\spad{x} is strictly smaller than \\spad{y} with respect to the \\spadfunFrom{euclideanSize}{EuclideanDomain}."))) -((-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) +((|constructor| (NIL "A constructive euclidean domain, \\spadignore{i.e.} one can divide producing a quotient and a remainder where the remainder is either zero or is smaller (\\spadfun{euclideanSize}) than the divisor. \\blankline Conditional attributes\\br \\tab{5}multiplicativeValuation\\tab{5}Size(a*b)=Size(a)*Size(b)\\br \\tab{5}additiveValuation\\tab{11}Size(a*b)=Size(a)+Size(b)")) (|multiEuclidean| (((|Union| (|List| $) "failed") (|List| $) $) "\\spad{multiEuclidean([f1,...,fn],z)} returns a list of coefficients \\spad{[a1, ..., an]} such that \\spad{ \\spad{z} / prod \\spad{fi} = sum aj/fj}. If no such list of coefficients exists, \"failed\" is returned.")) (|extendedEuclidean| (((|Union| (|Record| (|:| |coef1| $) (|:| |coef2| $)) "failed") $ $ $) "\\spad{extendedEuclidean(x,y,z)} either returns a record rec where \\spad{rec.coef1*x+rec.coef2*y=z} or returns \"failed\" if \\spad{z} cannot be expressed as a linear combination of \\spad{x} and \\spad{y.}") (((|Record| (|:| |coef1| $) (|:| |coef2| $) (|:| |generator| $)) $ $) "\\spad{extendedEuclidean(x,y)} returns a record rec where \\spad{rec.coef1*x+rec.coef2*y = rec.generator} and rec.generator is a \\spad{gcd} of \\spad{x} and \\spad{y.} The \\spad{gcd} is unique only up to associates if \\spadatt{canonicalUnitNormal} is not asserted. \\spadfun{principalIdeal} provides a version of this operation which accepts an arbitrary length list of arguments.")) (|rem| (($ $ $) "\\spad{x rem \\spad{y}} is the same as \\spad{divide(x,y).remainder}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|quo| (($ $ $) "\\spad{x quo \\spad{y}} is the same as \\spad{divide(x,y).quotient}. See \\spadfunFrom{divide}{EuclideanDomain}.")) (|divide| (((|Record| (|:| |quotient| $) (|:| |remainder| $)) $ $) "\\spad{divide(x,y)} divides \\spad{x} by \\spad{y} producing a record containing a \\spad{quotient} and \\spad{remainder}, where the remainder is smaller (see \\spadfunFrom{sizeLess?}{EuclideanDomain}) than the divisor \\spad{y.}")) (|euclideanSize| (((|NonNegativeInteger|) $) "\\spad{euclideanSize(x)} returns the euclidean size of the element \\spad{x.} Error: if \\spad{x} is zero.")) (|sizeLess?| (((|Boolean|) $ $) "\\spad{sizeLess?(x,y)} tests whether \\spad{x} is strictly smaller than \\spad{y} with respect to the \\spadfunFrom{euclideanSize}{EuclideanDomain}."))) +((-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) NIL (-303 S R) -((|constructor| (NIL "This category provides \\spadfun{eval} operations. A domain may belong to this category if it is possible to make ``evaluation\\spad{''} substitutions.")) (|eval| (($ $ (|List| (|Equation| |#2|))) "\\spad{eval(f,{} [x1 = v1,{}...,{}xn = vn])} replaces \\spad{xi} by \\spad{vi} in \\spad{f}.") (($ $ (|Equation| |#2|)) "\\spad{eval(f,{}x = v)} replaces \\spad{x} by \\spad{v} in \\spad{f}."))) +((|constructor| (NIL "This category provides \\spadfun{eval} operations. A domain may belong to this category if it is possible to make ``evaluation'' substitutions.")) (|eval| (($ $ (|List| (|Equation| |#2|))) "\\spad{eval(f, \\spad{[x1} = v1,...,xn = vn])} replaces \\spad{xi} by \\spad{vi} in \\spad{f.}") (($ $ (|Equation| |#2|)) "\\spad{eval(f,x = \\spad{v)}} replaces \\spad{x} by \\spad{v} in \\spad{f.}"))) NIL NIL (-304 R) -((|constructor| (NIL "This category provides \\spadfun{eval} operations. A domain may belong to this category if it is possible to make ``evaluation\\spad{''} substitutions.")) (|eval| (($ $ (|List| (|Equation| |#1|))) "\\spad{eval(f,{} [x1 = v1,{}...,{}xn = vn])} replaces \\spad{xi} by \\spad{vi} in \\spad{f}.") (($ $ (|Equation| |#1|)) "\\spad{eval(f,{}x = v)} replaces \\spad{x} by \\spad{v} in \\spad{f}."))) +((|constructor| (NIL "This category provides \\spadfun{eval} operations. A domain may belong to this category if it is possible to make ``evaluation'' substitutions.")) (|eval| (($ $ (|List| (|Equation| |#1|))) "\\spad{eval(f, \\spad{[x1} = v1,...,xn = vn])} replaces \\spad{xi} by \\spad{vi} in \\spad{f.}") (($ $ (|Equation| |#1|)) "\\spad{eval(f,x = \\spad{v)}} replaces \\spad{x} by \\spad{v} in \\spad{f.}"))) NIL NIL -(-305 -1564) -((|constructor| (NIL "This package is to be used in conjuction with the CycleIndicators package. It provides an evaluation function for SymmetricPolynomials.")) (|eval| ((|#1| (|Mapping| |#1| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{eval(f,{}s)} evaluates the cycle index \\spad{s} by applying \\indented{1}{the function \\spad{f} to each integer in a monomial partition,{}} \\indented{1}{forms their product and sums the results over all monomials.}"))) +(-305 -1647) +((|constructor| (NIL "This package is to be used in conjuction with the CycleIndicators package. It provides an evaluation function for SymmetricPolynomials.")) (|eval| ((|#1| (|Mapping| |#1| (|Integer|)) (|SymmetricPolynomial| (|Fraction| (|Integer|)))) "\\spad{eval(f,s)} evaluates the cycle index \\spad{s} by applying \\indented{1}{the function \\spad{f} to each integer in a monomial partition,} \\indented{1}{forms their product and sums the results over all monomials.}"))) NIL NIL (-306) -((|constructor| (NIL "A function which does not return directly to its caller should have Exit as its return type. \\blankline Note that It is convenient to have a formal \\spad{coerce} into each type from type Exit. This allows,{} for example,{} errors to be raised in one half of a type-balanced \\spad{if}."))) +((|constructor| (NIL "A function which does not return directly to its caller should have Exit as its return type. \\blankline Note that It is convenient to have a formal \\spad{coerce} into each type from type Exit. This allows, for example, errors to be raised in one half of a type-balanced \\spad{if}."))) NIL NIL (-307) @@ -1161,43 +1161,43 @@ NIL NIL NIL (-308 R FE |var| |cen|) -((|constructor| (NIL "UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent essential singularities of functions. Objects in this domain are quotients of sums,{} where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series.")) (|coerce| (($ (|UnivariatePuiseuxSeries| |#2| |#3| |#4|)) "\\spad{coerce(f)} converts a \\spadtype{UnivariatePuiseuxSeries} to an \\spadtype{ExponentialExpansion}.")) (|limitPlus| (((|Union| (|OrderedCompletion| |#2|) "failed") $) "\\spad{limitPlus(f(var))} returns \\spad{limit(var -> a+,{}f(var))}."))) -((-4527 . T) (-4533 . T) (-4528 . T) ((-4537 "*") . T) (-4529 . T) (-4530 . T) (-4532 . T)) -((|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-905))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -1038) (QUOTE (-1163)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-149))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-151))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-1022))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-816))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -1038) (QUOTE (-569)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-1137))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -882) (QUOTE (-569)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -882) (QUOTE (-382)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-382))))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (LIST (QUOTE -888) (QUOTE (-569))))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-226))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -896) (QUOTE (-1163)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -524) (QUOTE (-1163)) (LIST (QUOTE -1232) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -304) (LIST (QUOTE -1232) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (LIST (QUOTE -282) (LIST (QUOTE -1232) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)) (LIST (QUOTE -1232) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-302))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-551))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-843))) (-2232 (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-816))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-843)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-905)))) (-2232 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-905)))) (|HasCategory| (-1232 |#1| |#2| |#3| |#4|) (QUOTE (-149))))) +((|constructor| (NIL "UnivariatePuiseuxSeriesWithExponentialSingularity is a domain used to represent essential singularities of functions. Objects in this domain are quotients of sums, where each term in the sum is a univariate Puiseux series times the exponential of a univariate Puiseux series.")) (|coerce| (($ (|UnivariatePuiseuxSeries| |#2| |#3| |#4|)) "\\spad{coerce(f)} converts a \\spadtype{UnivariatePuiseuxSeries} to an \\spadtype{ExponentialExpansion}.")) (|limitPlus| (((|Union| (|OrderedCompletion| |#2|) "failed") $) "\\spad{limitPlus(f(var))} returns \\spad{limit(var \\spad{->} a+,f(var))}."))) +((-4563 . T) (-4569 . T) (-4564 . T) ((-4573 "*") . T) (-4565 . T) (-4566 . T) (-4568 . T)) +((|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-906))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -1039) (QUOTE (-1165)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-149))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-151))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (QUOTE (-542)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-1023))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-817))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -1039) (QUOTE (-569)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-1139))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -883) (QUOTE (-569)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -883) (QUOTE (-382)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-382))))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -610) (LIST (QUOTE -889) (QUOTE (-569))))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -631) (QUOTE (-569)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-226))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -897) (QUOTE (-1165)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -524) (QUOTE (-1165)) (LIST (QUOTE -1238) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -304) (LIST (QUOTE -1238) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (LIST (QUOTE -282) (LIST (QUOTE -1238) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)) (LIST (QUOTE -1238) (|devaluate| |#1|) (|devaluate| |#2|) (|devaluate| |#3|) (|devaluate| |#4|)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-302))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-551))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-844))) (-1929 (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-817))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-844)))) (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-906)))) (-1929 (-12 (|HasCategory| $ (QUOTE (-149))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-906)))) (|HasCategory| (-1238 |#1| |#2| |#3| |#4|) (QUOTE (-149))))) (-309 R S) -((|constructor| (NIL "Lifting of maps to Expressions.")) (|map| (((|Expression| |#2|) (|Mapping| |#2| |#1|) (|Expression| |#1|)) "\\spad{map(f,{} e)} applies \\spad{f} to all the constants appearing in \\spad{e}."))) +((|constructor| (NIL "Lifting of maps to Expressions.")) (|map| (((|Expression| |#2|) (|Mapping| |#2| |#1|) (|Expression| |#1|)) "\\spad{map(f, e)} applies \\spad{f} to all the constants appearing in e."))) NIL NIL (-310 R FE) -((|constructor| (NIL "This package provides functions to convert functional expressions to power series.")) (|series| (((|Any|) |#2| (|Equation| |#2|) (|Fraction| (|Integer|))) "\\spad{series(f,{}x = a,{}n)} expands the expression \\spad{f} as a series in powers of (\\spad{x} - a); terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2| (|Equation| |#2|)) "\\spad{series(f,{}x = a)} expands the expression \\spad{f} as a series in powers of (\\spad{x} - a).") (((|Any|) |#2| (|Fraction| (|Integer|))) "\\spad{series(f,{}n)} returns a series expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2|) "\\spad{series(f)} returns a series expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable.") (((|Any|) (|Symbol|)) "\\spad{series(x)} returns \\spad{x} viewed as a series.")) (|puiseux| (((|Any|) |#2| (|Equation| |#2|) (|Fraction| (|Integer|))) "\\spad{puiseux(f,{}x = a,{}n)} expands the expression \\spad{f} as a Puiseux series in powers of \\spad{(x - a)}; terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2| (|Equation| |#2|)) "\\spad{puiseux(f,{}x = a)} expands the expression \\spad{f} as a Puiseux series in powers of \\spad{(x - a)}.") (((|Any|) |#2| (|Fraction| (|Integer|))) "\\spad{puiseux(f,{}n)} returns a Puiseux expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2|) "\\spad{puiseux(f)} returns a Puiseux expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable.") (((|Any|) (|Symbol|)) "\\spad{puiseux(x)} returns \\spad{x} viewed as a Puiseux series.")) (|laurent| (((|Any|) |#2| (|Equation| |#2|) (|Integer|)) "\\spad{laurent(f,{}x = a,{}n)} expands the expression \\spad{f} as a Laurent series in powers of \\spad{(x - a)}; terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2| (|Equation| |#2|)) "\\spad{laurent(f,{}x = a)} expands the expression \\spad{f} as a Laurent series in powers of \\spad{(x - a)}.") (((|Any|) |#2| (|Integer|)) "\\spad{laurent(f,{}n)} returns a Laurent expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2|) "\\spad{laurent(f)} returns a Laurent expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable.") (((|Any|) (|Symbol|)) "\\spad{laurent(x)} returns \\spad{x} viewed as a Laurent series.")) (|taylor| (((|Any|) |#2| (|Equation| |#2|) (|NonNegativeInteger|)) "\\spad{taylor(f,{}x = a)} expands the expression \\spad{f} as a Taylor series in powers of \\spad{(x - a)}; terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2| (|Equation| |#2|)) "\\spad{taylor(f,{}x = a)} expands the expression \\spad{f} as a Taylor series in powers of \\spad{(x - a)}.") (((|Any|) |#2| (|NonNegativeInteger|)) "\\spad{taylor(f,{}n)} returns a Taylor expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \\spad{n}.") (((|Any|) |#2|) "\\spad{taylor(f)} returns a Taylor expansion of the expression \\spad{f}. Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable.") (((|Any|) (|Symbol|)) "\\spad{taylor(x)} returns \\spad{x} viewed as a Taylor series."))) +((|constructor| (NIL "This package provides functions to convert functional expressions to power series.")) (|series| (((|Any|) |#2| (|Equation| |#2|) (|Fraction| (|Integer|))) "\\spad{series(f,x = a,n)} expands the expression \\spad{f} as a series in powers of \\spad{(x} - a); terms will be computed up to order at least \\spad{n.}") (((|Any|) |#2| (|Equation| |#2|)) "\\spad{series(f,x = a)} expands the expression \\spad{f} as a series in powers of \\spad{(x} - a).") (((|Any|) |#2| (|Fraction| (|Integer|))) "\\spad{series(f,n)} returns a series expansion of the expression \\spad{f.} Note that \\spad{f} should have only one variable; the series will be expanded in powers of that variable and terms will be computed up to order at least \\spad{n.}") (((