From 0ff38af175d383430dc97e8d643df0e8b76cd9f7 Mon Sep 17 00:00:00 2001 From: Tim Daly Date: Mon, 11 Nov 2019 03:48:02 -0500 Subject: [PATCH] books/bookvol15 new book on Axiom Sane Compiler Goal: Proving Axiom Sane add first pass at Parsing --- books/Makefile.pamphlet | 51 + books/bookvol15.pamphlet | 14373 ++++++++++++++++++++++----------------- changelog | 4 + src/axiom-website/patches.html | 2 + 4 files changed, 8241 insertions(+), 6189 deletions(-) diff --git a/books/Makefile.pamphlet b/books/Makefile.pamphlet index 4f59f73..31368a4 100644 --- a/books/Makefile.pamphlet +++ b/books/Makefile.pamphlet @@ -259,6 +259,57 @@ ${PDF}/bookvol10.1.pdf: ${IN}/bookvol10.1.pamphlet \ ${RM} bookvol10.1.ilg bookvol10.1.ind ; \ ${RM} bookheader.tex ) +${PDF}/bookvol15.pdf: ${IN}/bookvol15.pamphlet \ + ${PDF}/axiom.bib ${PDF}/axiom.bst + @ echo =========================================== + @ echo making ${PDF}/bookvol15.pdf from ${IN}/bookvol15.pamphlet + @ echo =========================================== + @(cd ${PDF} ; \ + cp ${BOOKS}/*.sty ${PDF} ; \ + cp ${IN}/bookvol15.pamphlet ${PDF} ; \ + cp ${IN}/bookheader.tex ${PDF} ; \ + cp -pr ${IN}/ps ${PDF} ; \ + ${RM} bookvol15.toc ; \ + touch signatures.tex ; \ + touch bookvol15.sigs ; \ + if [ -z "${NOISE}" ] ; then \ + ${LATEX} bookvol15.pamphlet ; \ + cp signatures.tex bookvol15.sigs ; \ + ${MAKEINDEX} doc.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} code.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} cat.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} dom.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} pkg.idx 1>/dev/null 2>/dev/null ; \ + ${BIBTEX} bookvol15.aux ; \ + ${LATEX} bookvol15.pamphlet >/dev/null ; \ + ${LATEX} bookvol15.pamphlet >/dev/null ; \ + ${DVIPS} bookvol15.dvi 2>/dev/null ; \ + ${PS2PDF} bookvol15.ps 2>/dev/null ; \ + else \ + ${LATEX} bookvol15.pamphlet >${TMP}/trace ; \ + cp signatures.tex bookvol15.sigs ; \ + ${MAKEINDEX} doc.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} code.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} cat.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} dom.idx 1>/dev/null 2>/dev/null ; \ + ${MAKEINDEX} pkg.idx 1>/dev/null 2>/dev/null ; \ + ${BIBTEX} bookvol15.aux 1>/dev/null 2>/dev/null ; \ + ${LATEX} bookvol15.pamphlet >${TMP}/trace ; \ + ${LATEX} bookvol15.pamphlet >${TMP}/trace ; \ + ${DVIPS} bookvol15.dvi >${TMP}/trace ; \ + ${PS2PDF} bookvol15.ps >${TMP}/trace ; \ + fi ; \ + ${RM} bookvol15.aux bookvol15.dvi bookvol15.log \ + ${RM} bookvol15.ps bookvol15.idx bookvol15.tex \ + ${RM} bookvol15.pamphlet ; \ + ${RM} bookvol15.ilg bookvol15.ind *.sigs signatures.tex ; \ + ${RM} doc.idx doc.ilg doc.ind ; \ + ${RM} code.idx code.ilg code.ind ; \ + ${RM} cat.idx cat.ilg cat.ind ; \ + ${RM} dom.idx dom.ilg dom.ind ; \ + ${RM} pkg.idx pkg.ilg pkg.ind ; \ + ${RM} bookheader.tex ) + ${PDF}/%.pdf: ${IN}/%.pamphlet ${PDF}/axiom.bib ${PDF}/axiom.bst @ echo =========================================== @ echo making ${PDF}/$*.pdf from ${IN}/$*.pamphlet diff --git a/books/bookvol15.pamphlet b/books/bookvol15.pamphlet index c08affd..a3ce239 100755 --- a/books/bookvol15.pamphlet +++ b/books/bookvol15.pamphlet @@ -1,9 +1,343 @@ \documentclass{book} \newcommand{\VolumeName}{Volume 15: The Sane Compiler} -\input{bookheader.tex} +\usepackage{etex} % fix No room for a new \dimen +\reserveinserts{30} % fix No room for a new \dimen +\usepackage{imakeidx} % for multiple indicies +\makeindex[name=doc,intoc=false] +\makeindex[name=code,intoc=false] +\makeindex[name=cat,intoc=false] +\makeindex[name=dom,intoc=false] +\makeindex[name=pkg,intoc=false] +\usepackage{hyperref} +\hypersetup{colorlinks=true,linkcolor=blue,pdfborderstyle={/S/U/W 1},citecolor=red} +\usepackage[toc,page]{appendix} +\usepackage{mathtools} +\usepackage{amssymb} +\usepackage{axiom} +\usepackage{enumitem} % for noitemsep in itemize +\usepackage{bussproofs} % for prooftree environment +\usepackage[margin=1in]{geometry} % for white pages +\usepackage{catmac} % for Weber chapter in vol 10.1 +\usepackage{dissdef} % for Weber chapter in vol 10.1 +\usepackage{stmaryrd} % for llbracket +\usepackage{tikz} % for finite state diagrams +\usetikzlibrary{automata, positioning, arrows} +\tikzset{ + ->, % make the edges directed + >=stealth', % make arrow heads bold + node distance=2cm, % min distance between nodes + every state/.style={thick,fill=gray!10}, + initial text=$\epsilon$ % set text on start arrow +} + +\newtheorem{DoyeTheorem}[subsection]{Theorem} +\newtheorem{DoyeDefinition}[subsection]{Definition} +\newtheorem{DoyeExample}[subsection]{Example} +\newtheorem{DoyeNotation}[subsection]{Notation} +\newtheorem{DoyeConjecture}[subsection]{Conjecture} +\newtheorem{DoyeCorollary}[subsection]{Corollary} +\newtheorem{DoyeLemma}[subsection]{Lemma} +\newtheorem{DoyeAssumption}[subsection]{Assumption} +\newtheorem{DoyeAlgorithm}[subsection]{Algorithm} +\newcommand*{\QED}{\hfill\ensuremath{\blacksquare}} % for qed + +\setlength{\textwidth}{400pt} +%\makeindex +\usepackage{graphicx} +\usepackage{changepage} % for adjustwidth environment +\usepackage{pst-node} % for commutative diagrams +\newwrite\sigfile + +%\usepackage{breakurl} +%\def\UrlBreaks{\do\/\do\-} % line-breaking urls + +\begin{document} +\immediate\openout\sigfile=signatures.tex +\frontmatter +\setcounter{secnumdepth}{2} +\begin{titlepage} +\center{\includegraphics{ps/axiomfront.ps}} +\vskip 0.1in +\includegraphics{ps/bluebayou.ps}\\ +\vskip 0.1in +{\Huge{The 30 Year Horizon}} +\vskip 0.1in +$$ +\begin{array}{lll} +Manuel\ Bronstein & William\ Burge & Timothy\ Daly \\ +James\ Davenport & Michael\ Dewar & Martin\ Dunstan \\ +Albrecht\ Fortenbacher & Patrizia\ Gianni & Johannes\ Grabmeier \\ +Jocelyn\ Guidry & Richard\ Jenks & Larry\ Lambe \\ +Michael\ Monagan & Scott\ Morrison & William\ Sit \\ +Jonathan\ Steinbach & Robert\ Sutor & Barry\ Trager \\ +Stephen\ Watt & Jim\ Wen & Clifton\ Williamson +\end{array} +$$ +\center{\large{\VolumeName}} +\vskip 0.1in +\center{\today} +\vskip 0.1in +\center{\input{master}} +\end{titlepage} +\pagenumbering{roman} +\begin{verbatim} +Portions Copyright (c) 2005 Timothy Daly + +The Blue Bayou image Copyright (c) 2004 Jocelyn Guidry + +Portions Copyright (c) 2004 Martin Dunstan +Portions Copyright (c) 2007 Alfredo Portes +Portions Copyright (c) 2007 Arthur Ralfs +Portions Copyright (c) 2005 Timothy Daly + +Portions Copyright (c) 1991-2002, +The Numerical ALgorithms Group Ltd. +All rights reserved. + +This book and the Axiom software is licensed as follows: + +Redistribution and use in source and binary forms, with or +without modification, are permitted provided that the following +conditions are +met: + + - Redistributions of source code must retain the above + copyright notice, this list of conditions and the + following disclaimer. + + - Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the + following disclaimer in the documentation and/or other + materials provided with the distribution. + + - Neither the name of The Numerical ALgorithms Group Ltd. + nor the names of its contributors may be used to endorse + or promote products derived from this software without + specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND +CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, +INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR +CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS +INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, +WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF +SUCH DAMAGE. + +\end{verbatim} + +\vfill +\newpage +Inclusion of names in the list of credits is based on historical +information and is as accurate as possible. Inclusion of names +does not in any way imply an endorsement but represents historical +influence on Axiom development. + +\begin{tabular}{lll} +Michael Albaugh & Cyril Alberga & Roy Adler\\ +Christian Aistleitner & Richard Anderson & George Andrews\\ +Jerry Archibald & S.J. Atkins & Jeremy Avigad\\ +Knut Bahr & Henry Baker & Martin Baker\\ +Stephen Balzac & Yurij Baransky & David R. Barton\\ +Thomas Baruchel & Gerald Baumgartner & Gilbert Baumslag\\ +Michael Becker & Nelson H. F. Beebe & Jay Belanger\\ +Siddharth Bhat & David Bindel & Fred Blair\\ +Vladimir Bondarenko & Mark Botch & Raoul Bourquin\\ +Alexandre Bouyer & Karen Braman & Wolfgang Brehm\\ +Peter A. Broadbery & Martin Brock & Manuel Bronstein\\ +Christopher Brown & Stephen Buchwald & Florian Bundschuh\\ +Luanne Burns & William Burge & Ralph Byers\\ +Quentin Carpent & Jacques Carette & Pierre Casteran\\ +Robert Cavines & Pablo Cayuela & Bruce Char\\ +Ondrej Certik & Tzu-Yi Chen & Bobby Cheng\\ +Cheekai Chin & David V. Chudnovsky & Gregory V. Chudnovsky\\ +Mark Clements & Roland Coeurjoly & Emil Cohen\\ +Hirsh Cohen & Josh Cohen & James Cloos\\ +Jia Zhao Cong & Christophe Conil & Don Coppersmith\\ +George Corliss & Robert Corless & Gary Cornell\\ +Frank Costa & Meino Cramer & Karl Crary\\ +Jeremy Du Croz & David Cyganski & Nathaniel Daly\\ +Timothy Daly Sr. & Timothy Daly Jr. & James H. Davenport\\ +David Day & James Demmel & Didier Deshommes\\ +Michael Dewar & Inderjit Dhillon & Jack Dongarra\\ +Jean Della Dora & Gabriel Dos Reis & Claire DiCrescendo\\ +Sam Dooley & Nicolas James Doye & Zlatko Drmac\\ +Lionel Ducos & Iain Duff & Lee Duhem\\ +Martin Dunstan & Brian Dupee & Dominique Duval\\ +Robert Edwards & Hans-Dieter Ehrich & Heow Eide-Goodman\\ +Carl Engelman & Lars Erickson & Mark Fahey\\ +William Farmer & Richard Fateman & Bertfried Fauser\\ +Stuart Feldman & John Fletcher & Brian Ford\\ +Albrecht Fortenbacher & George Frances & Constantine Frangos\\ +Timothy Freeman & Korrinn Fu & Marc Gaetano\\ +Rudiger Gebauer & Van de Geijn & Kathy Gerber\\ +Patricia Gianni & Gustavo Goertkin & Samantha Goldrich\\ +Max Goldstein & Holger Gollan & Teresa Gomez-Diaz\\ +Ralph Gomory & Laureano Gonzalez-Vega & Stephen Gortler\\ +Johannes Grabmeier & Matt Grayson & Martin Griss\\ +Klaus Ebbe Grue & James Griesmer & Vladimir Grinberg\\ +Oswald Gschnitzer & Ming Gu & Fred Gustavson\\ +Jocelyn Guidry & Gaetan Hache & Steve Hague\\ +Satoshi Hamaguchi & Sven Hammarling & Mike Hansen\\ +Richard Hanson & Richard Harke & Joseph Harry\\ +Bill Hart & Vilya Harvey & Martin Hassner\\ +Arthur S. Hathaway & Dan Hatton & Waldek Hebisch\\ +Karl Hegbloom & Ralf Hemmecke & Tony Hearn\\ +Henderson & Antoine Hersen & Nicholas J. Higham\\ +Lou Hodes & Alan Hoffman & Hoon Hong\\ +Roger House & Gernot Hueber & Pietro Iglio\\ +Joan Jaffe & Alejandro Jakubi & Richard Jenks\\ +Bo Kagstrom & William Kahan & Kyriakos Kalorkoti\\ +Kai Kaminski & Grant Keady & Tom Kelsey\\ +Wilfrid Kendall & Tony Kennedy & David Kincaid\\ +Keshav Kini & Knut Korsvold & Ted Kosan\\ +\end{tabular} +\vfill +\newpage +\begin{tabular}{lll} +Paul Kosinski & Igor Kozachenko & Fred Krogh\\ +Klaus Kusche & Bernhard Kutzler & Tim Lahey\\ +Larry Lambe & Kaj Laurson & Charles Lawson\\ +George L. Legendre & Franz Lehner & Frederic Lehobey\\ +Michel Levaud & Howard Levy & J. Lewis\\ +Ren-Cang Li & John Lipson & Rudiger Loos\\ +Craig Lucas & Michael Lucks & Richard Luczak\\ +Camm Maguire & Dave Mainey & Francois Maltey\\ +William Martin & Ursula Martin & Osni Marques\\ +Alasdair McAndrew & Bob McElrath & Michael McGettrick\\ +Bob McNeill & Edi Meier & Ian Meikle\\ +David Mentre & Jonathan Millen & Victor S. Miller\\ +Gerard Milmeister & William Miranker & Mohammed Mobarak\\ +H. Michael Moeller & Michael Monagan & Marc Moreno-Maza\\ +Scott Morrison & Joel Moses & Mark Murray\\ +William Naylor & Patrice Naudin & C. Andrew Neff\\ +John Nelder & Godfrey Nolan & Arthur Norman\\ +Jinzhong Niu & Michael O'Connor & Summat Oemrawsingh\\ +Kostas Oikonomou & Humberto Ortiz-Zuazaga & Julian A. Padget\\ +Bill Page & David Parnas & Norm Pass\\ +Susan Pelzel & Michel Petitot & Didier Pinchon\\ +Ayal Pinkus & Frederick H. Pitts & Frank Pfenning\\ +Jose Alfredo Portes & E. Quintana-Orti & Gregorio Quintana-Orti\\ +Beresford Parlett & A. Petitet & Andre Platzer\\ +Peter Poromaas & Greg Puhak & Claude Quitte\\ +Arthur C. Ralfs & Norman Ramsey & Anatoly Raportirenko\\ +Guilherme Reis & Huan Ren & Albert D. Rich\\ +Michael Richardson & Jason Riedy & Renaud Rioboo\\ +Robert Risch & Jean Rivlin & Nicolas Robidoux\\ +Simon Robinson & Raymond Rogers & Michael Rothstein\\ +Martin Rubey & Jeff Rutter & R.W Ryniker II\\ +Philip Santas & David Saunders & Alfred Scheerhorn\\ +William Schelter & Gerhard Schneider & Martin Schoenert\\ +Marshall Schor & Frithjof Schulze & Fritz Schwartz\\ +Steven Segletes & V. Sima & Nick Simicich\\ +William Sit & Elena Smirnova & Jacob Nyffeler Smith\\ +Matthieu Sozeau & Srinivasan Seshan & Ken Stanley\\ +Jonathan Steinbach & Fabio Stumbo & Christine Sundaresan\\ +Klaus Sutner & Robert Sutor & Moss E. Sweedler\\ +Eugene Surowitz & Yong Kiam Tan & Max Tegmark\\ +T. Doug Telford & James Thatcher & Laurent Thery\\ +Balbir Thomas & Mike Thomas & Carol Thompson\\ +Dylan Thurston & Francoise Tisseur & Steve Toleque\\ +Dick Toupin & Raymond Toy & Barry Trager\\ +Hale Trotter & Themos T. Tsikas & Gregory Vanuxem\\ +Kresimir Veselic & Christof Voemel & E.G. Wagner\\ +Bernhard Wall & Paul Wang & Stephen Watt\\ +Andreas Weber & Jaap Weel & Al Weis\\ +Juergen Weiss & M. Weller & Mark Wegman\\ +James Wen & Thorsten Werther & Michael Wester\\ +R. Clint Whaley & James T. Wheeler & John M. Wiley\\ +Berhard Will & Clifton J. Williamson & Stephen Wilson\\ +Shmuel Winograd & Robert Wisbauer & Sandra Wityak\\ +Waldemar Wiwianka & Knut Wolf & Yanyang Xiao\\ +Liu Xiaojun & Clifford Yapp & David Yun\\ +Qian Yun & Vadim Zhytnikov & Richard Zippel\\ +Evelyn Zoernack & Bruno Zuercher & Dan Zwillinger\\ +\end{tabular} +\newpage + +\tableofcontents +\vfill +\eject +\setlength{\parindent}{0em} +\setlength{\parskip}{1ex} +{\Large{\bf New Foreword}} +\vskip .25in + +On October 1, 2001 Axiom was withdrawn from the market and ended +life as a commercial product. +On September 3, 2002 Axiom was released under the Modified BSD +license, including this document. +On August 27, 2003 Axiom was released as free and open source +software available for download from the Free Software Foundation's +website, Savannah. + +Work on Axiom has had the generous support of the Center for +Algorithms and Interactive Scientific Computation (CAISS) at +City College of New York. Special thanks go to Dr. Gilbert +Baumslag for his support of the long term goal. + +The online version of this documentation is roughly 1000 pages. +In order to make printed versions we've broken it up into three +volumes. The first volume is tutorial in nature. The second volume +is for programmers. The third volume is reference material. We've +also added a fourth volume for developers. All of these changes +represent an experiment in print-on-demand delivery of documentation. +Time will tell whether the experiment succeeded. + +Axiom has been in existence for over thirty years. It is estimated to +contain about three hundred man-years of research and has, as of +September 3, 2003, 143 people listed in the credits. All of these +people have contributed directly or indirectly to making Axiom +available. Axiom is being passed to the next generation. I'm looking +forward to future milestones. + +With that in mind I've introduced the theme of the ``30 year horizon''. +We must invent the tools that support the Computational Mathematician +working 30 years from now. How will research be done when every bit of +mathematical knowledge is online and instantly available? What happens +when we scale Axiom by a factor of 100, giving us 1.1 million domains? +How can we integrate theory with code? How will we integrate theorems +and proofs of the mathematics with space-time complexity proofs and +running code? What visualization tools are needed? How do we support +the conceptual structures and semantics of mathematics in effective +ways? How do we support results from the sciences? How do we teach +the next generation to be effective Computational Mathematicians? + +The ``30 year horizon'' is much nearer than it appears. + +\vskip .25in +%\noindent +Tim Daly\\ +CAISS, City College of New York\\ +November 10, 2003 ((iHy)) +\vfill +\eject +\pagenumbering{arabic} +\setcounter{chapter}{1} % Chapter 1 + + +%\chapter{A Short Description} +%\chapter{Getting Started} +%\chapter{Tutorial} +%\chapter{A Full Example} +%\chapter{Reference} +%\chapter{Architecture} \chapter{Motivation} +This literate program contains the actual source code for the new Sane +version of Axiom. One of the key goals is to support understanding and +long-term maintenance of this new version of Axiom.Key ideas as well +as their implementation in code details are discussed. + +Axiom support ``First Class Dynamic Types'' + \begin{quote} {\bf Let us change our traditional attitude to the construction of programs. Instead of imagining that our main task is to instruct a @@ -13,17 +347,52 @@ human beings what we want a computer to do.}\\ \end{quote} \begin{quote} +{\bf It would be a good thing to buy books if one could also buy the +time to read them; but one usually confuses the purchase of books with +the acquisition of thier contents. To desire that a man should retain +everything he has ever read, is the same as wishing him to retain in +his stomach all that he has ever eaten.}\\ +-- Schopenhauer \cite{Scho16} +\end{quote} + +\begin{quote} {\bf Beware of bugs in the above code. I have only proved it correct, not tried it.}\\ -- Donald Knuth \end{quote} \begin{quote} +{\bf No loop should be written down without providing proof of +termination nor without stating the invariaant that will not be +destroyed by the execution of the repeatable statement}\\ +-- Edsger Dijkstra \cite{Dijk72} +\end{quote} + +\begin{quote} +{\bf The only effective way to raise the confidence level of a program +significantly is to give a convincing proof of its correctness.}\\ +-- Edsger Dijkstra \cite{Dijk72} +\end{quote} + +\begin{quote} +{\bf The competent programmer is fully aware of the strictly limited +size of his own skull, therefore he approaches the programming task in +full humility.}\\ +-- Edsger Dijkstra \cite{Dijk72} +\end{quote} + +\begin{quote} {\bf For any perceived shortcoming of Common Lisp you can write a macro that fixes it for less effort than it takes to complain about it} \end{quote} \begin{quote} +{\bf A program without a specification cannot be incorrect, it can +only be surprising}\\ +-- J.J. Horning +\end{quote} + +\begin{quote} {\bf A proof assistant is what happens if you spend all your time developing a type checker for your language and forget that programs also need to be run.}\\ @@ -57,8 +426,9 @@ key problem is that most of the proof systems cannot handle fully dependent type theory. Axiom is unique among computer algebra systems as it has a scaffold -based on abstract algebra. This gives a solid theoretical framework -which provides obvious places to provide algebraic axioms. +based on abstract algebra. Abstract algebra framework gives a solid +theoretical base that provides obvious places to provide algebraic +axioms. Extending Axiom to provide these axioms means that they will be inherited just as signatures are inherited. Proofs of algorithms can @@ -90,6 +460,12 @@ verification, making some excellent points. He postulates a theorem: where every program is feasibly verifiable. \end{verbatim} +On the other hand, Doron Zeilberger \cite{Zeil02} writes: +\begin{quote} +In this process, computer algebra, that great implementer of +high-school algebra, will play a central role. The king (abstract +math) is dead. Long live the King (Concrete Mathematics). +\end{quote} \chapter{The Problem} \section{A Brief History} @@ -114,6 +490,10 @@ work on AUTOMATH. Scratchpad grew out of the computer algebra branch of computational mathematics. +Though they are both areas of computational mathematics, issues such +as equality are treated differently. Davenport \cite{Dave02} addresses +the issue of equality and its several ambiguities. + \section{Parallel Development} \section{Project Goals} @@ -291,8 +671,8 @@ theory. The Categories are essentially types from type theory. In Common Lisp the type hierarchy has a most general type 't'. In CLOS we define a new type {\bf AxiomClass} to be the most general -\index{AxiomClass!Category} -\index{Category!AxiomClass} +\index[code]{AxiomClass!Category} +\index[code]{Category!AxiomClass} type of our hierarchy. AxiomClass inherits methods from 't', such as {\bf print-object}. @@ -354,7 +734,7 @@ getAncestors 'PolynomialCategory PolynomialCategory is quite high up in the type hierarchy (15 levels up, actually) so most of these are already inherited. We provide a program -(called {\bf leaves}), which given the above list will compute the +(called {\bf leaves}), that given the above list will compute the types that are not inherited. For example, given the above Axiom output, \begin{verbatim} @@ -495,10 +875,6 @@ John Hughes \cite{Hugh19} identifies several types of specification tests: Due to type checking, these functions have to appear early in the file but we do it by using the literate reference. -\begin{chunk}{sane} -\getchunk{splitchar} -\end{chunk} - \chapter{Overview} \begin{quote} @@ -542,30 +918,35 @@ criticism of your code.}\\ \noindent The {\bf *Categories*} variable contains a list of all defined Categories. -\index{*Category*} -\begin{chunk}{sane} +\index[code]{*Category*} +\index[code]{defvar!*Categories*} +\index[code]{*Categories*!defvar} +\begin{chunk}{defvar categories} (defvar *Categories* nil) \end{chunk} \noindent The {\bf *Domains*} variable contains a list of all defined Domains. -\index{*Domains*} -\begin{chunk}{sane} +\index[code]{defvar!*Domains*} +\index[code]{*Domains*!defvar} +\begin{chunk}{defvar domains} (defvar *Domains* nil) \end{chunk} \noindent The {\bf *Packages*} variable contains a list of all defined Packages. -\index{*Packages*} -\begin{chunk}{sane} +\index[code]{defvar!*Packages*} +\index[code]{*Packages*!defvar} +\begin{chunk}{defvar packages} (defvar *Packages* nil) \end{chunk} -\index{*indent*} -\begin{chunk}{sane} +\index[code]{defvar!*indent*} +\index[code]{*indent*!defvar} +\begin{chunk}{defvar indent} (defvar *indent* " ") \end{chunk} @@ -595,17 +976,28 @@ runtime type checking tag the exported signatures \end{itemize} -\index{hasclause!defclass} -\index{defclass!hasclause} -\begin{chunk}{sane} +%\index[code]{hasclause!defclass} +\index[code]{defclass!hasclause} +\begin{chunk}{defclass hasclause} (defclass hasclause () ((whichtype :initarg :whichtype :initform nil :accessor hasclause-whichtype) (condition :initarg :condition :initform nil :accessor hasclause-condition) (siglist :initarg :siglist :initform nil :accessor hasclause-siglist))) +\end{chunk} + +\index[code]{make-hasclause!defun} +\index[code]{defun!make-hasclause} +\begin{chunk}{defun make-hasclause} (defun make-hasclause (type condition siglist) (make-instance 'hasclause :whichtype type :condition condition :siglist siglist)) +\end{chunk} + +\index[code]{print-object!defmethod!hasclause} +\index[code]{defmethod!print-object!hasclause} +\index[code]{hasclause!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defmethod print-object ((clause hasclause) stream) (let ((deeper (concatenate 'string " " *indent*))) (format stream "if ~a has ~a then~%~a~a~%" @@ -616,12 +1008,17 @@ the exported signatures \end{chunk} -\index{haslist!defclass} -\index{defclass!haslist} -\begin{chunk}{sane} +\index[code]{haslist!defclass} +\index[code]{defclass!haslist} +\begin{chunk}{defclass haslist} (defclass haslist () ((clauses :initarg :clauses :initform nil :accessor haslist-clauses))) +\end{chunk} + +\index[code]{make-haslist!defun} +\index[code]{defun!make-haslist} +\begin{chunk}{defun make-haslist} (defun make-haslist (clauses) (make-instance 'haslist :clauses clauses)) @@ -629,7 +1026,9 @@ the exported signatures The {\bf AxiomClass} is a place to hang Axiom-specific methods. \label{AxiomClass} -\begin{chunk}{sane} +\index[code]{defclass!AxiomClass} +\index[code]{AxiomClass!defclass} +\begin{chunk}{defclass AxiomClass} (defclass |AxiomClass| () ((marker :initform 'category :accessor marker :initarg :marker) (name :initform "AxiomClass" :reader name :allocation :class) @@ -642,15 +1041,15 @@ The {\bf AxiomClass} is a place to hang Axiom-specific methods. (abbreviation :initarg :abbreviation :reader abbreviation) (macros :initarg :macros :accessor macros :initform nil) (comment :initarg :comment :accessor comment :initform nil) - (arglist :initarg :arg :accessor arglist :initform nil) + (argslist :initarg :arg :accessor argslist :initform nil) (withlist :initarg :with :accessor withlist :initform nil) (haslist :initarg :has :accessor haslist :initform nil) (addlist :initarg :add :accessor addlist :initform nil))) \end{chunk} -\index{print-object!AxiomClass} -\index{AxiomClass!methods!print-object} +\index[code]{print-object!AxiomClass} +\index[code]{AxiomClass!methods!print-object} The print-oject method for AxiomClass re-creates the source level language from the internal data structures. The output of print-object @@ -663,8 +1062,10 @@ function. Because we may want to (dynamically?) change the output of any AxiomClass object, we provide the control strings as global variables. - -\begin{chunk}{sane} +\index[code]{print-object!defmethod!AxiomClass} +\index[code]{defmethod!print-object!AxiomClass} +\index[code]{AxiomClass!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defvar formatCategoryAbbrev "~&)abbrev category ~a ~a") (defvar formatCategorySIG "~&~a(~{~a~^, ~}) : Category == SIG where~2%") (defvar formatCategoryComment "~&~{~^++ ~a~%~}~%") @@ -689,22 +1090,22 @@ variables. (defvar formatHas "~%~aif % has ~a then~%") (defvar formatAdd " add ~%") - + (defmethod print-object ((cat |AxiomClass|) stream) (let (has condition) (cond ((eq (marker cat) 'category) (format stream formatCategoryAbbrev (abbreviation cat) (name cat)) (format stream formatCategoryComment (comment cat)) - (format stream formatCategorySIG (name cat) (arglist cat))) + (format stream formatCategorySIG (name cat) (argslist cat))) ((eq (marker cat) 'domain) (format stream formatDomainAbbrev (abbreviation cat) (name cat)) (format stream formatDomainComment (comment cat)) - (format stream formatDomainSIG (name cat) (arglist cat))) + (format stream formatDomainSIG (name cat) (argslist cat))) ((eq (marker cat) 'package) (format stream formatPackageAbbrev (abbreviation cat) (name cat)) (format stream formatPackageComment (comment cat)) - (format stream formatPackageSIG (name cat) (arglist cat)))) + (format stream formatPackageSIG (name cat) (argslist cat)))) (let ((adults (parents cat))) (cond ((null adults) (format stream formatNoSuper)) @@ -730,11 +1131,17 @@ variables. \end{chunk} -\begin{chunk}{sane} +\begin{chunk}{defclass typeParam} (defclass typeParam () ((variable :initarg :variable :reader typeParam-variable) (paramtype :initarg :paramtype :reader typeParam-paramtype))) +\end{chunk} + +\index[code]{print-object!defmethod!typeParam} +\index[code]{defmethod!print-object!typeParam} +\index[code]{typeParam!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defmethod print-object ((param typeParam) stream) (format stream "~a:~a" (typeParam-variable param) @@ -742,26 +1149,29 @@ variables. \end{chunk} -\begin{chunk}{sane} +\begin{chunk}{defclass WithClass} (defclass |WithClass| () ()) \end{chunk} -\begin{chunk}{sane} +\begin{chunk}{defclass AddClass} (defclass |AddClass| () ()) \end{chunk} -\index{showSig!CategoryClass} -\index{CategoryClass!methods!showSig} +%\index[code]{showSig!CategoryClass} +\index[code]{CategoryClass!methods!showSig} The {\bf showSig} method will show a signature of a CategoryClass object in abbreviated forms. So, for example, \begin{verbatim} (showSig |PAdicIntegerCategory|) ==> PADICCT(EUCDOM,CHARZ) \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defgeneric showSig} (defgeneric showSig (name)) +\end{chunk} + +\begin{chunk}{defmethod showSig} (defmethod showSig ((name |AxiomClass|)) (let ((parents (parents name)) abbrevs) (dolist (him parents) (push (abbreviation (symbol-value him)) abbrevs)) @@ -779,8 +1189,8 @@ an argument list. For example, these are all valid: (defunt one ((int p1) (int p2)) ...) \end{verbatim} -\index{defunt} -\begin{chunk}{sane} +\index[code]{defunt} +\begin{chunk}{defmacro defunt} (defmacro defunt (name (&rest args) &body body) "defun with optional type declarations" `(progn @@ -807,11 +1217,19 @@ an argument list. For example, these are all valid: \end{chunk} +We usually want lines without leading and trailig spaces. The +common lisp idiom for this is very wordy so we make a macro. +\begin{chunk}{defmacro trim} +(defmacro trim (arg) + `(string-trim '(#\space) ,arg)) + +\end{chunk} + Here we create the Axiom {\bf getAncestors} function. It walks the tree of ancestors to collect the union of the set. This accepts the symbol for the class or the instance. -\begin{chunk}{sane} +\begin{chunk}{defun getAncestors} (defun getAncestors (symbol) (labels ( (theAncestors (name) @@ -836,7 +1254,7 @@ This accepts the symbol for the class or the instance. We need to compute the most immediate ancestors (the leaves) of the type tree. -\begin{chunk}{sane} +\begin{chunk}{defun leaves} (defun leaves (survive) (let ((l survive)) (dolist (thing l) (setq survive (set-difference survive (getAncestors thing)))) @@ -845,7 +1263,7 @@ type tree. \end{chunk} We introduce the concept of a {\bf level} -\index{level} +\index[doc]{level} to order classes based on how deep they are in the inheritance hierarchy. Level 1 Categories only depend on {\bf CategoryClass}. Level 2 Categories only depend on Level 1, etc. @@ -857,7 +1275,7 @@ Each level defines a variable, e.g. {\bf level1}, {\bf level2}, etc that contains all of the Category instance symbols defined at that level. -\begin{chunk}{sane} +\begin{chunk}{defmacro ll} (defmacro ll (name) `(cond ((member ',name level1) 'level1) @@ -885,22 +1303,22 @@ level. Here we create the Axiom {\bf getDomains} function. It finds all of the domains that inherit this class. Given a domain it return an empty set. -\begin{chunk}{sane} +\begin{chunk}{defun getDomains} (defun getDomains ()) \end{chunk} \subsection{Signatures and OperationAlist} -\index{Signatures} -\index{OperationAlist} +\index[doc]{Signatures} +\index[doc]{OperationAlist} The {\bf OperationAlist} is a list of all of the operations that are available for the domain. Note that if there are two operations with the same name then they are combined into one operation but with different signatures. -\index{signature!defclass} -\index{defclass!signature} -\begin{chunk}{sane} +\index[code]{signature!defclass} +\index[code]{defclass!signature} +\begin{chunk}{defclass signature} (defclass signature () ((name :initarg :name :initform "" :accessor signature-name) (returns :initarg :returns :initform nil :accessor signature-returns) @@ -918,6 +1336,12 @@ they are combined into one operation but with different signatures. :examples examples :infix infix?)) +\end{chunk} + +\index[code]{print-object!defmethod!signature} +\index[code]{defmethod!print-object!signature} +\index[code]{signature!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defvar signatureFormatNull "~&~a~a ") (defvar signatureFormat1Arg "~&~a~a : ~{~^~a~^,~} -> ~a") (defvar signatureFormatArgs "~&~a~a : (~{~^~a~^,~}) -> ~a") @@ -1043,9 +1467,9 @@ they are combined into one operation but with different signatures. \end{chunk} -\index{macros!defclass} -\index{defclass!macros} -\begin{chunk}{sane} +%\index[code]{macros!defclass} +\index[code]{defclass!macros} +\begin{chunk}{defclass amacro} (defclass amacro () ((name :initarg :name @@ -1059,9 +1483,9 @@ they are combined into one operation but with different signatures. \end{chunk} -\index{operation!defclass} -\index{defclass!operation} -\begin{chunk}{sane} +\index[code]{operation!defclass} +\index[code]{defclass!operation} +\begin{chunk}{defclass operation} (defclass operation () ((name :initarg :name @@ -1074,7 +1498,14 @@ they are combined into one operation but with different signatures. :accessor operation-signatures :type list))) -(defvar *infixOperations* '("*" "**" "+" "<" "<=" "=" ">" ">=" "^" "quo" "rem" "~=" ".")) +\end{chunk} + +\index[code]{print-object!defmethod!operation} +\index[code]{defmethod!print-object!operation} +\index[code]{operation!defmethod!print-object} +\begin{chunk}{defmethod print-object} +(defvar *infixOperations* '("*" "**" "+" "<" "<=" "=" ">" ">=" "^" + "quo" "rem" "~=" ".")) (defmethod print-object ((op operation) stream) (let ((name (operation-name op)) (sigs (operation-signatures op))) @@ -1141,7 +1572,7 @@ From OperationAlist to Signatures (|subtractIfCan| (((|Union| $ "failed") $ $) 10)) -> subtractIfCan : (%,%) -> Union(%,"failed") \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defun operationToSignature} (defun operationToSignature (alistEntry) (let (returnType args sig result) (setq result (operation-make (car alistEntry))) @@ -1170,9 +1601,12 @@ The tabular format has two columns, the second column is at character position 40. The SBCL tabular output in format is broken so we had to create the {\bf padTo38} function to add pad characters to signatures. -\begin{chunk}{sane} +\begin{chunk}{defvar forcelongs} (defvar *forceLongs* '("exquo")) +\end{chunk} + +\begin{chunk}{defun operations-show} (defun operations-show (operationAlist) (labels ( ; split multiple signatures @@ -1212,7 +1646,7 @@ create the {\bf padTo38} function to add pad characters to signatures. From Signatures to OperationAlist -\begin{chunk}{sane} +\begin{chunk}{defun signatureToOperation} (defun signatureToOperation (sig) (declare (ignore sig)) ) @@ -1223,7 +1657,7 @@ From Signatures to OperationAlist \noindent Note that this function is inserted by the primitive support tools section above. -\begin{chunk}{splitchar} +\begin{chunk}{defun splitchar} (defun splitchar (string char) (loop for i = 0 then (1+ j) as j = (position char string :start i :test #'char=) @@ -1232,33 +1666,89 @@ section above. \end{chunk} -\begin{chunk}{splitchar} +\begin{chunk}{defun explode} (defun explode (string) (loop for c across string collect c)) \end{chunk} -\begin{chunk}{sane} -(defclass ParserClass () - ((abbrev :initarg :abbrev :initform nil :accessor parser-abbrev) +\begin{chunk}{defclass ParserClass} +(defclass ParserClass () + ((abbrev :initarg :abbrev :initform nil :accessor parser-abbrev) (topcomment :initarg :topcomment :initform nil :accessor parser-topcomment) - (macros :initarg :macros :initform nil :accessor parser-macros))) + (macros :initarg :macros :initform nil :accessor parser-macros) + (cdpsig :initarg :cdpsig :initform nil :accessor parser-cdpsig) + (with :initarg :with :initform nil :accessor parser-with) + (add :initarg :add :initform nil :accessor parser-add))) \end{chunk} -\begin{chunk}{sane} +\index[code]{print-object!defmethod!ParserClass} +\index[code]{defmethod!print-object!ParserClass} +\index[code]{ParserClass!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defvar formatabbrev "~a") (defvar formattopcomment "~a~%") (defvar formatmacros "~a ==> ~a~%") +(defvar formatcdpsig "~a~%") (defmethod print-object ((p ParserClass) stream) (format stream formatabbrev (parser-abbrev p)) (format stream formattopcomment (parser-topcomment p)) - (loop for acons in (parser-macros p) do - (format stream formatmacros (car acons) (cdr acons)))) + (format stream formatcdpsig (parser-cdpsig p))) + +;(defmethod print-object ((p ParserClass) stream) +; (format stream formatabbrev (parser-abbrev p)) +; (format stream formattopcomment (parser-topcomment p)) +; (loop for acons in (parser-macros p) do +; (format stream formatmacros (car acons) (cdr acons)))) \end{chunk} +\section{The Compiler Function} + +Given a {\bf theparse} structure, construct the corresponding +defclass. + +\begin{verbatim} +(defclass |BitsType| (|BitAggregateType|) + ((parents :initform '(|BitAggregate|)) + (name :initform "Bits") + (marker :initform 'domain) + (abbreviation :initform 'BITS) + (comment :initform (list + "Bits provides logical functions for Indexed Bits.")) + (argslist :initform nil) + (macros :initform nil) + (withlist :initform nil) + (haslist :initform nil) + (addlist :initform nil))) + +(defvar |Bits| + (progn + (push '|Bits| *Domains*) + (make-instance '|BitsType|))) + +\end{verbatim} + +\begin{chunk}{defun compileSpad} +(defun compileSpad (theparse) + (let* ((abbrev (parser-abbrev theparse)) + (classname (intern (concatenate 'string (abbreviation-string abbrev) "Type")))) + (print + `(progn + (defclass ,classname () + ((name :initform ,(abbreviation-string abbrev)) + (marker :initform ,(abbreviation-class abbrev)) + (abbreviation :initform ,(abbreviation-abbrev abbrev)) + (comment :initform ,(parser-topcomment theparse)))) + (defvar ,(abbreviation-name abbrev) + (progn + (push ',(abbreviation-name abbrev) *Domains*) + (make-instance ',classname))))) + (values))) + +\end{chunk} \section{The Language} \begin{verbatim} @@ -1331,23 +1821,23 @@ abbreviation instance would be: \noindent Things to note about this code are that the variables {\bf split} -\index{split!variable} -\index{variable!split} +\index[code]{split!variable} +\index[code]{variable!split} and {\bf result} -\index{result!variable} -\index{variable!result} +\index[code]{result!variable} +\index[code]{variable!result} are expected to be in the environment of the macros. When this code successfully recognizes the input line it constructs a class object to hold the result. \noindent The {\bf FSM-OR} -\index{FSM-OR!defmacro} -\index{defmacro!FSM-OR} +\index[code]{FSM-OR!defmacro} +\index[code]{defmacro!FSM-OR} macro mimics the action of the choice vertical bar in the grammar. It accepts a list of tests and returns if one of the tests succeeds. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-OR} (defmacro FSM-OR (&body FSM-tests) `(or ,@FSM-tests)) @@ -1355,12 +1845,12 @@ tests succeeds. \noindent The {\bf FSM-AND} -\index{FSM-AND!defmacro} -\index{defmacro!FSM-AND} +\index[code]{FSM-AND!defmacro} +\index[code]{defmacro!FSM-AND} macro mimics the action of a sequence of matches in the grammar. It accepts a list of tests and returns if all of the tests succeed. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-AND} (defmacro FSM-AND (&body FSM-tests) `(and ,@FSM-tests)) @@ -1368,17 +1858,21 @@ tests succeed. \noindent The {\bf gather} class holds the result of collecting several -\index{defclass!gather} -\index{gather!defclass} +\index[code]{defclass!gather} +\index[code]{gather!defclass} associated lines. It is filled by side-effect by {\bf FSM-gather}. -\begin{chunk}{sane} +\begin{chunk}{defclass gather} (defclass gather () ((lines :initarg :lines :initform nil :accessor gather-lines))) \end{chunk} -\begin{chunk}{sane} +\index[code]{print-object!defmethod!gather} +\index[code]{defmethod!print-object!gather} +\index[code]{gather!defmethod!print-object} +\begin{chunk}{defmethod print-object} (defvar formatgather "~{~a~%~^~}") + (defmethod print-object ((g gather) stream) (format stream formatgather (gather-lines g))) @@ -1386,8 +1880,8 @@ associated lines. It is filled by side-effect by {\bf FSM-gather}. \noindent The {\bf FSM-gather} macro rips lines that pass the test -\index{defmacro!FSM-gather} -\index{FSM-gather!defmacro} +\index[code]{defmacro!FSM-gather} +\index[code]{FSM-gather!defmacro} from the list of input strings.It expects 3 arguments \begin{enumerate} \item {\bf linelist} is a list of input strings from the raw @@ -1395,7 +1889,7 @@ field of the sourcecode class object. \item {\bf test} is a test to decide whether this line should be gathered from the linelist. \item {\bf into} is an instance of the {\bf gather} class -which will hold the lines that pass the test. +that will hold the lines that pass the test. \end{enumerate} Given a linelist that looks like: \begin{verbatim} @@ -1423,7 +1917,7 @@ when invoked with: (multiple-value-setq (t3 t4) (fsm-comment t2)) \end{verbatim} we end up with t4 as a {\bf gather} instance containing the -lines which passed the {\bf FSM-match} test. For example, +lines that passed the {\bf FSM-match} test. For example, \begin{verbatim} The object is a STANDARD-OBJECT of type GATHER. 0. LINES: @@ -1440,7 +1934,7 @@ The t3 variable contains the new linelist without the matching lines: " CODE ==> IndexedBits(1) add" " bits(n,b) == new(n,b)") \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-gather} (defmacro FSM-gather (linelist test into) `(let ((split (splitchar (first ,linelist) #\space))) (loop while (and linelist ,test) do @@ -1453,12 +1947,12 @@ The t3 variable contains the new linelist without the matching lines: \noindent NOTE: {\bf These macros assume two variables in the environment.} -\index{split!variable} -\index{variable!split} -\index{result!variable} -\index{variable!result} +\index[code]{split!variable} +\index[code]{variable!split} +\index[code]{result!variable} +\index[code]{variable!result} \begin{enumerate} -\item {\bf split} which is a tokenized list of the input, +\item {\bf split} that is a tokenized list of the input, usually by calling the {\bf splitchar} function. Each element of the list is a string. \item {\bf result} is a variable used to collect matches in a list. @@ -1466,15 +1960,15 @@ list is a string. \noindent The {\bf FSM-startsWith} -\index{defmacro!FSM-startsWith} -\index{FSM-startsWith!defmacro} +\index[code]{defmacro!FSM-startsWith} +\index[code]{FSM-startsWith!defmacro} occurs in cases where we want to check whether the prefix is a word we expect, such as looking for the category name, for example, \begin{verbatim} Bits() : Category FSM-match "Bits" \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-startsWith} (defmacro FSM-startsWith (word) `(let ((term (explode (first split)))) (setq result t) @@ -1487,11 +1981,11 @@ word we expect, such as looking for the category name, for example, \noindent The {\bf FSM-match} -\index{FSM-match!defmacro} -\index{defmacro!FSM-match} +\index[code]{FSM-match!defmacro} +\index[code]{defmacro!FSM-match} matches a string with any case and, when successful, it adds the matched word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-match} (defmacro FSM-match (word) `(when (string-equal (first split) ,word) (push (first split) result) @@ -1501,11 +1995,11 @@ matched word to the result and pops it off the split. \noindent The {\bf FSM-dword} -\index{FSM-dword!defmacro} -\index{defmacro!FSM-dword} +\index[code]{FSM-dword!defmacro} +\index[code]{defmacro!FSM-dword} matches the lowercased word, then match. When successful, it adds the matched word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-dword} (defmacro FSM-dword (word) `(when (string= (string-downcase ,word) (first split)) (push (first split) result) @@ -1515,11 +2009,11 @@ matched word to the result and pops it off the split. \noindent The {\bf FSM-uword} -\index{FSM-uword!defmacro} -\index{defmacro!FSM-uword} +\index[code]{FSM-uword!defmacro} +\index[code]{defmacro!FSM-uword} matches the uppercased word, then match. When successful, it adds the matched word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-uword} (defmacro FSM-uword (word) `(when (string= (string-upcase ,word) (first split)) (push (first split) result) @@ -1529,11 +2023,11 @@ matched word to the result and pops it off the split. \noindent The {\bf FSM-word} -\index{FSM-word!defmacro} -\index{defmacro!FSM-word} +\index[code]{FSM-word!defmacro} +\index[code]{defmacro!FSM-word} simply return the next word. It always succeeds. It adds the word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-word} (defmacro FSM-word () '(progn (push (first split) result) @@ -1543,8 +2037,8 @@ the result and pops it off the split. \noindent The {\bf FSM-cdpname} -\index{FSM-cdpname!defmacro} -\index{defmacro!FSM-cdpname} +\index[code]{FSM-cdpname!defmacro} +\index[code]{defmacro!FSM-cdpname} checks to see if the next word in the split is a known class. For example, \begin{verbatim} @@ -1553,7 +2047,7 @@ For example, will check if the string at the top of the split is in the known list of category names. (Note that it interns the string first). It adds the word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-cdpname} (defmacro FSM-cdpname (cdplist) `(when (member (intern (first split)) ,cdplist) (push (first split) result) @@ -1567,63 +2061,157 @@ characters and all uppercase. \noindent The {\bf FSM-abbname} -\index{FSM-abbname!defmacro} -\index{defmacro!FSM-abbname} +\index[code]{FSM-abbname!defmacro} +\index[code]{defmacro!FSM-abbname} performs this check. When successful, it adds the word to the result and pops it off the split. -\begin{chunk}{sane} +\begin{chunk}{defmacro FSM-abbname} (defmacro FSM-abbname () `(let ((word (first split))) (when (and (<= (length word) 8) (loop with result for c across word - while (setq result (upper-case-p c)) + while (setq result (or (digit-char-p c) (upper-case-p c))) finally (return result))) (push (first split) result) (pop split)))) \end{chunk} -\begin{chunk}{sane} -(defun FSM-gatherList (str) - (let (result (depth 0) (more t) instring) - (loop for c across str while more do - (cond - ; end of string? - ((and instring (char= c #\")) - (setq instring nil) - (push c result)) - ; still in string? - (instring - (push c result)) - ; start string? - ((and (not instring) (char= c #\")) - (setq instring t) - (push c result)) - ; start list? - ((char= c #\() - (incf depth) - (push #\( result)) - ; exit nested list? - ((and (> depth 0) (char= c #\))) - (decf depth) - (when (= depth 0) (setq more nil)) - (push #\) result)) - ; end list? - ((and (= depth 0) (char= c #\))) - (push #\) result) - (setq more nil)) - (t - (push c result)))) - (unless more - (coerce (nreverse result) 'string)))) +This function is called when an open-paren is detected as the next +character in the first line of the linelist. It will walk across the +linelist gathering all of the text between the open-paren and the +balancing closed-paren, even if there are newlines or other parens. +It works character by character. The {\bf result} variable is the +parenthesized object, including the delimiting parens. +The {\bf depth} variable is used to handle embedded parens. Only a +closed paren at depth 0 is considered a match. The {\bf more} variable +causes the loop to exit when it becomes false. The {\bf instring} +variable is used to ignore parens embedded in strings. The {\bf str} +variable is the current string we are walking. The complication is +that there could be newlines between balancing parens so we have to +move to the next string in the linelist. The {\bf c} character is the +current character we are considering. There are several cases with +associated comments. The {\bf listlen} variable is a counter which +counts how much of the string we need to remove before returning. The +complication is that when we have multiple lines we have to also +consider the leading spaces in indents. + +\begin{chunk}{defun FSM-gatherList} +(defun FSM-gatherList (linelist) + (let (result (depth 0) (more t) instring str c (listlen 0)) + (setq str (explode (first linelist))) + (loop while more do + (setq c (pop str)) + (cond + ; hit a newline? + ((null c) + (pop linelist) + (setq listlen (indent (first linelist))) + (setq str (explode (trim (first linelist)))) + (push #\space str)) + ; end of string? + ((and instring (char= c #\")) + (setq instring nil) + (incf listlen) + (push c result)) + ; still in string? + (instring + (incf listlen) + (push c result)) + ; start string? + ((and (not instring) (char= c #\")) + (setq instring t) + (incf listlen) + (push c result)) + ; start list? + ((char= c #\() + (incf depth) + (incf listlen) + (push #\( result)) + ; exit nested list? + ((and (> depth 0) (char= c #\))) + (decf depth) + (when (= depth 0) (setq more nil)) + (incf listlen) + (push #\) result)) + ; end list? + ((and (= depth 0) (char= c #\))) + (incf listlen) + (push #\) result) + (setq more nil)) + (t + (incf listlen) + (push c result)))) + (setq result (coerce (nreverse result) 'string)) + (setf (first linelist) (subseq (first linelist) listlen)) + (values linelist result) +)) + +\end{chunk} + +This function expects a list of arguments to a function. It breaks up +the list based on the top-level commas, ignoring commas in strings and +in embedded arguments that are not top-level. It returns a list of +strings, one per top level argument. + +\begin{chunk}{defun FSM-gatherVars} +; ARGLIST -> LIST(ARGS) +(defun FSM-gatherVars (argslist) + (let (result (depth 0) (more t) instring str c vars) + (setq str (explode (trim (first argslist)))) + (pop str) + (loop while more do + (setq c (pop str)) + (cond + ; hit a newline? + ((null c) + (pop argslist) + (if argslist + (progn + (setq str (explode (trim (first argslist)))) + (push #\space str)) + (progn + (push (trim (coerce (nreverse result) 'string)) vars) + (setq more nil)))) + ; found a top-level comma? + ((and (= depth 0) (not instring) (char= c #\,)) + (push (trim (coerce (nreverse result) 'string)) vars) + (setq result nil)) + ; end of string? + ((and instring (char= c #\")) + (setq instring nil) + (push c result)) + ; still in string? + (instring + (push c result)) + ; start string? + ((and (not instring) (char= c #\")) + (setq instring t) + (push c result)) + ; start list? + ((char= c #\() + (incf depth) + (push #\( result)) + ; exit nested list? + ((and (> depth 0) (char= c #\))) + (decf depth) + (push #\) result)) + ; end list? + ((and (= depth 0) (not instring) (char= c #\))) + (push (trim (coerce (nreverse result) 'string)) vars) + (setq more nil)) + (t + (push c result)))) + (nreverse vars) +)) \end{chunk} \section{Reading the source file} The {\bf sourcecode} type contains 4 fields: -\index{sourcecode} +%\index[code]{sourcecode} \begin{enumerate} \item name -- the filename of the source file \item rawcode -- the exact source text in the file @@ -1631,9 +2219,10 @@ The {\bf sourcecode} type contains 4 fields: \item tree -- piled strings to a nested tree \end{enumerate} -\index{defclass!sourcecode} -\index{sourcecode!defclass} -\begin{chunk}{sane} +\index[code]{defclass!sourcecode} +\index[code]{sourcecode!defclass} +\label{lst:sourcecode} +\begin{chunk}{defclass sourcecode} (defclass sourcecode () ((name :initarg :name :initform nil :accessor sourcecode-name) (rawcode :initarg :rawcode :initform nil :accessor sourcecode-rawcode) @@ -1642,12 +2231,10 @@ The {\bf sourcecode} type contains 4 fields: \end{chunk} -\index{defmethod!sourcecode!print-object} -\index{sourcecode!print-object} -\index{print-object!sourcecode} -\index{print-object!defmethod} -\index{defmethod!print-object} -\begin{chunk}{sane} +\index[code]{print-object!defmethod!sourcecode} +\index[code]{defmethod!print-object!sourcecode} +\index[code]{sourcecode!defmethod!print-object} +\begin{chunk}{defmethod print-object} ;(defmethod print-object ((source sourcecode) stream) ; (pretty (sourcecode-tree source))) @@ -1658,7 +2245,7 @@ on the indentation. \section{Sourcecode Tree Utilities} -We process the original source code into a ``clean form'' which +We process the original source code into a ``clean form'' that has no $--$ comments, no blank lines, and no line continuations. We call this the ``{bf pile}'' form of the code. This is just a list of strings. @@ -1667,13 +2254,15 @@ Next we convert the pile form into tree form using the indentation. Elements at the same level of identation are grouped togehter. The {\bf indent} -\index{indent} +\index[doc]{indent} function tells us how many spaces, aka the indentation, we have at the beginning of the line. \begin{verbatim} STRING -> DEPTH \end{verbatim} -\begin{chunk}{sane} +\index[code]{defun!indent} +\index[code]{indent!defun} +\begin{chunk}{defun indent} (defun indent (line) (let ((result 0)) (loop for char across line do @@ -1690,36 +2279,36 @@ pairs, the car of which is the indentation and the cdr is anything. The {\bf birth} function -\index{birth} +\index[doc]{birth} expects the indentation count and anything, and just conses them together. \begin{verbatim} DEPTH, ANY -> BIRTHFORM \end{verbatim} -\begin{chunk}{sane} -(defun birth (depth name) (cons depth name)) +\begin{chunk}{defmacro birth} +(defmacro birth (depth name) `(cons ,depth ,name)) \end{chunk} Naturally, if we have a cons, we need to disassemble it. The {\bf depthof} function returns the indentation. -\index{depthof} +\index[doc]{depthof} \begin{verbatim} BIRTHFORM -> DEPTH \end{verbatim} -\begin{chunk}{sane} -(defun depthof (node) (car node)) +\begin{chunk}{defmacro depthof} +(defmacro depthof (node) `(car ,node)) \end{chunk} And the {\bf nameof} -\index{nameof} +\index[doc]{nameof} returns the thing we put in the cdr. \begin{verbatim} BIRTHFORM -> ANY \end{verbatim} -\begin{chunk}{sane} -(defun nameof (node) (cdr node)) +\begin{chunk}{defmacro nameof} +(defmacro nameof (node) `(cdr ,node)) \end{chunk} @@ -1727,39 +2316,21 @@ Given a list of strings, each of which has a variable number of leading blanks, we construct pairs where the car is the indentation and the cdr is anything, usually the source string. We call this rewrite the {\bf spawn} -\index{spawn} +\index[doc]{spawn} of the tree. From this information we can compute things like the depth of nesting. \begin{verbatim} PILEFORM -> SPAWNFORM \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defun spawn} (defun spawn (tree) (loop for node in tree collect (birth (indent node) node))) \end{chunk} -The {\bf deep} -\index{deep} -function will walk a spawn-ed tree and return a reverse -sorted list of the indentations. We use this to walk the -spawn tree ``inside-out'', handling the most deeply nexted -nodes first. -\begin{verbatim} - SPAWNFORM -> LIST DEPTH -\end{verbatim} -\begin{chunk}{sane} -(defun deep (tree) - (let (result) - (loop for node in tree do - (setq result (adjoin (depthof node) result))) - (sort result #'>))) - -\end{chunk} - The {\bf pile2tree} -\index{pile2tree} +\index[code]{pile2tree} function takes a {\bf sourcecode pile} which looks like: \begin{verbatim} (")abbrev domain BITS Bits" @@ -1774,8 +2345,8 @@ function takes a {\bf sourcecode pile} which looks like: \end{verbatim} -and inserts parentheses which groups the code into a tree form, -called a {\bf sourcecode tree} which looks like: +and inserts parentheses that group the code into a tree form, +called a {\bf sourcecode tree} looks like: \begin{verbatim} (")abbrev domain BITS Bits" "++ Author: Stephen M. Watt" "++ Description:" @@ -1791,7 +2362,14 @@ called a {\bf sourcecode tree} which looks like: \end{verbatim} -\begin{chunk}{sane} +The {\bf deep} +\index[doc]{deep} +function will walk a spawn-ed tree and return a reverse +sorted list of the indentations. We use this to walk the +spawn tree ``inside-out'', handling the most deeply nested +nodes first. + +\begin{chunk}{defun pile2tree} ; PILEFORM -> TREEFORM (defun pile2tree (pile) (labels ( @@ -1802,7 +2380,14 @@ called a {\bf sourcecode tree} which looks like: ; INTEGER -> STRING of SPACES (spaces (count) (let (result) - (coerce (dotimes (i (* 2 count) result) (push #\space result)) 'string))) + (coerce (dotimes (i (* 2 count) result) (push #\space result)) + 'string))) + ; SPAWNFORM -> LIST DEPTH + (deep (tree) + (let (result) + (loop for node in tree do + (setq result (adjoin (depthof node) result))) + (sort result #'>))) ; PILE -> PILE (redepth (pile) (let (deeplist thepile) @@ -1819,7 +2404,7 @@ called a {\bf sourcecode tree} which looks like: (let ((was 0) lastline closers) (let (stack) (loop for line in (redepth pile) do - (setf (cdr line) (string-trim '(#\space) (cdr line))) + (setf (cdr line) (trim (cdr line))) (cond ((= (depthof line) was) (setf (cdr line) (concatenate 'string (spaces (car line)) " " (cdr line))) @@ -1842,13 +2427,13 @@ called a {\bf sourcecode tree} which looks like: \end{chunk} The {\bf pretty} -\index{pretty} +\index[doc]{pretty} function takes a sourcecode-tree, or a sublist thereof, and prints it in a form we prefer. \begin{verbatim} TREEFORM -> VOID \end{verbatim} -\begin{chunk}{sane} +\begin{chunk}{defun pretty} (defun pretty (tree) (cond ((stringp tree) (format t "~a~%" tree)) @@ -1866,7 +2451,7 @@ converted from pile form to tree form. The signature is \end{verbatim} The {\bf make-Sourcecode} function -\index{make-Sourcecode} +\index[doc]{make-Sourcecode} reads a spad file in as a list of strings. All minus comments are deleted, using {\bf noComments}, from the initial $--$ to the end of the line. @@ -1875,7 +2460,7 @@ The result is a {\bf sourcecode} instance contains the raw contents of the file, the cleaned up version called a pile, and a tree version, containing parens indicating depth. -Then, using {\bf oneline}, any line which has a trailing escape +Then, using {\bf oneline}, any line that has a trailing escape character (the underscore) gets merged with the following line. The {\bf escaped?} predicate checks for the trailing underscore. @@ -1889,13 +2474,17 @@ A bit of clever optimization is possible if the {\bf oneline} function processed the list of strings in reverse so the two calls to nreverse could be removed. -\begin{chunk}{sane} +\label{lst:make-Sourcecode} +\begin{chunk}{defun make-Sourcecode} + +(defvar formatMakeSourcecode "make-Sourcecode: ERROR: File ~a does not exist") + ; FILENAME -> SOURCECODE (defun make-Sourcecode (filename) (labels ( ; LINE -> BOOLEAN (blankline? (line) - (string= "" (string-trim '(#\space) line))) + (string= "" (trim line))) ; LINE -> LINE (noComments (line) (subseq line 0 (search "--" line))) @@ -1929,15 +2518,17 @@ calls to nreverse could be removed. result)) ) (let (rawcode listLine pile) (with-open-file (file filename :direction :input :if-does-not-exist nil) - (let ((done (gensym))) - (do ((line (read-line file nil done) (read-line file nil done))) - ((eq line done) (setq pile (nreverse (oneline (nreverse listLine))))) - (push line rawcode) - (push (noComments line) listLine)) - (make-instance 'sourcecode :name filename - :rawcode (nreverse rawcode) - :pile pile - :tree (pile2tree pile))))))) + (if file + (let ((done (gensym))) + (do ((line (read-line file nil done) (read-line file nil done))) + ((eq line done) (setq pile (nreverse (oneline (nreverse listLine))))) + (push line rawcode) + (push (noComments line) listLine)) + (make-instance 'sourcecode :name filename + :rawcode (nreverse rawcode) + :pile pile + :tree (pile2tree pile))) + (error formatMakeSourcecode filename)))))) \end{chunk} @@ -2045,7 +2636,7 @@ and {\bf outtype}, the output type specification may both be very complex type specifications. They are recognized by a separate finite state machine. -A signature may also have a conditional specification which +A signature may also have a conditional specification that is handled by its own finite state machine. The {\bf look} function just peeks at the next character. @@ -2055,7 +2646,7 @@ The {\bf next} function updates the {\bf nextstate} variable. The {\bf here} function outputs debugging information. -\begin{chunk}{sane} +\begin{chunk}{defun FSMSIG} (defun FSMSIG (&optional (debug nil)) (let (nextstate prev char (eofsym (gensym)) (indenting? t) (indent 0) @@ -2149,16 +2740,16 @@ characters and all uppercase, and the Bits field must be a valid constructor name. The {\bf abbreviation} -\index{abbreviation!defclass} -\index{defclass!abbreviation} +\index[code]{abbreviation!defclass} +\index[code]{defclass!abbreviation} holds the result of parsing an )abbrev line. The {\bf FSM-abbrev} -\index{FSM-abbrev!function} -\index{function!FSM-abbrev} +\index[code]{FSM-abbrev!function} +\index[code]{function!FSM-abbrev} function parses an )abbrev line. -\begin{chunk}{sane} +\begin{chunk}{defclass abbreviation} (defclass abbreviation () ((class :initarg :class :initform nil :accessor abbreviation-class) (abbrev :initarg :abbrev :initform nil :accessor abbreviation-abbrev) @@ -2169,12 +2760,23 @@ function parses an )abbrev line. (make-instance 'abbreviation :class class :abbrev abbrev :string string :name (intern string))) +\end{chunk} + +\index[code]{print-object!defmethod!abbreviation} +\index[code]{defmethod!print-object!abbreviation} +\index[code]{abbreviation!defmethod!print-object} +\begin{chunk}{defmethod print-object} +(defvar formatAbbreviation ")abbrev ~a ~a ~a~%") + (defmethod print-object ((abb abbreviation) stream) - (format stream ")abbrev ~a ~a ~a~%" + (format stream formatAbbreviation (abbreviation-class abb) (abbreviation-abbrev abb) (abbreviation-string abb))) +\end{chunk} + +\begin{chunk}{defun FSM-abbrev} (defun FSM-abbrev (linelist) (let ((split (splitchar (first linelist) #\space)) result) (when @@ -2192,25 +2794,40 @@ function parses an )abbrev line. \end{chunk} +\begin{chunk}{defun FSM-cdpsig} +(defun FSM-cdpsig (linelist theparse) + (let ((split (splitchar (first linelist) #\space)) result cdpname argslist) + (when (FSM-startsWith (first split)) + (setq result (make-instance 'CDPSigClass)) + (setf (CDPSigClass-cdptag result) (abbreviation-class (parser-abbrev theparse))) + (setq cdpname (abbreviation-string (parser-abbrev theparse))) + (setf (CDPSigClass-cdpname result) cdpname) + (setq linelist (cons (subseq (pop linelist) (length cdpname)) linelist)) + (multiple-value-setq (linelist argslist) (FSM-gatherList linelist)) + (setf (CDPSigClass-argslist result) argslist) + (values linelist result)))) + +\end{chunk} + \subsection{Parse Comments} The {\bf FSM-comment} function strips off the comments from linelist, gathering them together. It returns 2 values, the first is a new linelist without the comments. The second is a gather object containing the comment lines. -\begin{chunk}{sane} +\begin{chunk}{defun FSM-comment} (defun FSM-comment (linelist) (let (comment result) (setq comment (make-instance 'gather)) (values - (FSM-gather linelist (FSM-match "++") comment) + (FSM-gather linelist (FSM-startsWith "++") comment) comment))) \end{chunk} \subsection{Gather Macros} -\begin{chunk}{sane} +\begin{chunk}{defun FSM-extract1Macro} (defun FSM-extract1Macro (linelist) (let (pre middle indent) (setq pre @@ -2227,7 +2844,7 @@ containing the comment lines. \end{chunk} -\begin{chunk}{sane} +\begin{chunk}{defun FSM-macros} (defun FSM-macros (linelist) (labels ( (hasMacros? (linelist) @@ -2238,7 +2855,7 @@ containing the comment lines. (makeAlist (gather) (let (alllines line name def) (setq alllines (gather-lines gather)) - (setq line (splitchar (string-trim '(#\space) (pop alllines)) #\space)) + (setq line (splitchar (trim (pop alllines)) #\space)) (setq name (intern (first line))) (setq def (cons (join (cddr line)) alllines)) (cons name def))) @@ -2251,21 +2868,43 @@ containing the comment lines. \end{chunk} -\begin{chunk}{sane} +\begin{chunk}{defun FSM-macroNames} (defun FSM-macroNames (theparse) (mapcar #'(lambda (x) (car x)) (parser-macros theparse))) \end{chunk} +\begin{chunk}{defclass CDPSigClass} +(defclass CDPSigClass () + ((cdpname :initarg :classname :initform nil :accessor CDPSigClass-cdpname) + (argslist :initarg :argslist :initform nil :accessor CDPSigClass-argslist) + (cdptag :initarg :cdptag :initform nil :accessor CDPSigClass-cdptag))) + +\end{chunk} + +\index[code]{print-object!defmethod!CDPSigClass} +\index[code]{defmethod!print-object!CDPSigClass} +\index[code]{CDPSigClass!defmethod!print-object} +\begin{chunk}{defmethod print-object} +(defvar formatcat "~a~a : Category == ~%") +(defvar formatdp "~a~a : ~%") + +(defmethod print-object ((cdp CDPSigClass) stream) + (if (string-equal "category" (CDPSigClass-cdptag cdp)) + (format stream formatcat (CDPSigClass-cdpname cdp) (CDPSigClass-argslist cdp)) + (format stream formatdp (CDPSigClass-cdpname cdp) (CDPSigClass-argslist cdp)))) + +\end{chunk} + \subsection{parseSignature} -\index{parseSignature!parser} -\index{parser!parseSignature} -\begin{chunk}{sane} +\index[code]{parseSignature!parser} +\index[code]{parser!parseSignature} +\begin{chunk}{defun parseSignature} (defun parseSignature (lines) - (let (funcname return arglist comment colon arrow line control plusplus) + (let (funcname return argslist comment colon arrow line control plusplus) (labels ( (substring (line start &optional end) - (string-trim '(#\space) (subseq line start end))) + (trim (subseq line start end))) (nospad (line) (let (pos) (cond @@ -2293,7 +2932,7 @@ containing the comment lines. (setq arrow (search "->" line)) ; parse out the pieces (setq funcname (intern (substring line 0 colon))) - (setq arglist (mangle (substring line (1+ colon) arrow))) + (setq argslist (mangle (substring line (1+ colon) arrow))) (setq return (mangle (substring line (+ 2 arrow)))) ; collect the comment lines (dolist (line (cdr lines)) @@ -2309,48 +2948,108 @@ containing the comment lines. (t (setq control (concatenate 'string control " '(|~a|)")))) (cond - ((string= arglist "()") + ((string= argslist "()") (setq control (concatenate 'string control " '~a "))) - ((string= arglist "%") + ((string= argslist "%") (setq control (concatenate 'string control " '(~a) "))) (t (setq control (concatenate 'string control " '(|~a|)")))) (setq control (concatenate 'string control " '~s)~%")) - (format t control funcname return arglist (nreverse comment)) + (format t control funcname return argslist (nreverse comment)) (values))) \end{chunk} \section{The Parse Function} -\begin{chunk}{sane} -(defvar place "/research/20190531/src/algebra/") +\index[code]{defvar!*place*} +\index[code]{*place*!defvar} +\begin{chunk}{defvar place} +(defvar *place* "/research/20191011/src/algebra/") +; "/research/fricas/waldek/fricasNew/src/algebra/" \end{chunk} -\begin{chunk}{sane} -(defvar t1 nil) +\index[code]{defvar!theparse} +\index[code]{theparse!defvar} +\begin{chunk}{defvar theparse} +(defvar theparse nil) \end{chunk} -\begin{chunk}{sane} -(defvar theparse nil) + +\begin{chunk}{defun FSM-isCategory?} +(defun FSM-isCategory? (linelist theparse) + (let ((split (splitchar (first linelist) #\space)) result tmp) + (FSM-match ":") + (setq tmp (abbreviation-class (parser-abbrev theparse))) + (if (and (string-equal tmp "category") (FSM-match tmp)) + (values split t) + (values split nil)))) + +\end{chunk} + +\begin{chunk}{defun FSM-catBody} +(defun FSM-catBody (linelist theparse) + (let ((split (splitchar (first linelist) #\space)) result) + (FSM-match "==") + split)) + +\end{chunk} + +\begin{chunk}{defun FSM-dpBody} +(defun FSM-dpBody (linelist theparser) + (declare (ignore linelist theparser))) + +\end{chunk} + +The parser operates on the input stream step by step. + +The {\bf make-Sourcecode} [p\pageref{lst:make-Sourcecode}] +\index[doc]{make-sourcecode!caller} +\index[all]{caller!make-sourcecode} +reads the file and constructs a +{\bf sourcecode} [p\pageref{lst:sourcecode}] object. + +The {bf make-Sourcecode} function constructs a {\bf sourcecode-pile} +field containing a ``useful'' version of the original source, +(e.g. the source stripped of $--$ comments and joining contiued lines) +so we can easily parse the result. + +\begin{chunk}{defun Parse} +(defvar t1 nil "a copy of the source code for debugging") + +(defvar formatParse1 "Parse 1: ~% In ~a~% Missing )abbrev line~%") (defun Parse (filename) - (let (pile object alist) - (setq t1 (make-sourcecode (concatenate 'string place filename ".spad"))) - (setq pile (sourcecode-pile t1)) - (setq theparse (make-instance 'ParserClass)) - (multiple-value-setq (pile object) (FSM-abbrev pile)) - (setf (parser-abbrev theparse) object) - (multiple-value-setq (pile object) (FSM-comment pile)) - (setf (parser-topcomment theparse) object) - (multiple-value-setq (pile alist) (FSM-macros pile)) - (setf (parser-macros theparse) alist) - (values theparse pile))) + (unwind-protect + (let (pile object alist iscat?) + (setq t1 (make-Sourcecode (concatenate 'string *place* filename ".spad"))) + (setq pile (sourcecode-pile t1)) + (setq theparse (make-instance 'ParserClass)) + (multiple-value-setq (pile object) (FSM-abbrev pile)) + (unless object + (error formatParse1 (concatenate 'string *place* filename ".spad"))) + (setf (parser-abbrev theparse) object) + (multiple-value-setq (pile object) (FSM-comment pile)) + (setf (parser-topcomment theparse) object) + (multiple-value-setq (pile alist) (FSM-macros pile)) + (setf (parser-macros theparse) alist) + (multiple-value-setq (pile object) (FSM-cdpsig pile theparse)) + (setf (parser-cdpsig theparse) object) + (multiple-value-setq (pile iscat?) (FSM-isCategory? pile theparse)) + (if iscat? + (multiple-value-setq (pile object) (FSM-catBody pile theparse)) + (multiple-value-setq (pile object) (FSM-dpBody pile theparse)) ) + (values theparse pile)) + (print (list 'gotit)))) + + +(defun expandMacro (name) + (cdr (assoc name (parser-macros theparse)))) (defun P (filename) - (setq t1 (make-sourcecode (concatenate 'string place filename ".spad"))) + (setq t1 (make-sourcecode (concatenate 'string *place* filename ".spad"))) (pretty (sourcecode-tree t1)) (values)) @@ -2415,7 +3114,7 @@ compiler will find some random reason to complain. \section{Level 1} This is a searchable list of all of the Categories in level 1. -\begin{chunk}{sane} +\begin{chunk}{defvar level1} (defvar level1 '(|AdditiveValuationAttribute| |ApproximateAttribute| |ArbitraryExponentAttribute| |ArbitraryPrecisionAttribute| @@ -2436,10 +3135,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{AdditiveValuationAttribute} -\index{AdditiveValuationAttribute!Category} -\index{Category!AdditiveValuationAttribute} -\index{ATADDVA} -\begin{chunk}{sane} +\index[cat]{AdditiveValuationAttribute!Category} +\index[cat]{Category!AdditiveValuationAttribute} +\index[cat]{ATADDVA} +\begin{chunk}{defclass AdditiveValuationAttributeType} (defclass |AdditiveValuationAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "AdditiveValuationAttributeType") @@ -2449,7 +3148,7 @@ This is a searchable list of all of the Categories in level 1. (comment :initform (list "The class of all euclidean domains such that" "euclideanSize(a*b) = EuclideanSize(a)+euclideanSize(b)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -2463,10 +3162,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{ApproximateAttribute} -\index{ApproximateAttribute!Category} -\index{Category!ApproximateAttribute} -\index{ATAPPRO} -\begin{chunk}{sane} +\index[cat]{ApproximateAttribute!Category} +\index[cat]{Category!ApproximateAttribute} +\index[cat]{ATAPPRO} +\begin{chunk}{defclass ApproximateAttributeType} (defclass |ApproximateAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "ApproximateAttribute") @@ -2484,10 +3183,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{ArbitraryExponentAttribute} -\index{ArbitraryExponentAttribute!Category} -\index{Category!ArbitraryExponentAttribute} -\index{ATARBEX} -\begin{chunk}{sane} +\index[cat]{ArbitraryExponentAttribute!Category} +\index[cat]{Category!ArbitraryExponentAttribute} +\index[cat]{ATARBEX} +\begin{chunk}{defclass ArbitraryExponentAttributeType} (defclass |ArbitraryExponentAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "ArbitraryExponentAttribute") @@ -2496,7 +3195,7 @@ This is a searchable list of all of the Categories in level 1. (abbreviation :initform 'ATARBEX) (comment :initform (list "Approximate numbers with arbitrarily large exponents")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -2510,10 +3209,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{ArbitraryPrecisionAttribute} -\index{ArbitraryPrecisionAttribute!Category} -\index{Category!ArbitraryPrecisionAttribute} -\index{ATARBPR} -\begin{chunk}{sane} +\index[cat]{ArbitraryPrecisionAttribute!Category} +\index[cat]{Category!ArbitraryPrecisionAttribute} +\index[cat]{ATARBPR} +\begin{chunk}{defclass ArbitraryPrecisionAttributeType} (defclass |ArbitraryPrecisionAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "ArbitraryPrecisionAttribute") @@ -2523,7 +3222,7 @@ This is a searchable list of all of the Categories in level 1. (comment :initform (list "Approximate numbers for which the user can set the precision" "for subsequent calculations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -2537,10 +3236,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{ArcHyperbolicFunctionCategory} -\index{ArcHyperbolicFunctionCategory!Category} -\index{Category!ArcHyperbolicFunctionCategory} -\index{AHYP} -\begin{chunk}{sane} +\index[cat]{ArcHyperbolicFunctionCategory!Category} +\index[cat]{Category!ArcHyperbolicFunctionCategory} +\index[cat]{AHYP} +\begin{chunk}{defclass ArcHyperbolicFunctionCategoryType} (defclass |ArcHyperbolicFunctionCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "ArcHyperbolicFunctionCategory") @@ -2549,7 +3248,7 @@ This is a searchable list of all of the Categories in level 1. (abbreviation :initform 'AHYP) (comment :initform (list "Category for the inverse hyperbolic trigonometric functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|acosh| '(%) '(%) @@ -2576,10 +3275,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{ArcTrigonometricFunctionCategory} -\index{ArcTrigonometricFunctionCategory!Category} -\index{Category!ArcTrigonometricFunctionCategory} -\index{ATRIG} -\begin{chunk}{sane} +\index[cat]{ArcTrigonometricFunctionCategory!Category} +\index[cat]{Category!ArcTrigonometricFunctionCategory} +\index[cat]{ATRIG} +\begin{chunk}{defclass ArcTrigonometricFunctionCategoryType} (defclass |ArcTrigonometricFunctionCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "ArcTrigonometricFunctionCategory") @@ -2588,7 +3287,7 @@ This is a searchable list of all of the Categories in level 1. (abbreviation :initform 'ATRIG) (comment :initform (list "Category for the inverse trigonometric functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|acos| '(%) '(%) @@ -2631,10 +3330,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{AttributeRegistry} -\index{AttributeRegistry!Category} -\index{Category!AttributeRegistry} -\index{ATTREG} -\begin{chunk}{sane} +\index[cat]{AttributeRegistry!Category} +\index[cat]{Category!AttributeRegistry} +\index[cat]{ATTREG} +\begin{chunk}{defclass AttributeRegistryType} (defclass |AttributeRegistryType| (|AxiomClass|) ((parents :initform ()) (name :initform "AttributeRegistry") @@ -2643,7 +3342,7 @@ This is a searchable list of all of the Categories in level 1. (abbreviation :initform 'ATTREG) (comment :initform (list "This category exports the attributes in the AXIOM Library")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|finiteAggregate| () () @@ -2727,10 +3426,10 @@ This is a searchable list of all of the Categories in level 1. \end{chunk} \subsection{BasicType} -\index{BasicType!Category} -\index{Category!BasicType} -\index{BASTYPE} -\begin{chunk}{sane} +\index[cat]{BasicType!Category} +\index[cat]{Category!BasicType} +\index[cat]{BASTYPE} +\begin{chunk}{defclass BasicTypeType} (defclass |BasicTypeType| (|AxiomClass|) ((parents :initform ()) (name :initform "BasicType") @@ -2740,7 +3439,7 @@ This is a searchable list of all of the Categories in level 1. (comment :initform (list "BasicType is the basic category for describing a collection" "of elements with = (equality).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|=| '(|Boolean|) '(% %) @@ -3157,10 +3856,10 @@ Value = NIL \end{verbatim} \subsection{CanonicalAttribute} -\index{CanonicalAttribute!Category} -\index{Category!CanonicalAttribute} -\index{ATCANON} -\begin{chunk}{sane} +\index[cat]{CanonicalAttribute!Category} +\index[cat]{Category!CanonicalAttribute} +\index[cat]{ATCANON} +\begin{chunk}{defclass CanonicalAttributeType} (defclass |CanonicalAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "CanonicalAttribute") @@ -3170,7 +3869,7 @@ Value = NIL (comment :initform (list "The class of all domains which have canonical represenntation," "that is, mathematically equal elements have the same data structure.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3184,10 +3883,10 @@ Value = NIL \end{chunk} \subsection{CanonicalClosedAttribute} -\index{CanonicalClosedAttribute!Category} -\index{Category!CanonicalClosedAttribute} -\index{ATCANCL} -\begin{chunk}{sane} +\index[cat]{CanonicalClosedAttribute!Category} +\index[cat]{Category!CanonicalClosedAttribute} +\index[cat]{ATCANCL} +\begin{chunk}{defclass CanonicalClosedAttributeType} (defclass |CanonicalClosedAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "CanonicalClosedAttribute") @@ -3197,7 +3896,7 @@ Value = NIL (comment :initform (list "The class of all integral domains such that" "unitCanonical(a)*unitCanonical(b) = unitCanonical(a*b)}")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3211,10 +3910,10 @@ Value = NIL \end{chunk} \subsection{CanonicalUnitNormalAttribute} -\index{CanonicalUnitNormalAttribute!Category} -\index{Category!CanonicalUnitNormalAttribute} -\index{ATCUNOR} -\begin{chunk}{sane} +\index[cat]{CanonicalUnitNormalAttribute!Category} +\index[cat]{Category!CanonicalUnitNormalAttribute} +\index[cat]{ATCUNOR} +\begin{chunk}{defclass CanonicalUnitNormalAttributeType} (defclass |CanonicalUnitNormalAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "CanonicalUnitNormalAttribute") @@ -3226,7 +3925,7 @@ Value = NIL "representative for each class of associate elements. That is," "associates?(a,b) returns true if and only if" "unitCanonical(a) = unitCanonical(b)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3240,10 +3939,10 @@ Value = NIL \end{chunk} \subsection{CentralAttribute} -\index{CentralAttribute!Category} -\index{Category!CentralAttribute} -\index{ATCENRL} -\begin{chunk}{sane} +\index[cat]{CentralAttribute!Category} +\index[cat]{Category!CentralAttribute} +\index[cat]{ATCENRL} +\begin{chunk}{defclass CentralAttributeType} (defclass |CentralAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "CentralAttribute") @@ -3255,7 +3954,7 @@ Value = NIL "is the center of the algebra. For example, the set of members of the" "algebra which commute with all others is precisely the image of R" "in the algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3269,10 +3968,10 @@ Value = NIL \end{chunk} \subsection{CoercibleTo} -\index{CoercibleTo!Category} -\index{Category!CoercibleTo} -\index{KOERCE} -\begin{chunk}{sane} +\index[cat]{CoercibleTo!Category} +\index[cat]{Category!CoercibleTo} +\index[cat]{KOERCE} +\begin{chunk}{defclass CoercibleToType} (defclass |CoercibleToType| (|AxiomClass|) ((parents :initform ()) (name :initform "CoercibleTo") @@ -3282,7 +3981,7 @@ Value = NIL (comment :initform (list "A is coercible to B means any element of A can automatically be" "converted into an element of B by the interpreter.")) - (arglist :initform (list (make-instance 'typeParam :variable 'S :paramtype '|Type|))) + (argslist :initform (list (make-instance 'typeParam :variable 'S :paramtype '|Type|))) (macros :initform nil) (withlist :initform (list (make-signature '|coerce| 'S '(%) @@ -3298,10 +3997,10 @@ Value = NIL \end{chunk} \subsection{CombinatorialFunctionCategory} -\index{CombinatorialFunctionCategory!Category} -\index{Category!CombinatorialFunctionCategory} -\index{CFCAT} -\begin{chunk}{sane} +\index[cat]{CombinatorialFunctionCategory!Category} +\index[cat]{Category!CombinatorialFunctionCategory} +\index[cat]{CFCAT} +\begin{chunk}{defclass CombinatorialFunctionCategoryType} (defclass |CombinatorialFunctionCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "CombinatorialFunctionCategory") @@ -3310,7 +4009,7 @@ Value = NIL (abbreviation :initform 'CFCAT) (comment :initform (list "Category for the usual combinatorial functions;")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|binomial| '% '(% %) @@ -3337,10 +4036,10 @@ Value = NIL \end{chunk} \subsection{CommutativeStarAttribute} -\index{CommutativeStarAttribute!Category} -\index{Category!CommutativeStarAttribute} -\index{ATCS} -\begin{chunk}{sane} +\index[cat]{CommutativeStarAttribute!Category} +\index[cat]{Category!CommutativeStarAttribute} +\index[cat]{ATCS} +\begin{chunk}{defclass CommutativeStarAttributeType} (defclass |CommutativeStarAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "CommutativeStarAttribute") @@ -3351,7 +4050,7 @@ Value = NIL "The class of all commutative semigroups in multiplicative notation." "In other words domain D with '*': (D,D) -> D} which is" "commutative. Typically applied to rings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3365,10 +4064,10 @@ Value = NIL \end{chunk} \subsection{ConvertibleTo} -\index{ConvertibleTo!Category} -\index{Category!ConvertibleTo} -\index{KONVERT} -\begin{chunk}{sane} +\index[cat]{ConvertibleTo!Category} +\index[cat]{Category!ConvertibleTo} +\index[cat]{KONVERT} +\begin{chunk}{defclass ConvertibleToType} (defclass |ConvertibleToType| (|AxiomClass|) ((parents :initform ()) (name :initform "ConvertibleTo") @@ -3379,7 +4078,7 @@ Value = NIL "A is convertible to B means any element of A" "can be converted into an element of B," "but not automatically by the interpreter.")) - (arglist :initform (list (make-instance 'typeParam :variable 'S :paramtype '|Type|))) + (argslist :initform (list (make-instance 'typeParam :variable 'S :paramtype '|Type|))) (macros :initform nil) (withlist :initform (list (make-signature '|convert| 'S '(%) @@ -3395,10 +4094,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionCategory} -\index{ElementaryFunctionCategory!Category} -\index{Category!ElementaryFunctionCategory} -\index{ELEMFUN} -\begin{chunk}{sane} +\index[cat]{ElementaryFunctionCategory!Category} +\index[cat]{Category!ElementaryFunctionCategory} +\index[cat]{ELEMFUN} +\begin{chunk}{defclass ElementaryFunctionCategoryType} (defclass |ElementaryFunctionCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionCategory") @@ -3407,7 +4106,7 @@ Value = NIL (abbreviation :initform 'ELEMFUN) (comment :initform (list "Category for the elementary functions;")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|log| '% '(%) @@ -3430,10 +4129,10 @@ Value = NIL \end{chunk} \subsection{Eltable} -\index{Eltable!Category} -\index{Category!Eltable} -\index{ELTAB} -\begin{chunk}{sane} +\index[cat]{Eltable!Category} +\index[cat]{Category!Eltable} +\index[cat]{ELTAB} +\begin{chunk}{defclass EltableType} (defclass |EltableType| (|AxiomClass|) ((parents :initform ()) (name :initform "Eltable") @@ -3445,7 +4144,7 @@ Value = NIL "as a function from D to I. Examples of eltable structures range from" "data structures, For example, those of type List, to algebraic" "structures like Polynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|elt| '(|Index|) '(% S) @@ -3462,10 +4161,10 @@ Value = NIL \end{chunk} \subsection{FiniteAggregateAttribute} -\index{FiniteAggregateAttribute!Category} -\index{Category!FiniteAggregateAttribute} -\index{ATFINAG} -\begin{chunk}{sane} +\index[cat]{FiniteAggregateAttribute!Category} +\index[cat]{Category!FiniteAggregateAttribute} +\index[cat]{ATFINAG} +\begin{chunk}{defclass FiniteAggregateAttributeType} (defclass |FiniteAggregateAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteAggregateAttribute") @@ -3474,7 +4173,7 @@ Value = NIL (abbreviation :initform 'ATFINAG) (comment :initform (list "The class of all aggregates with a finite number of arguments")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3488,10 +4187,10 @@ Value = NIL \end{chunk} \subsection{HyperbolicFunctionCategory} -\index{HyperbolicFunctionCategory!Category} -\index{Category!HyperbolicFunctionCategory} -\index{HYPCAT} -\begin{chunk}{sane} +\index[cat]{HyperbolicFunctionCategory!Category} +\index[cat]{Category!HyperbolicFunctionCategory} +\index[cat]{HYPCAT} +\begin{chunk}{defclass HyperbolicFunctionCategoryType} (defclass |HyperbolicFunctionCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "HyperbolicFunctionCategory") @@ -3500,7 +4199,7 @@ Value = NIL (abbreviation :initform 'HYPCAT) (comment :initform (list "Category for the hyperbolic trigonometric functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|cosh| '(%) '(%) @@ -3527,10 +4226,10 @@ Value = NIL \end{chunk} \subsection{InnerEvalable} -\index{InnerEvalable!Category} -\index{Category!InnerEvalable} -\index{IEVALAB} -\begin{chunk}{sane} +\index[cat]{InnerEvalable!Category} +\index[cat]{Category!InnerEvalable} +\index[cat]{IEVALAB} +\begin{chunk}{defclass InnerEvalableType} (defclass |InnerEvalableType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerEvalable") @@ -3544,7 +4243,7 @@ Value = NIL "and Evalable is that the operations in this category" "specify the substitution as a pair of arguments rather than as" "an equation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|eval| '(%) '(% A B) @@ -3563,10 +4262,10 @@ Value = NIL \end{chunk} \subsection{JacobiIdentityAttribute} -\index{JacobiIdentityAttribute!Category} -\index{Category!JacobiIdentityAttribute} -\index{ATJACID} -\begin{chunk}{sane} +\index[cat]{JacobiIdentityAttribute!Category} +\index[cat]{Category!JacobiIdentityAttribute} +\index[cat]{ATJACID} +\begin{chunk}{defclass JacobiIdentityAttributeType} (defclass |JacobiIdentityAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "JacobiIdentityAttribute") @@ -3575,7 +4274,7 @@ Value = NIL (abbreviation :initform 'ATJACID) (comment :initform (list "JacobiIdentity means that [x,[y,z]]+[y,[z,x]]+[z,[x,y]] = 0 holds.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3589,10 +4288,10 @@ Value = NIL \end{chunk} \subsection{LazyRepresentationAttribute} -\index{LazyRepresentationAttribute!Category} -\index{Category!LazyRepresentationAttribute} -\index{ATLR} -\begin{chunk}{sane} +\index[cat]{LazyRepresentationAttribute!Category} +\index[cat]{Category!LazyRepresentationAttribute} +\index[cat]{ATLR} +\begin{chunk}{defclass LazyRepresentationAttributeType} (defclass |LazyRepresentationAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "LazyRepresentationAttribute") @@ -3601,7 +4300,7 @@ Value = NIL (abbreviation :initform 'ATLR) (comment :initform (list "The class of all domains which have a lazy representation")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3615,10 +4314,10 @@ Value = NIL \end{chunk} \subsection{LeftUnitaryAttribute} -\index{LeftUnitaryAttribute!Category} -\index{Category!LeftUnitaryAttribute} -\index{ATLUNIT} -\begin{chunk}{sane} +\index[cat]{LeftUnitaryAttribute!Category} +\index[cat]{Category!LeftUnitaryAttribute} +\index[cat]{ATLUNIT} +\begin{chunk}{defclass LeftUnitaryAttributeType} (defclass |LeftUnitaryAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "LeftUnitaryAttribute") @@ -3627,7 +4326,7 @@ Value = NIL (abbreviation :initform 'ATLUNIT) (comment :initform (list "LeftUnitary is true if 1 * x = x for all x.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3641,10 +4340,10 @@ Value = NIL \end{chunk} \subsection{ModularAlgebraicGcdOperations} -\index{ModularAlgebraicGcdOperations!Category} -\index{Category!ModularAlgebraicGcdOperations} -\index{MAGCDOC} -\begin{chunk}{sane} +\index[cat]{ModularAlgebraicGcdOperations!Category} +\index[cat]{Category!ModularAlgebraicGcdOperations} +\index[cat]{MAGCDOC} +\begin{chunk}{defclass ModularAlgebraicGcdOperationsType} (defclass |ModularAlgebraicGcdOperationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ModularAlgebraicGcdOperations") @@ -3665,7 +4364,7 @@ Value = NIL "array and exponents (in main variable and in auxilary" "variables representing generators of algebrac extension)" "stored in parallel array.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|pseudoRem| 'MPT '(MPT MPT MD) @@ -3705,10 +4404,10 @@ Value = NIL \end{chunk} \subsection{MultiplicativeValuationAttribute} -\index{MultiplicativeValuationAttribute!Category} -\index{Category!MultiplicativeValuationAttribute} -\index{ATMULVA} -\begin{chunk}{sane} +\index[cat]{MultiplicativeValuationAttribute!Category} +\index[cat]{Category!MultiplicativeValuationAttribute} +\index[cat]{ATMULVA} +\begin{chunk}{defclass MultiplicativeValuationAttributeType} (defclass |MultiplicativeValuationAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultiplicativeValuationAttribute") @@ -3718,7 +4417,7 @@ Value = NIL (comment :initform (list "The class of all euclidean domains such that" "euclideanSize(a*b)=euclideanSize(a)*euclideanSize(b)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3732,10 +4431,10 @@ Value = NIL \end{chunk} \subsection{NoZeroDivisorsAttribute} -\index{NoZeroDivisorsAttribute!Category} -\index{Category!NoZeroDivisorsAttribute} -\index{ATNZDIV} -\begin{chunk}{sane} +\index[cat]{NoZeroDivisorsAttribute!Category} +\index[cat]{Category!NoZeroDivisorsAttribute} +\index[cat]{ATNZDIV} +\begin{chunk}{defclass NoZeroDivisorsAttributeType} (defclass |NoZeroDivisorsAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "NoZeroDivisorsAttribute") @@ -3745,7 +4444,7 @@ Value = NIL (comment :initform (list "The class of all semirings such that x * y ~= 0 implies" "both x and y are non-zero.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3759,10 +4458,10 @@ Value = NIL \end{chunk} \subsection{NotherianAttribute} -\index{NotherianAttribute!Category} -\index{Category!NotherianAttribute} -\index{ATNOTHR} -\begin{chunk}{sane} +\index[cat]{NotherianAttribute!Category} +\index[cat]{Category!NotherianAttribute} +\index[cat]{ATNOTHR} +\begin{chunk}{defclass NotherianAttributeType} (defclass |NotherianAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "NotherianAttribute") @@ -3771,7 +4470,7 @@ Value = NIL (abbreviation :initform 'ATNOTHR) (comment :initform (list "Notherian is true if all of its ideals are finitely generated.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3785,10 +4484,10 @@ Value = NIL \end{chunk} \subsection{NullSquareAttribute} -\index{NullSquareAttribute!Category} -\index{Category!NullSquareAttribute} -\index{ATNULSQ} -\begin{chunk}{sane} +\index[cat]{NullSquareAttribute!Category} +\index[cat]{Category!NullSquareAttribute} +\index[cat]{ATNULSQ} +\begin{chunk}{defclass NullSquareAttributeType} (defclass |NullSquareAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "NullSquareAttribute") @@ -3797,7 +4496,7 @@ Value = NIL (abbreviation :initform 'ATNULSQ) (comment :initform (list "NullSquare means that [x,x] = 0 holds. See LieAlgebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -3811,10 +4510,10 @@ Value = NIL \end{chunk} \subsection{OpenMath} -\index{OpenMath!Category} -\index{Category!OpenMath} -\index{OM} -\begin{chunk}{sane} +\index[cat]{OpenMath!Category} +\index[cat]{Category!OpenMath} +\index[cat]{OM} +\begin{chunk}{defclass OpenMathType} (defclass |OpenMathType| (|AxiomClass|) ((parents :initform ()) (name :initform "OpenMath") @@ -3824,7 +4523,7 @@ Value = NIL (comment :initform (list "OpenMath provides operations for exporting an object" "in OpenMath format.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|OMwrite| '(|String|) '(%) @@ -3853,10 +4552,10 @@ Value = NIL \end{chunk} \subsection{PartialTranscendentalFunctions} -\index{PartialTranscendentalFunctions!Category} -\index{Category!PartialTranscendentalFunctions} -\index{PTRANFN} -\begin{chunk}{sane} +\index[cat]{PartialTranscendentalFunctions!Category} +\index[cat]{Category!PartialTranscendentalFunctions} +\index[cat]{PTRANFN} +\begin{chunk}{defclass PartialTranscendentalFunctionsType} (defclass |PartialTranscendentalFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PartialTranscendentalFunctions") @@ -3868,7 +4567,7 @@ Value = NIL "functions, for example, functions which return an answer or 'failed'" "This is the description of any package which provides partial" "functions on a domain belonging to TranscendentalFunctionCategory.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|nthRootIfCan| '(|Union| K "failed") '(K NNI) @@ -3938,10 +4637,10 @@ Value = NIL \end{chunk} \subsection{PartiallyOrderedSetAttribute} -\index{PartiallyOrderedSetAttribute!Category} -\index{Category!PartiallyOrderedSetAttribute} -\index{ATPOSET} -\begin{chunk}{sane} +\index[cat]{PartiallyOrderedSetAttribute!Category} +\index[cat]{Category!PartiallyOrderedSetAttribute} +\index[cat]{ATPOSET} +\begin{chunk}{defclass PartiallyOrderedSetAttributeType} (defclass |PartiallyOrderedSetAttributeType| (|AxiomClass|) ((parents :initform ()) (name :initform "PartiallyOrderedSetAttribute") @@ -3951,7 +4650,7 @@ Value = NIL (comment :initform (list "PartiallyOrderedSet is true if a set with < is transitive," "but not(a | A A)) @@ -5563,10 +6264,10 @@ Value = NIL \end{chunk} \subsection{LiouvillianFunctionCategory} -\index{LiouvillianFunctionCategory!Category} -\index{Category!LiouvillianFunctionCategory} -\index{LFCAT} -\begin{chunk}{sane} +\index[cat]{LiouvillianFunctionCategory!Category} +\index[cat]{Category!LiouvillianFunctionCategory} +\index[cat]{LFCAT} +\begin{chunk}{defclass LiouvillianFunctionCategoryType} (defclass |LiouvillianFunctionCategoryType| (|PrimitiveFunctionCategoryType| |TranscendentalFunctionCategoryType|) ((parents :initform '(|PrimitiveFunctionCategory| |TranscendentalFunctionCategory|)) @@ -5576,7 +6277,7 @@ Value = NIL (abbreviation :initform 'LFCAT) (comment :initform (list "Category for the transcendental Liouvillian functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|Ei| '(|%|) '(|%|) @@ -5622,10 +6323,10 @@ Value = NIL \end{chunk} \subsection{Monad} -\index{Monad!Category} -\index{Category!Monad} -\index{MONAD} -\begin{chunk}{sane} +\index[cat]{Monad!Category} +\index[cat]{Category!Monad} +\index[cat]{MONAD} +\begin{chunk}{defclass MonadType} (defclass |MonadType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Monad") @@ -5635,7 +6336,7 @@ Value = NIL (comment :initform (list "Monad is the class of all multiplicative monads, that is sets" "with a binary operation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform (list (make-signature '|*| '(|%|) '(|%| |%|) @@ -5664,10 +6365,10 @@ Value = NIL \end{chunk} \subsection{NumericalIntegrationCategory} -\index{NumericalIntegrationCategory!Category} -\index{Category!NumericalIntegrationCategory} -\index{NUMINT} -\begin{chunk}{sane} +\index[cat]{NumericalIntegrationCategory!Category} +\index[cat]{Category!NumericalIntegrationCategory} +\index[cat]{NUMINT} +\begin{chunk}{defclass NumericalIntegrationCategoryType} (defclass |NumericalIntegrationCategoryType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalIntegrationCategory") @@ -5678,7 +6379,7 @@ Value = NIL "NumericalIntegrationCategory is the category for" "describing the set of Numerical Integration domains with" "measure and numericalIntegration.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -5692,10 +6393,10 @@ Value = NIL \end{chunk} \subsection{NumericalOptimizationCategory} -\index{NumericalOptimizationCategory!Category} -\index{Category!NumericalOptimizationCategory} -\index{OPTCAT} -\begin{chunk}{sane} +\index[cat]{NumericalOptimizationCategory!Category} +\index[cat]{Category!NumericalOptimizationCategory} +\index[cat]{OPTCAT} +\begin{chunk}{defclass NumericalOptimizationCategoryType} (defclass |NumericalOptimizationCategoryType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalOptimizationCategory") @@ -5706,7 +6407,7 @@ Value = NIL "NumericalOptimizationCategory is the category for" "describing the set of Numerical Optimization domains with" "measure and optimize.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -5720,10 +6421,10 @@ Value = NIL \end{chunk} \subsection{OrderedSet} -\index{OrderedSet!Category} -\index{Category!OrderedSet} -\index{ORDSET} -\begin{chunk}{sane} +\index[cat]{OrderedSet!Category} +\index[cat]{Category!OrderedSet} +\index[cat]{ORDSET} +\begin{chunk}{defclass OrderedSetType} (defclass |OrderedSetType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "OrderedSet") @@ -5735,7 +6436,7 @@ Value = NIL "pair of elements (a,b)" "exactly one of the following relations holds a a x+z < y+z")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -6965,10 +7666,10 @@ Value = NIL \end{chunk} \subsection{OrderedFinite} -\index{OrderedFinite!Category} -\index{Category!OrderedFinite} -\index{ORDFIN} -\begin{chunk}{sane} +\index[cat]{OrderedFinite!Category} +\index[cat]{Category!OrderedFinite} +\index[cat]{ORDFIN} +\begin{chunk}{defclass OrderedFiniteType} (defclass |OrderedFiniteType| (|OrderedSetType| |FiniteType|) ((parents :initform '(|OrderedSet| |Finite|)) (name :initform "OrderedFinite") @@ -6977,7 +7678,7 @@ Value = NIL (abbreviation :initform 'ORDFIN) (comment :initform (list "Ordered finite sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -6991,10 +7692,10 @@ Value = NIL \end{chunk} \subsection{PlacesCategory} -\index{PlacesCategory!Category} -\index{Category!PlacesCategory} -\index{PLACESC} -\begin{chunk}{sane} +\index[cat]{PlacesCategory!Category} +\index[cat]{Category!PlacesCategory} +\index[cat]{PLACESC} +\begin{chunk}{defclass PlacesCategoryType} (defclass |PlacesCategoryType| (|SetCategoryWithDegreeType|) ((parents :initform '(|SetCategoryWithDegree|)) (name :initform "PlacesCategory") @@ -7003,7 +7704,7 @@ Value = NIL (abbreviation :initform 'PLACESC) (comment :initform (list "This is part of the PAFF package, related to projective space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7017,10 +7718,10 @@ Value = NIL \end{chunk} \subsection{ProjectiveSpaceCategory} -\index{ProjectiveSpaceCategory!Category} -\index{Category!ProjectiveSpaceCategory} -\index{PRSPCAT} -\begin{chunk}{sane} +\index[cat]{ProjectiveSpaceCategory!Category} +\index[cat]{Category!ProjectiveSpaceCategory} +\index[cat]{PRSPCAT} +\begin{chunk}{defclass ProjectiveSpaceCategoryType} (defclass |ProjectiveSpaceCategoryType| (|SetCategoryWithDegreeType|) ((parents :initform '(|SetCategoryWithDegree|)) (name :initform "ProjectiveSpaceCategory") @@ -7029,7 +7730,7 @@ Value = NIL (abbreviation :initform 'PRSPCAT) (comment :initform (list "This is part of the PAFF package, related to projective space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7043,10 +7744,10 @@ Value = NIL \end{chunk} \subsection{RecursiveAggregate} -\index{RecursiveAggregate!Category} -\index{Category!RecursiveAggregate} -\index{RCAGG} -\begin{chunk}{sane} +\index[cat]{RecursiveAggregate!Category} +\index[cat]{Category!RecursiveAggregate} +\index[cat]{RCAGG} +\begin{chunk}{defclass RecursiveAggregateType} (defclass |RecursiveAggregateType| (|HomogeneousAggregateType|) ((parents :initform '(|HomogeneousAggregate|)) (name :initform "RecursiveAggregate") @@ -7062,7 +7763,7 @@ Value = NIL "A node with no children is called a leaf node." "A recursive aggregate may be cyclic for which some operations as noted" "may go into an infinite loop.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7076,10 +7777,10 @@ Value = NIL \end{chunk} \subsection{TwoDimensionalArrayCategory} -\index{TwoDimensionalArrayCategory!Category} -\index{Category!TwoDimensionalArrayCategory} -\index{ARR2CAT} -\begin{chunk}{sane} +\index[cat]{TwoDimensionalArrayCategory!Category} +\index[cat]{Category!TwoDimensionalArrayCategory} +\index[cat]{ARR2CAT} +\begin{chunk}{defclass TwoDimensionalArrayCategoryType} (defclass |TwoDimensionalArrayCategoryType| (|HomogeneousAggregateType|) ((parents :initform '(|HomogeneousAggregate|)) (name :initform "TwoDimensionalArrayCategory") @@ -7088,7 +7789,7 @@ Value = NIL (abbreviation :initform 'ARR2CAT) (comment :initform (list "Two dimensional array categories and domains")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7103,7 +7804,7 @@ Value = NIL \section{Level 5} -\begin{chunk}{sane} +\begin{chunk}{defvar level5} (defvar level5 '(|BinaryRecursiveAggregate| |CancellationAbelianMonoid| |DesingTreeCategory| |DoublyLinkedAggregate| |Group| |LinearAggregate| |MatrixCategory| @@ -7114,10 +7815,10 @@ Value = NIL \end{chunk} \subsection{BinaryRecursiveAggregate} -\index{BinaryRecursiveAggregate!Category} -\index{Category!BinaryRecursiveAggregate} -\index{BRAGG} -\begin{chunk}{sane} +\index[cat]{BinaryRecursiveAggregate!Category} +\index[cat]{Category!BinaryRecursiveAggregate} +\index[cat]{BRAGG} +\begin{chunk}{defclass BinaryRecursiveAggregateType} (defclass |BinaryRecursiveAggregateType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "BinaryRecursiveAggregate") @@ -7127,7 +7828,7 @@ Value = NIL (comment :initform (list "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")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7141,10 +7842,10 @@ Value = NIL \end{chunk} \subsection{CancellationAbelianMonoid} -\index{CancellationAbelianMonoid!Category} -\index{Category!CancellationAbelianMonoid} -\index{CABMON} -\begin{chunk}{sane} +\index[cat]{CancellationAbelianMonoid!Category} +\index[cat]{Category!CancellationAbelianMonoid} +\index[cat]{CABMON} +\begin{chunk}{defclass CancellationAbelianMonoidType} (defclass |CancellationAbelianMonoidType| (|AbelianMonoidType|) ((parents :initform '(|AbelianMonoid|)) (name :initform "CancellationAbelianMonoid") @@ -7157,7 +7858,7 @@ Value = NIL "This is formalised by the partial subtraction operator," "which satisfies the Axioms" " c = a+b <=> c-b = a")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7171,10 +7872,10 @@ Value = NIL \end{chunk} \subsection{DesingTreeCategory} -\index{DesingTreeCategory!Category} -\index{Category!DesingTreeCategory} -\index{DSTRCAT} -\begin{chunk}{sane} +\index[cat]{DesingTreeCategory!Category} +\index[cat]{Category!DesingTreeCategory} +\index[cat]{DSTRCAT} +\begin{chunk}{defclass DesingTreeCategoryType} (defclass |DesingTreeCategoryType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "DesingTreeCategory") @@ -7183,7 +7884,7 @@ Value = NIL (abbreviation :initform 'DSTRCAT) (comment :initform (list "This category is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7197,10 +7898,10 @@ Value = NIL \end{chunk} \subsection{DoublyLinkedAggregate} -\index{DoublyLinkedAggregate!Category} -\index{Category!DoublyLinkedAggregate} -\index{DLAGG} -\begin{chunk}{sane} +\index[cat]{DoublyLinkedAggregate!Category} +\index[cat]{Category!DoublyLinkedAggregate} +\index[cat]{DLAGG} +\begin{chunk}{defclass DoublyLinkedAggregateType} (defclass |DoublyLinkedAggregateType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "DoublyLinkedAggregate") @@ -7211,7 +7912,7 @@ Value = 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7225,10 +7926,10 @@ Value = NIL \end{chunk} \subsection{Group} -\index{Group!Category} -\index{Category!Group} -\index{GROUP} -\begin{chunk}{sane} +\index[cat]{Group!Category} +\index[cat]{Category!Group} +\index[cat]{GROUP} +\begin{chunk}{defclass GroupType} (defclass |GroupType| (|MonoidType|) ((parents :initform '(|Monoid|)) (name :initform "Group") @@ -7238,7 +7939,7 @@ Value = NIL (comment :initform (list "The class of multiplicative groups, that is, monoids with" "multiplicative inverses.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7252,10 +7953,10 @@ Value = NIL \end{chunk} \subsection{LinearAggregate} -\index{LinearAggregate!Category} -\index{Category!LinearAggregate} -\index{LNAGG} -\begin{chunk}{sane} +\index[cat]{LinearAggregate!Category} +\index[cat]{Category!LinearAggregate} +\index[cat]{LNAGG} +\begin{chunk}{defclass LinearAggregateType} (defclass |LinearAggregateType| (|CollectionType| |IndexedAggregateType|) ((parents :initform '(|Collection| |IndexedAggregate|)) (name :initform "LinearAggregate") @@ -7273,7 +7974,7 @@ Value = NIL "arguments. Most of the operations exported here apply to infinite" "objects (for example, streams) as well to finite ones." "For finite linear aggregates, see FiniteLinearAggregate.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7287,10 +7988,10 @@ Value = NIL \end{chunk} \subsection{MatrixCategory} -\index{MatrixCategory!Category} -\index{Category!MatrixCategory} -\index{MATCAT} -\begin{chunk}{sane} +\index[cat]{MatrixCategory!Category} +\index[cat]{Category!MatrixCategory} +\index[cat]{MATCAT} +\begin{chunk}{defclass MatrixCategoryType} (defclass |MatrixCategoryType| (|TwoDimensionalArrayCategoryType|) ((parents :initform '(|TwoDimensionalArrayCategory|)) (name :initform "MatrixCategory") @@ -7308,7 +8009,7 @@ Value = NIL "be obtained by calling the function minColIndex. The index of" "the first element of a Row is the same as the index of the" "first column in a matrix and vice versa.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7322,10 +8023,10 @@ Value = NIL \end{chunk} \subsection{OrderedAbelianMonoid} -\index{OrderedAbelianMonoid!Category} -\index{Category!OrderedAbelianMonoid} -\index{OAMON} -\begin{chunk}{sane} +\index[cat]{OrderedAbelianMonoid!Category} +\index[cat]{Category!OrderedAbelianMonoid} +\index[cat]{OAMON} +\begin{chunk}{defclass OrderedAbelianMonoidType} (defclass |OrderedAbelianMonoidType| (|AbelianMonoidType| |OrderedAbelianSemiGroupType|) ((parents :initform '(|AbelianMonoid| |OrderedAbelianSemiGroup|)) (name :initform "OrderedAbelianMonoid") @@ -7335,7 +8036,7 @@ Value = NIL (comment :initform (list "Ordered sets which are also abelian monoids, such that the addition" "preserves the ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7349,10 +8050,10 @@ Value = NIL \end{chunk} \subsection{OrderedMonoid} -\index{OrderedMonoid!Category} -\index{Category!OrderedMonoid} -\index{ORDMON} -\begin{chunk}{sane} +\index[cat]{OrderedMonoid!Category} +\index[cat]{Category!OrderedMonoid} +\index[cat]{ORDMON} +\begin{chunk}{defclass OrderedMonoidType} (defclass |OrderedMonoidType| (|OrderedSetType| |MonoidType|) ((parents :initform '(|OrderedSet| |Monoid|)) (name :initform "OrderedMonoid") @@ -7362,7 +8063,7 @@ Value = NIL (comment :initform (list "Ordered sets which are also monoids, such that multiplication" "preserves the ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7376,10 +8077,10 @@ Value = NIL \end{chunk} \subsection{PolynomialSetCategory} -\index{PolynomialSetCategory!Category} -\index{Category!PolynomialSetCategory} -\index{PSETCAT} -\begin{chunk}{sane} +\index[cat]{PolynomialSetCategory!Category} +\index[cat]{Category!PolynomialSetCategory} +\index[cat]{PSETCAT} +\begin{chunk}{defclass PolynomialSetCategoryType} (defclass |PolynomialSetCategoryType| (|CollectionType|) ((parents :initform '(|Collection|)) (name :initform "PolynomialSetCategory") @@ -7396,7 +8097,7 @@ Value = NIL "or the set of its zeros (described for instance by the radical of the" "previous ideal, or a split of the associated affine variety) and so on." "So this category provides operations about those different notions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7410,10 +8111,10 @@ Value = NIL \end{chunk} \subsection{PriorityQueueAggregate} -\index{PriorityQueueAggregate!Category} -\index{Category!PriorityQueueAggregate} -\index{PRQAGG} -\begin{chunk}{sane} +\index[cat]{PriorityQueueAggregate!Category} +\index[cat]{Category!PriorityQueueAggregate} +\index[cat]{PRQAGG} +\begin{chunk}{defclass PriorityQueueAggregateType} (defclass |PriorityQueueAggregateType| (|BagAggregateType|) ((parents :initform '(|BagAggregate|)) (name :initform "PriorityQueueAggregate") @@ -7423,7 +8124,7 @@ Value = NIL (comment :initform (list "A priority queue is a bag of items from an ordered set where the item" "extracted is always the maximum element.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7437,10 +8138,10 @@ Value = NIL \end{chunk} \subsection{QueueAggregate} -\index{QueueAggregate!Category} -\index{Category!QueueAggregate} -\index{QUAGG} -\begin{chunk}{sane} +\index[cat]{QueueAggregate!Category} +\index[cat]{Category!QueueAggregate} +\index[cat]{QUAGG} +\begin{chunk}{defclass QueueAggregateType} (defclass |QueueAggregateType| (|BagAggregateType|) ((parents :initform '(|BagAggregate|)) (name :initform "QueueAggregate") @@ -7450,7 +8151,7 @@ Value = NIL (comment :initform (list "A queue is a bag where the first item inserted is the first" "item extracted.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7464,10 +8165,10 @@ Value = NIL \end{chunk} \subsection{SetAggregate} -\index{SetAggregate!Category} -\index{Category!SetAggregate} -\index{SETAGG} -\begin{chunk}{sane} +\index[cat]{SetAggregate!Category} +\index[cat]{Category!SetAggregate} +\index[cat]{SETAGG} +\begin{chunk}{defclass SetAggregateType} (defclass |SetAggregateType| (|CollectionType|) ((parents :initform '(|Collection|)) (name :initform "SetAggregate") @@ -7481,7 +8182,7 @@ Value = NIL "Although the operations defined for set categories are" "common to both, the relationship between the two cannot" "be described by inclusion or inheritance.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7495,10 +8196,10 @@ Value = NIL \end{chunk} \subsection{StackAggregate} -\index{StackAggregate!Category} -\index{Category!StackAggregate} -\index{SKAGG} -\begin{chunk}{sane} +\index[cat]{StackAggregate!Category} +\index[cat]{Category!StackAggregate} +\index[cat]{SKAGG} +\begin{chunk}{defclass StackAggregateType} (defclass |StackAggregateType| (|BagAggregateType|) ((parents :initform '(|BagAggregate|)) (name :initform "StackAggregate") @@ -7507,7 +8208,7 @@ Value = NIL (abbreviation :initform 'SKAGG) (comment :initform (list "A stack is a bag where the last item inserted is the first item extracted.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7521,10 +8222,10 @@ Value = NIL \end{chunk} \subsection{UnaryRecursiveAggregate} -\index{UnaryRecursiveAggregate!Category} -\index{Category!UnaryRecursiveAggregate} -\index{URAGG} -\begin{chunk}{sane} +\index[cat]{UnaryRecursiveAggregate!Category} +\index[cat]{Category!UnaryRecursiveAggregate} +\index[cat]{URAGG} +\begin{chunk}{defclass UnaryRecursiveAggregateType} (defclass |UnaryRecursiveAggregateType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "UnaryRecursiveAggregate") @@ -7541,7 +8242,7 @@ Value = NIL "of the list, and the child designating the tail, or rest," "of the list. A node with no child then designates the empty list." "Since these aggregates are recursive aggregates, they may be cyclic.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7556,7 +8257,7 @@ Value = NIL \section{Level 6} -\begin{chunk}{sane} +\begin{chunk}{defvar level6} (defvar level6 '(|AbelianGroup| |BinaryTreeCategory| |DequeueAggregate| |DictionaryOperations| |ExtensibleLinearAggregate| |FiniteLinearAggregate| @@ -7567,10 +8268,10 @@ Value = NIL \end{chunk} \subsection{AbelianGroup} -\index{AbelianGroup!Category} -\index{Category!AbelianGroup} -\index{ABELGRP} -\begin{chunk}{sane} +\index[cat]{AbelianGroup!Category} +\index[cat]{Category!AbelianGroup} +\index[cat]{ABELGRP} +\begin{chunk}{defclass AbelianGroupType} (defclass |AbelianGroupType| (|CancellationAbelianMonoidType|) ((parents :initform '(|CancellationAbelianMonoid|)) (name :initform "AbelianGroup") @@ -7580,7 +8281,7 @@ Value = NIL (comment :initform (list "The class of abelian groups, additive monoids where" "each element has an additive inverse.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7594,10 +8295,10 @@ Value = NIL \end{chunk} \subsection{BinaryTreeCategory} -\index{BinaryTreeCategory!Category} -\index{Category!BinaryTreeCategory} -\index{BTCAT} -\begin{chunk}{sane} +\index[cat]{BinaryTreeCategory!Category} +\index[cat]{Category!BinaryTreeCategory} +\index[cat]{BTCAT} +\begin{chunk}{defclass BinaryTreeCategoryType} (defclass |BinaryTreeCategoryType| (|BinaryRecursiveAggregateType|) ((parents :initform '(|BinaryRecursiveAggregate|)) (name :initform "BinaryTreeCategory") @@ -7609,7 +8310,7 @@ Value = NIL "binary trees: a tree which is either empty or else is a" "node consisting of a value and a left and" "right, both binary trees. ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7623,10 +8324,10 @@ Value = NIL \end{chunk} \subsection{DequeueAggregate} -\index{DequeueAggregate!Category} -\index{Category!DequeueAggregate} -\index{DQAGG} -\begin{chunk}{sane} +\index[cat]{DequeueAggregate!Category} +\index[cat]{Category!DequeueAggregate} +\index[cat]{DQAGG} +\begin{chunk}{defclass DequeueAggregateType} (defclass |DequeueAggregateType| (|QueueAggregateType| |StackAggregateType|) ((parents :initform '(|QueueAggregate| |StackAggregate|)) (name :initform "DequeueAggregate") @@ -7637,7 +8338,7 @@ Value = 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7651,10 +8352,10 @@ Value = NIL \end{chunk} \subsection{DictionaryOperations} -\index{DictionaryOperations!Category} -\index{Category!DictionaryOperations} -\index{DIOPS} -\begin{chunk}{sane} +\index[cat]{DictionaryOperations!Category} +\index[cat]{Category!DictionaryOperations} +\index[cat]{DIOPS} +\begin{chunk}{defclass DictionaryOperationsType} (defclass |DictionaryOperationsType| (|BagAggregateType| |CollectionType|) ((parents :initform '(|BagAggregate| |Collection|)) (name :initform "DictionaryOperations") @@ -7664,7 +8365,7 @@ Value = NIL (comment :initform (list "This category is a collection of operations common to both" "categories Dictionary and MultiDictionary")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7678,10 +8379,10 @@ Value = NIL \end{chunk} \subsection{ExtensibleLinearAggregate} -\index{ExtensibleLinearAggregate!Category} -\index{Category!ExtensibleLinearAggregate} -\index{ELAGG} -\begin{chunk}{sane} +\index[cat]{ExtensibleLinearAggregate!Category} +\index[cat]{Category!ExtensibleLinearAggregate} +\index[cat]{ELAGG} +\begin{chunk}{defclass ExtensibleLinearAggregateType} (defclass |ExtensibleLinearAggregateType| (|LinearAggregateType|) ((parents :initform '(|LinearAggregate|)) (name :initform "ExtensibleLinearAggregate") @@ -7695,7 +8396,7 @@ Value = NIL "concatenation efficient. However, access to elements of these" "extensible aggregates is generally slow since access is made from the end." "See FlexibleArray for an exception.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7709,10 +8410,10 @@ Value = NIL \end{chunk} \subsection{FiniteLinearAggregate} -\index{FiniteLinearAggregate!Category} -\index{Category!FiniteLinearAggregate} -\index{FLAGG} -\begin{chunk}{sane} +\index[cat]{FiniteLinearAggregate!Category} +\index[cat]{Category!FiniteLinearAggregate} +\index[cat]{FLAGG} +\begin{chunk}{defclass FiniteLinearAggregateType} (defclass |FiniteLinearAggregateType| (|OrderedSetType| |LinearAggregateType|) ((parents :initform '(|OrderedSet| |LinearAggregate|)) (name :initform "FiniteLinearAggregate") @@ -7724,7 +8425,7 @@ Value = NIL "The finite property of the aggregate adds several exports to the" "list of exports from LinearAggregate such as" "reverse, sort, and so on.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7738,10 +8439,10 @@ Value = NIL \end{chunk} \subsection{FreeAbelianMonoidCategory} -\index{FreeAbelianMonoidCategory!Category} -\index{Category!FreeAbelianMonoidCategory} -\index{FAMONC} -\begin{chunk}{sane} +\index[cat]{FreeAbelianMonoidCategory!Category} +\index[cat]{Category!FreeAbelianMonoidCategory} +\index[cat]{FAMONC} +\begin{chunk}{defclass FreeAbelianMonoidCategoryType} (defclass |FreeAbelianMonoidCategoryType| (|RetractableToType| |CancellationAbelianMonoidType|) ((parents :initform '(|RetractableTo| |CancellationAbelianMonoid|)) (name :initform "FreeAbelianMonoidCategory") @@ -7752,7 +8453,7 @@ Value = NIL "A free abelian monoid on a set S is the monoid of finite sums of" "the form reduce(+,[ni * si]) where the si's are in S, and the ni's" "are in a given abelian monoid. The operation is commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7766,10 +8467,10 @@ Value = NIL \end{chunk} \subsection{OrderedCancellationAbelianMonoid} -\index{OrderedCancellationAbelianMonoid!Category} -\index{Category!OrderedCancellationAbelianMonoid} -\index{OCAMON} -\begin{chunk}{sane} +\index[cat]{OrderedCancellationAbelianMonoid!Category} +\index[cat]{Category!OrderedCancellationAbelianMonoid} +\index[cat]{OCAMON} +\begin{chunk}{defclass OrderedCancellationAbelianMonoidType} (defclass |OrderedCancellationAbelianMonoidType| (|CancellationAbelianMonoidType| |OrderedAbelianMonoidType|) ((parents :initform '(|CancellationAbelianMonoid| @@ -7781,7 +8482,7 @@ Value = NIL (comment :initform (list "Ordered sets which are also abelian cancellation monoids," "such that the addition preserves the ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7795,10 +8496,10 @@ Value = NIL \end{chunk} \subsection{PermutationCategory} -\index{PermutationCategory!Category} -\index{Category!PermutationCategory} -\index{PERMCAT} -\begin{chunk}{sane} +\index[cat]{PermutationCategory!Category} +\index[cat]{Category!PermutationCategory} +\index[cat]{PERMCAT} +\begin{chunk}{defclass PermutationCategoryType} (defclass |PermutationCategoryType| (|OrderedSetType| |GroupType|) ((parents :initform '(|OrderedSet| |Group|)) (name :initform "PermutationCategory") @@ -7808,7 +8509,7 @@ Value = NIL (comment :initform (list "PermutationCategory provides a categorial environment" "for subgroups of bijections of a set (that is, permutations)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7822,10 +8523,10 @@ Value = NIL \end{chunk} \subsection{StreamAggregate} -\index{StreamAggregate!Category} -\index{Category!StreamAggregate} -\index{STAGG} -\begin{chunk}{sane} +\index[cat]{StreamAggregate!Category} +\index[cat]{Category!StreamAggregate} +\index[cat]{STAGG} +\begin{chunk}{defclass StreamAggregateType} (defclass |StreamAggregateType| (|LinearAggregateType| |UnaryRecursiveAggregateType|) ((parents :initform '(|LinearAggregate| |UnaryRecursiveAggregate|)) (name :initform "StreamAggregate") @@ -7839,7 +8540,7 @@ Value = NIL "structures such power series can be built. A stream aggregate may" "also be infinite since it may be cyclic." "For example, see DecimalExpansion.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7853,10 +8554,10 @@ Value = NIL \end{chunk} \subsection{TriangularSetCategory} -\index{TriangularSetCategory!Category} -\index{Category!TriangularSetCategory} -\index{TSETCAT} -\begin{chunk}{sane} +\index[cat]{TriangularSetCategory!Category} +\index[cat]{Category!TriangularSetCategory} +\index[cat]{TSETCAT} +\begin{chunk}{defclass TriangularSetCategoryType} (defclass |TriangularSetCategoryType| (|PolynomialSetCategoryType|) ((parents :initform '(|PolynomialSetCategory|)) (name :initform "TriangularSetCategory") @@ -7881,7 +8582,7 @@ Value = NIL "is less than the main degree of Q." "A polynomial P is reduced w.r.t a triangular set T" "if it is reduced w.r.t. every polynomial of T.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7896,7 +8597,7 @@ Value = NIL \section{Level 7} -\begin{chunk}{sane} +\begin{chunk}{defvar level7} (defvar level7 '(|Dictionary| |FiniteDivisorCategory| |LazyStreamAggregate| |LeftModule| |ListAggregate| |MultiDictionary| |MultisetAggregate| |NonAssociativeRng| @@ -7906,10 +8607,10 @@ Value = NIL \end{chunk} \subsection{Dictionary} -\index{Dictionary!Category} -\index{Category!Dictionary} -\index{DIAGG} -\begin{chunk}{sane} +\index[cat]{Dictionary!Category} +\index[cat]{Category!Dictionary} +\index[cat]{DIAGG} +\begin{chunk}{defclass DictionaryType} (defclass |DictionaryType| (|DictionaryOperationsType|) ((parents :initform '(|DictionaryOperations|)) (name :initform "Dictionary") @@ -7922,7 +8623,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7936,10 +8637,10 @@ Value = NIL \end{chunk} \subsection{FiniteDivisorCategory} -\index{FiniteDivisorCategory!Category} -\index{Category!FiniteDivisorCategory} -\index{FDIVCAT} -\begin{chunk}{sane} +\index[cat]{FiniteDivisorCategory!Category} +\index[cat]{Category!FiniteDivisorCategory} +\index[cat]{FDIVCAT} +\begin{chunk}{defclass FiniteDivisorCategoryType} (defclass |FiniteDivisorCategoryType| (|AbelianGroupType|) ((parents :initform '(|AbelianGroup|)) (name :initform "FiniteDivisorCategory") @@ -7950,7 +8651,7 @@ Value = NIL "This category describes finite rational divisors on a curve, that" "is finite formal sums SUM(n * P) where the n's are integers and the" "P's are finite rational points on the curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7964,10 +8665,10 @@ Value = NIL \end{chunk} \subsection{LazyStreamAggregate} -\index{LazyStreamAggregate!Category} -\index{Category!LazyStreamAggregate} -\index{LZSTAGG} -\begin{chunk}{sane} +\index[cat]{LazyStreamAggregate!Category} +\index[cat]{Category!LazyStreamAggregate} +\index[cat]{LZSTAGG} +\begin{chunk}{defclass LazyStreamAggregateType} (defclass |LazyStreamAggregateType| (|StreamAggregateType|) ((parents :initform '(|StreamAggregate|)) (name :initform "LazyStreamAggregate") @@ -7980,7 +8681,7 @@ Value = NIL "cause lazy evaluation if necessary to determine if there are" "entries. Functions which call 'empty?', for example 'first' and 'rest'," "will also cause lazy evaluation if necessary.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -7994,10 +8695,10 @@ Value = NIL \end{chunk} \subsection{LeftModule} -\index{LeftModule!Category} -\index{Category!LeftModule} -\index{LMODULE} -\begin{chunk}{sane} +\index[cat]{LeftModule!Category} +\index[cat]{Category!LeftModule} +\index[cat]{LMODULE} +\begin{chunk}{defclass LeftModuleType} (defclass |LeftModuleType| (|AbelianGroupType|) ((parents :initform '(|AbelianGroup|)) (name :initform "LeftModule") @@ -8007,7 +8708,7 @@ Value = NIL (comment :initform (list "This is an abelian group which supports left multiplication by elements of" "the rng.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8021,10 +8722,10 @@ Value = NIL \end{chunk} \subsection{ListAggregate} -\index{ListAggregate!Category} -\index{Category!ListAggregate} -\index{LSAGG} -\begin{chunk}{sane} +\index[cat]{ListAggregate!Category} +\index[cat]{Category!ListAggregate} +\index[cat]{LSAGG} +\begin{chunk}{defclass ListAggregateType} (defclass |ListAggregateType| (|ExtensibleLinearAggregateType| |FiniteLinearAggregateType| |StreamAggregateType|) @@ -8040,7 +8741,7 @@ Value = NIL "A linked list is a versatile" "data structure. Insertion and deletion are efficient and" "searching is a linear operation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8054,10 +8755,10 @@ Value = NIL \end{chunk} \subsection{MultiDictionary} -\index{MultiDictionary!Category} -\index{Category!MultiDictionary} -\index{MDAGG} -\begin{chunk}{sane} +\index[cat]{MultiDictionary!Category} +\index[cat]{Category!MultiDictionary} +\index[cat]{MDAGG} +\begin{chunk}{defclass MultiDictionaryType} (defclass |MultiDictionaryType| (|DictionaryOperationsType|) ((parents :initform '(|DictionaryOperations|)) (name :initform "MultiDictionary") @@ -8068,7 +8769,7 @@ Value = NIL "A multi-dictionary is a dictionary which may contain duplicates." "As for any dictionary, its size is assumed large so that" "copying (non-destructive) operations are generally to be avoided.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8082,10 +8783,10 @@ Value = NIL \end{chunk} \subsection{MultisetAggregate} -\index{MultisetAggregate!Category} -\index{Category!MultisetAggregate} -\index{MSETAGG} -\begin{chunk}{sane} +\index[cat]{MultisetAggregate!Category} +\index[cat]{Category!MultisetAggregate} +\index[cat]{MSETAGG} +\begin{chunk}{defclass MultisetAggregateType} (defclass |MultisetAggregateType| (|SetAggregateType| |MultiDictionaryType|) ((parents :initform '(|SetAggregate| |MultiDictionary|)) (name :initform "MultisetAggregate") @@ -8095,7 +8796,7 @@ Value = NIL (comment :initform (list "A multi-set aggregate is a set which keeps track of the multiplicity" "of its elements.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8109,10 +8810,10 @@ Value = NIL \end{chunk} \subsection{NonAssociativeRng} -\index{NonAssociativeRng!Category} -\index{Category!NonAssociativeRng} -\index{NARNG} -\begin{chunk}{sane} +\index[cat]{NonAssociativeRng!Category} +\index[cat]{Category!NonAssociativeRng} +\index[cat]{NARNG} +\begin{chunk}{defclass NonAssociativeRngType} (defclass |NonAssociativeRngType| (|MonadType| |AbelianGroupType|) ((parents :initform '(|Monad| |AbelianGroup|)) (name :initform "NonAssociativeRng") @@ -8122,7 +8823,7 @@ Value = NIL (comment :initform (list "NonAssociativeRng is a basic ring-type structure, not necessarily" "commutative or associative, and not necessarily with unit.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8136,10 +8837,10 @@ Value = NIL \end{chunk} \subsection{OneDimensionalArrayAggregate} -\index{OneDimensionalArrayAggregate!Category} -\index{Category!OneDimensionalArrayAggregate} -\index{A1AGG} -\begin{chunk}{sane} +\index[cat]{OneDimensionalArrayAggregate!Category} +\index[cat]{Category!OneDimensionalArrayAggregate} +\index[cat]{A1AGG} +\begin{chunk}{defclass OneDimensionalArrayAggregateType} (defclass |OneDimensionalArrayAggregateType| (|FiniteLinearAggregateType|) ((parents :initform '(|FiniteLinearAggregate|)) (name :initform "OneDimensionalArrayAggregate") @@ -8160,7 +8861,7 @@ Value = NIL "(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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8174,10 +8875,10 @@ Value = NIL \end{chunk} \subsection{OrderedAbelianGroup} -\index{OrderedAbelianGroup!Category} -\index{Category!OrderedAbelianGroup} -\index{OAGROUP} -\begin{chunk}{sane} +\index[cat]{OrderedAbelianGroup!Category} +\index[cat]{Category!OrderedAbelianGroup} +\index[cat]{OAGROUP} +\begin{chunk}{defclass OrderedAbelianGroupType} (defclass |OrderedAbelianGroupType| (|AbelianGroupType| |OrderedCancellationAbelianMonoidType|) ((parents :initform '(|AbelianGroup| |OrderedCancellationAbelianMonoid|)) (name :initform "OrderedAbelianGroup") @@ -8187,7 +8888,7 @@ Value = NIL (comment :initform (list "Ordered sets which are also abelian groups, such that the" "addition preserves the ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8201,10 +8902,10 @@ Value = NIL \end{chunk} \subsection{OrderedAbelianMonoidSup} -\index{OrderedAbelianMonoidSup!Category} -\index{Category!OrderedAbelianMonoidSup} -\index{OAMONS} -\begin{chunk}{sane} +\index[cat]{OrderedAbelianMonoidSup!Category} +\index[cat]{Category!OrderedAbelianMonoidSup} +\index[cat]{OAMONS} +\begin{chunk}{defclass OrderedAbelianMonoidSupType} (defclass |OrderedAbelianMonoidSupType| (|OrderedCancellationAbelianMonoidType|) ((parents :initform '(|OrderedCancellationAbelianMonoid|)) (name :initform "OrderedAbelianMonoidSup") @@ -8217,7 +8918,7 @@ Value = NIL "in this domain is to act as a supremum with respect to the" "partial order imposed by `-`, rather than with respect to" "the total > order (since that is 'max').")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8231,10 +8932,10 @@ Value = NIL \end{chunk} \subsection{RegularTriangularSetCategory} -\index{RegularTriangularSetCategory!Category} -\index{Category!RegularTriangularSetCategory} -\index{RSETCAT} -\begin{chunk}{sane} +\index[cat]{RegularTriangularSetCategory!Category} +\index[cat]{Category!RegularTriangularSetCategory} +\index[cat]{RSETCAT} +\begin{chunk}{defclass RegularTriangularSetCategoryType} (defclass |RegularTriangularSetCategoryType| (|TriangularSetCategoryType|) ((parents :initform '(|TriangularSetCategory|)) (name :initform "RegularTriangularSetCategory") @@ -8280,7 +8981,7 @@ Value = NIL "the latter deals with varieties decomposition." "See the example illustrating the RegularTriangularSet constructor for more" "explanations about decompositions by means of regular triangular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8294,10 +8995,10 @@ Value = NIL \end{chunk} \subsection{RightModule} -\index{RightModule!Category} -\index{Category!RightModule} -\index{RMODULE} -\begin{chunk}{sane} +\index[cat]{RightModule!Category} +\index[cat]{Category!RightModule} +\index[cat]{RMODULE} +\begin{chunk}{defclass RightModuleType} (defclass |RightModuleType| (|AbelianGroupType|) ((parents :initform '(|AbelianGroup|)) (name :initform "RightModule") @@ -8308,7 +9009,7 @@ Value = NIL "The category of right modules over an rng (ring not necessarily" "with unit). This is an abelian group which supports right" "multiplication by elements of the rng.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8322,10 +9023,10 @@ Value = NIL \end{chunk} \subsection{Rng} -\index{Rng!Category} -\index{Category!Rng} -\index{RNG} -\begin{chunk}{sane} +\index[cat]{Rng!Category} +\index[cat]{Category!Rng} +\index[cat]{RNG} +\begin{chunk}{defclass RngType} (defclass |RngType| (|SemiGroupType| |AbelianGroupType|) ((parents :initform '(|SemiGroup| |AbelianGroup|)) (name :initform "Rng") @@ -8336,7 +9037,7 @@ Value = NIL "The category of associative rings, not necessarily commutative, and not" "necessarily with a 1. This is a combination of an abelian group" "and a semigroup, with multiplication distributing over addition.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8351,7 +9052,7 @@ Value = NIL \section{Level 8} -\begin{chunk}{sane} +\begin{chunk}{defvar level8} (defvar level8 '(|BiModule| |BitAggregate| |FiniteSetAggregate| |KeyedDictionary| |NonAssociativeRing| |NormalizedTriangularSetCategory| @@ -8361,10 +9062,10 @@ Value = NIL \end{chunk} \subsection{BiModule} -\index{BiModule!Category} -\index{Category!BiModule} -\index{BMODULE} -\begin{chunk}{sane} +\index[cat]{BiModule!Category} +\index[cat]{Category!BiModule} +\index[cat]{BMODULE} +\begin{chunk}{defclass BiModuleType} (defclass |BiModuleType| (|LeftModuleType| |RightModuleType|) ((parents :initform '(|LeftModule| |RightModule|)) (name :initform "BiModule") @@ -8374,7 +9075,7 @@ Value = NIL (comment :initform (list "A BiModule is both a left and right module with respect" "to potentially different rings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8388,10 +9089,10 @@ Value = NIL \end{chunk} \subsection{BitAggregate} -\index{BitAggregate!Category} -\index{Category!BitAggregate} -\index{BTAGG} -\begin{chunk}{sane} +\index[cat]{BitAggregate!Category} +\index[cat]{Category!BitAggregate} +\index[cat]{BTAGG} +\begin{chunk}{defclass |BitAggregateType} (defclass |BitAggregateType| (|LogicType| |OneDimensionalArrayAggregateType|) ((parents :initform '(|Logic| |OneDimensionalArrayAggregate|)) (name :initform "BitAggregate") @@ -8401,7 +9102,7 @@ Value = NIL (comment :initform (list "The bit aggregate category models aggregates representing large" "quantities of Boolean data.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8415,10 +9116,10 @@ Value = NIL \end{chunk} \subsection{FiniteSetAggregate} -\index{FiniteSetAggregate!Category} -\index{Category!FiniteSetAggregate} -\index{FSAGG} -\begin{chunk}{sane} +\index[cat]{FiniteSetAggregate!Category} +\index[cat]{Category!FiniteSetAggregate} +\index[cat]{FSAGG} +\begin{chunk}{defclass FiniteSetAggregateType} (defclass |FiniteSetAggregateType| (|FiniteType| |SetAggregateType| |DictionaryType|) ((parents :initform '(|Finite| |SetAggregate| |Dictionary|)) (name :initform "FiniteSetAggregate") @@ -8430,7 +9131,7 @@ Value = NIL "a collection of elements characterized by membership, but not" "by order or multiplicity." "See Set for an example.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8444,10 +9145,10 @@ Value = NIL \end{chunk} \subsection{KeyedDictionary} -\index{KeyedDictionary!Category} -\index{Category!KeyedDictionary} -\index{KDAGG} -\begin{chunk}{sane} +\index[cat]{KeyedDictionary!Category} +\index[cat]{Category!KeyedDictionary} +\index[cat]{KDAGG} +\begin{chunk}{defclass KeyedDictionaryType} (defclass |KeyedDictionaryType| (|DictionaryType|) ((parents :initform '(|Dictionary|)) (name :initform "KeyedDictionary") @@ -8457,7 +9158,7 @@ Value = NIL (comment :initform (list "A keyed dictionary is a dictionary of key-entry pairs for which there is" "a unique entry for each key.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8471,10 +9172,10 @@ Value = NIL \end{chunk} \subsection{NonAssociativeRing} -\index{NonAssociativeRing!Category} -\index{Category!NonAssociativeRing} -\index{NASRING} -\begin{chunk}{sane} +\index[cat]{NonAssociativeRing!Category} +\index[cat]{Category!NonAssociativeRing} +\index[cat]{NASRING} +\begin{chunk}{defclass NonAssociativeRingType} (defclass |NonAssociativeRingType| (|MonadWithUnitType| |NonAssociativeRngType|) ((parents :initform '(|MonadWithUnit| |NonAssociativeRng|)) (name :initform "NonAssociativeRing") @@ -8484,7 +9185,7 @@ Value = NIL (comment :initform (list "A NonAssociativeRing is a non associative rng which has a unit," "the multiplication is not necessarily commutative or associative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8498,10 +9199,10 @@ Value = NIL \end{chunk} \subsection{NormalizedTriangularSetCategory} -\index{NormalizedTriangularSetCategory!Category} -\index{Category!NormalizedTriangularSetCategory} -\index{NTSCAT} -\begin{chunk}{sane} +\index[cat]{NormalizedTriangularSetCategory!Category} +\index[cat]{Category!NormalizedTriangularSetCategory} +\index[cat]{NTSCAT} +\begin{chunk}{defclass NormalizedTriangularSetCategoryType} (defclass |NormalizedTriangularSetCategoryType| (|RegularTriangularSetCategoryType|) ((parents :initform '(|RegularTriangularSetCategory|)) (name :initform "NormalizedTriangularSetCategory") @@ -8517,7 +9218,7 @@ Value = NIL "polynomial q if p is constant or degree(p,mdeg(q)) = 0" "and init(p) is normalized w.r.t. q. One of the important" "features of normalized triangular sets is that they are regular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8531,10 +9232,10 @@ Value = NIL \end{chunk} \subsection{OrderedMultisetAggregate} -\index{OrderedMultisetAggregate!Category} -\index{Category!OrderedMultisetAggregate} -\index{OMSAGG} -\begin{chunk}{sane} +\index[cat]{OrderedMultisetAggregate!Category} +\index[cat]{Category!OrderedMultisetAggregate} +\index[cat]{OMSAGG} +\begin{chunk}{defclass OrderedMultisetAggregateType} (defclass |OrderedMultisetAggregateType| (|MultisetAggregateType| |PriorityQueueAggregateType|) ((parents :initform '(|MultisetAggregate| |PriorityQueueAggregate|)) (name :initform "OrderedMultisetAggregate") @@ -8545,7 +9246,7 @@ Value = NIL "An ordered-multiset aggregate is a multiset built over an ordered set S" "so that the relative sizes of its entries can be assessed." "These aggregates serve as models for priority queues.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8559,10 +9260,10 @@ Value = NIL \end{chunk} \subsection{Ring} -\index{Ring!Category} -\index{Category!Ring} -\index{RING} -\begin{chunk}{sane} +\index[cat]{Ring!Category} +\index[cat]{Category!Ring} +\index[cat]{RING} +\begin{chunk}{defclass RingType} (defclass |RingType| (|MonoidType| |LeftModuleType| |RngType|) ((parents :initform '(|Monoid| |LeftModule| |Rng|)) (name :initform "Ring") @@ -8572,7 +9273,7 @@ Value = NIL (comment :initform (list "The category of rings with unity, always associative, but" "not necessarily commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8586,10 +9287,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeRegularTriangularSetCategory} -\index{SquareFreeRegularTriangularSetCategory!Category} -\index{Category!SquareFreeRegularTriangularSetCategory} -\index{SFRTCAT} -\begin{chunk}{sane} +\index[cat]{SquareFreeRegularTriangularSetCategory!Category} +\index[cat]{Category!SquareFreeRegularTriangularSetCategory} +\index[cat]{SFRTCAT} +\begin{chunk}{defclass SquareFreeRegularTriangularSetCategoryType} (defclass |SquareFreeRegularTriangularSetCategoryType| (|RegularTriangularSetCategoryType|) ((parents :initform '(|RegularTriangularSetCategory|)) (name :initform "SquareFreeRegularTriangularSetCategory") @@ -8603,7 +9304,7 @@ Value = NIL "differentiate(p,mvar(p)) w.r.t. collectUnder(ts,mvar(p))" "has degree zero w.r.t. mvar(p). Thus any square-free regular" "set defines a tower of square-free simple extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8617,10 +9318,10 @@ Value = NIL \end{chunk} \subsection{StringAggregate} -\index{StringAggregate!Category} -\index{Category!StringAggregate} -\index{SRAGG} -\begin{chunk}{sane} +\index[cat]{StringAggregate!Category} +\index[cat]{Category!StringAggregate} +\index[cat]{SRAGG} +\begin{chunk}{defclass StringAggregateType} (defclass |StringAggregateType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "StringAggregate") @@ -8630,7 +9331,7 @@ Value = NIL (comment :initform (list "A string aggregate is a category for strings, that is," "one dimensional arrays of characters.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8644,10 +9345,10 @@ Value = NIL \end{chunk} \subsection{VectorCategory} -\index{VectorCategory!Category} -\index{Category!VectorCategory} -\index{VECTCAT} -\begin{chunk}{sane} +\index[cat]{VectorCategory!Category} +\index[cat]{Category!VectorCategory} +\index[cat]{VECTCAT} +\begin{chunk}{defclass |VectorCategoryType} (defclass |VectorCategoryType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "VectorCategory") @@ -8661,7 +9362,7 @@ Value = NIL "of the underlying components. Many operations from the component domain" "are defined for vectors componentwise. It can by assumed that extraction or" "updating components can be done in constant time.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8676,7 +9377,7 @@ Value = NIL \section{Level 9} -\begin{chunk}{sane} +\begin{chunk}{defvar level9} (defvar level9 '(|CharacteristicNonZero| |CharacteristicZero| |CommutativeRing| |DifferentialRing| |EntireRing| |LeftAlgebra| |LinearlyExplicitRingOver| @@ -8686,10 +9387,10 @@ Value = NIL \end{chunk} \subsection{CharacteristicNonZero} -\index{CharacteristicNonZero!Category} -\index{Category!CharacteristicNonZero} -\index{CHARNZ} -\begin{chunk}{sane} +\index[cat]{CharacteristicNonZero!Category} +\index[cat]{Category!CharacteristicNonZero} +\index[cat]{CHARNZ} +\begin{chunk}{defclass CharacteristicNonZeroType} (defclass |CharacteristicNonZeroType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "CharacteristicNonZero") @@ -8698,7 +9399,7 @@ Value = NIL (abbreviation :initform 'CHARNZ) (comment :initform (list "Rings of Characteristic Non Zero")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8712,10 +9413,10 @@ Value = NIL \end{chunk} \subsection{CharacteristicZero} -\index{CharacteristicZero!Category} -\index{Category!CharacteristicZero} -\index{CHARZ} -\begin{chunk}{sane} +\index[cat]{CharacteristicZero!Category} +\index[cat]{Category!CharacteristicZero} +\index[cat]{CHARZ} +\begin{chunk}{defclass CharacteristicZeroType} (defclass |CharacteristicZeroType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "CharacteristicZero") @@ -8724,7 +9425,7 @@ Value = NIL (abbreviation :initform 'CHARZ) (comment :initform (list "Rings of Characteristic Zero.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8738,10 +9439,10 @@ Value = NIL \end{chunk} \subsection{CommutativeRing} -\index{CommutativeRing!Category} -\index{Category!CommutativeRing} -\index{COMRING} -\begin{chunk}{sane} +\index[cat]{CommutativeRing!Category} +\index[cat]{Category!CommutativeRing} +\index[cat]{COMRING} +\begin{chunk}{defclass CommutativeRingType} (defclass |CommutativeRingType| (|RingType| |BiModuleType|) ((parents :initform '(|Ring| |BiModule|)) (name :initform "CommutativeRing") @@ -8752,7 +9453,7 @@ Value = NIL "The category of commutative rings with unity, rings where" "* is commutative, and which have a multiplicative identity" "element.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8766,10 +9467,10 @@ Value = NIL \end{chunk} \subsection{DifferentialRing} -\index{DifferentialRing!Category} -\index{Category!DifferentialRing} -\index{DIFRING} -\begin{chunk}{sane} +\index[cat]{DifferentialRing!Category} +\index[cat]{Category!DifferentialRing} +\index[cat]{DIFRING} +\begin{chunk}{defclass DifferentialRingType} (defclass |DifferentialRingType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "DifferentialRing") @@ -8779,7 +9480,7 @@ Value = NIL (comment :initform (list "An ordinary differential ring, that is, a ring with an operation" "differentiate.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8793,10 +9494,10 @@ Value = NIL \end{chunk} \subsection{EntireRing} -\index{EntireRing!Category} -\index{Category!EntireRing} -\index{ENTIRER} -\begin{chunk}{sane} +\index[cat]{EntireRing!Category} +\index[cat]{Category!EntireRing} +\index[cat]{ENTIRER} +\begin{chunk}{defclass EntireRingType} (defclass |EntireRingType| (|RingType| |BiModuleType|) ((parents :initform '(|Ring| |BiModule|)) (name :initform "EntireRing") @@ -8806,7 +9507,7 @@ Value = NIL (comment :initform (list "Entire Rings (non-commutative Integral Domains), a ring" "not necessarily commutative which has no zero divisors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8820,10 +9521,10 @@ Value = NIL \end{chunk} \subsection{LeftAlgebra} -\index{LeftAlgebra!Category} -\index{Category!LeftAlgebra} -\index{LALG} -\begin{chunk}{sane} +\index[cat]{LeftAlgebra!Category} +\index[cat]{Category!LeftAlgebra} +\index[cat]{LALG} +\begin{chunk}{defclass LeftAlgebraType} (defclass |LeftAlgebraType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "LeftAlgebra") @@ -8832,7 +9533,7 @@ Value = NIL (abbreviation :initform 'LALG) (comment :initform (list "The category of all left algebras over an arbitrary ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8846,10 +9547,10 @@ Value = NIL \end{chunk} \subsection{LinearlyExplicitRingOver} -\index{LinearlyExplicitRingOver!Category} -\index{Category!LinearlyExplicitRingOver} -\index{LINEXP} -\begin{chunk}{sane} +\index[cat]{LinearlyExplicitRingOver!Category} +\index[cat]{Category!LinearlyExplicitRingOver} +\index[cat]{LINEXP} +\begin{chunk}{defclass LinearlyExplicitRingOverType} (defclass |LinearlyExplicitRingOverType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "LinearlyExplicitRingOver") @@ -8858,7 +9559,7 @@ Value = NIL (abbreviation :initform 'LINEXP) (comment :initform (list "An extension ring with an explicit linear dependence test.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8872,10 +9573,10 @@ Value = NIL \end{chunk} \subsection{Module} -\index{Module!Category} -\index{Category!Module} -\index{MODULE} -\begin{chunk}{sane} +\index[cat]{Module!Category} +\index[cat]{Category!Module} +\index[cat]{MODULE} +\begin{chunk}{defclass ModuleType} (defclass |ModuleType| (|BiModuleType|) ((parents :initform '(|BiModule|)) (name :initform "Module") @@ -8884,7 +9585,7 @@ Value = NIL (abbreviation :initform 'MODULE) (comment :initform (list "The category of modules over a commutative ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8898,10 +9599,10 @@ Value = NIL \end{chunk} \subsection{OrderedRing} -\index{OrderedRing!Category} -\index{Category!OrderedRing} -\index{ORDRING} -\begin{chunk}{sane} +\index[cat]{OrderedRing!Category} +\index[cat]{Category!OrderedRing} +\index[cat]{ORDRING} +\begin{chunk}{defclass OrderedRingType} (defclass |OrderedRingType| (|OrderedAbelianGroupType| |RingType|) ((parents :initform '(|OrderedAbelianGroup| |Ring|)) (name :initform "OrderedRing") @@ -8911,7 +9612,7 @@ Value = NIL (comment :initform (list "Ordered sets which are also rings, that is, domains where the ring" "operations are compatible with the ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8925,10 +9626,10 @@ Value = NIL \end{chunk} \subsection{PartialDifferentialRing} -\index{PartialDifferentialRing!Category} -\index{Category!PartialDifferentialRing} -\index{PDRING} -\begin{chunk}{sane} +\index[cat]{PartialDifferentialRing!Category} +\index[cat]{Category!PartialDifferentialRing} +\index[cat]{PDRING} +\begin{chunk}{defclass PartialDifferentialRingType} (defclass |PartialDifferentialRingType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "PartialDifferentialRing") @@ -8938,7 +9639,7 @@ Value = NIL (comment :initform (list "A partial differential ring with differentiations indexed by a" "parameter type S.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8952,10 +9653,10 @@ Value = NIL \end{chunk} \subsection{PointCategory} -\index{PointCategory!Category} -\index{Category!PointCategory} -\index{PTCAT} -\begin{chunk}{sane} +\index[cat]{PointCategory!Category} +\index[cat]{Category!PointCategory} +\index[cat]{PTCAT} +\begin{chunk}{defclass PointCategoryType} (defclass |PointCategoryType| (|VectorCategoryType|) ((parents :initform '(|VectorCategory|)) (name :initform "PointCategory") @@ -8966,7 +9667,7 @@ Value = NIL "PointCategory is the category of points in space which" "may be plotted via the graphics facilities. Functions are provided for" "defining points and handling elements of points.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -8980,10 +9681,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeNormalizedTriangularSetCategory} -\index{SquareFreeNormalizedTriangularSetCategory!Category} -\index{Category!SquareFreeNormalizedTriangularSetCategory} -\index{SNTSCAT} -\begin{chunk}{sane} +\index[cat]{SquareFreeNormalizedTriangularSetCategory!Category} +\index[cat]{Category!SquareFreeNormalizedTriangularSetCategory} +\index[cat]{SNTSCAT} +\begin{chunk}{defclass SquareFreeNormalizedTriangularSetCategoryType} (defclass |SquareFreeNormalizedTriangularSetCategoryType| (|NormalizedTriangularSetCategoryType| |SquareFreeRegularTriangularSetCategoryType|) ((parents :initform '(|NormalizedTriangularSetCategory| |SquareFreeRegularTriangularSetCategory|)) @@ -8995,7 +9696,7 @@ Value = NIL "The category of square-free and normalized triangular sets." "Thus, up to the primitivity axiom of [1], these sets are Lazard" "triangular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9009,10 +9710,10 @@ Value = NIL \end{chunk} \subsection{StringCategory} -\index{StringCategory!Category} -\index{Category!StringCategory} -\index{STRICAT} -\begin{chunk}{sane} +\index[cat]{StringCategory!Category} +\index[cat]{Category!StringCategory} +\index[cat]{STRICAT} +\begin{chunk}{defclass StringCategoryType} (defclass |StringCategoryType| (|OpenMathType| |StringAggregateType|) ((parents :initform '(|OpenMath| |StringAggregate|)) (name :initform "StringCategory") @@ -9021,7 +9722,7 @@ Value = NIL (abbreviation :initform 'STRICAT) (comment :initform (list "A category for string-like objects")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9035,10 +9736,10 @@ Value = NIL \end{chunk} \subsection{TableAggregate} -\index{TableAggregate!Category} -\index{Category!TableAggregate} -\index{TBAGG} -\begin{chunk}{sane} +\index[cat]{TableAggregate!Category} +\index[cat]{Category!TableAggregate} +\index[cat]{TBAGG} +\begin{chunk}{defclass TableAggregateType} (defclass |TableAggregateType| (|KeyedDictionaryType| |IndexedAggregateType|) ((parents :initform '(|KeyedDictionary| |IndexedAggregate|)) (name :initform "TableAggregate") @@ -9048,7 +9749,7 @@ Value = NIL (comment :initform (list "A table aggregate is a model of a table, that is, a discrete many-to-one" "mapping from keys to entries.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9063,7 +9764,7 @@ Value = NIL \section{Level 10} -\begin{chunk}{sane} +\begin{chunk}{defvar level10} (defvar level10 '(|Algebra| |AssociationListAggregate| |DifferentialExtension| |DivisorCategory| |FreeModuleCat| |FullyLinearlyExplicitRingOver| |LeftOreRing| |LieAlgebra| @@ -9072,10 +9773,10 @@ Value = NIL \end{chunk} \subsection{Algebra} -\index{Algebra!Category} -\index{Category!Algebra} -\index{ALGEBRA} -\begin{chunk}{sane} +\index[cat]{Algebra!Category} +\index[cat]{Category!Algebra} +\index[cat]{ALGEBRA} +\begin{chunk}{defclass AlgebraType} (defclass |AlgebraType| (|RingType| |ModuleType|) ((parents :initform '(|Ring| |Module|)) (name :initform "Algebra") @@ -9084,7 +9785,7 @@ Value = NIL (abbreviation :initform 'ALGEBRA) (comment :initform (list "The category of associative algebras (modules which are themselves rings).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9098,10 +9799,10 @@ Value = NIL \end{chunk} \subsection{AssociationListAggregate} -\index{AssociationListAggregate!Category} -\index{Category!AssociationListAggregate} -\index{ALAGG} -\begin{chunk}{sane} +\index[cat]{AssociationListAggregate!Category} +\index[cat]{Category!AssociationListAggregate} +\index[cat]{ALAGG} +\begin{chunk}{defclass AssociationListAggregateType} (defclass |AssociationListAggregateType| (|ListAggregateType| |TableAggregateType|) ((parents :initform '(|ListAggregate| |TableAggregate|)) (name :initform "AssociationListAggregate") @@ -9112,7 +9813,7 @@ Value = 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9126,10 +9827,10 @@ Value = NIL \end{chunk} \subsection{DifferentialExtension} -\index{DifferentialExtension!Category} -\index{Category!DifferentialExtension} -\index{DIFEXT} -\begin{chunk}{sane} +\index[cat]{DifferentialExtension!Category} +\index[cat]{Category!DifferentialExtension} +\index[cat]{DIFEXT} +\begin{chunk}{defclass DifferentialExtensionType} (defclass |DifferentialExtensionType| (|DifferentialRingType| |PartialDifferentialRingType|) ((parents :initform '(|DifferentialRing| |PartialDifferentialRing|)) (name :initform "DifferentialExtension") @@ -9139,7 +9840,7 @@ Value = NIL (comment :initform (list "Differential extensions of a ring R." "Given a differentiation on R, extend it to a differentiation on %.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9153,10 +9854,10 @@ Value = NIL \end{chunk} \subsection{DivisorCategory} -\index{DivisorCategory!Category} -\index{Category!DivisorCategory} -\index{DIVCAT} -\begin{chunk}{sane} +\index[cat]{DivisorCategory!Category} +\index[cat]{Category!DivisorCategory} +\index[cat]{DIVCAT} +\begin{chunk}{defclass DivisorCategoryType} (defclass |DivisorCategoryType| (|FreeAbelianMonoidCategoryType| |ModuleType|) ((parents :initform '(|FreeAbelianMonoidCategory| |Module|)) (name :initform "DivisorCategory") @@ -9165,7 +9866,7 @@ Value = NIL (abbreviation :initform 'DIVCAT) (comment :initform (list "This category exports the function for domains ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9179,10 +9880,10 @@ Value = NIL \end{chunk} \subsection{FreeModuleCat} -\index{FreeModuleCat!Category} -\index{Category!FreeModuleCat} -\index{FMCAT} -\begin{chunk}{sane} +\index[cat]{FreeModuleCat!Category} +\index[cat]{Category!FreeModuleCat} +\index[cat]{FMCAT} +\begin{chunk}{defclass FreeModuleCatType} (defclass |FreeModuleCatType| (|RetractableToType| |ModuleType|) ((parents :initform '(|RetractableTo| |Module|)) (name :initform "FreeModuleCat") @@ -9200,7 +9901,7 @@ Value = NIL "See the XDistributedPolynomial constructor" "for examples of domains built with the FreeModuleCat" "category constructor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9214,10 +9915,10 @@ Value = NIL \end{chunk} \subsection{FullyLinearlyExplicitRingOver} -\index{FullyLinearlyExplicitRingOver!Category} -\index{Category!FullyLinearlyExplicitRingOver} -\index{FLINEXP} -\begin{chunk}{sane} +\index[cat]{FullyLinearlyExplicitRingOver!Category} +\index[cat]{Category!FullyLinearlyExplicitRingOver} +\index[cat]{FLINEXP} +\begin{chunk}{defclass FullyLinearlyExplicitRingOverType} (defclass |FullyLinearlyExplicitRingOverType| (|LinearlyExplicitRingOverType|) ((parents :initform '(|LinearlyExplicitRingOver|)) (name :initform "FullyLinearlyExplicitRingOver") @@ -9228,7 +9929,7 @@ Value = NIL "S is FullyLinearlyExplicitRingOver R means that S is a" "LinearlyExplicitRingOver R and, in addition, if R is a" "LinearlyExplicitRingOver Integer, then so is S")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9242,10 +9943,10 @@ Value = NIL \end{chunk} \subsection{LeftOreRing} -\index{LeftOreRing!Category} -\index{Category!LeftOreRing} -\index{LORER} -\begin{chunk}{sane} +\index[cat]{LeftOreRing!Category} +\index[cat]{Category!LeftOreRing} +\index[cat]{LORER} +\begin{chunk}{defclass LeftOreRingType} (defclass |LeftOreRingType| (|EntireRingType|) ((parents :initform '(|EntireRing|)) (name :initform "LeftOreRing") @@ -9256,7 +9957,7 @@ Value = NIL "This is the category of left ore rings, that is noncommutative" "rings without zero divisors where we can compute the least left" "common multiple.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9270,10 +9971,10 @@ Value = NIL \end{chunk} \subsection{LieAlgebra} -\index{LieAlgebra!Category} -\index{Category!LieAlgebra} -\index{LIECAT} -\begin{chunk}{sane} +\index[cat]{LieAlgebra!Category} +\index[cat]{Category!LieAlgebra} +\index[cat]{LIECAT} +\begin{chunk}{defclass LieAlgebraType} (defclass |LieAlgebraType| (|ModuleType|) ((parents :initform '(|Module|)) (name :initform "LieAlgebra") @@ -9284,7 +9985,7 @@ Value = NIL "The category of Lie Algebras." "It is used by the domains of non-commutative algebra," "LiePolynomial and XPBWPolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9298,10 +9999,10 @@ Value = NIL \end{chunk} \subsection{NonAssociativeAlgebra} -\index{NonAssociativeAlgebra!Category} -\index{Category!NonAssociativeAlgebra} -\index{NAALG} -\begin{chunk}{sane} +\index[cat]{NonAssociativeAlgebra!Category} +\index[cat]{Category!NonAssociativeAlgebra} +\index[cat]{NAALG} +\begin{chunk}{defclass NonAssociativeAlgebraType} (defclass |NonAssociativeAlgebraType| (|NonAssociativeRngType| |ModuleType|) ((parents :initform '(|NonAssociativeRng| |Module|)) (name :initform "NonAssociativeAlgebra") @@ -9311,7 +10012,7 @@ Value = NIL (comment :initform (list "NonAssociativeAlgebra is the category of non associative algebras" "(modules which are themselves non associative rngs).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9325,10 +10026,10 @@ Value = NIL \end{chunk} \subsection{RectangularMatrixCategory} -\index{RectangularMatrixCategory!Category} -\index{Category!RectangularMatrixCategory} -\index{RMATCAT} -\begin{chunk}{sane} +\index[cat]{RectangularMatrixCategory!Category} +\index[cat]{Category!RectangularMatrixCategory} +\index[cat]{RMATCAT} +\begin{chunk}{defclass RectangularMatrixCategoryType} (defclass |RectangularMatrixCategoryType| (|ModuleType| |HomogeneousAggregateType|) ((parents :initform '(|Module| |HomogeneousAggregate|)) (name :initform "RectangularMatrixCategory") @@ -9339,7 +10040,7 @@ Value = NIL "RectangularMatrixCategory is a category of matrices of fixed" "dimensions. The dimensions of the matrix will be parameters of the" "domain. Domains in this category will be R-modules and will be non-mutable.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9353,10 +10054,10 @@ Value = NIL \end{chunk} \subsection{VectorSpace} -\index{VectorSpace!Category} -\index{Category!VectorSpace} -\index{VSPACE} -\begin{chunk}{sane} +\index[cat]{VectorSpace!Category} +\index[cat]{Category!VectorSpace} +\index[cat]{VSPACE} +\begin{chunk}{defclass VectorSpaceType} (defclass |VectorSpaceType| (|ModuleType|) ((parents :initform '(|Module|)) (name :initform "VectorSpace") @@ -9365,7 +10066,7 @@ Value = NIL (abbreviation :initform 'VSPACE) (comment :initform (list "Vector Spaces (not necessarily finite dimensional) over a field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9380,7 +10081,7 @@ Value = NIL \section{Level 11} -\begin{chunk}{sane} +\begin{chunk}{defvar level11} (defvar level11 '(|DirectProductCategory| |DivisionRing| |FiniteRankAlgebra| |FiniteRankNonAssociativeAlgebra| |FreeLieAlgebra| |IntegralDomain| @@ -9390,10 +10091,10 @@ Value = NIL \end{chunk} \subsection{DirectProductCategory} -\index{DirectProductCategory!Category} -\index{Category!DirectProductCategory} -\index{DIRPCAT} -\begin{chunk}{sane} +\index[cat]{DirectProductCategory!Category} +\index[cat]{Category!DirectProductCategory} +\index[cat]{DIRPCAT} +\begin{chunk}{defclass DirectProductCategoryType} (defclass |DirectProductCategoryType| (|FullyRetractableToType| |FiniteType| |IndexedAggregateType| @@ -9421,7 +10122,7 @@ Value = NIL (comment :initform (list "This category represents a finite cartesian product of a given type." "Many categorical properties are preserved under this construction.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9435,10 +10136,10 @@ Value = NIL \end{chunk} \subsection{DivisionRing} -\index{DivisionRing!Category} -\index{Category!DivisionRing} -\index{DIVRING} -\begin{chunk}{sane} +\index[cat]{DivisionRing!Category} +\index[cat]{Category!DivisionRing} +\index[cat]{DIVRING} +\begin{chunk}{defclass DivisionRingType} (defclass |DivisionRingType| (|AlgebraType| |EntireRingType|) ((parents :initform '(|Algebra| |EntireRing|)) (name :initform "DivisionRing") @@ -9449,7 +10150,7 @@ Value = NIL "A division ring (sometimes called a skew field)," "a not necessarily commutative ring where" "all non-zero elements have multiplicative inverses.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9463,10 +10164,10 @@ Value = NIL \end{chunk} \subsection{FiniteRankAlgebra} -\index{FiniteRankAlgebra!Category} -\index{Category!FiniteRankAlgebra} -\index{FINRALG} -\begin{chunk}{sane} +\index[cat]{FiniteRankAlgebra!Category} +\index[cat]{Category!FiniteRankAlgebra} +\index[cat]{FINRALG} +\begin{chunk}{defclass FiniteRankAlgebraType} (defclass |FiniteRankAlgebraType| (|CharacteristicNonZeroType| |CharacteristicZeroType| |AlgebraType|) ((parents :initform '(|CharacteristicNonZero| |CharacteristicZero| @@ -9478,7 +10179,7 @@ Value = NIL (comment :initform (list "A FiniteRankAlgebra is an algebra over a commutative ring R which" "is a free R-module of finite rank.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9492,10 +10193,10 @@ Value = NIL \end{chunk} \subsection{FiniteRankNonAssociativeAlgebra} -\index{FiniteRankNonAssociativeAlgebra!Category} -\index{Category!FiniteRankNonAssociativeAlgebra} -\index{FINAALG} -\begin{chunk}{sane} +\index[cat]{FiniteRankNonAssociativeAlgebra!Category} +\index[cat]{Category!FiniteRankNonAssociativeAlgebra} +\index[cat]{FINAALG} +\begin{chunk}{defclass FiniteRankNonAssociativeAlgebraType} (defclass |FiniteRankNonAssociativeAlgebraType| (|NonAssociativeAlgebraType|) ((parents :initform '(|NonAssociativeAlgebra|)) (name :initform "FiniteRankNonAssociativeAlgebra") @@ -9505,7 +10206,7 @@ Value = NIL (comment :initform (list "A FiniteRankNonAssociativeAlgebra is a non associative algebra over" "a commutative ring R which is a free R-module of finite rank.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9519,10 +10220,10 @@ Value = NIL \end{chunk} \subsection{FreeLieAlgebra} -\index{FreeLieAlgebra!Category} -\index{Category!FreeLieAlgebra} -\index{FLALG} -\begin{chunk}{sane} +\index[cat]{FreeLieAlgebra!Category} +\index[cat]{Category!FreeLieAlgebra} +\index[cat]{FLALG} +\begin{chunk}{defclass FreeLieAlgebraType} (defclass |FreeLieAlgebraType| (|LieAlgebraType|) ((parents :initform '(|LieAlgebra|)) (name :initform "FreeLieAlgebra") @@ -9533,7 +10234,7 @@ Value = NIL "The category of free Lie algebras." "It is used by domains of non-commutative algebra:" "LiePolynomial and XPBWPolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9547,10 +10248,10 @@ Value = NIL \end{chunk} \subsection{IntegralDomain} -\index{IntegralDomain!Category} -\index{Category!IntegralDomain} -\index{INTDOM} -\begin{chunk}{sane} +\index[cat]{IntegralDomain!Category} +\index[cat]{Category!IntegralDomain} +\index[cat]{INTDOM} +\begin{chunk}{defclass IntegralDomainType} (defclass |IntegralDomainType| (|CommutativeRingType| |AlgebraType| |EntireRingType|) ((parents :initform '(|CommutativeRing| |Algebra| |EntireRing|)) (name :initform "IntegralDomain") @@ -9560,7 +10261,7 @@ Value = NIL (comment :initform (list "The category of commutative integral domains, commutative" "rings with no zero divisors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9574,10 +10275,10 @@ Value = NIL \end{chunk} \subsection{MonogenicLinearOperator} -\index{MonogenicLinearOperator!Category} -\index{Category!MonogenicLinearOperator} -\index{MLO} -\begin{chunk}{sane} +\index[cat]{MonogenicLinearOperator!Category} +\index[cat]{Category!MonogenicLinearOperator} +\index[cat]{MLO} +\begin{chunk}{defclass MonogenicLinearOperatorType} (defclass |MonogenicLinearOperatorType| (|AlgebraType|) ((parents :initform '(|Algebra|)) (name :initform "MonogenicLinearOperator") @@ -9597,7 +10298,7 @@ Value = NIL "Note that multiplication is not necessarily commutative." "In fact, if a is in R, it is quite normal" "to have a*G ^= G*a.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9611,10 +10312,10 @@ Value = NIL \end{chunk} \subsection{OctonionCategory} -\index{OctonionCategory!Category} -\index{Category!OctonionCategory} -\index{OC} -\begin{chunk}{sane} +\index[cat]{OctonionCategory!Category} +\index[cat]{Category!OctonionCategory} +\index[cat]{OC} +\begin{chunk}{defclass OctonionCategoryType} (defclass |OctonionCategoryType| (|ConvertibleToType| |FullyRetractableToType| |FiniteType| @@ -9640,7 +10341,7 @@ Value = NIL "octonions, and eight-dimensional non-associative algebra," "doubling the the quaternions in the same way as doubling" "the Complex numbers to get the quaternions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9654,10 +10355,10 @@ Value = NIL \end{chunk} \subsection{SquareMatrixCategory} -\index{SquareMatrixCategory!Category} -\index{Category!SquareMatrixCategory} -\index{SMATCAT} -\begin{chunk}{sane} +\index[cat]{SquareMatrixCategory!Category} +\index[cat]{Category!SquareMatrixCategory} +\index[cat]{SMATCAT} +\begin{chunk}{defclass SquareMatrixCategoryType} (defclass |SquareMatrixCategoryType| (|FullyRetractableToType| |AlgebraType| |DifferentialExtensionType| |FullyLinearlyExplicitRingOverType| |RectangularMatrixCategoryType|) @@ -9673,7 +10374,7 @@ Value = NIL "allows different representations and indexing schemes. Rows and" "columns may be extracted with rows returned as objects of" "type Row and colums returned as objects of type Col.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9687,10 +10388,10 @@ Value = NIL \end{chunk} \subsection{UnivariateSkewPolynomialCategory} -\index{UnivariateSkewPolynomialCategory!Category} -\index{Category!UnivariateSkewPolynomialCategory} -\index{OREPCAT} -\begin{chunk}{sane} +\index[cat]{UnivariateSkewPolynomialCategory!Category} +\index[cat]{Category!UnivariateSkewPolynomialCategory} +\index[cat]{OREPCAT} +\begin{chunk}{defclass UnivariateSkewPolynomialCategoryType} (defclass |UnivariateSkewPolynomialCategoryType| (|FullyRetractableToType| |AlgebraType|) ((parents :initform '(|FullyRetractableTo| |Algebra|)) (name :initform "UnivariateSkewPolynomialCategory") @@ -9704,7 +10405,7 @@ Value = NIL "This category is an evolution of the types" "MonogenicLinearOperator, OppositeMonogenicLinearOperator, and" "NonCommutativeOperatorDivision")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9718,10 +10419,10 @@ Value = NIL \end{chunk} \subsection{XAlgebra} -\index{XAlgebra!Category} -\index{Category!XAlgebra} -\index{XALG} -\begin{chunk}{sane} +\index[cat]{XAlgebra!Category} +\index[cat]{Category!XAlgebra} +\index[cat]{XALG} +\begin{chunk}{defclass XAlgebraType} (defclass |XAlgebraType| (|AlgebraType|) ((parents :initform '(|Algebra|)) (name :initform "XAlgebra") @@ -9732,7 +10433,7 @@ Value = NIL "This is the category of algebras over non-commutative rings." "It is used by constructors of non-commutative algebras such as" "XPolynomialRing and XFreeAlgebra")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9747,7 +10448,7 @@ Value = NIL \section{Level 12} -\begin{chunk}{sane} +\begin{chunk}{defvar level12} (defvar level12 '(|AbelianMonoidRing| |FortranMachineTypeCategory| |FramedAlgebra| |FramedNonAssociativeAlgebra| |GcdDomain| @@ -9757,10 +10458,10 @@ Value = NIL \end{chunk} \subsection{AbelianMonoidRing} -\index{AbelianMonoidRing!Category} -\index{Category!AbelianMonoidRing} -\index{AMR} -\begin{chunk}{sane} +\index[cat]{AbelianMonoidRing!Category} +\index[cat]{Category!AbelianMonoidRing} +\index[cat]{AMR} +\begin{chunk}{defclass AbelianMonoidRingType} (defclass |AbelianMonoidRingType| (|CharacteristicNonZeroType| |CharacteristicZeroType| |IntegralDomainType|) ((parents :initform '(|CharacteristicNonZero| |CharacteristicZero| |IntegralDomain|)) (name :initform "AbelianMonoidRing") @@ -9777,7 +10478,7 @@ Value = NIL "See 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9791,10 +10492,10 @@ Value = NIL \end{chunk} \subsection{FortranMachineTypeCategory} -\index{FortranMachineTypeCategory!Category} -\index{Category!FortranMachineTypeCategory} -\index{FMTC} -\begin{chunk}{sane} +\index[cat]{FortranMachineTypeCategory!Category} +\index[cat]{Category!FortranMachineTypeCategory} +\index[cat]{FMTC} +\begin{chunk}{defclass FortranMachineTypeCategoryType} (defclass |FortranMachineTypeCategoryType| (|RetractableToType| |OrderedSetType| |IntegralDomainType|) ((parents :initform '(|RetractableTo| |OrderedSet| @@ -9806,7 +10507,7 @@ Value = NIL (comment :initform (list "A category of domains which model machine arithmetic" "used by machines in the AXIOM-NAG link.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9820,10 +10521,10 @@ Value = NIL \end{chunk} \subsection{FramedAlgebra} -\index{FramedAlgebra!Category} -\index{Category!FramedAlgebra} -\index{FRAMALG} -\begin{chunk}{sane} +\index[cat]{FramedAlgebra!Category} +\index[cat]{Category!FramedAlgebra} +\index[cat]{FRAMALG} +\begin{chunk}{defclass FramedAlgebraType} (defclass |FramedAlgebraType| (|FiniteRankAlgebraType|) ((parents :initform '(|FiniteRankAlgebra|)) (name :initform "FramedAlgebra") @@ -9833,7 +10534,7 @@ Value = NIL (comment :initform (list "A FramedAlgebra is a FiniteRankAlgebra together" "with a fixed R-module basis.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9847,10 +10548,10 @@ Value = NIL \end{chunk} \subsection{FramedNonAssociativeAlgebra} -\index{FramedNonAssociativeAlgebra!Category} -\index{Category!FramedNonAssociativeAlgebra} -\index{FRNAALG} -\begin{chunk}{sane} +\index[cat]{FramedNonAssociativeAlgebra!Category} +\index[cat]{Category!FramedNonAssociativeAlgebra} +\index[cat]{FRNAALG} +\begin{chunk}{defclass FramedNonAssociativeAlgebraType} (defclass |FramedNonAssociativeAlgebraType| (|FiniteRankNonAssociativeAlgebraType|) ((parents :initform '(|FiniteRankNonAssociativeAlgebra|)) (name :initform "FramedNonAssociativeAlgebra") @@ -9862,7 +10563,7 @@ Value = NIL "FiniteRankNonAssociativeAlgebra (a non associative" "algebra over R which is a free R-module of finite rank)" "over a commutative ring R together with a fixed R-module basis.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9876,10 +10577,10 @@ Value = NIL \end{chunk} \subsection{GcdDomain} -\index{GcdDomain!Category} -\index{Category!GcdDomain} -\index{GCDDOM} -\begin{chunk}{sane} +\index[cat]{GcdDomain!Category} +\index[cat]{Category!GcdDomain} +\index[cat]{GCDDOM} +\begin{chunk}{defclass GcdDomainType} (defclass |GcdDomainType| (|IntegralDomainType| |LeftOreRingType|) ((parents :initform '(|IntegralDomain| |LeftOreRing|)) (name :initform "GcdDomain") @@ -9892,7 +10593,7 @@ Value = NIL "of the existence of factor operation for factorisation" "into irreducibles. However, if such a factor operation exist," "factorization will be unique up to order and units.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -9998,10 +10699,10 @@ Value = NIL \end{verbatim} \subsection{LinearOrdinaryDifferentialOperatorCategory} -\index{LinearOrdinaryDifferentialOperatorCategory!Category} -\index{Category!LinearOrdinaryDifferentialOperatorCategory} -\index{LODOCAT} -\begin{chunk}{sane} +\index[cat]{LinearOrdinaryDifferentialOperatorCategory!Category} +\index[cat]{Category!LinearOrdinaryDifferentialOperatorCategory} +\index[cat]{LODOCAT} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperatorCategoryType} (defclass |LinearOrdinaryDifferentialOperatorCategoryType| ( |EltableType| |UnivariateSkewPolynomialCategoryType|) ((parents :initform '(|Eltable| |UnivariateSkewPolynomialCategory|)) @@ -10016,7 +10717,7 @@ Value = NIL " " "Multiplication of operators corresponds to functional composition:" " (L1 * L2).(f) = L1 L2 f")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10030,10 +10731,10 @@ Value = NIL \end{chunk} \subsection{OrderedIntegralDomain} -\index{OrderedIntegralDomain!Category} -\index{Category!OrderedIntegralDomain} -\index{OINTDOM} -\begin{chunk}{sane} +\index[cat]{OrderedIntegralDomain!Category} +\index[cat]{Category!OrderedIntegralDomain} +\index[cat]{OINTDOM} +\begin{chunk}{defclass OrderedIntegralDomainType} (defclass |OrderedIntegralDomainType| (|OrderedRingType| |IntegralDomainType|) ((parents :initform '(|OrderedRing| |IntegralDomain|)) (name :initform "OrderedIntegralDomain") @@ -10043,7 +10744,7 @@ Value = NIL (comment :initform (list "The category of ordered commutative integral domains, where ordering" "and the arithmetic operations are compatible")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10057,10 +10758,10 @@ Value = NIL \end{chunk} \subsection{QuaternionCategory} -\index{QuaternionCategory!Category} -\index{Category!QuaternionCategory} -\index{QUATCAT} -\begin{chunk}{sane} +\index[cat]{QuaternionCategory!Category} +\index[cat]{Category!QuaternionCategory} +\index[cat]{QUATCAT} +\begin{chunk}{defclass QuaternionCategoryType} (defclass |QuaternionCategoryType| (|ConvertibleToType| |FullyRetractableToType| |FullyEvalableOverType| @@ -10086,7 +10787,7 @@ Value = NIL (comment :initform (list "QuaternionCategory describes the category of quaternions" "and implements functions that are not representation specific.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10100,10 +10801,10 @@ Value = NIL \end{chunk} \subsection{XFreeAlgebra} -\index{XFreeAlgebra!Category} -\index{Category!XFreeAlgebra} -\index{XFALG} -\begin{chunk}{sane} +\index[cat]{XFreeAlgebra!Category} +\index[cat]{Category!XFreeAlgebra} +\index[cat]{XFALG} +\begin{chunk}{defclass XFreeAlgebraType} (defclass |XFreeAlgebraType| (|RetractableToType| |XAlgebraType|) ((parents :initform '(|RetractableTo| |XAlgebra|)) (name :initform "XFreeAlgebra") @@ -10113,7 +10814,7 @@ Value = NIL (comment :initform (list "This category specifies opeations for polynomials" "and formal series with non-commutative variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10128,7 +10829,7 @@ Value = NIL \section{Level 13} -\begin{chunk}{sane} +\begin{chunk}{defvar level13} (defvar level13 '(|FiniteAbelianMonoidRing| |IntervalCategory| |PowerSeriesCategory| |PrincipalIdealDomain| |UniqueFactorizationDomain| |XPolynomialsCat|)) @@ -10136,10 +10837,10 @@ Value = NIL \end{chunk} \subsection{FiniteAbelianMonoidRing} -\index{FiniteAbelianMonoidRing!Category} -\index{Category!FiniteAbelianMonoidRing} -\index{FAMR} -\begin{chunk}{sane} +\index[cat]{FiniteAbelianMonoidRing!Category} +\index[cat]{Category!FiniteAbelianMonoidRing} +\index[cat]{FAMR} +\begin{chunk}{defclass FiniteAbelianMonoidRingType} (defclass |FiniteAbelianMonoidRingType| (|FullyRetractableToType| |AbelianMonoidRingType|) ((parents :initform '(|FullyRetractableTo| |AbelianMonoidRing|)) (name :initform "FiniteAbelianMonoidRing") @@ -10150,7 +10851,7 @@ Value = NIL "This category is similar to AbelianMonoidRing, except that the sum is" "assumed to be finite. It is a useful model for polynomials," "but is somewhat more general.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10164,10 +10865,10 @@ Value = NIL \end{chunk} \subsection{IntervalCategory} -\index{IntervalCategory!Category} -\index{Category!IntervalCategory} -\index{INTCAT} -\begin{chunk}{sane} +\index[cat]{IntervalCategory!Category} +\index[cat]{Category!IntervalCategory} +\index[cat]{INTCAT} +\begin{chunk}{defclass IntervalCategoryType} (defclass |IntervalCategoryType| (|RadicalCategoryType| |RetractableToType| |TranscendentalFunctionCategoryType| |OrderedSetType| |GcdDomainType|) @@ -10181,7 +10882,7 @@ Value = NIL (comment :initform (list "This category implements of interval arithmetic and transcendental" "functions over intervals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10195,10 +10896,10 @@ Value = NIL \end{chunk} \subsection{PowerSeriesCategory} -\index{PowerSeriesCategory!Category} -\index{Category!PowerSeriesCategory} -\index{PSCAT} -\begin{chunk}{sane} +\index[cat]{PowerSeriesCategory!Category} +\index[cat]{Category!PowerSeriesCategory} +\index[cat]{PSCAT} +\begin{chunk}{defclass PowerSeriesCategoryType} (defclass |PowerSeriesCategoryType| (|AbelianMonoidRingType|) ((parents :initform '(|AbelianMonoidRing|)) (name :initform "PowerSeriesCategory") @@ -10208,7 +10909,7 @@ Value = NIL (comment :initform (list "PowerSeriesCategory is the most general power series" "category with exponents in an ordered abelian monoid.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10222,10 +10923,10 @@ Value = NIL \end{chunk} \subsection{PrincipalIdealDomain} -\index{PrincipalIdealDomain!Category} -\index{Category!PrincipalIdealDomain} -\index{PID} -\begin{chunk}{sane} +\index[cat]{PrincipalIdealDomain!Category} +\index[cat]{Category!PrincipalIdealDomain} +\index[cat]{PID} +\begin{chunk}{defclass PrincipalIdealDomainType} (defclass |PrincipalIdealDomainType| (|GcdDomainType|) ((parents :initform '(|GcdDomain|)) (name :initform "PrincipalIdealDomain") @@ -10239,7 +10940,7 @@ Value = NIL "Note that this constructive definition only implies that" "finitely generated ideals are principal. It is not clear" "what we would mean by an infinitely generated ideal.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10253,10 +10954,10 @@ Value = NIL \end{chunk} \subsection{UniqueFactorizationDomain} -\index{UniqueFactorizationDomain!Category} -\index{Category!UniqueFactorizationDomain} -\index{UFD} -\begin{chunk}{sane} +\index[cat]{UniqueFactorizationDomain!Category} +\index[cat]{Category!UniqueFactorizationDomain} +\index[cat]{UFD} +\begin{chunk}{defclass UniqueFactorizationDomainType} (defclass |UniqueFactorizationDomainType| (|GcdDomainType|) ((parents :initform '(|GcdDomain|)) (name :initform "UniqueFactorizationDomain") @@ -10267,7 +10968,7 @@ Value = NIL "A constructive unique factorization domain, where" "we can constructively factor members into a product of" "a finite number of irreducible elements.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10281,10 +10982,10 @@ Value = NIL \end{chunk} \subsection{XPolynomialsCat} -\index{XPolynomialsCat!Category} -\index{Category!XPolynomialsCat} -\index{XPOLYC} -\begin{chunk}{sane} +\index[cat]{XPolynomialsCat!Category} +\index[cat]{Category!XPolynomialsCat} +\index[cat]{XPOLYC} +\begin{chunk}{defclass XPolynomialsCatType} (defclass |XPolynomialsCatType| (|XFreeAlgebraType|) ((parents :initform '(|XFreeAlgebra|)) (name :initform "XPolynomialsCat") @@ -10295,7 +10996,7 @@ Value = NIL "The Category of polynomial rings with non-commutative variables." "The coefficient ring may be non-commutative too." "However coefficients commute with variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10310,7 +11011,7 @@ Value = NIL \section{Level 14} -\begin{chunk}{sane} +\begin{chunk}{defvar level14} (defvar level14 '(|EuclideanDomain| |MultivariateTaylorSeriesCategory| |PolynomialFactorizationExplicit| |UnivariatePowerSeriesCategory|)) @@ -10318,10 +11019,10 @@ Value = NIL \end{chunk} \subsection{EuclideanDomain} -\index{EuclideanDomain!Category} -\index{Category!EuclideanDomain} -\index{EUCDOM} -\begin{chunk}{sane} +\index[cat]{EuclideanDomain!Category} +\index[cat]{Category!EuclideanDomain} +\index[cat]{EUCDOM} +\begin{chunk}{defclass EuclideanDomainType} (defclass |EuclideanDomainType| (|PrincipalIdealDomainType|) ((parents :initform '(|PrincipalIdealDomain|)) (name :initform "EuclideanDomain") @@ -10332,7 +11033,7 @@ Value = NIL "A constructive euclidean domain, one can divide producing" "a quotient and a remainder where the remainder is either zero" "or is smaller (euclideanSize) than the divisor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10346,10 +11047,10 @@ Value = NIL \end{chunk} \subsection{MultivariateTaylorSeriesCategory} -\index{MultivariateTaylorSeriesCategory!Category} -\index{Category!MultivariateTaylorSeriesCategory} -\index{MTSCAT} -\begin{chunk}{sane} +\index[cat]{MultivariateTaylorSeriesCategory!Category} +\index[cat]{Category!MultivariateTaylorSeriesCategory} +\index[cat]{MTSCAT} +\begin{chunk}{defclass MultivariateTaylorSeriesCategoryType} (defclass |MultivariateTaylorSeriesCategoryType| (|RadicalCategoryType| |EvalableType| |TranscendentalFunctionCategoryType| @@ -10367,7 +11068,7 @@ Value = NIL (comment :initform (list "MultivariateTaylorSeriesCategory is the most general" "multivariate Taylor series category.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10381,10 +11082,10 @@ Value = NIL \end{chunk} \subsection{PolynomialFactorizationExplicit} -\index{PolynomialFactorizationExplicit!Category} -\index{Category!PolynomialFactorizationExplicit} -\index{PFECAT} -\begin{chunk}{sane} +\index[cat]{PolynomialFactorizationExplicit!Category} +\index[cat]{Category!PolynomialFactorizationExplicit} +\index[cat]{PFECAT} +\begin{chunk}{defclass PolynomialFactorizationExplicitType} (defclass |PolynomialFactorizationExplicitType| (|UniqueFactorizationDomainType|) ((parents :initform '(|UniqueFactorizationDomain|)) (name :initform "PolynomialFactorizationExplicit") @@ -10397,7 +11098,7 @@ Value = NIL "This will be used in future releases for supporting factorization" "over finitely generated coefficient fields, it is not yet available" "in the current release of axiom.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10411,10 +11112,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePowerSeriesCategory} -\index{UnivariatePowerSeriesCategory!Category} -\index{Category!UnivariatePowerSeriesCategory} -\index{UPSCAT} -\begin{chunk}{sane} +\index[cat]{UnivariatePowerSeriesCategory!Category} +\index[cat]{Category!UnivariatePowerSeriesCategory} +\index[cat]{UPSCAT} +\begin{chunk}{defclass UnivariatePowerSeriesCategoryType} (defclass |UnivariatePowerSeriesCategoryType| (|EltableType| |PowerSeriesCategoryType| |DifferentialRingType| @@ -10435,7 +11136,7 @@ Value = NIL "possible to multiply exponents." "Also note that this category exports a derivative operation if it is" "possible to multiply coefficients by exponents.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10450,7 +11151,7 @@ Value = NIL \section{Level 15} -\begin{chunk}{sane} +\begin{chunk}{defvar level15} (defvar level15 '(|Field| |IntegerNumberSystem| |PAdicIntegerCategory| |PolynomialCategory| |UnivariateTaylorSeriesCategory|)) @@ -10458,10 +11159,10 @@ Value = NIL \end{chunk} \subsection{Field} -\index{Field!Category} -\index{Category!Field} -\index{FIELD} -\begin{chunk}{sane} +\index[cat]{Field!Category} +\index[cat]{Category!Field} +\index[cat]{FIELD} +\begin{chunk}{defclass FieldType} (defclass |FieldType| (|DivisionRingType| |UniqueFactorizationDomainType| |EuclideanDomainType|) ((parents :initform '(|DivisionRing| |UniqueFactorizationDomain| |EuclideanDomain|)) @@ -10473,7 +11174,7 @@ Value = NIL "The category of commutative fields, commutative rings" "where all non-zero elements have multiplicative inverses." "The factor operation while trivial is useful to have defined.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10487,10 +11188,10 @@ Value = NIL \end{chunk} \subsection{IntegerNumberSystem} -\index{IntegerNumberSystem!Category} -\index{Category!IntegerNumberSystem} -\index{INS} -\begin{chunk}{sane} +\index[cat]{IntegerNumberSystem!Category} +\index[cat]{Category!IntegerNumberSystem} +\index[cat]{INS} +\begin{chunk}{defclass IntegerNumberSystemType} (defclass |IntegerNumberSystemType| (|CombinatorialFunctionCategoryType| |RetractableToType| |RealConstantType| @@ -10519,7 +11220,7 @@ Value = NIL (abbreviation :initform 'INS) (comment :initform (list "An IntegerNumberSystem is a model for the integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10533,10 +11234,10 @@ Value = NIL \end{chunk} \subsection{PAdicIntegerCategory} -\index{PAdicIntegerCategory!Category} -\index{Category!PAdicIntegerCategory} -\index{PADICCT} -\begin{chunk}{sane} +\index[cat]{PAdicIntegerCategory!Category} +\index[cat]{Category!PAdicIntegerCategory} +\index[cat]{PADICCT} +\begin{chunk}{defclass PAdicIntegerCategoryType} (defclass |PAdicIntegerCategoryType| (|CharacteristicZeroType| |EuclideanDomainType|) ((parents :initform '(|CharacteristicZero| |EuclideanDomain|)) (name :initform "PAdicIntegerCategory") @@ -10546,7 +11247,7 @@ Value = NIL (comment :initform (list "This is the category of stream-based representations of" "the p-adic integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10560,10 +11261,10 @@ Value = NIL \end{chunk} \subsection{PolynomialCategory} -\index{PolynomialCategory!Category} -\index{Category!PolynomialCategory} -\index{POLYCAT} -\begin{chunk}{sane} +\index[cat]{PolynomialCategory!Category} +\index[cat]{Category!PolynomialCategory} +\index[cat]{POLYCAT} +\begin{chunk}{defclass PolynomialCategoryType} (defclass |PolynomialCategoryType| (|ConvertibleToType| |EvalableType| |OrderedSetType| @@ -10587,7 +11288,7 @@ Value = NIL (comment :initform (list "The category for general multi-variate polynomials over a ring" "R, in variables from VarSet, with exponents from the OrderedAbelianMonoidSup.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10601,10 +11302,10 @@ Value = NIL \end{chunk} \subsection{UnivariateTaylorSeriesCategory} -\index{UnivariateTaylorSeriesCategory!Category} -\index{Category!UnivariateTaylorSeriesCategory} -\index{UTSCAT} -\begin{chunk}{sane} +\index[cat]{UnivariateTaylorSeriesCategory!Category} +\index[cat]{Category!UnivariateTaylorSeriesCategory} +\index[cat]{UTSCAT} +\begin{chunk}{defclass UnivariateTaylorSeriesCategoryType} (defclass |UnivariateTaylorSeriesCategoryType| (|RadicalCategoryType| |TranscendentalFunctionCategoryType| |UnivariatePowerSeriesCategoryType|) @@ -10618,7 +11319,7 @@ Value = NIL (comment :initform (list "UnivariateTaylorSeriesCategory is the category of Taylor" "series in one variable.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10633,7 +11334,7 @@ Value = NIL \section{Level 16} -\begin{chunk}{sane} +\begin{chunk}{defvar level16} (defvar level16 '(|AlgebraicallyClosedField| |DifferentialPolynomialCategory| |FieldOfPrimeCharacteristic| |FunctionSpace| |LocalPowerSeriesCategory| @@ -10645,10 +11346,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicallyClosedField} -\index{AlgebraicallyClosedField!Category} -\index{Category!AlgebraicallyClosedField} -\index{ACF} -\begin{chunk}{sane} +\index[cat]{AlgebraicallyClosedField!Category} +\index[cat]{Category!AlgebraicallyClosedField} +\index[cat]{ACF} +\begin{chunk}{defclass AlgebraicallyClosedFieldType} (defclass |AlgebraicallyClosedFieldType| (|RadicalCategoryType| |FieldType|) ((parents :initform '(|RadicalCategory| |Field|)) (name :initform "AlgebraicallyClosedField") @@ -10657,7 +11358,7 @@ Value = NIL (abbreviation :initform 'ACF) (comment :initform (list "Model for algebraically closed fields.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10671,10 +11372,10 @@ Value = NIL \end{chunk} \subsection{DifferentialPolynomialCategory} -\index{DifferentialPolynomialCategory!Category} -\index{Category!DifferentialPolynomialCategory} -\index{DPOLCAT} -\begin{chunk}{sane} +\index[cat]{DifferentialPolynomialCategory!Category} +\index[cat]{Category!DifferentialPolynomialCategory} +\index[cat]{DPOLCAT} +\begin{chunk}{defclass DifferentialPolynomialCategoryType} (defclass |DifferentialPolynomialCategoryType| (|DifferentialExtensionType| |PolynomialCategoryType|) ((parents :initform '(|DifferentialExtension| |PolynomialCategory|)) @@ -10707,7 +11408,7 @@ Value = NIL "of the differential indeterminates, and a set E of" "exponents in bijection with the set of differential monomials" "in the given differential indeterminates.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10721,10 +11422,10 @@ Value = NIL \end{chunk} \subsection{FieldOfPrimeCharacteristic} -\index{FieldOfPrimeCharacteristic!Category} -\index{Category!FieldOfPrimeCharacteristic} -\index{FPC} -\begin{chunk}{sane} +\index[cat]{FieldOfPrimeCharacteristic!Category} +\index[cat]{Category!FieldOfPrimeCharacteristic} +\index[cat]{FPC} +\begin{chunk}{defclass FieldOfPrimeCharacteristicType} (defclass |FieldOfPrimeCharacteristicType| (|CharacteristicNonZeroType| |FieldType|) ((parents :initform '(|CharacteristicNonZero| |Field|)) (name :initform "FieldOfPrimeCharacteristic") @@ -10736,7 +11437,7 @@ Value = NIL "characteristic, for example, finite fields, algebraic closures of" "fields of prime characteristic, transcendental extensions of" "of fields of prime characteristic.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10750,10 +11451,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpace} -\index{FunctionSpace!Category} -\index{Category!FunctionSpace} -\index{FS} -\begin{chunk}{sane} +\index[cat]{FunctionSpace!Category} +\index[cat]{Category!FunctionSpace} +\index[cat]{FS} +\begin{chunk}{defclass FunctionSpaceType} (defclass |FunctionSpaceType| (|PatternableType| |FullyRetractableToType| |ExpressionSpaceType| @@ -10780,7 +11481,7 @@ Value = NIL (abbreviation :initform 'FS) (comment :initform (list "A space of formal functions with arguments in an arbitrary ordered set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10794,10 +11495,10 @@ Value = NIL \end{chunk} \subsection{LocalPowerSeriesCategory} -\index{LocalPowerSeriesCategory!Category} -\index{Category!LocalPowerSeriesCategory} -\index{LOCPOWC} -\begin{chunk}{sane} +\index[cat]{LocalPowerSeriesCategory!Category} +\index[cat]{Category!LocalPowerSeriesCategory} +\index[cat]{LOCPOWC} +\begin{chunk}{defclass LocalPowerSeriesCategoryType} (defclass |LocalPowerSeriesCategoryType| (|UnivariatePowerSeriesCategoryType| |FieldType|) ((parents :initform '(|UnivariatePowerSeriesCategory| |Field|)) (name :initform "LocalPowerSeriesCategory") @@ -10805,7 +11506,7 @@ Value = NIL (level :initform 16) (abbreviation :initform 'LOCPOWC) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10819,10 +11520,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfPerfectFieldCategory} -\index{PseudoAlgebraicClosureOfPerfectFieldCategory!Category} -\index{Category!PseudoAlgebraicClosureOfPerfectFieldCategory} -\index{PACPERC} -\begin{chunk}{sane} +\index[cat]{PseudoAlgebraicClosureOfPerfectFieldCategory!Category} +\index[cat]{Category!PseudoAlgebraicClosureOfPerfectFieldCategory} +\index[cat]{PACPERC} +\begin{chunk}{defclass PseudoAlgebraicClosureOfPerfectFieldCategoryType} (defclass |PseudoAlgebraicClosureOfPerfectFieldCategoryType| (|FieldType|) ((parents :initform '(|Field|)) (name :initform "PseudoAlgebraicClosureOfPerfectFieldCategory") @@ -10845,7 +11546,7 @@ Value = NIL "Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are coming from" "a set of related tower extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10859,10 +11560,10 @@ Value = NIL \end{chunk} \subsection{QuotientFieldCategory} -\index{QuotientFieldCategory!Category} -\index{Category!QuotientFieldCategory} -\index{QFCAT} -\begin{chunk}{sane} +\index[cat]{QuotientFieldCategory!Category} +\index[cat]{Category!QuotientFieldCategory} +\index[cat]{QFCAT} +\begin{chunk}{defclass QuotientFieldCategoryType} (defclass |QuotientFieldCategoryType| (|PatternableType| |RetractableToType| |RealConstantType| @@ -10895,7 +11596,7 @@ Value = NIL (abbreviation :initform 'QFCAT) (comment :initform (list "QuotientField(S) is the category of fractions of an Integral Domain S.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10909,10 +11610,10 @@ Value = NIL \end{chunk} \subsection{RealClosedField} -\index{RealClosedField!Category} -\index{Category!RealClosedField} -\index{RCFIELD} -\begin{chunk}{sane} +\index[cat]{RealClosedField!Category} +\index[cat]{Category!RealClosedField} +\index[cat]{RCFIELD} +\begin{chunk}{defclass RealClosedFieldType} (defclass |RealClosedFieldType| (|RadicalCategoryType| |FullyRetractableToType| |CharacteristicZeroType| |OrderedRingType| |FieldType|) @@ -10927,7 +11628,7 @@ Value = NIL "RealClosedField provides common access" "functions for all real closed fields." "provides computations with generic real roots of polynomials")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10941,10 +11642,10 @@ Value = NIL \end{chunk} \subsection{RealNumberSystem} -\index{RealNumberSystem!Category} -\index{Category!RealNumberSystem} -\index{RNS} -\begin{chunk}{sane} +\index[cat]{RealNumberSystem!Category} +\index[cat]{Category!RealNumberSystem} +\index[cat]{RNS} +\begin{chunk}{defclass RealNumberSystemType} (defclass |RealNumberSystemType| (|RadicalCategoryType| |RetractableToType| |RealConstantType| |PatternMatchableType| |CharacteristicZeroType| |OrderedRingType| |FieldType|) @@ -10961,7 +11662,7 @@ Value = NIL "we have purposely not included DifferentialRing or" "the elementary functions (see TranscendentalFunctionCategory)" "in the definition.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -10975,10 +11676,10 @@ Value = NIL \end{chunk} \subsection{RecursivePolynomialCategory} -\index{RecursivePolynomialCategory!Category} -\index{Category!RecursivePolynomialCategory} -\index{RPOLCAT} -\begin{chunk}{sane} +\index[cat]{RecursivePolynomialCategory!Category} +\index[cat]{Category!RecursivePolynomialCategory} +\index[cat]{RPOLCAT} +\begin{chunk}{defclass RecursivePolynomialCategoryType} (defclass |RecursivePolynomialCategoryType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "RecursivePolynomialCategory") @@ -10986,7 +11687,7 @@ Value = NIL (level :initform 16) (abbreviation :initform 'RPOLCAT) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11000,10 +11701,10 @@ Value = NIL \end{chunk} \subsection{UnivariateLaurentSeriesCategory} -\index{UnivariateLaurentSeriesCategory!Category} -\index{Category!UnivariateLaurentSeriesCategory} -\index{ULSCAT} -\begin{chunk}{sane} +\index[cat]{UnivariateLaurentSeriesCategory!Category} +\index[cat]{Category!UnivariateLaurentSeriesCategory} +\index[cat]{ULSCAT} +\begin{chunk}{defclass UnivariateLaurentSeriesCategoryType} (defclass |UnivariateLaurentSeriesCategoryType| (|RadicalCategoryType| |TranscendentalFunctionCategoryType| |UnivariatePowerSeriesCategoryType| @@ -11019,7 +11720,7 @@ Value = NIL (comment :initform (list "UnivariateLaurentSeriesCategory is the category of" "Laurent series in one variable.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11033,10 +11734,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomialCategory} -\index{UnivariatePolynomialCategory!Category} -\index{Category!UnivariatePolynomialCategory} -\index{UPOLYC} -\begin{chunk}{sane} +\index[cat]{UnivariatePolynomialCategory!Category} +\index[cat]{Category!UnivariatePolynomialCategory} +\index[cat]{UPOLYC} +\begin{chunk}{defclass UnivariatePolynomialCategoryType} (defclass |UnivariatePolynomialCategoryType| (|EltableType| |StepThroughType| |DifferentialExtensionType| |EuclideanDomainType| @@ -11053,7 +11754,7 @@ Value = NIL "The category of univariate polynomials over a ring R." "No particular model is assumed - implementations can be either" "sparse or dense.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11067,10 +11768,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePuiseuxSeriesCategory} -\index{UnivariatePuiseuxSeriesCategory!Category} -\index{Category!UnivariatePuiseuxSeriesCategory} -\index{UPXSCAT} -\begin{chunk}{sane} +\index[cat]{UnivariatePuiseuxSeriesCategory!Category} +\index[cat]{Category!UnivariatePuiseuxSeriesCategory} +\index[cat]{UPXSCAT} +\begin{chunk}{defclass UnivariatePuiseuxSeriesCategoryType} (defclass |UnivariatePuiseuxSeriesCategoryType| (|RadicalCategoryType| |TranscendentalFunctionCategoryType| |UnivariatePowerSeriesCategoryType| @@ -11086,7 +11787,7 @@ Value = NIL (comment :initform (list "UnivariatePuiseuxSeriesCategory is the category of Puiseux" "series in one variable.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11101,7 +11802,7 @@ Value = NIL \section{Level 17} -\begin{chunk}{sane} +\begin{chunk}{defvar level17} (defvar level17 '(|AlgebraicallyClosedFunctionSpace| |ExtensionField| |FiniteFieldCategory| |FloatingPointSystem| |UnivariateLaurentSeriesConstructorCategory| @@ -11110,10 +11811,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicallyClosedFunctionSpace} -\index{AlgebraicallyClosedFunctionSpace!Category} -\index{Category!AlgebraicallyClosedFunctionSpace} -\index{ACFS} -\begin{chunk}{sane} +\index[cat]{AlgebraicallyClosedFunctionSpace!Category} +\index[cat]{Category!AlgebraicallyClosedFunctionSpace} +\index[cat]{ACFS} +\begin{chunk}{defclass AlgebraicallyClosedFunctionSpaceType} (defclass |AlgebraicallyClosedFunctionSpaceType| (|AlgebraicallyClosedFieldType| |FunctionSpaceType|) ((parents :initform '(|AlgebraicallyClosedField| |FunctionSpace|)) (name :initform "AlgebraicallyClosedFunctionSpace") @@ -11122,7 +11823,7 @@ Value = NIL (abbreviation :initform 'ACFS) (comment :initform (list "Model for algebraically closed function spaces.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11136,10 +11837,10 @@ Value = NIL \end{chunk} \subsection{ExtensionField} -\index{ExtensionField!Category} -\index{Category!ExtensionField} -\index{XF} -\begin{chunk}{sane} +\index[cat]{ExtensionField!Category} +\index[cat]{Category!ExtensionField} +\index[cat]{XF} +\begin{chunk}{defclass ExtensionFieldType} (defclass |ExtensionFieldType| (|RetractableToType| |CharacteristicZeroType| |VectorSpaceType| @@ -11154,7 +11855,7 @@ Value = NIL (abbreviation :initform 'XF) (comment :initform (list "ExtensionField F is the category of fields which extend the field F")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11168,10 +11869,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldCategory} -\index{FiniteFieldCategory!Category} -\index{Category!FiniteFieldCategory} -\index{FFIELDC} -\begin{chunk}{sane} +\index[cat]{FiniteFieldCategory!Category} +\index[cat]{Category!FiniteFieldCategory} +\index[cat]{FFIELDC} +\begin{chunk}{defclass FiniteFieldCategoryType} (defclass |FiniteFieldCategoryType| (|FiniteType| |StepThroughType| |DifferentialRingType| |FieldOfPrimeCharacteristicType|) @@ -11184,7 +11885,7 @@ Value = NIL (abbreviation :initform 'FFIELDC) (comment :initform (list "FiniteFieldCategory is the category of finite fields")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11198,10 +11899,10 @@ Value = NIL \end{chunk} \subsection{FloatingPointSystem} -\index{FloatingPointSystem!Category} -\index{Category!FloatingPointSystem} -\index{FPS} -\begin{chunk}{sane} +\index[cat]{FloatingPointSystem!Category} +\index[cat]{Category!FloatingPointSystem} +\index[cat]{FPS} +\begin{chunk}{defclass FloatingPointSystemType} (defclass |FloatingPointSystemType| (|RealNumberSystemType|) ((parents :initform '(|RealNumberSystem|)) (name :initform "FloatingPointSystem") @@ -11225,7 +11926,7 @@ Value = NIL "the attributes do not hold. In particular associative('+')" "does not hold. Algorithms defined over a field need special" "considerations when the field is a floating point system.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11239,10 +11940,10 @@ Value = NIL \end{chunk} \subsection{UnivariateLaurentSeriesConstructorCategory} -\index{UnivariateLaurentSeriesConstructorCategory!Category} -\index{Category!UnivariateLaurentSeriesConstructorCategory} -\index{ULSCCAT} -\begin{chunk}{sane} +\index[cat]{UnivariateLaurentSeriesConstructorCategory!Category} +\index[cat]{Category!UnivariateLaurentSeriesConstructorCategory} +\index[cat]{ULSCCAT} +\begin{chunk}{defclass UnivariateLaurentSeriesConstructorCategoryType} (defclass |UnivariateLaurentSeriesConstructorCategoryType| ( |QuotientFieldCategoryType| |UnivariateLaurentSeriesCategoryType|) ((parents :initform '( @@ -11257,7 +11958,7 @@ Value = NIL "[n,f(x)], where n is an arbitrary integer and f(x)" "is a Taylor series. This pair represents the Laurent series" "x**n * f(x).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11271,10 +11972,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePuiseuxSeriesConstructorCategory} -\index{UnivariatePuiseuxSeriesConstructorCategory!Category} -\index{Category!UnivariatePuiseuxSeriesConstructorCategory} -\index{UPXSCCA} -\begin{chunk}{sane} +\index[cat]{UnivariatePuiseuxSeriesConstructorCategory!Category} +\index[cat]{Category!UnivariatePuiseuxSeriesConstructorCategory} +\index[cat]{UPXSCCA} +\begin{chunk}{defclass UnivariatePuiseuxSeriesConstructorCategoryType} (defclass |UnivariatePuiseuxSeriesConstructorCategoryType| (|RetractableToType| |UnivariatePuiseuxSeriesCategoryType|) ((parents :initform '(|RetractableTo| |UnivariatePuiseuxSeriesCategory|)) @@ -11288,7 +11989,7 @@ Value = NIL "by a pair [r,f(x)], where r is a positive rational number and" "f(x) is a Laurent series. This pair represents the Puiseux" "series f(x^r).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11303,7 +12004,7 @@ Value = NIL \section{Level 18} -\begin{chunk}{sane} +\begin{chunk}{defvar level18} (defvar level18 '(|FiniteAlgebraicExtensionField| |MonogenicAlgebra| |PseudoAlgebraicClosureOfFiniteFieldCategory| @@ -11312,10 +12013,10 @@ Value = NIL \end{chunk} \subsection{FiniteAlgebraicExtensionField} -\index{FiniteAlgebraicExtensionField!Category} -\index{Category!FiniteAlgebraicExtensionField} -\index{FAXF} -\begin{chunk}{sane} +\index[cat]{FiniteAlgebraicExtensionField!Category} +\index[cat]{Category!FiniteAlgebraicExtensionField} +\index[cat]{FAXF} +\begin{chunk}{defclass FiniteAlgebraicExtensionFieldType} (defclass |FiniteAlgebraicExtensionFieldType| (|FiniteFieldCategoryType| |ExtensionFieldType|) ((parents :initform '(|FiniteFieldCategory| |ExtensionField|)) (name :initform "FiniteAlgebraicExtensionField") @@ -11346,7 +12047,7 @@ Value = NIL "linearAssociatedExp. These are the functions" "linearAssociatedOrder and linearAssociatedLog," "respectively.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11360,10 +12061,10 @@ Value = NIL \end{chunk} \subsection{MonogenicAlgebra} -\index{MonogenicAlgebra!Category} -\index{Category!MonogenicAlgebra} -\index{MONOGEN} -\begin{chunk}{sane} +\index[cat]{MonogenicAlgebra!Category} +\index[cat]{Category!MonogenicAlgebra} +\index[cat]{MONOGEN} +\begin{chunk}{defclass MonogenicAlgebraType} (defclass |MonogenicAlgebraType| (|ConvertibleToType| |FullyRetractableToType| |DifferentialExtensionType| |FullyLinearlyExplicitRingOverType| @@ -11379,7 +12080,7 @@ Value = NIL (comment :initform (list "A MonogenicAlgebra is an algebra of finite rank which" "can be generated by a single element.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11393,10 +12094,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfFiniteFieldCategory} -\index{PseudoAlgebraicClosureOfFiniteFieldCategory!Category} -\index{Category!PseudoAlgebraicClosureOfFiniteFieldCategory} -\index{PACFFC} -\begin{chunk}{sane} +\index[cat]{PseudoAlgebraicClosureOfFiniteFieldCategory!Category} +\index[cat]{Category!PseudoAlgebraicClosureOfFiniteFieldCategory} +\index[cat]{PACFFC} +\begin{chunk}{defclass PseudoAlgebraicClosureOfFiniteFieldCategoryType} (defclass |PseudoAlgebraicClosureOfFiniteFieldCategoryType| ( |PseudoAlgebraicClosureOfPerfectFieldCategoryType| |FiniteFieldCategoryType|) ((parents :initform '( @@ -11421,7 +12122,7 @@ Value = NIL "(or i=1,2,...,n2). Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11435,10 +12136,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfRationalNumberCategory} -\index{PseudoAlgebraicClosureOfRationalNumberCategory!Category} -\index{Category!PseudoAlgebraicClosureOfRationalNumberCategory} -\index{PACRATC} -\begin{chunk}{sane} +\index[cat]{PseudoAlgebraicClosureOfRationalNumberCategory!Category} +\index[cat]{Category!PseudoAlgebraicClosureOfRationalNumberCategory} +\index[cat]{PACRATC} +\begin{chunk}{defclass PseudoAlgebraicClosureOfRationalNumberCategoryType} (defclass |PseudoAlgebraicClosureOfRationalNumberCategoryType| ( |ExtensionFieldType| |PseudoAlgebraicClosureOfPerfectFieldCategoryType|) ((parents :initform '(|ExtensionField| |PseudoAlgebraicClosureOfPerfectFieldCategory|)) @@ -11462,7 +12163,7 @@ Value = NIL "(or i=1,2,...,n2). Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11477,7 +12178,7 @@ Value = NIL \section{Level 19} -\begin{chunk}{sane} +\begin{chunk}{defvar level19} (defvar level19 '(|ComplexCategory| |FunctionFieldCategory| |PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory|)) @@ -11485,10 +12186,10 @@ Value = NIL \end{chunk} \subsection{ComplexCategory} -\index{ComplexCategory!Category} -\index{Category!ComplexCategory} -\index{COMPCAT} -\begin{chunk}{sane} +\index[cat]{ComplexCategory!Category} +\index[cat]{Category!ComplexCategory} +\index[cat]{COMPCAT} +\begin{chunk}{defclass ComplexCategoryType} (defclass |ComplexCategoryType| (|PatternableType| |RadicalCategoryType| |TranscendentalFunctionCategoryType| |FullyEvalableOverType| |OrderedSetType| @@ -11507,7 +12208,7 @@ Value = NIL (abbreviation :initform 'COMPCAT) (comment :initform (list "This category represents the extension of a ring by a square root of -1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11521,10 +12222,10 @@ Value = NIL \end{chunk} \subsection{FunctionFieldCategory} -\index{FunctionFieldCategory!Category} -\index{Category!FunctionFieldCategory} -\index{FFCAT} -\begin{chunk}{sane} +\index[cat]{FunctionFieldCategory!Category} +\index[cat]{Category!FunctionFieldCategory} +\index[cat]{FFCAT} +\begin{chunk}{defclass FunctionFieldCategoryType} (defclass |FunctionFieldCategoryType| (|MonogenicAlgebraType|) ((parents :initform '(|MonogenicAlgebra|)) (name :initform "FunctionFieldCategory") @@ -11534,7 +12235,7 @@ Value = NIL (comment :initform (list "This category is a model for the function field of a" "plane algebraic curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11548,10 +12249,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory} -\index{PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory!Category} -\index{Category!PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory} -\index{PACEXTC} -\begin{chunk}{sane} +\index[cat]{PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory!Category} +\index[cat]{Category!PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory} +\index[cat]{PACEXTC} +\begin{chunk}{defclass PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategoryType} (defclass |PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategoryType| ( |PseudoAlgebraicClosureOfRationalNumberCategoryType|) ((parents :initform '(|PseudoAlgebraicClosureOfRationalNumberCategory|)) @@ -11574,7 +12275,7 @@ Value = NIL "Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -11739,7 +12440,8 @@ will return the database structure object. Each operation has a property on its symbol name called 'operation which is a list of all of the signatures of operations with that name. -\defstruct{database} +\index[code]{defstruct!database} +\index[code]{database!defstruct} \begin{chunk}{initvars} (defstruct database abbreviation ; interp. @@ -11767,7 +12469,8 @@ which is a list of all of the signatures of operations with that name. \end{chunk} -\defvar{*defaultdomain-list*} +\index[code]{defvar!*defaultdomain-list*} +\index[code]{*defaultdomain-list*!defvar} There are only a small number of domains that have default domains. rather than keep this slot in every domain we maintain a list here. \begin{chunk}{initvars} @@ -11791,13 +12494,13 @@ rather than keep this slot in every domain we maintain a list here. \end{chunk} -\defvar{*operation-hash*} +\index[code]{*operation-hash*} \begin{chunk}{initvars} (defvar *operation-hash* nil "given an operation name, what are its modemaps?") \end{chunk} -\defvar{*hasCategory-hash*} +\index[all]{*hasCategory-hash*} This hash table is used to answer the question``does domain x have category y?''. this is answered by constructing a pair of (x . y) and doing an equal hash into this table. @@ -11806,7 +12509,7 @@ have category y?''. this is answered by constructing a pair of \end{chunk} -\defvar{*miss*} +\index[all]{*miss*} This variable is used for debugging. If a hash table lookup fails and this variable is non-nil then a message is printed. \begin{chunk}{initvars} @@ -12019,10 +12722,10 @@ Value = NIL \section{A} \subsection{AffinePlane} -\index{AffinePlane!Domain} -\index{Domain!AffinePlane} -\index{AFFPL} -\begin{chunk}{sane} +\index[dom]{AffinePlane!Domain} +\index[dom]{Domain!AffinePlane} +\index[dom]{AFFPL} +\begin{chunk}{defclass AffinePlaneType} (defclass |AffinePlaneType| (|AffineSpaceCategoryType|) ((parents :initform '(|AffineSpaceCategory|)) (name :initform "AffinePlane") @@ -12031,7 +12734,7 @@ Value = NIL (comment :initform (list "The following is all the categories and domains related to projective" "space and part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12045,10 +12748,10 @@ Value = NIL \end{chunk} \subsection{AffinePlaneOverPseudoAlgebraicClosureOfFiniteField} -\index{AffinePlaneOverPseudoAlgebraicClosureOfFiniteField!Domain} -\index{Domain!AffinePlaneOverPseudoAlgebraicClosureOfFiniteField} -\index{AFFPLPS} -\begin{chunk}{sane} +\index[dom]{AffinePlaneOverPseudoAlgebraicClosureOfFiniteField!Domain} +\index[dom]{Domain!AffinePlaneOverPseudoAlgebraicClosureOfFiniteField} +\index[dom]{AFFPLPS} +\begin{chunk}{defclass AffinePlaneOverPseudoAlgebraicClosureOfFiniteFieldType} (defclass |AffinePlaneOverPseudoAlgebraicClosureOfFiniteFieldType| (|AffineSpaceCategoryType|) ((parents :initform '(|AffineSpaceCategory|)) (name :initform "AffinePlaneOverPseudoAlgebraicClosureOfFiniteField") @@ -12057,7 +12760,7 @@ Value = NIL (comment :initform (list "The following is all the categories and domains related to projective" "space and part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12071,10 +12774,10 @@ Value = NIL \end{chunk} \subsection{AffineSpace} -\index{AffineSpace!Domain} -\index{Domain!AffineSpace} -\index{AFFSP} -\begin{chunk}{sane} +\index[dom]{AffineSpace!Domain} +\index[dom]{Domain!AffineSpace} +\index[dom]{AFFSP} +\begin{chunk}{defclass AffineSpaceType} (defclass |AffineSpaceType| (|AffineSpaceCategoryType|) ((parents :initform '(|AffineSpaceCategory|)) (name :initform "AffineSpace") @@ -12083,7 +12786,7 @@ Value = NIL (comment :initform (list "The following is all the categories and domains related to projective" "space and part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12097,10 +12800,10 @@ Value = NIL \end{chunk} \subsection{AlgebraGivenByStructuralConstants} -\index{AlgebraGivenByStructuralConstants!Domain} -\index{Domain!AlgebraGivenByStructuralConstants} -\index{ALGSC} -\begin{chunk}{sane} +\index[dom]{AlgebraGivenByStructuralConstants!Domain} +\index[dom]{Domain!AlgebraGivenByStructuralConstants} +\index[dom]{ALGSC} +\begin{chunk}{defclass AlgebraGivenByStructuralConstantsType} (defclass |AlgebraGivenByStructuralConstantsType| (|FramedNonAssociativeAlgebraType|) ((parents :initform '(|FramedNonAssociativeAlgebra|)) (name :initform "AlgebraGivenByStructuralConstants") @@ -12109,7 +12812,7 @@ Value = NIL (comment :initform (list "The following is all the categories and domains related to projective" "space and part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12123,10 +12826,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicFunctionField} -\index{AlgebraicFunctionField!Domain} -\index{Domain!AlgebraicFunctionField} -\index{ALGFF} -\begin{chunk}{sane} +\index[dom]{AlgebraicFunctionField!Domain} +\index[dom]{Domain!AlgebraicFunctionField} +\index[dom]{ALGFF} +\begin{chunk}{defclass AlgebraicFunctionFieldType} (defclass |AlgebraicFunctionFieldType| (|FunctionFieldCategoryType|) ((parents :initform '(|FunctionFieldCategory|)) (name :initform "AlgebraicFunctionField") @@ -12134,7 +12837,7 @@ Value = NIL (abbreviation :initform 'ALGFF) (comment :initform (list "Function field defined by f(x, y) = 0.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12148,10 +12851,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicNumber} -\index{AlgebraicNumber!Domain} -\index{Domain!AlgebraicNumber} -\index{AN} -\begin{chunk}{sane} +\index[dom]{AlgebraicNumber!Domain} +\index[dom]{Domain!AlgebraicNumber} +\index[dom]{AN} +\begin{chunk}{defclass AlgebraicNumberType} (defclass |AlgebraicNumberType| (|AlgebraicallyClosedFieldType| |CharacteristicZeroType| |DifferentialRingType| @@ -12169,7 +12872,7 @@ Value = NIL (abbreviation :initform 'AN) (comment :initform (list "Algebraic closure of the rational numbers, with mathematical =")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12183,10 +12886,10 @@ Value = NIL \end{chunk} \subsection{AnonymousFunction} -\index{AnonymousFunction!Domain} -\index{Domain!AnonymousFunction} -\index{ANON} -\begin{chunk}{sane} +\index[dom]{AnonymousFunction!Domain} +\index[dom]{Domain!AnonymousFunction} +\index[dom]{ANON} +\begin{chunk}{defclass AnonymousFunctionType} (defclass |AnonymousFunctionType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "AnonymousFunction") @@ -12194,7 +12897,7 @@ Value = NIL (abbreviation :initform 'ANON) (comment :initform (list "This domain implements anonymous functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12208,10 +12911,10 @@ Value = NIL \end{chunk} \subsection{AntiSymm} -\index{AntiSymm!Domain} -\index{Domain!AntiSymm} -\index{ANTISYM} -\begin{chunk}{sane} +\index[dom]{AntiSymm!Domain} +\index[dom]{Domain!AntiSymm} +\index[dom]{ANTISYM} +\begin{chunk}{defclass AntiSymmType} (defclass |AntiSymmType| (|RetractableToType| |LeftAlgebraType|) ((parents :initform '(|RetractableTo| |LeftAlgebra|)) (name :initform "AntiSymm") @@ -12219,7 +12922,7 @@ Value = NIL (abbreviation :initform 'ANTISYM) (comment :initform (list "The domain of antisymmetric polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12233,10 +12936,10 @@ Value = NIL \end{chunk} \subsection{Any} -\index{Any!Domain} -\index{Domain!Any} -\index{ANY} -\begin{chunk}{sane} +\index[dom]{Any!Domain} +\index[dom]{Domain!Any} +\index[dom]{ANY} +\begin{chunk}{defclass AnyType} (defclass |AnyType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Any") @@ -12250,7 +12953,7 @@ Value = NIL "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 Any.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12264,10 +12967,10 @@ Value = NIL \end{chunk} \subsection{ArrayStack} -\index{ArrayStack!Domain} -\index{Domain!ArrayStack} -\index{ASTACK} -\begin{chunk}{sane} +\index[dom]{ArrayStack!Domain} +\index[dom]{Domain!ArrayStack} +\index[dom]{ASTACK} +\begin{chunk}{defclass ArrayStackType} (defclass |ArrayStackType| (|StackAggregateType|) ((parents :initform '(|StackAggregate|)) (name :initform "ArrayStack") @@ -12275,7 +12978,7 @@ Value = NIL (abbreviation :initform 'ASTACK) (comment :initform (list "A stack represented as a flexible array.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12289,10 +12992,10 @@ Value = NIL \end{chunk} \subsection{Asp1} -\index{Asp1!Domain} -\index{Domain!Asp1} -\index{Asp1} -\begin{chunk}{sane} +\index[dom]{Asp1!Domain} +\index[dom]{Domain!Asp1} +\index[dom]{Asp1} +\begin{chunk}{defclass Asp1Type} (defclass |Asp1Type| (|FortranFunctionCategoryType|) ((parents :initform '(|FortranFunctionCategory|)) (name :initform "Asp1") @@ -12308,7 +13011,7 @@ Value = NIL " F=DSIN(X)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12322,10 +13025,10 @@ Value = NIL \end{chunk} \subsection{Asp10} -\index{Asp10!Domain} -\index{Domain!Asp10} -\index{ASP10} -\begin{chunk}{sane} +\index[dom]{Asp10!Domain} +\index[dom]{Domain!Asp10} +\index[dom]{ASP10} +\begin{chunk}{defclass Asp10Type} (defclass |Asp10Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp10") @@ -12343,7 +13046,7 @@ Value = NIL " DQDL=1.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12357,10 +13060,10 @@ Value = NIL \end{chunk} \subsection{Asp12} -\index{Asp12!Domain} -\index{Domain!Asp12} -\index{ASP12} -\begin{chunk}{sane} +\index[dom]{Asp12!Domain} +\index[dom]{Domain!Asp12} +\index[dom]{ASP12} +\begin{chunk}{defclass |Asp12Type} (defclass |Asp12Type| (|FortranProgramCategoryType|) ((parents :initform '(|FortranProgramCategory|)) (name :initform "Asp12") @@ -12379,7 +13082,7 @@ Value = NIL " PRINT*,MAXIT,IFLAG,ELAM,(FINFO(I),I=1,4)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12393,10 +13096,10 @@ Value = NIL \end{chunk} \subsection{Asp19} -\index{Asp19!Domain} -\index{Domain!Asp19} -\index{ASP19} -\begin{chunk}{sane} +\index[dom]{Asp19!Domain} +\index[dom]{Domain!Asp19} +\index[dom]{ASP19} +\begin{chunk}{defclass Asp19Type} (defclass |Asp19Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp19") @@ -12509,7 +13212,7 @@ Value = NIL " FJACC(15,3)=-15.0D0/(XC(3)**2+2.0D0*XC(2)*XC(3)+XC(2)**2)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12523,10 +13226,10 @@ Value = NIL \end{chunk} \subsection{Asp20} -\index{Asp20!Domain} -\index{Domain!Asp20} -\index{ASP20} -\begin{chunk}{sane} +\index[dom]{Asp20!Domain} +\index[dom]{Domain!Asp20} +\index[dom]{ASP20} +\begin{chunk}{defclass Asp20Type} (defclass |Asp20Type| (|FortranMatrixFunctionCategoryType|) ((parents :initform '(|FortranMatrixFunctionCategory|)) (name :initform "Asp20") @@ -12547,7 +13250,7 @@ Value = NIL " HX(7)=(-2.0D0*X(7))+(-2.0D0*X(6))" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12561,10 +13264,10 @@ Value = NIL \end{chunk} \subsection{Asp24} -\index{Asp24!Domain} -\index{Domain!Asp24} -\index{ASP24} -\begin{chunk}{sane} +\index[dom]{Asp24!Domain} +\index[dom]{Domain!Asp24} +\index[dom]{ASP24} +\begin{chunk}{defclass Asp24Type} (defclass |Asp24Type| (|FortranFunctionCategoryType|) ((parents :initform '(|FortranFunctionCategory|)) (name :initform "Asp24") @@ -12585,7 +13288,7 @@ Value = NIL " &2)+10.0D0*XC(1)**4+XC(1)**2" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12599,10 +13302,10 @@ Value = NIL \end{chunk} \subsection{Asp27} -\index{Asp27!Domain} -\index{Domain!Asp27} -\index{ASP27} -\begin{chunk}{sane} +\index[dom]{Asp27!Domain} +\index[dom]{Domain!Asp27} +\index[dom]{ASP27} +\begin{chunk}{defclass Asp27Type} (defclass |Asp27Type| (|FortranMatrixCategoryType|) ((parents :initform '(|FortranMatrixCategory|)) (name :initform "Asp27") @@ -12627,7 +13330,7 @@ Value = NIL " &2)+(-0.5D0*W(1)))*Z(2)+((-0.5D0*W(2))+W(1))*Z(1)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12641,10 +13344,10 @@ Value = NIL \end{chunk} \subsection{Asp28} -\index{Asp28!Domain} -\index{Domain!Asp28} -\index{ASP28} -\begin{chunk}{sane} +\index[dom]{Asp28!Domain} +\index[dom]{Domain!Asp28} +\index[dom]{ASP28} +\begin{chunk}{defclass Asp28Type} (defclass |Asp28Type| (|FortranMatrixCategoryType|) ((parents :initform '(|FortranMatrixCategory|)) (name :initform "Asp28") @@ -12785,7 +13488,7 @@ Value = NIL " &Z(1)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12799,10 +13502,10 @@ Value = NIL \end{chunk} \subsection{Asp29} -\index{Asp29!Domain} -\index{Domain!Asp29} -\index{ASP29} -\begin{chunk}{sane} +\index[dom]{Asp29!Domain} +\index[dom]{Domain!Asp29} +\index[dom]{ASP29} +\begin{chunk}{defclass Asp29Type} (defclass |Asp29Type| (|FortranProgramCategoryType|) ((parents :initform '(|FortranProgramCategory|)) (name :initform "Asp29") @@ -12818,7 +13521,7 @@ Value = NIL " CALL F02FJZ(ISTATE,NEXTIT,NEVALS,NEVECS,K,F,D)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12832,10 +13535,10 @@ Value = NIL \end{chunk} \subsection{Asp30} -\index{Asp30!Domain} -\index{Domain!Asp30} -\index{ASP30} -\begin{chunk}{sane} +\index[dom]{Asp30!Domain} +\index[dom]{Domain!Asp30} +\index[dom]{ASP30} +\begin{chunk}{defclass Asp30Type} (defclass |Asp30Type| (|FortranMatrixCategoryType|) ((parents :initform '(|FortranMatrixCategory|)) (name :initform "Asp30") @@ -12882,7 +13585,7 @@ Value = NIL " ENDIF" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12896,10 +13599,10 @@ Value = NIL \end{chunk} \subsection{Asp31} -\index{Asp31!Domain} -\index{Domain!Asp31} -\index{ASP31} -\begin{chunk}{sane} +\index[dom]{Asp31!Domain} +\index[dom]{Domain!Asp31} +\index[dom]{ASP31} +\begin{chunk}{defclass Asp31Type} (defclass |Asp31Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp31") @@ -12923,7 +13626,7 @@ Value = NIL " PW(3,3)=0.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12937,10 +13640,10 @@ Value = NIL \end{chunk} \subsection{Asp33} -\index{Asp33!Domain} -\index{Domain!Asp33} -\index{ASP33} -\begin{chunk}{sane} +\index[dom]{Asp33!Domain} +\index[dom]{Domain!Asp33} +\index[dom]{ASP33} +\begin{chunk}{defclass Asp33Type} (defclass |Asp33Type| (|FortranProgramCategoryType|) ((parents :initform '(|FortranProgramCategory|)) (name :initform "Asp33") @@ -12955,7 +13658,7 @@ Value = NIL " INTEGER JINT" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -12969,10 +13672,10 @@ Value = NIL \end{chunk} \subsection{Asp34} -\index{Asp34!Domain} -\index{Domain!Asp34} -\index{ASP34} -\begin{chunk}{sane} +\index[dom]{Asp34!Domain} +\index[dom]{Domain!Asp34} +\index[dom]{ASP34} +\begin{chunk}{defclass Asp34Type} (defclass |Asp34Type| (|FortranMatrixCategoryType|) ((parents :initform '(|FortranMatrixCategory|)) (name :initform "Asp34") @@ -13000,7 +13703,7 @@ Value = NIL " IFLAG=-IFLAG" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13014,10 +13717,10 @@ Value = NIL \end{chunk} \subsection{Asp35} -\index{Asp35!Domain} -\index{Domain!Asp35} -\index{ASP35} -\begin{chunk}{sane} +\index[dom]{Asp35!Domain} +\index[dom]{Domain!Asp35} +\index[dom]{ASP35} +\begin{chunk}{defclass Asp35Type} (defclass |Asp35Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp35") @@ -13046,7 +13749,7 @@ Value = NIL " FJAC(3,3)=3.0D0" " ENDIF" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13060,10 +13763,10 @@ Value = NIL \end{chunk} \subsection{Asp4} -\index{Asp4!Domain} -\index{Domain!Asp4} -\index{ASP4} -\begin{chunk}{sane} +\index[dom]{Asp4!Domain} +\index[dom]{Domain!Asp4} +\index[dom]{ASP4} +\begin{chunk}{defclass Asp4Type} (defclass |Asp4Type| (|FortranFunctionCategoryType|) ((parents :initform '(|FortranFunctionCategory|)) (name :initform "Asp4") @@ -13080,7 +13783,7 @@ Value = NIL " &X(2)+2.0D0)*X(4)+X(2)**2+2.0D0*X(2)+1.0D0)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13094,10 +13797,10 @@ Value = NIL \end{chunk} \subsection{Asp41} -\index{Asp41!Domain} -\index{Domain!Asp41} -\index{ASP41} -\begin{chunk}{sane} +\index[dom]{Asp41!Domain} +\index[dom]{Domain!Asp41} +\index[dom]{ASP41} +\begin{chunk}{defclass Asp41Type} (defclass |Asp41Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp41") @@ -13139,7 +13842,7 @@ Value = NIL " F(3)=2.0D0*Y(2)**2-2.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13153,10 +13856,10 @@ Value = NIL \end{chunk} \subsection{Asp42} -\index{Asp42!Domain} -\index{Domain!Asp42} -\index{ASP42} -\begin{chunk}{sane} +\index[dom]{Asp42!Domain} +\index[dom]{Domain!Asp42} +\index[dom]{ASP42} +\begin{chunk}{defclass Asp42Type} (defclass |Asp42Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp42") @@ -13208,7 +13911,7 @@ Value = NIL " BCEP(3)=0.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13222,10 +13925,10 @@ Value = NIL \end{chunk} \subsection{Asp49} -\index{Asp49!Domain} -\index{Domain!Asp49} -\index{ASP49} -\begin{chunk}{sane} +\index[dom]{Asp49!Domain} +\index[dom]{Domain!Asp49} +\index[dom]{ASP49} +\begin{chunk}{defclass Asp49Type} (defclass |Asp49Type| (|FortranFunctionCategoryType|) ((parents :initform '(|FortranFunctionCategory|)) (name :initform "Asp49") @@ -13251,7 +13954,7 @@ Value = NIL " OBJGRD(9)=X(4)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13265,10 +13968,10 @@ Value = NIL \end{chunk} \subsection{Asp50} -\index{Asp50!Domain} -\index{Domain!Asp50} -\index{ASP50} -\begin{chunk}{sane} +\index[dom]{Asp50!Domain} +\index[dom]{Domain!Asp50} +\index[dom]{ASP50} +\begin{chunk}{defclass Asp50Type} (defclass |Asp50Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp50") @@ -13312,7 +14015,7 @@ Value = NIL " FVECC(15)=((XC(1)-4.39D0)*XC(3)+(XC(1)-4.39D0)*XC(2)+15.0D0)/(XC(3" " &)+XC(2))" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13326,10 +14029,10 @@ Value = NIL \end{chunk} \subsection{Asp55} -\index{Asp55!Domain} -\index{Domain!Asp55} -\index{ASP55} -\begin{chunk}{sane} +\index[dom]{Asp55!Domain} +\index[dom]{Domain!Asp55} +\index[dom]{ASP55} +\begin{chunk}{defclass Asp55Type} (defclass |Asp55Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp55") @@ -13372,7 +14075,7 @@ Value = NIL " ENDIF" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13386,10 +14089,10 @@ Value = NIL \end{chunk} \subsection{Asp6} -\index{Asp6!Domain} -\index{Domain!Asp6} -\index{ASP6} -\begin{chunk}{sane} +\index[dom]{Asp6!Domain} +\index[dom]{Domain!Asp6} +\index[dom]{ASP6} +\begin{chunk}{defclass Asp6Type} (defclass |Asp6Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp6") @@ -13420,7 +14123,7 @@ Value = NIL " FVEC(9)=(-2.0D0*X(9)**2)+3.0D0*X(9)+(-1.0D0*X(8))+1.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13434,10 +14137,10 @@ Value = NIL \end{chunk} \subsection{Asp7} -\index{Asp7!Domain} -\index{Domain!Asp7} -\index{ASP7} -\begin{chunk}{sane} +\index[dom]{Asp7!Domain} +\index[dom]{Domain!Asp7} +\index[dom]{ASP7} +\begin{chunk}{defclass Asp7Type} (defclass |Asp7Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp7") @@ -13456,7 +14159,7 @@ Value = NIL " F(3)=-0.03199999999999999D0/(X*Z(2)**2)" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13470,10 +14173,10 @@ Value = NIL \end{chunk} \subsection{Asp73} -\index{Asp73!Domain} -\index{Domain!Asp73} -\index{ASP73} -\begin{chunk}{sane} +\index[dom]{Asp73!Domain} +\index[dom]{Domain!Asp73} +\index[dom]{ASP73} +\begin{chunk}{defclass Asp73Type} (defclass |Asp73Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp73") @@ -13494,7 +14197,7 @@ Value = NIL " PSI=Y" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13508,10 +14211,10 @@ Value = NIL \end{chunk} \subsection{Asp74} -\index{Asp74!Domain} -\index{Domain!Asp74} -\index{ASp74} -\begin{chunk}{sane} +\index[dom]{Asp74!Domain} +\index[dom]{Domain!Asp74} +\index[dom]{ASp74} +\begin{chunk}{defclass Asp74Type} (defclass |Asp74Type| (|FortranMatrixFunctionCategoryType|) ((parents :initform '(|FortranMatrixFunctionCategory|)) (name :initform "Asp74") @@ -13542,7 +14245,7 @@ Value = NIL " C=-1.0D0*DSIN(Y)" " ENDIF" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13556,10 +14259,10 @@ Value = NIL \end{chunk} \subsection{Asp77} -\index{Asp77!Domain} -\index{Domain!Asp77} -\index{ASP77} -\begin{chunk}{sane} +\index[dom]{Asp77!Domain} +\index[dom]{Domain!Asp77} +\index[dom]{ASP77} +\begin{chunk}{defclass Asp77Type} (defclass |Asp77Type| (|FortranMatrixFunctionCategoryType|) ((parents :initform '(|FortranMatrixFunctionCategory|)) (name :initform "Asp77") @@ -13578,7 +14281,7 @@ Value = NIL " F(2,2)=-10.0D0" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13592,10 +14295,10 @@ Value = NIL \end{chunk} \subsection{Asp78} -\index{Asp78!Domain} -\index{Domain!Asp78} -\index{ASP78} -\begin{chunk}{sane} +\index[dom]{Asp78!Domain} +\index[dom]{Domain!Asp78} +\index[dom]{ASP78} +\begin{chunk}{defclass Asp78Type} (defclass |Asp78Type| (|FortranVectorFunctionCategoryType|) ((parents :initform '(|FortranVectorFunctionCategory|)) (name :initform "Asp78") @@ -13610,7 +14313,7 @@ Value = NIL " G(1)=0.0D0" " G(2)=0.0D0" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13624,10 +14327,10 @@ Value = NIL \end{chunk} \subsection{Asp8} -\index{Asp8!Domain} -\index{Domain!Asp8} -\index{ASP8} -\begin{chunk}{sane} +\index[dom]{Asp8!Domain} +\index[dom]{Domain!Asp8} +\index[dom]{ASP8} +\begin{chunk}{defclass Asp8Type} (defclass |Asp8Type| (|FortranVectorCategoryType|) ((parents :initform '(|FortranVectorCategory|)) (name :initform "Asp8") @@ -13667,7 +14370,7 @@ Value = NIL " XSOL=POINTS(COUNT)" " ENDIF" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13681,10 +14384,10 @@ Value = NIL \end{chunk} \subsection{Asp80} -\index{Asp80!Domain} -\index{Domain!Asp80} -\index{ASP80} -\begin{chunk}{sane} +\index[dom]{Asp80!Domain} +\index[dom]{Domain!Asp80} +\index[dom]{ASP80} +\begin{chunk}{defclass Asp80Type} (defclass |Asp80Type| (|FortranMatrixFunctionCategoryType|) ((parents :initform '(|FortranMatrixFunctionCategory|)) (name :initform "Asp80") @@ -13702,7 +14405,7 @@ Value = NIL " YR(2)=-1.0D0*DSQRT(XR+(-1.0D0*ELAM))" " RETURN" " END")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13716,10 +14419,10 @@ Value = NIL \end{chunk} \subsection{Asp9} -\index{Asp9!Domain} -\index{Domain!Asp9} -\index{ASP9} -\begin{chunk}{sane} +\index[dom]{Asp9!Domain} +\index[dom]{Domain!Asp9} +\index[dom]{ASP9} +\begin{chunk}{defclass Asp9Type} (defclass |Asp9Type| (|FortranFunctionCategoryType|) ((parents :initform '(|FortranFunctionCategory|)) (name :initform "Asp9") @@ -13739,7 +14442,7 @@ Value = NIL "If the user provides a constant value for G, then extra information is added" "via COMMON blocks used by certain routines. This specifies that the value" "returned by G in this case is to be ignored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13753,10 +14456,10 @@ Value = NIL \end{chunk} \subsection{AssociatedJordanAlgebra} -\index{AssociatedJordanAlgebra!Domain} -\index{Domain!AssociatedJordanAlgebra} -\index{JORDAN} -\begin{chunk}{sane} +\index[dom]{AssociatedJordanAlgebra!Domain} +\index[dom]{Domain!AssociatedJordanAlgebra} +\index[dom]{JORDAN} +\begin{chunk}{defclass AssociatedJordanAlgebraType} (defclass |AssociatedJordanAlgebraType| (|FramedNonAssociativeAlgebraType|) ((parents :initform '(|FramedNonAssociativeAlgebra|)) (name :initform "AssociatedJordanAlgebra") @@ -13783,7 +14486,7 @@ Value = NIL "FiniteRankNonAssociativeAlgebra(R) (a non" "associative algebra over R which is a free R-module of finite" "rank), then the same true for the associated Jordan algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13797,10 +14500,10 @@ Value = NIL \end{chunk} \subsection{AssociatedLieAlgebra} -\index{AssociatedLieAlgebra!Domain} -\index{Domain!AssociatedLieAlgebra} -\index{LIE} -\begin{chunk}{sane} +\index[dom]{AssociatedLieAlgebra!Domain} +\index[dom]{Domain!AssociatedLieAlgebra} +\index[dom]{LIE} +\begin{chunk}{defclass AssociatedLieAlgebraType} (defclass |AssociatedLieAlgebraType| (|FramedNonAssociativeAlgebraType|) ((parents :initform '(|FramedNonAssociativeAlgebra|)) (name :initform "AssociatedLieAlgebra") @@ -13827,7 +14530,7 @@ Value = NIL "FiniteRankNonAssociativeAlgebra(R) (a non" "associative algebra over R which is a free R-module of finite" "rank), then the same is true for the associated Lie algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13841,10 +14544,10 @@ Value = NIL \end{chunk} \subsection{AssociationList} -\index{AssociationList!Domain} -\index{Domain!AssociationList} -\index{ALIST} -\begin{chunk}{sane} +\index[dom]{AssociationList!Domain} +\index[dom]{Domain!AssociationList} +\index[dom]{ALIST} +\begin{chunk}{defclass AssociationListType} (defclass |AssociationListType| (|AssociationListAggregateType|) ((parents :initform '(|AssociationListAggregate|)) (name :initform "AssociationList") @@ -13856,7 +14559,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13870,10 +14573,10 @@ Value = NIL \end{chunk} \subsection{AttributeButtons} -\index{AttributeButtons!Domain} -\index{Domain!AttributeButtons} -\index{ATTRBUT} -\begin{chunk}{sane} +\index[dom]{AttributeButtons!Domain} +\index[dom]{Domain!AttributeButtons} +\index[dom]{ATTRBUT} +\begin{chunk}{defclass AttributeButtonsType} (defclass |AttributeButtonsType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "AttributeButtons") @@ -13898,7 +14601,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13912,10 +14615,10 @@ Value = NIL \end{chunk} \subsection{Automorphism} -\index{Automorphism!Domain} -\index{Domain!Automorphism} -\index{AUTOMOR} -\begin{chunk}{sane} +\index[dom]{Automorphism!Domain} +\index[dom]{Domain!Automorphism} +\index[dom]{AUTOMOR} +\begin{chunk}{defclass AutomorphismType} (defclass |AutomorphismType| (|EltableType| |GroupType|) ((parents :initform '(|Eltable| |Group|)) (name :initform "Automorphism") @@ -13926,7 +14629,7 @@ Value = NIL "In fact, non-invertible endomorphism are allowed as partial functions." "This domain is noncanonical in that f*f^{-1} will be the identity" "function but won't be equal to 1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13942,10 +14645,10 @@ Value = NIL \section{B} \subsection{BalancedBinaryTree} -\index{BalancedBinaryTree!Domain} -\index{Domain!BalancedBinaryTree} -\index{BBTREE} -\begin{chunk}{sane} +\index[dom]{BalancedBinaryTree!Domain} +\index[dom]{Domain!BalancedBinaryTree} +\index[dom]{BBTREE} +\begin{chunk}{defclass BalancedBinaryTreeType} (defclass |BalancedBinaryTreeType| (|BinaryTreeCategoryType|) ((parents :initform '(|BinaryTreeCategory|)) (name :initform "BalancedBinaryTree") @@ -13958,7 +14661,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13972,10 +14675,10 @@ Value = NIL \end{chunk} \subsection{BalancedPAdicInteger} -\index{BalancedPAdicInteger!Domain} -\index{Domain!BalancedPAdicInteger} -\index{BPADIC} -\begin{chunk}{sane} +\index[dom]{BalancedPAdicInteger!Domain} +\index[dom]{Domain!BalancedPAdicInteger} +\index[dom]{BPADIC} +\begin{chunk}{defclass BalancedPAdicIntegerType} (defclass |BalancedPAdicIntegerType| (|PAdicIntegerCategoryType|) ((parents :initform '(|PAdicIntegerCategory|)) (name :initform "BalancedPAdicInteger") @@ -13984,7 +14687,7 @@ Value = NIL (comment :initform (list "Stream-based implementation of Zp: p-adic numbers are represented as" "sum(i = 0.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -13998,10 +14701,10 @@ Value = NIL \end{chunk} \subsection{BalancedPAdicRational} -\index{BalancedPAdicRational!Domain} -\index{Domain!BalancedPAdicRational} -\index{BPADICRT} -\begin{chunk}{sane} +\index[dom]{BalancedPAdicRational!Domain} +\index[dom]{Domain!BalancedPAdicRational} +\index[dom]{BPADICRT} +\begin{chunk}{defclass BalancedPAdicRationalType} (defclass |BalancedPAdicRationalType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "BalancedPAdicRational") @@ -14010,7 +14713,7 @@ Value = NIL (comment :initform (list "Stream-based implementation of Qp: numbers are represented as" "sum(i = k.., a[i] * p^i), where the a[i] lie in -(p - 1)/2,...,(p - 1)/2.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14024,10 +14727,10 @@ Value = NIL \end{chunk} \subsection{BasicFunctions} -\index{BasicFunctions!Domain} -\index{Domain!BasicFunctions} -\index{BFUNCT} -\begin{chunk}{sane} +\index[dom]{BasicFunctions!Domain} +\index[dom]{Domain!BasicFunctions} +\index[dom]{BFUNCT} +\begin{chunk}{defclass BasicFunctionsType} (defclass |BasicFunctionsType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "BasicFunctions") @@ -14036,7 +14739,7 @@ Value = NIL (comment :initform (list "A Domain which implements a table containing details of" "points at which particular functions have evaluation problems.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14050,10 +14753,10 @@ Value = NIL \end{chunk} \subsection{BasicOperator} -\index{BasicOperator!Domain} -\index{Domain!BasicOperator} -\index{BOP} -\begin{chunk}{sane} +\index[dom]{BasicOperator!Domain} +\index[dom]{Domain!BasicOperator} +\index[dom]{BOP} +\begin{chunk}{defclass BasicOperatorType} (defclass |BasicOperatorType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "BasicOperator") @@ -14062,7 +14765,7 @@ Value = NIL (comment :initform (list "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14076,10 +14779,10 @@ Value = NIL \end{chunk} \subsection{BasicStochasticDifferential} -\index{BasicStochasticDifferential!Domain} -\index{Domain!BasicStochasticDifferential} -\index{BSD} -\begin{chunk}{sane} +\index[dom]{BasicStochasticDifferential!Domain} +\index[dom]{Domain!BasicStochasticDifferential} +\index[dom]{BSD} +\begin{chunk}{defclass BasicStochasticDifferentialType} (defclass |BasicStochasticDifferentialType| (|ConvertibleToType| |OrderedSetType|) ((parents :initform '(|ConvertibleTo| |OrderedSet|)) (name :initform "BasicStochasticDifferential") @@ -14094,7 +14797,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14108,10 +14811,10 @@ Value = NIL \end{chunk} \subsection{BinaryExpansion} -\index{BinaryExpansion!Domain} -\index{Domain!BinaryExpansion} -\index{BINARY} -\begin{chunk}{sane} +\index[dom]{BinaryExpansion!Domain} +\index[dom]{Domain!BinaryExpansion} +\index[dom]{BINARY} +\begin{chunk}{defclass BinaryExpansionType} (defclass |BinaryExpansionType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "BinaryExpansion") @@ -14120,7 +14823,7 @@ Value = NIL (comment :initform (list "This domain allows rational numbers to be presented as repeating" "binary expansions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14134,10 +14837,10 @@ Value = NIL \end{chunk} \subsection{BinaryFile} -\index{BinaryFile!Domain} -\index{Domain!BinaryFile} -\index{BINFILE} -\begin{chunk}{sane} +\index[dom]{BinaryFile!Domain} +\index[dom]{Domain!BinaryFile} +\index[dom]{BINFILE} +\begin{chunk}{defclass BinaryFileType} (defclass |BinaryFileType| (|FileCategoryType|) ((parents :initform '(|FileCategory|)) (name :initform "BinaryFile") @@ -14146,7 +14849,7 @@ Value = NIL (comment :initform (list "This domain provides an implementation of binary files. Data is" "accessed one byte at a time as a small integer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14160,10 +14863,10 @@ Value = NIL \end{chunk} \subsection{BinarySearchTree} -\index{BinarySearchTree!Domain} -\index{Domain!BinarySearchTree} -\index{BSTREE} -\begin{chunk}{sane} +\index[dom]{BinarySearchTree!Domain} +\index[dom]{Domain!BinarySearchTree} +\index[dom]{BSTREE} +\begin{chunk}{defclass BinarySearchTreeType} (defclass |BinarySearchTreeType| (|BinaryTreeCategoryType|) ((parents :initform '(|BinaryTreeCategory|)) (name :initform "BinarySearchTree") @@ -14176,7 +14879,7 @@ Value = NIL "a value which is an S, and a" "right and left which are both BinaryTree(S)" "Elements are ordered across the tree.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14190,10 +14893,10 @@ Value = NIL \end{chunk} \subsection{BinaryTournament} -\index{BinaryTournament!Domain} -\index{Domain!BinaryTournament} -\index{BTOURN} -\begin{chunk}{sane} +\index[dom]{BinaryTournament!Domain} +\index[dom]{Domain!BinaryTournament} +\index[dom]{BTOURN} +\begin{chunk}{defclass BinaryTournamentType} (defclass |BinaryTournamentType| (|BinaryTreeCategoryType|) ((parents :initform '(|BinaryTreeCategory|)) (name :initform "BinaryTournament") @@ -14202,7 +14905,7 @@ Value = NIL (comment :initform (list "BinaryTournament creates a binary tournament with the" "elements of ls as values at the nodes.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14216,10 +14919,10 @@ Value = NIL \end{chunk} \subsection{BinaryTree} -\index{BinaryTree!Domain} -\index{Domain!BinaryTree} -\index{BTREE} -\begin{chunk}{sane} +\index[dom]{BinaryTree!Domain} +\index[dom]{Domain!BinaryTree} +\index[dom]{BTREE} +\begin{chunk}{defclass BinaryTreeType} (defclass |BinaryTreeType| (|BinaryTreeCategoryType|) ((parents :initform '(|BinaryTreeCategory|)) (name :initform "BinaryTree") @@ -14230,7 +14933,7 @@ Value = NIL "binary trees. A binary tree over S is either empty or has" "a value which is an S and a right" "and left which are both binary trees.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14244,10 +14947,10 @@ Value = NIL \end{chunk} \subsection{Bits} -\index{Bits!Domain} -\index{Domain!Bits} -\index{BITS} -\begin{chunk}{sane} +\index[dom]{Bits!Domain} +\index[dom]{Domain!Bits} +\index[dom]{BITS} +\begin{chunk}{defclass BitsType} (defclass |BitsType| (|BitAggregateType|) ((parents :initform '(|BitAggregate|)) (name :initform "Bits") @@ -14255,7 +14958,7 @@ Value = NIL (abbreviation :initform 'BITS) (comment :initform (list "Bits provides logical functions for Indexed Bits.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14269,10 +14972,10 @@ Value = NIL \end{chunk} \subsection{BlowUpWithHamburgerNoether} -\index{BlowUpWithHamburgerNoether!Domain} -\index{Domain!BlowUpWithHamburgerNoether} -\index{BLHN} -\begin{chunk}{sane} +\index[dom]{BlowUpWithHamburgerNoether!Domain} +\index[dom]{Domain!BlowUpWithHamburgerNoether} +\index[dom]{BLHN} +\begin{chunk}{defclass BlowUpWithHamburgerNoetherType} (defclass |BlowUpWithHamburgerNoetherType| (|BlowUpMethodCategoryType|) ((parents :initform '(|BlowUpMethodCategory|)) (name :initform "BlowUpWithHamburgerNoether") @@ -14280,7 +14983,7 @@ Value = NIL (abbreviation :initform 'BLHN) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14294,10 +14997,10 @@ Value = NIL \end{chunk} \subsection{BlowUpWithQuadTrans} -\index{BlowUpWithQuadTrans!Domain} -\index{Domain!BlowUpWithQuadTrans} -\index{BLQT} -\begin{chunk}{sane} +\index[dom]{BlowUpWithQuadTrans!Domain} +\index[dom]{Domain!BlowUpWithQuadTrans} +\index[dom]{BLQT} +\begin{chunk}{defclass BlowUpWithQuadTransType} (defclass |BlowUpWithQuadTransType| (|BlowUpMethodCategoryType|) ((parents :initform '(|BlowUpMethodCategory|)) (name :initform "BlowUpWithQuadTrans") @@ -14305,7 +15008,7 @@ Value = NIL (abbreviation :initform 'BLQT) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14319,10 +15022,10 @@ Value = NIL \end{chunk} \subsection{Boolean} -\index{Boolean!Domain} -\index{Domain!Boolean} -\index{BOOLEAN} -\begin{chunk}{sane} +\index[dom]{Boolean!Domain} +\index[dom]{Domain!Boolean} +\index[dom]{BOOLEAN} +\begin{chunk}{defclass BooleanType} (defclass |BooleanType| (|ConvertibleToType| |FiniteType| |LogicType| |OrderedSetType|) ((parents :initform '(|ConvertibleTo| |Finite| |Logic| |OrderedSet|)) (name :initform "Boolean") @@ -14331,7 +15034,7 @@ Value = NIL (comment :initform (list "Boolean is the elementary logic with 2 values:" "true and false")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14347,10 +15050,10 @@ Value = NIL \section{C} \subsection{CardinalNumber} -\index{CardinalNumber!Domain} -\index{Domain!CardinalNumber} -\index{CARD} -\begin{chunk}{sane} +\index[dom]{CardinalNumber!Domain} +\index[dom]{Domain!CardinalNumber} +\index[dom]{CARD} +\begin{chunk}{defclass CardinalNumberType} (defclass |CardinalNumberType| (|AbelianMonoidType| |MonoidType| |OrderedSetType| |RetractableToType|) ((parents :initform '(|AbelianMonoid| |Monoid| |OrderedSet| |RetractableTo|)) (name :initform "CardinalNumber") @@ -14385,7 +15088,7 @@ Value = NIL " " "In this domain, these values are obtained using" " a := Aleph 0, c := 2**a, f := 2**c.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14399,10 +15102,10 @@ Value = NIL \end{chunk} \subsection{CartesianTensor} -\index{CartesianTensor!Domain} -\index{Domain!CartesianTensor} -\index{CARTEN} -\begin{chunk}{sane} +\index[dom]{CartesianTensor!Domain} +\index[dom]{Domain!CartesianTensor} +\index[dom]{CARTEN} +\begin{chunk}{defclass CartesianTensorType} (defclass |CartesianTensorType| (|GradedAlgebraType|) ((parents :initform '(|GradedAlgebra|)) (name :initform "CartesianTensor") @@ -14413,7 +15116,7 @@ Value = NIL "components belonging to a commutative ring R. These tensors" "can have any number of indices. Each index takes values from" "minix to minix + dim - 1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14427,17 +15130,17 @@ Value = NIL \end{chunk} \subsection{Cell} -\index{Cell!Domain} -\index{Domain!Cell} -\index{CELL} -\begin{chunk}{sane} +\index[dom]{Cell!Domain} +\index[dom]{Domain!Cell} +\index[dom]{CELL} +\begin{chunk}{defclass CellType} (defclass |CellType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "Cell") (marker :initform 'domain) (abbreviation :initform 'CELL) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14451,10 +15154,10 @@ Value = NIL \end{chunk} \subsection{Character} -\index{Character!Domain} -\index{Domain!Character} -\index{CHAR} -\begin{chunk}{sane} +\index[dom]{Character!Domain} +\index[dom]{Domain!Character} +\index[dom]{CHAR} +\begin{chunk}{defclass CharacterType} (defclass |CharacterType| (|OrderedFiniteType|) ((parents :initform '(|OrderedFinite|)) (name :initform "Character") @@ -14469,10 +15172,10 @@ Value = NIL \end{chunk} \subsection{CharacterClass} -\index{CharacterClass!Domain} -\index{Domain!CharacterClass} -\index{CCLASS} -\begin{chunk}{sane} +\index[dom]{CharacterClass!Domain} +\index[dom]{Domain!CharacterClass} +\index[dom]{CCLASS} +\begin{chunk}{defclass CharacterClassType} (defclass |CharacterClassType| (|FiniteSetAggregateType|) ((parents :initform '(|FiniteSetAggregate|)) (name :initform "CharacterClass") @@ -14481,7 +15184,7 @@ Value = NIL (comment :initform (list "This domain allows classes of characters to be defined and manipulated" "efficiently.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14495,10 +15198,10 @@ Value = NIL \end{chunk} \subsection{CliffordAlgebra} -\index{CliffordAlgebra!Domain} -\index{Domain!CliffordAlgebra} -\index{CLIF} -\begin{chunk}{sane} +\index[dom]{CliffordAlgebra!Domain} +\index[dom]{Domain!CliffordAlgebra} +\index[dom]{CLIF} +\begin{chunk}{defclass CliffordAlgebraType} (defclass |CliffordAlgebraType| (|VectorSpaceType| |AlgebraType|) ((parents :initform '(|VectorSpace| |Algebra|)) (name :initform "CliffordAlgebra") @@ -14519,7 +15222,7 @@ Value = NIL " " "Examples of Clifford Algebras are: gaussians, quaternions, exterior" "algebras and spin algebras.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14533,10 +15236,10 @@ Value = NIL \end{chunk} \subsection{Color} -\index{Color!Domain} -\index{Domain!Color} -\index{COLOR} -\begin{chunk}{sane} +\index[dom]{Color!Domain} +\index[dom]{Domain!Color} +\index[dom]{COLOR} +\begin{chunk}{defclass ColorType} (defclass |ColorType| (|AbelianSemiGroupType|) ((parents :initform '(|AbelianSemiGroup|)) (name :initform "Color") @@ -14545,7 +15248,7 @@ Value = NIL (comment :initform (list "Color() specifies a domain of 27 colors provided in the" "Axiom system (the colors mix additively).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14559,10 +15262,10 @@ Value = NIL \end{chunk} \subsection{Commutator} -\index{Commutator!Domain} -\index{Domain!Commutator} -\index{COMM} -\begin{chunk}{sane} +\index[dom]{Commutator!Domain} +\index[dom]{Domain!Commutator} +\index[dom]{COMM} +\begin{chunk}{defclass CommutatorType} (defclass |CommutatorType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Commutator") @@ -14570,7 +15273,7 @@ Value = NIL (abbreviation :initform 'COMM) (comment :initform (list "A type for basic commutators")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14584,10 +15287,10 @@ Value = NIL \end{chunk} \subsection{Complex} -\index{Complex!Domain} -\index{Domain!Complex} -\index{COMPLEX} -\begin{chunk}{sane} +\index[dom]{Complex!Domain} +\index[dom]{Domain!Complex} +\index[dom]{COMPLEX} +\begin{chunk}{defclass ComplexType} (defclass |ComplexType| (|ComplexCategoryType| |OpenMathType|) ((parents :initform '(|ComplexCategory| |OpenMath|)) (name :initform "Complex") @@ -14597,7 +15300,7 @@ Value = NIL "Complex(R) creates the domain of elements of the form" "a + b * i where a and b come from the ring R," "and i is a new element such that i**2 = -1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14611,10 +15314,10 @@ Value = NIL \end{chunk} \subsection{ComplexDoubleFloatMatrix} -\index{ComplexDoubleFloatMatrix!Domain} -\index{Domain!ComplexDoubleFloatMatrix} -\index{CDFMAT} -\begin{chunk}{sane} +\index[dom]{ComplexDoubleFloatMatrix!Domain} +\index[dom]{Domain!ComplexDoubleFloatMatrix} +\index[dom]{CDFMAT} +\begin{chunk}{defclass ComplexDoubleFloatMatrixType} (defclass |ComplexDoubleFloatMatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "ComplexDoubleFloatMatrix") @@ -14625,7 +15328,7 @@ Value = NIL "(two dimensional arrays) of complex double precision floating point" "numbers. Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14639,10 +15342,10 @@ Value = NIL \end{chunk} \subsection{ComplexDoubleFloatVector} -\index{ComplexDoubleFloatVector!Domain} -\index{Domain!ComplexDoubleFloatVector} -\index{CDFVEC} -\begin{chunk}{sane} +\index[dom]{ComplexDoubleFloatVector!Domain} +\index[dom]{Domain!ComplexDoubleFloatVector} +\index[dom]{CDFVEC} +\begin{chunk}{defclass ComplexDoubleFloatVectorType} (defclass |ComplexDoubleFloatVectorType| (|VectorCategoryType|) ((parents :initform '(|VectorCategory|)) (name :initform "ComplexDoubleFloatVector") @@ -14653,7 +15356,7 @@ Value = NIL "(one dimensional arrays) of complex double precision floating point" "numbers. Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14667,10 +15370,10 @@ Value = NIL \end{chunk} \subsection{ContinuedFraction} -\index{ContinuedFraction!Domain} -\index{Domain!ContinuedFraction} -\index{CONTFRAC} -\begin{chunk}{sane} +\index[dom]{ContinuedFraction!Domain} +\index[dom]{Domain!ContinuedFraction} +\index[dom]{CONTFRAC} +\begin{chunk}{defclass ContinuedFractionType} (defclass |ContinuedFractionType| (|FieldType|) ((parents :initform '(|Field|)) (name :initform "ContinuedFraction") @@ -14685,7 +15388,7 @@ Value = NIL "This is enforced by ensuring the partial numerators and partial" "denominators are greater than 0 in the Euclidean domain view of R" "(sizeLess?(0, x)).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14701,10 +15404,10 @@ Value = NIL \section{D} \subsection{Database} -\index{Database!Domain} -\index{Domain!Database} -\index{DBASE} -\begin{chunk}{sane} +\index[dom]{Database!Domain} +\index[dom]{Domain!Database} +\index[dom]{DBASE} +\begin{chunk}{defclass DatabaseType} (defclass |DatabaseType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Database") @@ -14713,7 +15416,7 @@ Value = NIL (comment :initform (list "This domain implements a simple view of a database whose fields are" "indexed by symbols")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14727,10 +15430,10 @@ Value = NIL \end{chunk} \subsection{DataList} -\index{DataList!Domain} -\index{Domain!DataList} -\index{DLIST} -\begin{chunk}{sane} +\index[dom]{DataList!Domain} +\index[dom]{Domain!DataList} +\index[dom]{DLIST} +\begin{chunk}{defclass DataListType} (defclass |DataListType| (|ListAggregateType|) ((parents :initform '(|ListAggregate|)) (name :initform "DataList") @@ -14738,7 +15441,7 @@ Value = NIL (abbreviation :initform 'DLIST) (comment :initform (list "This domain provides some nice functions on lists")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14752,10 +15455,10 @@ Value = NIL \end{chunk} \subsection{DecimalExpansion} -\index{DecimalExpansion!Domain} -\index{Domain!DecimalExpansion} -\index{DECIMAL} -\begin{chunk}{sane} +\index[dom]{DecimalExpansion!Domain} +\index[dom]{Domain!DecimalExpansion} +\index[dom]{DECIMAL} +\begin{chunk}{defclass DecimalExpansionType} (defclass |DecimalExpansionType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "DecimalExpansion") @@ -14764,7 +15467,7 @@ Value = NIL (comment :initform (list "This domain allows rational numbers to be presented as repeating" "decimal expansions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14778,10 +15481,10 @@ Value = NIL \end{chunk} \subsection{DenavitHartenbergMatrix} -\index{DenavitHartenbergMatrix!Domain} -\index{Domain!DenavitHartenbergMatrix} -\index{DHMATRIX} -\begin{chunk}{sane} +\index[dom]{DenavitHartenbergMatrix!Domain} +\index[dom]{Domain!DenavitHartenbergMatrix} +\index[dom]{DHMATRIX} +\begin{chunk}{defclass DenavitHartenbergMatrixType} (defclass |DenavitHartenbergMatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "DenavitHartenbergMatrix") @@ -14800,7 +15503,7 @@ Value = NIL " nz oz az pz" " 0 0 0 1" "(n, o, and a are the direction cosines)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14814,10 +15517,10 @@ Value = NIL \end{chunk} \subsection{Dequeue} -\index{Dequeue!Domain} -\index{Domain!Dequeue} -\index{DEQUEUE} -\begin{chunk}{sane} +\index[dom]{Dequeue!Domain} +\index[dom]{Domain!Dequeue} +\index[dom]{DEQUEUE} +\begin{chunk}{defclass DequeueType} (defclass |DequeueType| (|DequeueAggregateType|) ((parents :initform '(|DequeueAggregate|)) (name :initform "Dequeue") @@ -14825,7 +15528,7 @@ Value = NIL (abbreviation :initform 'DEQUEUE) (comment :initform (list "Linked list implementation of a Dequeue")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14839,10 +15542,10 @@ Value = NIL \end{chunk} \subsection{DeRhamComplex} -\index{DeRhamComplex!Domain} -\index{Domain!DeRhamComplex} -\index{DERHAM} -\begin{chunk}{sane} +\index[dom]{DeRhamComplex!Domain} +\index[dom]{Domain!DeRhamComplex} +\index[dom]{DERHAM} +\begin{chunk}{defclass DeRhamComplexType} (defclass |DeRhamComplexType| (|RetractableToType| |LeftAlgebraType|) ((parents :initform '(|RetractableTo| |LeftAlgebra|)) (name :initform "DeRhamComplex") @@ -14853,7 +15556,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14867,10 +15570,10 @@ Value = NIL \end{chunk} \subsection{DesingTree} -\index{DesingTree!Domain} -\index{Domain!DesingTree} -\index{DSTREE} -\begin{chunk}{sane} +\index[dom]{DesingTree!Domain} +\index[dom]{Domain!DesingTree} +\index[dom]{DSTREE} +\begin{chunk}{defclass DesingTreeType} (defclass |DesingTreeType| (|DesingTreeCategoryType|) ((parents :initform '(|DesingTreeCategory|)) (name :initform "DesingTree") @@ -14878,7 +15581,7 @@ Value = NIL (abbreviation :initform 'DSTREE) (comment :initform (list "This category is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14892,10 +15595,10 @@ Value = NIL \end{chunk} \subsection{DifferentialSparseMultivariatePolynomial} -\index{DifferentialSparseMultivariatePolynomial!Domain} -\index{Domain!DifferentialSparseMultivariatePolynomial} -\index{DSMP} -\begin{chunk}{sane} +\index[dom]{DifferentialSparseMultivariatePolynomial!Domain} +\index[dom]{Domain!DifferentialSparseMultivariatePolynomial} +\index[dom]{DSMP} +\begin{chunk}{defclass DifferentialSparseMultivariatePolynomialType} (defclass |DifferentialSparseMultivariatePolynomialType| (|DifferentialPolynomialCategoryType|) ((parents :initform '(|DifferentialPolynomialCategory|)) (name :initform "DifferentialSparseMultivariatePolynomial") @@ -14906,7 +15609,7 @@ Value = NIL "an ordinary differential polynomial ring by combining a" "domain belonging to the category DifferentialVariableCategory" "with the domain SparseMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14920,10 +15623,10 @@ Value = NIL \end{chunk} \subsection{DirectProduct} -\index{DirectProduct!Domain} -\index{Domain!DirectProduct} -\index{DIRPROD} -\begin{chunk}{sane} +\index[dom]{DirectProduct!Domain} +\index[dom]{Domain!DirectProduct} +\index[dom]{DIRPROD} +\begin{chunk}{defclass DirectProductType} (defclass |DirectProductType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "DirectProduct") @@ -14939,7 +15642,7 @@ Value = NIL "vector elements using the directProduct function" "or by taking appropriate linear combinations of basis vectors provided" "by the unitVector operation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14953,10 +15656,10 @@ Value = NIL \end{chunk} \subsection{DirectProductMatrixModule} -\index{DirectProductMatrixModule!Domain} -\index{Domain!DirectProductMatrixModule} -\index{DPMM} -\begin{chunk}{sane} +\index[dom]{DirectProductMatrixModule!Domain} +\index[dom]{Domain!DirectProductMatrixModule} +\index[dom]{DPMM} +\begin{chunk}{defclass DirectProductMatrixModuleType} (defclass |DirectProductMatrixModuleType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "DirectProductMatrixModule") @@ -14965,7 +15668,7 @@ Value = NIL (comment :initform (list "This constructor provides a direct product type with a" "left matrix-module view.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -14979,10 +15682,10 @@ Value = NIL \end{chunk} \subsection{DirectProductModule} -\index{DirectProductModule!Domain} -\index{Domain!DirectProductModule} -\index{DPMO} -\begin{chunk}{sane} +\index[dom]{DirectProductModule!Domain} +\index[dom]{Domain!DirectProductModule} +\index[dom]{DPMO} +\begin{chunk}{defclass DirectProductModuleType} (defclass |DirectProductModuleType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "DirectProductModule") @@ -14991,7 +15694,7 @@ Value = NIL (comment :initform (list "This constructor provides a direct product of R-modules" "with an R-module view.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15005,10 +15708,10 @@ Value = NIL \end{chunk} \subsection{DirichletRing} -\index{DirichletRing!Domain} -\index{Domain!DirichletRing} -\index{DIRRING} -\begin{chunk}{sane} +\index[dom]{DirichletRing!Domain} +\index[dom]{Domain!DirichletRing} +\index[dom]{DIRRING} +\begin{chunk}{defclass DirichletRingType} (defclass |DirichletRingType| (|IntegralDomainType| |EltableType|) ((parents :initform '(|IntegralDomain| |Eltable|)) (name :initform "DirichletRing") @@ -15017,7 +15720,7 @@ Value = NIL (comment :initform (list "DirichletRing is the ring of arithmetical functions" "with Dirichlet convolution as multiplication")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15031,10 +15734,10 @@ Value = NIL \end{chunk} \subsection{DistributedMultivariatePolynomial} -\index{DistributedMultivariatePolynomial!Domain} -\index{Domain!DistributedMultivariatePolynomial} -\index{DMP} -\begin{chunk}{sane} +\index[dom]{DistributedMultivariatePolynomial!Domain} +\index[dom]{Domain!DistributedMultivariatePolynomial} +\index[dom]{DMP} +\begin{chunk}{defclass DistributedMultivariatePolynomialType} (defclass |DistributedMultivariatePolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "DistributedMultivariatePolynomial") @@ -15047,7 +15750,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15061,10 +15764,10 @@ Value = NIL \end{chunk} \subsection{Divisor} -\index{Divisor!Domain} -\index{Domain!Divisor} -\index{DIV} -\begin{chunk}{sane} +\index[dom]{Divisor!Domain} +\index[dom]{Domain!Divisor} +\index[dom]{DIV} +\begin{chunk}{defclass DivisorType} (defclass |DivisorType| (|DivisorCategoryType|) ((parents :initform '(|DivisorCategory|)) (name :initform "Divisor") @@ -15072,7 +15775,7 @@ Value = NIL (abbreviation :initform 'DIV) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15086,10 +15789,10 @@ Value = NIL \end{chunk} \subsection{DoubleFloat} -\index{DoubleFloat!Domain} -\index{Domain!DoubleFloat} -\index{DFLOAT} -\begin{chunk}{sane} +\index[dom]{DoubleFloat!Domain} +\index[dom]{Domain!DoubleFloat} +\index[dom]{DFLOAT} +\begin{chunk}{defclass DoubleFloatType} (defclass |DoubleFloatType| (|TranscendentalFunctionCategoryType| |SpecialFunctionCategoryType| |OpenMathType| @@ -15125,7 +15828,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15139,10 +15842,10 @@ Value = NIL \end{chunk} \subsection{DoubleFloatMatrix} -\index{DoubleFloatMatrix!Domain} -\index{Domain!DoubleFloatMatrix} -\index{DFMAT} -\begin{chunk}{sane} +\index[dom]{DoubleFloatMatrix!Domain} +\index[dom]{Domain!DoubleFloatMatrix} +\index[dom]{DFMAT} +\begin{chunk}{defclass DoubleFloatMatrixType} (defclass |DoubleFloatMatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "DoubleFloatMatrix") @@ -15153,7 +15856,7 @@ Value = NIL "(two dimensional arrays) of double precision floating point" "numbers. Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15167,10 +15870,10 @@ Value = NIL \end{chunk} \subsection{DoubleFloatVector} -\index{DoubleFloatVector!Domain} -\index{Domain!DoubleFloatVector} -\index{DFVEC} -\begin{chunk}{sane} +\index[dom]{DoubleFloatVector!Domain} +\index[dom]{Domain!DoubleFloatVector} +\index[dom]{DFVEC} +\begin{chunk}{defclass DoubleFloatVectorType} (defclass |DoubleFloatVectorType| (|VectorCategoryType|) ((parents :initform '(|VectorCategory|)) (name :initform "DoubleFloatVector") @@ -15181,7 +15884,7 @@ Value = NIL "(one dimensional arrays) of double precision floating point" "numbers. Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15195,10 +15898,10 @@ Value = NIL \end{chunk} \subsection{DrawOption} -\index{DrawOption!Domain} -\index{Domain!DrawOption} -\index{DROPT} -\begin{chunk}{sane} +\index[dom]{DrawOption!Domain} +\index[dom]{Domain!DrawOption} +\index[dom]{DROPT} +\begin{chunk}{defclass DrawOptionType} (defclass |DrawOptionType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "DrawOption") @@ -15207,7 +15910,7 @@ Value = NIL (comment :initform (list "DrawOption allows the user to specify defaults for the" "creation and rendering of plots.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15221,10 +15924,10 @@ Value = NIL \end{chunk} \subsection{d01ajfAnnaType} -\index{d01ajfAnnaType!Domain} -\index{Domain!d01ajfAnnaType} -\index{D01AJFA} -\begin{chunk}{sane} +\index[dom]{d01ajfAnnaType!Domain} +\index[dom]{Domain!d01ajfAnnaType} +\index[dom]{D01AJFA} +\begin{chunk}{defclass d01ajfAnnaTypeType} (defclass |d01ajfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01ajfAnnaType") @@ -15238,7 +15941,7 @@ Value = NIL "measure measures the usefulness of the routine D01AJF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15252,10 +15955,10 @@ Value = NIL \end{chunk} \subsection{d01akfAnnaType} -\index{d01akfAnnaType!Domain} -\index{Domain!d01akfAnnaType} -\index{D01AKFA} -\begin{chunk}{sane} +\index[dom]{d01akfAnnaType!Domain} +\index[dom]{Domain!d01akfAnnaType} +\index[dom]{D01AKFA} +\begin{chunk}{defclass d01akfAnnaTypeType} (defclass |d01akfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01akfAnnaType") @@ -15269,7 +15972,7 @@ Value = NIL "measure measures the usefulness of the routine D01AKF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15283,10 +15986,10 @@ Value = NIL \end{chunk} \subsection{d01alfAnnaType} -\index{d01alfAnnaType!Domain} -\index{Domain!d01alfAnnaType} -\index{D01ALFA} -\begin{chunk}{sane} +\index[dom]{d01alfAnnaType!Domain} +\index[dom]{Domain!d01alfAnnaType} +\index[dom]{D01ALFA} +\begin{chunk}{defclass d01alfAnnaTypeType} (defclass |d01alfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01alfAnnaType") @@ -15300,7 +16003,7 @@ Value = NIL "function measure measures the usefulness of the routine D01ALF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15314,10 +16017,10 @@ Value = NIL \end{chunk} \subsection{d01amfAnnaType} -\index{d01amfAnnaType!Domain} -\index{Domain!d01amfAnnaType} -\index{D01AMFA} -\begin{chunk}{sane} +\index[dom]{d01amfAnnaType!Domain} +\index[dom]{Domain!d01amfAnnaType} +\index[dom]{D01AMFA} +\begin{chunk}{defclass d01amfAnnaTypeType} (defclass |d01amfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01amfAnnaType") @@ -15331,7 +16034,7 @@ Value = NIL "function measure measures the usefulness of the routine D01AMF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15345,10 +16048,10 @@ Value = NIL \end{chunk} \subsection{d01anfAnnaType} -\index{d01anfAnnaType!Domain} -\index{Domain!d01anfAnnaType} -\index{D01ANFA} -\begin{chunk}{sane} +\index[dom]{d01anfAnnaType!Domain} +\index[dom]{Domain!d01anfAnnaType} +\index[dom]{D01ANFA} +\begin{chunk}{defclass d01anfAnnaTypeType} (defclass |d01anfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01anfAnnaType") @@ -15362,7 +16065,7 @@ Value = NIL "function measure measures the usefulness of the routine D01ANF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15376,10 +16079,10 @@ Value = NIL \end{chunk} \subsection{d01apfAnnaType} -\index{d01apfAnnaType!Domain} -\index{Domain!d01apfAnnaType} -\index{D01APFA} -\begin{chunk}{sane} +\index[dom]{d01apfAnnaType!Domain} +\index[dom]{Domain!d01apfAnnaType} +\index[dom]{D01APFA} +\begin{chunk}{defclass d01apfAnnaTypeType} (defclass |d01apfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01apfAnnaType") @@ -15394,7 +16097,7 @@ Value = NIL "function measure measures the usefulness of the routine D01APF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15408,10 +16111,10 @@ Value = NIL \end{chunk} \subsection{d01aqfAnnaType} -\index{d01aqfAnnaType!Domain} -\index{Domain!d01aqfAnnaType} -\index{D01AQFA} -\begin{chunk}{sane} +\index[dom]{d01aqfAnnaType!Domain} +\index[dom]{Domain!d01aqfAnnaType} +\index[dom]{D01AQFA} +\begin{chunk}{defclass d01aqfAnnaTypeType} (defclass |d01aqfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01aqfAnnaType") @@ -15426,7 +16129,7 @@ Value = NIL "The function measure measures the usefulness of the routine" "D01AQF for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15440,10 +16143,10 @@ Value = NIL \end{chunk} \subsection{d01asfAnnaType} -\index{d01asfAnnaType!Domain} -\index{Domain!d01asfAnnaType} -\index{D01ASFA} -\begin{chunk}{sane} +\index[dom]{d01asfAnnaType!Domain} +\index[dom]{Domain!d01asfAnnaType} +\index[dom]{D01ASFA} +\begin{chunk}{defclass d01asfAnnaTypeType} (defclass |d01asfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01asfAnnaType") @@ -15458,7 +16161,7 @@ Value = NIL "function measure measures the usefulness of the routine D01ASF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15472,10 +16175,10 @@ Value = NIL \end{chunk} \subsection{d01fcfAnnaType} -\index{d01fcfAnnaType!Domain} -\index{Domain!d01fcfAnnaType} -\index{D01FCFA} -\begin{chunk}{sane} +\index[dom]{d01fcfAnnaType!Domain} +\index[dom]{Domain!d01fcfAnnaType} +\index[dom]{D01FCFA} +\begin{chunk}{defclass d01fcfAnnaTypeType} (defclass |d01fcfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01fcfAnnaType") @@ -15489,7 +16192,7 @@ Value = NIL "function measure measures the usefulness of the routine D01GBF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15503,10 +16206,10 @@ Value = NIL \end{chunk} \subsection{d01gbfAnnaType} -\index{d01gbfAnnaType!Domain} -\index{Domain!d01gbfAnnaType} -\index{D01GBFA} -\begin{chunk}{sane} +\index[dom]{d01gbfAnnaType!Domain} +\index[dom]{Domain!d01gbfAnnaType} +\index[dom]{D01GBFA} +\begin{chunk}{defclass d01gbfAnnaTypeType} (defclass |d01gbfAnnaTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01gbfAnnaType") @@ -15520,7 +16223,7 @@ Value = NIL "function measure measures the usefulness of the routine D01GBF" "for the given problem. The function numericalIntegration" "performs the integration by using NagIntegrationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15534,10 +16237,10 @@ Value = NIL \end{chunk} \subsection{d01TransformFunctionType} -\index{d01TransformFunctionType!Domain} -\index{Domain!d01TransformFunctionType} -\index{D01TRNS} -\begin{chunk}{sane} +\index[dom]{d01TransformFunctionType!Domain} +\index[dom]{Domain!d01TransformFunctionType} +\index[dom]{D01TRNS} +\begin{chunk}{defclass d01TransformFunctionTypeType} (defclass |d01TransformFunctionTypeType| (|NumericalIntegrationCategoryType|) ((parents :initform '(|NumericalIntegrationCategory|)) (name :initform "d01TransformFunctionType") @@ -15549,7 +16252,7 @@ Value = NIL "d01TransformFunctionType uses the mapping x -> 1/x" "and contains the functions measure and" "numericalIntegration.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15563,10 +16266,10 @@ Value = NIL \end{chunk} \subsection{d02bbfAnnaType} -\index{d02bbfAnnaType!Domain} -\index{Domain!d02bbfAnnaType} -\index{D02BBFA} -\begin{chunk}{sane} +\index[dom]{d02bbfAnnaType!Domain} +\index[dom]{Domain!d02bbfAnnaType} +\index[dom]{D02BBFA} +\begin{chunk}{defclass d02bbfAnnaTypeType} (defclass |d02bbfAnnaTypeType| (|OrdinaryDifferentialEquationsSolverCategoryType|) ((parents :initform '(|OrdinaryDifferentialEquationsSolverCategory|)) (name :initform "d02bbfAnnaType") @@ -15581,7 +16284,7 @@ Value = NIL "usefulness of the routine D02BBF for the given problem. The" "function ODESolve performs the integration by using" "NagOrdinaryDifferentialEquationsPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15595,10 +16298,10 @@ Value = NIL \end{chunk} \subsection{d02bhfAnnaType} -\index{d02bhfAnnaType!Domain} -\index{Domain!d02bhfAnnaType} -\index{D02BHFA} -\begin{chunk}{sane} +\index[dom]{d02bhfAnnaType!Domain} +\index[dom]{Domain!d02bhfAnnaType} +\index[dom]{D02BHFA} +\begin{chunk}{defclass d02bhfAnnaTypeType} (defclass |d02bhfAnnaTypeType| (|OrdinaryDifferentialEquationsSolverCategoryType|) ((parents :initform '(|OrdinaryDifferentialEquationsSolverCategory|)) (name :initform "d02bhfAnnaType") @@ -15613,7 +16316,7 @@ Value = NIL "usefulness of the routine D02BHF for the given problem. The" "function ODESolve performs the integration by using" "NagOrdinaryDifferentialEquationsPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15627,10 +16330,10 @@ Value = NIL \end{chunk} \subsection{d02cjfAnnaType} -\index{d02cjfAnnaType!Domain} -\index{Domain!d02cjfAnnaType} -\index{D02CJFA} -\begin{chunk}{sane} +\index[dom]{d02cjfAnnaType!Domain} +\index[dom]{Domain!d02cjfAnnaType} +\index[dom]{D02CJFA} +\begin{chunk}{defclass d02cjfAnnaTypeType} (defclass |d02cjfAnnaTypeType| (|OrdinaryDifferentialEquationsSolverCategoryType|) ((parents :initform '(|OrdinaryDifferentialEquationsSolverCategory|)) (name :initform "d02cjfAnnaType") @@ -15645,7 +16348,7 @@ Value = NIL "usefulness of the routine D02CJF for the given problem. The" "function ODESolve performs the integration by using" "NagOrdinaryDifferentialEquationsPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15659,10 +16362,10 @@ Value = NIL \end{chunk} \subsection{d02ejfAnnaType} -\index{d02ejfAnnaType!Domain} -\index{Domain!d02ejfAnnaType} -\index{D02EJFA} -\begin{chunk}{sane} +\index[dom]{d02ejfAnnaType!Domain} +\index[dom]{Domain!d02ejfAnnaType} +\index[dom]{D02EJFA} +\begin{chunk}{defclass d02ejfAnnaTypeType} (defclass |d02ejfAnnaTypeType| (|OrdinaryDifferentialEquationsSolverCategoryType|) ((parents :initform '(|OrdinaryDifferentialEquationsSolverCategory|)) (name :initform "d02ejfAnnaType") @@ -15677,7 +16380,7 @@ Value = NIL "the usefulness of the routine D02EJF for the given problem. The" "function ODESolve performs the integration by using" "NagOrdinaryDifferentialEquationsPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15691,10 +16394,10 @@ Value = NIL \end{chunk} \subsection{d03eefAnnaType} -\index{d03eefAnnaType!Domain} -\index{Domain!d03eefAnnaType} -\index{D03EEFA} -\begin{chunk}{sane} +\index[dom]{d03eefAnnaType!Domain} +\index[dom]{Domain!d03eefAnnaType} +\index[dom]{D03EEFA} +\begin{chunk}{defclass d03eefAnnaTypeType} (defclass |d03eefAnnaTypeType| (|PartialDifferentialEquationsSolverCategoryType|) ((parents :initform '(|PartialDifferentialEquationsSolverCategory|)) (name :initform "d03eefAnnaType") @@ -15704,7 +16407,7 @@ Value = NIL "d03eefAnnaType is a domain of" "PartialDifferentialEquationsSolverCategory" "for the NAG routines D03EEF/D03EDF.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15718,10 +16421,10 @@ Value = NIL \end{chunk} \subsection{d03fafAnnaType} -\index{d03fafAnnaType!Domain} -\index{Domain!d03fafAnnaType} -\index{D03FAFA} -\begin{chunk}{sane} +\index[dom]{d03fafAnnaType!Domain} +\index[dom]{Domain!d03fafAnnaType} +\index[dom]{D03FAFA} +\begin{chunk}{defclass d03fafAnnaTypeType} (defclass |d03fafAnnaTypeType| (|PartialDifferentialEquationsSolverCategoryType|) ((parents :initform '(|PartialDifferentialEquationsSolverCategory|)) (name :initform "d03fafAnnaType") @@ -15731,7 +16434,7 @@ Value = NIL "d03fafAnnaType is a domain of" "PartialDifferentialEquationsSolverCategory" "for the NAG routine D03FAF.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15747,10 +16450,10 @@ Value = NIL \section{E} \subsection{ElementaryFunctionsUnivariateLaurentSeries} -\index{ElementaryFunctionsUnivariateLaurentSeries!Domain} -\index{Domain!ElementaryFunctionsUnivariateLaurentSeries} -\index{EFULS} -\begin{chunk}{sane} +\index[dom]{ElementaryFunctionsUnivariateLaurentSeries!Domain} +\index[dom]{Domain!ElementaryFunctionsUnivariateLaurentSeries} +\index[dom]{EFULS} +\begin{chunk}{defclass ElementaryFunctionsUnivariateLaurentSeriesType} (defclass |ElementaryFunctionsUnivariateLaurentSeriesType| (|PartialTranscendentalFunctionsType|) ((parents :initform '(|PartialTranscendentalFunctions|)) (name :initform "ElementaryFunctionsUnivariateLaurentSeries") @@ -15764,7 +16467,7 @@ Value = NIL "provide 'partial functions' which compute transcendental" "functions of Laurent series when possible and return 'failed'" "when this is not possible.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15778,10 +16481,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionsUnivariatePuiseuxSeries} -\index{ElementaryFunctionsUnivariatePuiseuxSeries!Domain} -\index{Domain!ElementaryFunctionsUnivariatePuiseuxSeries} -\index{EFUPXS} -\begin{chunk}{sane} +\index[dom]{ElementaryFunctionsUnivariatePuiseuxSeries!Domain} +\index[dom]{Domain!ElementaryFunctionsUnivariatePuiseuxSeries} +\index[dom]{EFUPXS} +\begin{chunk}{defclass ElementaryFunctionsUnivariatePuiseuxSeriesType} (defclass |ElementaryFunctionsUnivariatePuiseuxSeriesType| (|PartialTranscendentalFunctionsType|) ((parents :initform '(|PartialTranscendentalFunctions|)) (name :initform "ElementaryFunctionsUnivariatePuiseuxSeries") @@ -15795,7 +16498,7 @@ Value = NIL "provide 'partial functions' which compute transcendental" "functions of Laurent series when possible and return 'failed'" "when this is not possible.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15809,10 +16512,10 @@ Value = NIL \end{chunk} \subsection{Equation} -\index{Equation!Domain} -\index{Domain!Equation} -\index{EQ} -\begin{chunk}{sane} +\index[dom]{Equation!Domain} +\index[dom]{Domain!Equation} +\index[dom]{EQ} +\begin{chunk}{defclass EquationType} (defclass |EquationType| (|GroupType| |InnerEvalableType| |PartialDifferentialRingType| @@ -15831,7 +16534,7 @@ Value = NIL "for example being an abelian group are carried over the equation domain," "by performing the structural operations on the left and on the" "right hand side.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15845,10 +16548,10 @@ Value = NIL \end{chunk} \subsection{EqTable} -\index{EqTable!Domain} -\index{Domain!EqTable} -\index{EQTBL} -\begin{chunk}{sane} +\index[dom]{EqTable!Domain} +\index[dom]{Domain!EqTable} +\index[dom]{EQTBL} +\begin{chunk}{defclass EqTableType} (defclass |EqTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "EqTable") @@ -15858,7 +16561,7 @@ Value = NIL "This domain provides tables where the keys are compared using" "eq?. Thus keys are considered equal only if they" "are the same instance of a structure.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15872,10 +16575,10 @@ Value = NIL \end{chunk} \subsection{EuclideanModularRing} -\index{EuclideanModularRing!Domain} -\index{Domain!EuclideanModularRing} -\index{EMR} -\begin{chunk}{sane} +\index[dom]{EuclideanModularRing!Domain} +\index[dom]{Domain!EuclideanModularRing} +\index[dom]{EMR} +\begin{chunk}{defclass EuclideanModularRingType} (defclass |EuclideanModularRingType| (|EuclideanDomainType|) ((parents :initform '(|EuclideanDomain|)) (name :initform "EuclideanModularRing") @@ -15886,7 +16589,7 @@ Value = NIL "of univariate polynomials over the integers in order to work modulo" "different primes." "See ModularRing, ModularField")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15900,10 +16603,10 @@ Value = NIL \end{chunk} \subsection{Exit} -\index{Exit!Domain} -\index{Domain!Exit} -\index{EXIT} -\begin{chunk}{sane} +\index[dom]{Exit!Domain} +\index[dom]{Domain!Exit} +\index[dom]{EXIT} +\begin{chunk}{defclass ExitType} (defclass |ExitType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Exit") @@ -15916,7 +16619,7 @@ Value = NIL "Note that It is convenient to have a formal coerce into each type" "from type Exit. This allows, for example, errors to be raised in" "one half of a type-balanced if.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15930,10 +16633,10 @@ Value = NIL \end{chunk} \subsection{ExponentialExpansion} -\index{ExponentialExpansion!Domain} -\index{Domain!ExponentialExpansion} -\index{EXPEXPAN} -\begin{chunk}{sane} +\index[dom]{ExponentialExpansion!Domain} +\index[dom]{Domain!ExponentialExpansion} +\index[dom]{EXPEXPAN} +\begin{chunk}{defclass ExponentialExpansionType} (defclass |ExponentialExpansionType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "ExponentialExpansion") @@ -15944,7 +16647,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15958,10 +16661,10 @@ Value = NIL \end{chunk} \subsection{Expression} -\index{Expression!Domain} -\index{Domain!Expression} -\index{EXPR} -\begin{chunk}{sane} +\index[dom]{Expression!Domain} +\index[dom]{Domain!Expression} +\index[dom]{EXPR} +\begin{chunk}{defclass ExpressionType} (defclass |ExpressionType| (|SpecialFunctionCategoryType| |LiouvillianFunctionCategoryType| |CombinatorialOpsCategoryType| @@ -15975,7 +16678,7 @@ Value = NIL (abbreviation :initform 'EXPR) (comment :initform (list "Top-level mathematical expressions involving symbolic functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -15989,10 +16692,10 @@ Value = NIL \end{chunk} \subsection{ExponentialOfUnivariatePuiseuxSeries} -\index{ExponentialOfUnivariatePuiseuxSeries!Domain} -\index{Domain!ExponentialOfUnivariatePuiseuxSeries} -\index{EXPUPXS} -\begin{chunk}{sane} +\index[dom]{ExponentialOfUnivariatePuiseuxSeries!Domain} +\index[dom]{Domain!ExponentialOfUnivariatePuiseuxSeries} +\index[dom]{EXPUPXS} +\begin{chunk}{defclass ExponentialOfUnivariatePuiseuxSeriesType} (defclass |ExponentialOfUnivariatePuiseuxSeriesType| (|OrderedAbelianMonoidType| |UnivariatePuiseuxSeriesCategoryType|) ((parents :initform '(|OrderedAbelianMonoid| |UnivariatePuiseuxSeriesCategory|)) @@ -16011,7 +16714,7 @@ Value = NIL "then exp(f(x)) > exp(g(x)). If order(f(x)) = order(g(x))," "then the ordering is essentially random. This domain is used" "in computing limits involving functions with essential singularities.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16025,10 +16728,10 @@ Value = NIL \end{chunk} \subsection{ExtAlgBasis} -\index{ExtAlgBasis!Domain} -\index{Domain!ExtAlgBasis} -\index{EAB} -\begin{chunk}{sane} +\index[dom]{ExtAlgBasis!Domain} +\index[dom]{Domain!ExtAlgBasis} +\index[dom]{EAB} +\begin{chunk}{defclass ExtAlgBasisType} (defclass |ExtAlgBasisType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "ExtAlgBasis") @@ -16048,7 +16751,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16062,10 +16765,10 @@ Value = NIL \end{chunk} \subsection{e04dgfAnnaType} -\index{e04dgfAnnaType!Domain} -\index{Domain!e04dgfAnnaType} -\index{E04DGFA} -\begin{chunk}{sane} +\index[dom]{e04dgfAnnaType!Domain} +\index[dom]{Domain!e04dgfAnnaType} +\index[dom]{E04DGFA} +\begin{chunk}{defclass e04dgfAnnaTypeType} (defclass |e04dgfAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04dgfAnnaType") @@ -16078,7 +16781,7 @@ Value = NIL "measure measures the usefulness of the routine E04DGF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16092,10 +16795,10 @@ Value = NIL \end{chunk} \subsection{e04fdfAnnaType} -\index{e04fdfAnnaType!Domain} -\index{Domain!e04fdfAnnaType} -\index{E04FDFA} -\begin{chunk}{sane} +\index[dom]{e04fdfAnnaType!Domain} +\index[dom]{Domain!e04fdfAnnaType} +\index[dom]{E04FDFA} +\begin{chunk}{defclass e04fdfAnnaTypeType} (defclass |e04fdfAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04fdfAnnaType") @@ -16108,7 +16811,7 @@ Value = NIL "measure measures the usefulness of the routine E04FDF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16122,10 +16825,10 @@ Value = NIL \end{chunk} \subsection{e04gcfAnnaType} -\index{e04gcfAnnaType!Domain} -\index{Domain!e04gcfAnnaType} -\index{E04GCFA} -\begin{chunk}{sane} +\index[dom]{e04gcfAnnaType!Domain} +\index[dom]{Domain!e04gcfAnnaType} +\index[dom]{E04GCFA} +\begin{chunk}{defclass e04gcfAnnaTypeType} (defclass |e04gcfAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04gcfAnnaType") @@ -16138,7 +16841,7 @@ Value = NIL "measure measures the usefulness of the routine E04GCF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16152,10 +16855,10 @@ Value = NIL \end{chunk} \subsection{e04jafAnnaType} -\index{e04jafAnnaType!Domain} -\index{Domain!e04jafAnnaType} -\index{E04JAFA} -\begin{chunk}{sane} +\index[dom]{e04jafAnnaType!Domain} +\index[dom]{Domain!e04jafAnnaType} +\index[dom]{E04JAFA} +\begin{chunk}{defclass e04jafAnnaTypeType} (defclass |e04jafAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04jafAnnaType") @@ -16168,7 +16871,7 @@ Value = NIL "measure measures the usefulness of the routine E04JAF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16182,10 +16885,10 @@ Value = NIL \end{chunk} \subsection{e04mbfAnnaType} -\index{e04mbfAnnaType!Domain} -\index{Domain!e04mbfAnnaType} -\index{E04MBFA} -\begin{chunk}{sane} +\index[dom]{e04mbfAnnaType!Domain} +\index[dom]{Domain!e04mbfAnnaType} +\index[dom]{E04MBFA} +\begin{chunk}{defclass e04mbfAnnaTypeType} (defclass |e04mbfAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04mbfAnnaType") @@ -16198,7 +16901,7 @@ Value = NIL "measure measures the usefulness of the routine E04MBF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16212,10 +16915,10 @@ Value = NIL \end{chunk} \subsection{e04nafAnnaType} -\index{e04nafAnnaType!Domain} -\index{Domain!e04nafAnnaType} -\index{E04NAFA} -\begin{chunk}{sane} +\index[dom]{e04nafAnnaType!Domain} +\index[dom]{Domain!e04nafAnnaType} +\index[dom]{E04NAFA} +\begin{chunk}{defclass e04nafAnnaTypeType} (defclass |e04nafAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04nafAnnaType") @@ -16228,7 +16931,7 @@ Value = NIL "measure measures the usefulness of the routine E04NAF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16242,10 +16945,10 @@ Value = NIL \end{chunk} \subsection{e04ucfAnnaType} -\index{e04ucfAnnaType!Domain} -\index{Domain!e04ucfAnnaType} -\index{E04UCFA} -\begin{chunk}{sane} +\index[dom]{e04ucfAnnaType!Domain} +\index[dom]{Domain!e04ucfAnnaType} +\index[dom]{E04UCFA} +\begin{chunk}{defclass e04ucfAnnaTypeType} (defclass |e04ucfAnnaTypeType| (|NumericalOptimizationCategoryType|) ((parents :initform '(|NumericalOptimizationCategory|)) (name :initform "e04ucfAnnaType") @@ -16258,7 +16961,7 @@ Value = NIL "measure measures the usefulness of the routine E04UCF" "for the given problem. The function numericalOptimization" "performs the optimization by using NagOptimisationPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16274,10 +16977,10 @@ Value = NIL \section{F} \subsection{Factored} -\index{Factored!Domain} -\index{Domain!Factored} -\index{FR} -\begin{chunk}{sane} +\index[dom]{Factored!Domain} +\index[dom]{Domain!Factored} +\index[dom]{FR} +\begin{chunk}{defclass FactoredType} (defclass |FactoredType| (|UniqueFactorizationDomainType| |RealConstantType| |FullyRetractableToType| @@ -16305,7 +17008,7 @@ Value = NIL "irreducible, or it is prime. The current" "restriction to integral domains allows simplification to be" "performed without worrying about multiplication order.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16319,10 +17022,10 @@ Value = NIL \end{chunk} \subsection{File} -\index{File!Domain} -\index{Domain!File} -\index{FILE} -\begin{chunk}{sane} +\index[dom]{File!Domain} +\index[dom]{Domain!File} +\index[dom]{FILE} +\begin{chunk}{defclass FileType} (defclass |FileType| (|FileCategoryType|) ((parents :initform '(|FileCategory|)) (name :initform "File") @@ -16331,7 +17034,7 @@ Value = NIL (comment :initform (list "This domain provides a basic model of files to save arbitrary values." "The operations provide sequential access to the contents.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16345,10 +17048,10 @@ Value = NIL \end{chunk} \subsection{FileName} -\index{FileName!Domain} -\index{Domain!FileName} -\index{FNAME} -\begin{chunk}{sane} +\index[dom]{FileName!Domain} +\index[dom]{Domain!FileName} +\index[dom]{FNAME} +\begin{chunk}{defclass FileNameType} (defclass |FileNameType| (|FileNameCategoryType|) ((parents :initform '(|FileNameCategory|)) (name :initform "FileName") @@ -16356,7 +17059,7 @@ Value = NIL (abbreviation :initform 'FNAME) (comment :initform (list "This domain provides an interface to names in the file system.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16370,10 +17073,10 @@ Value = NIL \end{chunk} \subsection{FiniteDivisor} -\index{FiniteDivisor!Domain} -\index{Domain!FiniteDivisor} -\index{FDIV} -\begin{chunk}{sane} +\index[dom]{FiniteDivisor!Domain} +\index[dom]{Domain!FiniteDivisor} +\index[dom]{FDIV} +\begin{chunk}{defclass FiniteDivisorType} (defclass |FiniteDivisorType| (|FiniteDivisorCategoryType|) ((parents :initform '(|FiniteDivisorCategory|)) (name :initform "FiniteDivisor") @@ -16383,7 +17086,7 @@ Value = NIL "This domains implements finite rational divisors on a curve, that" "is finite formal sums SUM(n * P) where the n's are integers and the" "P's are finite rational points on the curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16397,10 +17100,10 @@ Value = NIL \end{chunk} \subsection{FiniteField} -\index{FiniteField!Domain} -\index{Domain!FiniteField} -\index{FF} -\begin{chunk}{sane} +\index[dom]{FiniteField!Domain} +\index[dom]{Domain!FiniteField} +\index[dom]{FF} +\begin{chunk}{defclass FiniteFieldType} (defclass |FiniteFieldType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteField") @@ -16410,7 +17113,7 @@ Value = NIL "FiniteField(p,n) implements finite fields with p**n elements." "This packages checks that p is prime." "For a non-checking version, see InnerFiniteField.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16424,10 +17127,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldCyclicGroup} -\index{FiniteFieldCyclicGroup!Domain} -\index{Domain!FiniteFieldCyclicGroup} -\index{FFCG} -\begin{chunk}{sane} +\index[dom]{FiniteFieldCyclicGroup!Domain} +\index[dom]{Domain!FiniteFieldCyclicGroup} +\index[dom]{FFCG} +\begin{chunk}{defclass FiniteFieldCyclicGroupType} (defclass |FiniteFieldCyclicGroupType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldCyclicGroup") @@ -16443,7 +17146,7 @@ Value = NIL "in a table of size half of the field size, and use SingleInteger" "for representing field elements, hence, there are restrictions" "on the size of the field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16457,10 +17160,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldCyclicGroupExtension} -\index{FiniteFieldCyclicGroupExtension!Domain} -\index{Domain!FiniteFieldCyclicGroupExtension} -\index{FFCGX} -\begin{chunk}{sane} +\index[dom]{FiniteFieldCyclicGroupExtension!Domain} +\index[dom]{Domain!FiniteFieldCyclicGroupExtension} +\index[dom]{FFCGX} +\begin{chunk}{defclass FiniteFieldCyclicGroupExtensionType} (defclass |FiniteFieldCyclicGroupExtensionType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldCyclicGroupExtension") @@ -16476,7 +17179,7 @@ Value = NIL "in a table of size half of the field size, and use SingleInteger" "for representing field elements, hence, there are restrictions" "on the size of the field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16490,10 +17193,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldCyclicGroupExtensionByPolynomial} -\index{FiniteFieldCyclicGroupExtensionByPolynomial!Domain} -\index{Domain!FiniteFieldCyclicGroupExtensionByPolynomial} -\index{FFCGP} -\begin{chunk}{sane} +\index[dom]{FiniteFieldCyclicGroupExtensionByPolynomial!Domain} +\index[dom]{Domain!FiniteFieldCyclicGroupExtensionByPolynomial} +\index[dom]{FFCGP} +\begin{chunk}{defclass FiniteFieldCyclicGroupExtensionByPolynomialType} (defclass |FiniteFieldCyclicGroupExtensionByPolynomialType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldCyclicGroupExtensionByPolynomial") @@ -16509,7 +17212,7 @@ Value = NIL "in a table of size half of the field size, and use SingleInteger" "for representing field elements, hence, there are restrictions" "on the size of the field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16523,10 +17226,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldExtension} -\index{FiniteFieldExtension!Domain} -\index{Domain!FiniteFieldExtension} -\index{FFX} -\begin{chunk}{sane} +\index[dom]{FiniteFieldExtension!Domain} +\index[dom]{Domain!FiniteFieldExtension} +\index[dom]{FFX} +\begin{chunk}{defclass FiniteFieldExtensionType} (defclass |FiniteFieldExtensionType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldExtension") @@ -16537,7 +17240,7 @@ Value = NIL "of the finite field GF of degree n generated by the extension" "polynomial constructed by createIrreduciblePoly from" "FiniteFieldPolynomialPackage.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16551,10 +17254,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldExtensionByPolynomial} -\index{FiniteFieldExtensionByPolynomial!Domain} -\index{Domain!FiniteFieldExtensionByPolynomial} -\index{FFP} -\begin{chunk}{sane} +\index[dom]{FiniteFieldExtensionByPolynomial!Domain} +\index[dom]{Domain!FiniteFieldExtensionByPolynomial} +\index[dom]{FFP} +\begin{chunk}{defclass FiniteFieldExtensionByPolynomialType} (defclass |FiniteFieldExtensionByPolynomialType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldExtensionByPolynomial") @@ -16566,7 +17269,7 @@ Value = NIL "defpol which MUST be irreducible." "Note: the user has the responsibility to ensure that" "defpol is irreducible.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16580,10 +17283,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldNormalBasis} -\index{FiniteFieldNormalBasis!Domain} -\index{Domain!FiniteFieldNormalBasis} -\index{FFNB} -\begin{chunk}{sane} +\index[dom]{FiniteFieldNormalBasis!Domain} +\index[dom]{Domain!FiniteFieldNormalBasis} +\index[dom]{FFNB} +\begin{chunk}{defclass FiniteFieldNormalBasisType} (defclass |FiniteFieldNormalBasisType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldNormalBasis") @@ -16598,7 +17301,7 @@ Value = NIL "this case called normal element." "This is chosen as a root of the extension polynomial" "created by createNormalPoly")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16612,10 +17315,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldNormalBasisExtension} -\index{FiniteFieldNormalBasisExtension!Domain} -\index{Domain!FiniteFieldNormalBasisExtension} -\index{FFNBX} -\begin{chunk}{sane} +\index[dom]{FiniteFieldNormalBasisExtension!Domain} +\index[dom]{Domain!FiniteFieldNormalBasisExtension} +\index[dom]{FFNBX} +\begin{chunk}{defclass FiniteFieldNormalBasisExtensionType} (defclass |FiniteFieldNormalBasisExtensionType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldNormalBasisExtension") @@ -16630,7 +17333,7 @@ Value = NIL "in this case called normal element. This is chosen as a root of the extension" "polynomial, created by createNormalPoly from" "FiniteFieldPolynomialPackage")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16644,10 +17347,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldNormalBasisExtensionByPolynomial} -\index{FiniteFieldNormalBasisExtensionByPolynomial!Domain} -\index{Domain!FiniteFieldNormalBasisExtensionByPolynomial} -\index{FFNBP} -\begin{chunk}{sane} +\index[dom]{FiniteFieldNormalBasisExtensionByPolynomial!Domain} +\index[dom]{Domain!FiniteFieldNormalBasisExtensionByPolynomial} +\index[dom]{FFNBP} +\begin{chunk}{defclass FiniteFieldNormalBasisExtensionByPolynomialType} (defclass |FiniteFieldNormalBasisExtensionByPolynomialType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "FiniteFieldNormalBasisExtensionByPolynomial") @@ -16661,7 +17364,7 @@ Value = NIL "called normal element, where q is the size of GF." "The normal element is chosen as a root of the extension" "polynomial, which MUST be normal over GF (user responsibility)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16675,10 +17378,10 @@ Value = NIL \end{chunk} \subsection{FlexibleArray} -\index{FlexibleArray!Domain} -\index{Domain!FlexibleArray} -\index{FARRAY} -\begin{chunk}{sane} +\index[dom]{FlexibleArray!Domain} +\index[dom]{Domain!FlexibleArray} +\index[dom]{FARRAY} +\begin{chunk}{defclass FlexibleArrayType} (defclass |FlexibleArrayType| (|ExtensibleLinearAggregateType| |OneDimensionalArrayAggregateType|) ((parents :initform '(|ExtensibleLinearAggregate| |OneDimensionalArrayAggregate|)) @@ -16700,7 +17403,7 @@ Value = NIL "becomes less than 1/2 full, it is copied into a smaller array." "Flexible arrays provide for an efficient implementation of many" "data structures in particular heaps, stacks and sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16714,10 +17417,10 @@ Value = NIL \end{chunk} \subsection{Float} -\index{Float!Domain} -\index{Domain!Float} -\index{FLOAT} -\begin{chunk}{sane} +\index[dom]{Float!Domain} +\index[dom]{Domain!Float} +\index[dom]{FLOAT} +\begin{chunk}{defclass FloatType} (defclass |FloatType| (|TranscendentalFunctionCategoryType| |OpenMathType| |FloatingPointSystemType| @@ -16787,7 +17490,7 @@ Value = NIL "*, /, sqrt, pi, exp1, log2, log10: O( n**2 )" "exp, log, sin, atan: O(sqrt(n) n**2)" "The other elementary functions are coded in terms of the ones above.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16801,10 +17504,10 @@ Value = NIL \end{chunk} \subsection{FortranCode} -\index{FortranCode!Domain} -\index{Domain!FortranCode} -\index{FC} -\begin{chunk}{sane} +\index[dom]{FortranCode!Domain} +\index[dom]{Domain!FortranCode} +\index[dom]{FC} +\begin{chunk}{defclass FortranCodeType} (defclass |FortranCodeType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "FortranCode") @@ -16813,7 +17516,7 @@ Value = NIL (comment :initform (list "This domain builds representations of program code segments for use with" "the FortranProgram domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16827,10 +17530,10 @@ Value = NIL \end{chunk} \subsection{FortranExpression} -\index{FortranExpression!Domain} -\index{Domain!FortranExpression} -\index{FEXPR} -\begin{chunk}{sane} +\index[dom]{FortranExpression!Domain} +\index[dom]{Domain!FortranExpression} +\index[dom]{FEXPR} +\begin{chunk}{defclass FortranExpressionType} (defclass |FortranExpressionType| (|AlgebraType| |ExpressionSpaceType| |PartialDifferentialRingType|) @@ -16844,7 +17547,7 @@ Value = NIL "A domain of expressions involving functions which can be" "translated into standard Fortran-77, with some extra extensions from" "the NAG Fortran Library.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16858,10 +17561,10 @@ Value = NIL \end{chunk} \subsection{FortranProgram} -\index{FortranProgram!Domain} -\index{Domain!FortranProgram} -\index{FORTRAN} -\begin{chunk}{sane} +\index[dom]{FortranProgram!Domain} +\index[dom]{Domain!FortranProgram} +\index[dom]{FORTRAN} +\begin{chunk}{defclass FortranProgramType} (defclass |FortranProgramType| (|FortranProgramCategoryType|) ((parents :initform '(|FortranProgramCategory|)) (name :initform "FortranProgram") @@ -16871,7 +17574,7 @@ Value = NIL "FortranProgram allows the user to build and manipulate simple" "models of FORTRAN subprograms. These can then be transformed into" "actual FORTRAN notation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16885,10 +17588,10 @@ Value = NIL \end{chunk} \subsection{FortranScalarType} -\index{FortranScalarType!Domain} -\index{Domain!FortranScalarType} -\index{FST} -\begin{chunk}{sane} +\index[dom]{FortranScalarType!Domain} +\index[dom]{Domain!FortranScalarType} +\index[dom]{FST} +\begin{chunk}{defclass FortranScalarTypeType} (defclass |FortranScalarTypeType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "FortranScalarType") @@ -16897,7 +17600,7 @@ Value = NIL (comment :initform (list "Creates and manipulates objects which correspond to the" "basic FORTRAN data types: REAL, INTEGER, COMPLEX, LOGICAL and CHARACTER")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16911,10 +17614,10 @@ Value = NIL \end{chunk} \subsection{FortranTemplate} -\index{FortranTemplate!Domain} -\index{Domain!FortranTemplate} -\index{FTEM} -\begin{chunk}{sane} +\index[dom]{FortranTemplate!Domain} +\index[dom]{Domain!FortranTemplate} +\index[dom]{FTEM} +\begin{chunk}{defclass FortranTemplateType} (defclass |FortranTemplateType| (|FileCategoryType|) ((parents :initform '(|FileCategory|)) (name :initform "FortranTemplate") @@ -16922,7 +17625,7 @@ Value = NIL (abbreviation :initform 'FTEM) (comment :initform (list "Code to manipulate Fortran templates")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16936,10 +17639,10 @@ Value = NIL \end{chunk} \subsection{FortranType} -\index{FortranType!Domain} -\index{Domain!FortranType} -\index{FT} -\begin{chunk}{sane} +\index[dom]{FortranType!Domain} +\index[dom]{Domain!FortranType} +\index[dom]{FT} +\begin{chunk}{defclass FortranTypeType} (defclass |FortranTypeType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "FortranType") @@ -16948,7 +17651,7 @@ Value = NIL (comment :initform (list "Creates and manipulates objects which correspond to FORTRAN" "data types, including array dimensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16962,10 +17665,10 @@ Value = NIL \end{chunk} \subsection{FourierComponent} -\index{FourierComponent!Domain} -\index{Domain!FourierComponent} -\index{FCOMP} -\begin{chunk}{sane} +\index[dom]{FourierComponent!Domain} +\index[dom]{Domain!FourierComponent} +\index[dom]{FCOMP} +\begin{chunk}{defclass FourierComponentType} (defclass |FourierComponentType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "FourierComponent") @@ -16973,7 +17676,7 @@ Value = NIL (abbreviation :initform 'FCOMP) (comment :initform (list "This domain creates kernels for use in Fourier series")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -16987,10 +17690,10 @@ Value = NIL \end{chunk} \subsection{FourierSeries} -\index{FourierSeries!Domain} -\index{Domain!FourierSeries} -\index{FSERIES} -\begin{chunk}{sane} +\index[dom]{FourierSeries!Domain} +\index[dom]{Domain!FourierSeries} +\index[dom]{FSERIES} +\begin{chunk}{defclass FourierSeriesType} (defclass |FourierSeriesType| (|AlgebraType|) ((parents :initform '(|Algebra|)) (name :initform "FourierSeries") @@ -16998,7 +17701,7 @@ Value = NIL (abbreviation :initform 'FSERIES) (comment :initform (list "This domain converts terms into Fourier series")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17012,10 +17715,10 @@ Value = NIL \end{chunk} \subsection{Fraction} -\index{Fraction!Domain} -\index{Domain!Fraction} -\index{FRAC} -\begin{chunk}{sane} +\index[dom]{Fraction!Domain} +\index[dom]{Domain!Fraction} +\index[dom]{FRAC} +\begin{chunk}{defclass FractionType} (defclass |FractionType| (|QuotientFieldCategoryType| |OpenMathType|) ((parents :initform '(|QuotientFieldCategory| |OpenMath|)) (name :initform "Fraction") @@ -17026,7 +17729,7 @@ Value = NIL "the domain of Fractions with numerators and denominators from S." "If S is also a GcdDomain, then gcd's between numerator and" "denominator will be cancelled during all operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17040,10 +17743,10 @@ Value = NIL \end{chunk} \subsection{FractionalIdeal} -\index{FractionalIdeal!Domain} -\index{Domain!FractionalIdeal} -\index{FRIDEAL} -\begin{chunk}{sane} +\index[dom]{FractionalIdeal!Domain} +\index[dom]{Domain!FractionalIdeal} +\index[dom]{FRIDEAL} +\begin{chunk}{defclass FractionalIdealType} (defclass |FractionalIdealType| (|GroupType|) ((parents :initform '(|Group|)) (name :initform "FractionalIdeal") @@ -17051,7 +17754,7 @@ Value = NIL (abbreviation :initform 'FRIDEAL) (comment :initform (list "Fractional ideals in a framed algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17065,10 +17768,10 @@ Value = NIL \end{chunk} \subsection{FramedModule} -\index{FramedModule!Domain} -\index{Domain!FramedModule} -\index{FRMOD} -\begin{chunk}{sane} +\index[dom]{FramedModule!Domain} +\index[dom]{Domain!FramedModule} +\index[dom]{FRMOD} +\begin{chunk}{defclass FramedModuleType} (defclass |FramedModuleType| (|MonoidType|) ((parents :initform '(|Monoid|)) (name :initform "FramedModule") @@ -17076,7 +17779,7 @@ Value = NIL (abbreviation :initform 'FRMOD) (comment :initform (list "Module representation of fractional ideals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17090,10 +17793,10 @@ Value = NIL \end{chunk} \subsection{FreeAbelianGroup} -\index{FreeAbelianGroup!Domain} -\index{Domain!FreeAbelianGroup} -\index{FAGROUP} -\begin{chunk}{sane} +\index[dom]{FreeAbelianGroup!Domain} +\index[dom]{Domain!FreeAbelianGroup} +\index[dom]{FAGROUP} +\begin{chunk}{defclass FreeAbelianGroupType} (defclass |FreeAbelianGroupType| (|OrderedSetType| |ModuleType| |FreeAbelianMonoidCategoryType|) @@ -17106,7 +17809,7 @@ Value = NIL "The free abelian group on a set S is the monoid of finite sums of" "the form reduce(+,[ni * si]) where the si's are in S, and the ni's" "are integers. The operation is commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17120,10 +17823,10 @@ Value = NIL \end{chunk} \subsection{FreeAbelianMonoid} -\index{FreeAbelianMonoid!Domain} -\index{Domain!FreeAbelianMonoid} -\index{FAMONOID} -\begin{chunk}{sane} +\index[dom]{FreeAbelianMonoid!Domain} +\index[dom]{Domain!FreeAbelianMonoid} +\index[dom]{FAMONOID} +\begin{chunk}{defclass FreeAbelianMonoidType} (defclass |FreeAbelianMonoidType| (|FreeAbelianMonoidCategoryType|) ((parents :initform '(|FreeAbelianMonoidCategory|)) (name :initform "FreeAbelianMonoid") @@ -17134,7 +17837,7 @@ Value = NIL "The free abelian monoid on a set S is the monoid of finite sums of" "the form reduce(+,[ni * si]) where the si's are in S, and the ni's" "are non-negative integers. The operation is commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17148,10 +17851,10 @@ Value = NIL \end{chunk} \subsection{FreeGroup} -\index{FreeGroup!Domain} -\index{Domain!FreeGroup} -\index{FGROUP} -\begin{chunk}{sane} +\index[dom]{FreeGroup!Domain} +\index[dom]{Domain!FreeGroup} +\index[dom]{FGROUP} +\begin{chunk}{defclass FreeGroupType} (defclass |FreeGroupType| (|GroupType| |RetractableToType|) ((parents :initform '(|Group| |RetractableTo|)) (name :initform "FreeGroup") @@ -17162,7 +17865,7 @@ Value = NIL "The free group on a set S is the group of finite products of" "the form reduce(*,[si ** ni]) where the si's are in S, and the ni's" "are integers. The multiplication is not commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17176,10 +17879,10 @@ Value = NIL \end{chunk} \subsection{FreeModule} -\index{FreeModule!Domain} -\index{Domain!FreeModule} -\index{FM} -\begin{chunk}{sane} +\index[dom]{FreeModule!Domain} +\index[dom]{Domain!FreeModule} +\index[dom]{FM} +\begin{chunk}{defclass FreeModuleType} (defclass |FreeModuleType| (|IndexedDirectProductCategoryType| |ModuleType|) ((parents :initform '(|IndexedDirectProductCategory| |Module|)) @@ -17191,7 +17894,7 @@ Value = NIL "over a ring with generators indexed by an ordered set." "Each element can be expressed as a finite linear combination of" "generators. Only non-zero terms are stored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17205,10 +17908,10 @@ Value = NIL \end{chunk} \subsection{FreeModule1} -\index{FreeModule1!Domain} -\index{Domain!FreeModule1} -\index{FM1} -\begin{chunk}{sane} +\index[dom]{FreeModule1!Domain} +\index[dom]{Domain!FreeModule1} +\index[dom]{FM1} +\begin{chunk}{defclass FreeModule1Type} (defclass |FreeModule1Type| (|FreeModuleCatType|) ((parents :initform '(|FreeModuleCat|)) (name :initform "FreeModule1") @@ -17221,7 +17924,7 @@ Value = NIL "and R is a ring (which may be non-commutative)." "This domain is used by domains of non-commutative algebra such as:" "XDistributedPolynomial, XRecursivePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17235,10 +17938,10 @@ Value = NIL \end{chunk} \subsection{FreeMonoid} -\index{FreeMonoid!Domain} -\index{Domain!FreeMonoid} -\index{FMONOID} -\begin{chunk}{sane} +\index[dom]{FreeMonoid!Domain} +\index[dom]{Domain!FreeMonoid} +\index[dom]{FMONOID} +\begin{chunk}{defclass FreeMonoidType} (defclass |FreeMonoidType| (|MonoidType| |OrderedSetType| |RetractableToType|) ((parents :initform '(|Monoid| |OrderedSet| |RetractableTo|)) (name :initform "FreeMonoid") @@ -17249,7 +17952,7 @@ Value = NIL "The free monoid on a set S is the monoid of finite products of" "the form reduce(*,[si ** ni]) where the si's are in S, and the ni's" "are nonnegative integers. The multiplication is not commutative.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17263,10 +17966,10 @@ Value = NIL \end{chunk} \subsection{FreeNilpotentLie} -\index{FreeNilpotentLie!Domain} -\index{Domain!FreeNilpotentLie} -\index{FNLA} -\begin{chunk}{sane} +\index[dom]{FreeNilpotentLie!Domain} +\index[dom]{Domain!FreeNilpotentLie} +\index[dom]{FNLA} +\begin{chunk}{defclass FreeNilpotentLieType} (defclass |FreeNilpotentLieType| (|NonAssociativeAlgebraType|) ((parents :initform '(|NonAssociativeAlgebra|)) (name :initform "FreeNilpotentLie") @@ -17275,7 +17978,7 @@ Value = NIL (comment :initform (list "Generate the Free Lie Algebra over a ring R with identity;" "A P. Hall basis is generated by a package call to HallBasis.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17289,10 +17992,10 @@ Value = NIL \end{chunk} \subsection{FullPartialFractionExpansion} -\index{FullPartialFractionExpansion!Domain} -\index{Domain!FullPartialFractionExpansion} -\index{FPARFRAC} -\begin{chunk}{sane} +\index[dom]{FullPartialFractionExpansion!Domain} +\index[dom]{Domain!FullPartialFractionExpansion} +\index[dom]{FPARFRAC} +\begin{chunk}{defclass FullPartialFractionExpansionType} (defclass |FullPartialFractionExpansionType| (|SetCategoryType| |ConvertibleToType|) ((parents :initform '(|SetCategory| |ConvertibleTo|)) (name :initform "FullPartialFractionExpansion") @@ -17300,7 +18003,7 @@ Value = NIL (abbreviation :initform 'FPARFRAC) (comment :initform (list "Full partial fraction expansion of rational functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17314,10 +18017,10 @@ Value = NIL \end{chunk} \subsection{FunctionCalled} -\index{FunctionCalled!Domain} -\index{Domain!FunctionCalled} -\index{FUNCTION} -\begin{chunk}{sane} +\index[dom]{FunctionCalled!Domain} +\index[dom]{Domain!FunctionCalled} +\index[dom]{FUNCTION} +\begin{chunk}{defclass FunctionCalledType} (defclass |FunctionCalledType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "FunctionCalled") @@ -17325,7 +18028,7 @@ Value = NIL (abbreviation :initform 'FUNCTION) (comment :initform (list "This domain implements named functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17341,10 +18044,10 @@ Value = NIL \section{G} \subsection{GeneralDistributedMultivariatePolynomial} -\index{GeneralDistributedMultivariatePolynomial!Domain} -\index{Domain!GeneralDistributedMultivariatePolynomial} -\index{GDMP} -\begin{chunk}{sane} +\index[dom]{GeneralDistributedMultivariatePolynomial!Domain} +\index[dom]{Domain!GeneralDistributedMultivariatePolynomial} +\index[dom]{GDMP} +\begin{chunk}{defclass GeneralDistributedMultivariatePolynomialType} (defclass |GeneralDistributedMultivariatePolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "GeneralDistributedMultivariatePolynomial") @@ -17361,7 +18064,7 @@ Value = NIL "SplitHomogeneousDirectProduct and finally" "OrderedDirectProduct which accepts an arbitrary user" "function to define a term ordering.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17375,10 +18078,10 @@ Value = NIL \end{chunk} \subsection{GeneralModulePolynomial} -\index{GeneralModulePolynomial!Domain} -\index{Domain!GeneralModulePolynomial} -\index{GMODPOL} -\begin{chunk}{sane} +\index[dom]{GeneralModulePolynomial!Domain} +\index[dom]{Domain!GeneralModulePolynomial} +\index[dom]{GMODPOL} +\begin{chunk}{defclass GeneralModulePolynomialType} (defclass |GeneralModulePolynomialType| (|ModuleType|) ((parents :initform '(|Module|)) (name :initform "GeneralModulePolynomial") @@ -17386,7 +18089,7 @@ Value = NIL (abbreviation :initform 'GMODPOL) (comment :initform (list "This package is undocumented")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17400,10 +18103,10 @@ Value = NIL \end{chunk} \subsection{GenericNonAssociativeAlgebra} -\index{GenericNonAssociativeAlgebra!Domain} -\index{Domain!GenericNonAssociativeAlgebra} -\index{GCNAALG} -\begin{chunk}{sane} +\index[dom]{GenericNonAssociativeAlgebra!Domain} +\index[dom]{Domain!GenericNonAssociativeAlgebra} +\index[dom]{GCNAALG} +\begin{chunk}{defclass GenericNonAssociativeAlgebraType} (defclass |GenericNonAssociativeAlgebraType| (|FramedNonAssociativeAlgebraType|) ((parents :initform '(|FramedNonAssociativeAlgebra|)) (name :initform "GenericNonAssociativeAlgebra") @@ -17413,7 +18116,7 @@ Value = NIL "AlgebraGenericElementPackage allows you to create generic elements" "of an algebra, the scalars are extended to include symbolic" "coefficients")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17427,10 +18130,10 @@ Value = NIL \end{chunk} \subsection{GeneralPolynomialSet} -\index{GeneralPolynomialSet!Domain} -\index{Domain!GeneralPolynomialSet} -\index{GPOLSET} -\begin{chunk}{sane} +\index[dom]{GeneralPolynomialSet!Domain} +\index[dom]{Domain!GeneralPolynomialSet} +\index[dom]{GPOLSET} +\begin{chunk}{defclass GeneralPolynomialSetType} (defclass |GeneralPolynomialSetType| (|PolynomialSetCategoryType|) ((parents :initform '(|PolynomialSetCategory|)) (name :initform "GeneralPolynomialSet") @@ -17438,7 +18141,7 @@ Value = NIL (abbreviation :initform 'GPOLSET) (comment :initform (list "A domain for polynomial sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17452,10 +18155,10 @@ Value = NIL \end{chunk} \subsection{GeneralSparseTable} -\index{GeneralSparseTable!Domain} -\index{Domain!GeneralSparseTable} -\index{GSTBL} -\begin{chunk}{sane} +\index[dom]{GeneralSparseTable!Domain} +\index[dom]{Domain!GeneralSparseTable} +\index[dom]{GSTBL} +\begin{chunk}{defclass GeneralSparseTableType} (defclass |GeneralSparseTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "GeneralSparseTable") @@ -17464,7 +18167,7 @@ Value = NIL (comment :initform (list "A sparse table has a default entry, which is returned if no other" "value has been explicitly stored for a key.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17478,10 +18181,10 @@ Value = NIL \end{chunk} \subsection{GeneralTriangularSet} -\index{GeneralTriangularSet!Domain} -\index{Domain!GeneralTriangularSet} -\index{GTSET} -\begin{chunk}{sane} +\index[dom]{GeneralTriangularSet!Domain} +\index[dom]{Domain!GeneralTriangularSet} +\index[dom]{GTSET} +\begin{chunk}{defclass GeneralTriangularSetType} (defclass |GeneralTriangularSetType| (|TriangularSetCategoryType|) ((parents :initform '(|TriangularSetCategory|)) (name :initform "GeneralTriangularSet") @@ -17495,7 +18198,7 @@ Value = NIL "not be auto-reduced or consistent. Triangular sets are stored" "as sorted lists w.r.t. the main variables of their members but they" "are displayed in reverse order.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17509,10 +18212,10 @@ Value = NIL \end{chunk} \subsection{GeneralUnivariatePowerSeries} -\index{GeneralUnivariatePowerSeries!Domain} -\index{Domain!GeneralUnivariatePowerSeries} -\index{GSERIES} -\begin{chunk}{sane} +\index[dom]{GeneralUnivariatePowerSeries!Domain} +\index[dom]{Domain!GeneralUnivariatePowerSeries} +\index[dom]{GSERIES} +\begin{chunk}{defclass GeneralUnivariatePowerSeriesType} (defclass |GeneralUnivariatePowerSeriesType| (|UnivariatePuiseuxSeriesCategoryType|) ((parents :initform '(|UnivariatePuiseuxSeriesCategory|)) (name :initform "GeneralUnivariatePowerSeries") @@ -17524,7 +18227,7 @@ Value = NIL "by a pair [r,f(x)], where r is a positive rational number and" "f(x) is a Laurent series. This pair represents the Puiseux" "series f(x\^r).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17538,10 +18241,10 @@ Value = NIL \end{chunk} \subsection{GraphImage} -\index{GraphImage!Domain} -\index{Domain!GraphImage} -\index{GRIMAGE} -\begin{chunk}{sane} +\index[dom]{GraphImage!Domain} +\index[dom]{Domain!GraphImage} +\index[dom]{GRIMAGE} +\begin{chunk}{defclass GraphImageType} (defclass |GraphImageType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "GraphImage") @@ -17550,7 +18253,7 @@ Value = NIL (comment :initform (list "TwoDimensionalGraph creates virtual two dimensional graphs" "(to be displayed on TwoDimensionalViewports).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17564,10 +18267,10 @@ Value = NIL \end{chunk} \subsection{GuessOption} -\index{GuessOption!Domain} -\index{Domain!GuessOption} -\index{GOPT} -\begin{chunk}{sane} +\index[dom]{GuessOption!Domain} +\index[dom]{Domain!GuessOption} +\index[dom]{GOPT} +\begin{chunk}{defclass GuessOptionType} (defclass |GuessOptionType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "GuessOption") @@ -17576,7 +18279,7 @@ Value = NIL (comment :initform (list "GuessOption is a domain whose elements are various options used" "by Guess.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17590,10 +18293,10 @@ Value = NIL \end{chunk} \subsection{GuessOptionFunctions0} -\index{GuessOptionFunctions0!Domain} -\index{Domain!GuessOptionFunctions0} -\index{GOPT0} -\begin{chunk}{sane} +\index[dom]{GuessOptionFunctions0!Domain} +\index[dom]{Domain!GuessOptionFunctions0} +\index[dom]{GOPT0} +\begin{chunk}{defclass GuessOptionFunctions0Type} (defclass |GuessOptionFunctions0Type| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "GuessOptionFunctions0") @@ -17602,7 +18305,7 @@ Value = NIL (comment :initform (list "GuessOptionFunctions0 provides operations that extract the" "values of options for Guess.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17618,10 +18321,10 @@ Value = NIL \section{H} \subsection{HashTable} -\index{HashTable!Domain} -\index{Domain!HashTable} -\index{HASHTBL} -\begin{chunk}{sane} +\index[dom]{HashTable!Domain} +\index[dom]{Domain!HashTable} +\index[dom]{HASHTBL} +\begin{chunk}{defclass HashTableType} (defclass |HashTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "HashTable") @@ -17631,7 +18334,7 @@ Value = NIL "This domain provides access to the underlying Lisp hash tables." "By varying the hashfn parameter, tables suited for different" "purposes can be obtained.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17645,10 +18348,10 @@ Value = NIL \end{chunk} \subsection{Heap} -\index{Heap!Domain} -\index{Domain!Heap} -\index{HEAP} -\begin{chunk}{sane} +\index[dom]{Heap!Domain} +\index[dom]{Domain!Heap} +\index[dom]{HEAP} +\begin{chunk}{defclass HeapType} (defclass |HeapType| (|PriorityQueueAggregateType|) ((parents :initform '(|PriorityQueueAggregate|)) (name :initform "Heap") @@ -17657,7 +18360,7 @@ Value = NIL (comment :initform (list "Heap implemented in a flexible array to allow for insertions" "Complexity: O(log n) insertion, extraction and O(n) construction")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17671,10 +18374,10 @@ Value = NIL \end{chunk} \subsection{HexadecimalExpansion} -\index{HexadecimalExpansion!Domain} -\index{Domain!HexadecimalExpansion} -\index{HEXADEC} -\begin{chunk}{sane} +\index[dom]{HexadecimalExpansion!Domain} +\index[dom]{Domain!HexadecimalExpansion} +\index[dom]{HEXADEC} +\begin{chunk}{defclass HexadecimalExpansionType} (defclass |HexadecimalExpansionType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "HexadecimalExpansion") @@ -17683,7 +18386,7 @@ Value = NIL (comment :initform (list "This domain allows rational numbers to be presented as repeating" "hexadecimal expansions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17697,10 +18400,10 @@ Value = NIL \end{chunk} \subsection{HTMLFormat} -\index{HTMLFormat!Domain} -\index{Domain!HTMLFormat} -\index{HTMLFORM} -\begin{chunk}{sane} +\index[dom]{HTMLFormat!Domain} +\index[dom]{Domain!HTMLFormat} +\index[dom]{HTMLFORM} +\begin{chunk}{defclass HTMLFormatType} (defclass |HTMLFormatType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "HTMLFormat") @@ -17708,7 +18411,7 @@ Value = NIL (abbreviation :initform 'HTMLFORM) (comment :initform (list "HtmlFormat provides a coercion from OutputForm to html.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17722,10 +18425,10 @@ Value = NIL \end{chunk} \subsection{HomogeneousDirectProduct} -\index{HomogeneousDirectProduct!Domain} -\index{Domain!HomogeneousDirectProduct} -\index{HDP} -\begin{chunk}{sane} +\index[dom]{HomogeneousDirectProduct!Domain} +\index[dom]{Domain!HomogeneousDirectProduct} +\index[dom]{HDP} +\begin{chunk}{defclass HomogeneousDirectProductType} (defclass |HomogeneousDirectProductType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "HomogeneousDirectProduct") @@ -17737,7 +18440,7 @@ Value = NIL "by the sum of their components, and then refined using a reverse" "lexicographic ordering. This type is a suitable third argument for" "GeneralDistributedMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17751,10 +18454,10 @@ Value = NIL \end{chunk} \subsection{HomogeneousDistributedMultivariatePolynomial} -\index{HomogeneousDistributedMultivariatePolynomial!Domain} -\index{Domain!HomogeneousDistributedMultivariatePolynomial} -\index{HDMP} -\begin{chunk}{sane} +\index[dom]{HomogeneousDistributedMultivariatePolynomial!Domain} +\index[dom]{Domain!HomogeneousDistributedMultivariatePolynomial} +\index[dom]{HDMP} +\begin{chunk}{defclass HomogeneousDistributedMultivariatePolynomialType} (defclass |HomogeneousDistributedMultivariatePolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "HomogeneousDistributedMultivariatePolynomial") @@ -17768,7 +18471,7 @@ Value = NIL "The term ordering is total degree ordering refined by reverse" "lexicographic ordering with respect to the position that the variables" "appear in the list of variables parameter.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17782,10 +18485,10 @@ Value = NIL \end{chunk} \subsection{HyperellipticFiniteDivisor} -\index{HyperellipticFiniteDivisor!Domain} -\index{Domain!HyperellipticFiniteDivisor} -\index{HELLFDIV} -\begin{chunk}{sane} +\index[dom]{HyperellipticFiniteDivisor!Domain} +\index[dom]{Domain!HyperellipticFiniteDivisor} +\index[dom]{HELLFDIV} +\begin{chunk}{defclass HyperellipticFiniteDivisorType} (defclass |HyperellipticFiniteDivisorType| (|FiniteDivisorCategoryType|) ((parents :initform '(|FiniteDivisorCategory|)) (name :initform "HyperellipticFiniteDivisor") @@ -17796,7 +18499,7 @@ Value = NIL "that is finite formal sums SUM(n * P) where the n's are integers and the" "P's are finite rational points on the curve." "The equation of the curve must be y^2 = f(x) and f must have odd degree.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17812,10 +18515,10 @@ Value = NIL \section{I} \subsection{InfClsPt} -\index{InfClsPt!Domain} -\index{Domain!InfClsPt} -\index{ICP} -\begin{chunk}{sane} +\index[dom]{InfClsPt!Domain} +\index[dom]{Domain!InfClsPt} +\index[dom]{ICP} +\begin{chunk}{defclass InfClsPtType} (defclass |InfClsPtType| (|InfinitlyClosePointCategoryType|) ((parents :initform '(|InfinitlyClosePointCategory|)) (name :initform "InfClsPt") @@ -17823,7 +18526,7 @@ Value = NIL (abbreviation :initform 'ICP) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17837,10 +18540,10 @@ Value = NIL \end{chunk} \subsection{IndexCard} -\index{IndexCard!Domain} -\index{Domain!IndexCard} -\index{ICARD} -\begin{chunk}{sane} +\index[dom]{IndexCard!Domain} +\index[dom]{Domain!IndexCard} +\index[dom]{ICARD} +\begin{chunk}{defclass IndexCardType} (defclass |IndexCardType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "IndexCard") @@ -17848,7 +18551,7 @@ Value = NIL (abbreviation :initform 'ICARD) (comment :initform (list "This domain implements a container of information about the AXIOM library")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17862,10 +18565,10 @@ Value = NIL \end{chunk} \subsection{IndexedBits} -\index{IndexedBits!Domain} -\index{Domain!IndexedBits} -\index{IBITS} -\begin{chunk}{sane} +\index[dom]{IndexedBits!Domain} +\index[dom]{Domain!IndexedBits} +\index[dom]{IBITS} +\begin{chunk}{defclass IndexedBitsType} (defclass |IndexedBitsType| (|BitAggregateType|) ((parents :initform '(|BitAggregate|)) (name :initform "IndexedBits") @@ -17874,7 +18577,7 @@ Value = NIL (comment :initform (list "IndexedBits is a domain to compactly represent" "large quantities of Boolean data.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17888,10 +18591,10 @@ Value = NIL \end{chunk} \subsection{IndexedDirectProductAbelianGroup} -\index{IndexedDirectProductAbelianGroup!Domain} -\index{Domain!IndexedDirectProductAbelianGroup} -\index{IDPAG} -\begin{chunk}{sane} +\index[dom]{IndexedDirectProductAbelianGroup!Domain} +\index[dom]{Domain!IndexedDirectProductAbelianGroup} +\index[dom]{IDPAG} +\begin{chunk}{defclass IndexedDirectProductAbelianGroupType} (defclass |IndexedDirectProductAbelianGroupType| (|AbelianGroupType| |IndexedDirectProductCategoryType|) ((parents :initform '(|AbelianGroup| @@ -17903,7 +18606,7 @@ Value = NIL "Indexed direct products of abelian groups over an abelian group A of" "generators indexed by the ordered set S." "All items have finite support: only non-zero terms are stored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17917,10 +18620,10 @@ Value = NIL \end{chunk} \subsection{IndexedDirectProductAbelianMonoid} -\index{IndexedDirectProductAbelianMonoid!Domain} -\index{Domain!IndexedDirectProductAbelianMonoid} -\index{IDPAM} -\begin{chunk}{sane} +\index[dom]{IndexedDirectProductAbelianMonoid!Domain} +\index[dom]{Domain!IndexedDirectProductAbelianMonoid} +\index[dom]{IDPAM} +\begin{chunk}{defclass IndexedDirectProductAbelianMonoidType} (defclass |IndexedDirectProductAbelianMonoidType| (|AbelianMonoidType| |IndexedDirectProductCategoryType|) ((parents :initform '(|AbelianMonoid| @@ -17932,7 +18635,7 @@ Value = NIL "Indexed direct products of abelian monoids over an abelian monoid" "A of generators indexed by the ordered set S. All items have" "finite support. Only non-zero terms are stored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17946,10 +18649,10 @@ Value = NIL \end{chunk} \subsection{IndexedDirectProductObject} -\index{IndexedDirectProductObject!Domain} -\index{Domain!IndexedDirectProductObject} -\index{IDPO} -\begin{chunk}{sane} +\index[dom]{IndexedDirectProductObject!Domain} +\index[dom]{Domain!IndexedDirectProductObject} +\index[dom]{IDPO} +\begin{chunk}{defclass IndexedDirectProductObjectType} (defclass |IndexedDirectProductObjectType| (|IndexedDirectProductCategoryType|) ((parents :initform '(|IndexedDirectProductCategory|)) (name :initform "IndexedDirectProductObject") @@ -17958,7 +18661,7 @@ Value = NIL (comment :initform (list "Indexed direct products of objects over a set A" "of generators indexed by an ordered set S. All items have finite support.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -17972,10 +18675,10 @@ Value = NIL \end{chunk} \subsection{IndexedDirectProductOrderedAbelianMonoid} -\index{IndexedDirectProductOrderedAbelianMonoid!Domain} -\index{Domain!IndexedDirectProductOrderedAbelianMonoid} -\index{IDPOAM} -\begin{chunk}{sane} +\index[dom]{IndexedDirectProductOrderedAbelianMonoid!Domain} +\index[dom]{Domain!IndexedDirectProductOrderedAbelianMonoid} +\index[dom]{IDPOAM} +\begin{chunk}{defclass IndexedDirectProductOrderedAbelianMonoidType} (defclass |IndexedDirectProductOrderedAbelianMonoidType| (|OrderedAbelianMonoidType| |IndexedDirectProductCategoryType|) ((parents :initform '(|OrderedAbelianMonoid| @@ -17988,7 +18691,7 @@ Value = NIL "generators indexed by the ordered set S." "The inherited order is lexicographical." "All items have finite support: only non-zero terms are stored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18002,10 +18705,10 @@ Value = NIL \end{chunk} \subsection{IndexedDirectProductOrderedAbelianMonoidSup} -\index{IndexedDirectProductOrderedAbelianMonoidSup!Domain} -\index{Domain!IndexedDirectProductOrderedAbelianMonoidSup} -\index{IDPOAMS} -\begin{chunk}{sane} +\index[dom]{IndexedDirectProductOrderedAbelianMonoidSup!Domain} +\index[dom]{Domain!IndexedDirectProductOrderedAbelianMonoidSup} +\index[dom]{IDPOAMS} +\begin{chunk}{defclass IndexedDirectProductOrderedAbelianMonoidSupType} (defclass |IndexedDirectProductOrderedAbelianMonoidSupType| (|IndexedDirectProductCategoryType| |OrderedAbelianMonoidSupType|) ((parents :initform '(|IndexedDirectProductCategory| |OrderedAbelianMonoidSup|)) @@ -18016,7 +18719,7 @@ Value = NIL "Indexed direct products of ordered abelian monoid sups A," "generators indexed by the ordered set S." "All items have finite support: only non-zero terms are stored.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18030,10 +18733,10 @@ Value = NIL \end{chunk} \subsection{IndexedExponents} -\index{IndexedExponents!Domain} -\index{Domain!IndexedExponents} -\index{INDE} -\begin{chunk}{sane} +\index[dom]{IndexedExponents!Domain} +\index[dom]{Domain!IndexedExponents} +\index[dom]{INDE} +\begin{chunk}{defclass IndexedExponentsType} (defclass |IndexedExponentsType| (|IndexedDirectProductCategoryType| |OrderedAbelianMonoidSupType|) ((parents :initform '(|IndexedDirectProductCategory| |OrderedAbelianMonoidSup|)) @@ -18044,7 +18747,7 @@ Value = NIL "IndexedExponents of an ordered set of variables gives a representation" "for the degree of polynomials in commuting variables. It gives an ordered" "pairing of non negative integer exponents with variables")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18058,10 +18761,10 @@ Value = NIL \end{chunk} \subsection{IndexedFlexibleArray} -\index{IndexedFlexibleArray!Domain} -\index{Domain!IndexedFlexibleArray} -\index{IFARRAY} -\begin{chunk}{sane} +\index[dom]{IndexedFlexibleArray!Domain} +\index[dom]{Domain!IndexedFlexibleArray} +\index[dom]{IFARRAY} +\begin{chunk}{defclass IndexedFlexibleArrayType} (defclass |IndexedFlexibleArrayType| (|ExtensibleLinearAggregateType| |OneDimensionalArrayAggregateType|) ((parents :initform '(|ExtensibleLinearAggregate| |OneDimensionalArrayAggregate|)) @@ -18083,7 +18786,7 @@ Value = NIL "becomes less than 1/2 full, it is copied into a smaller array." "Flexible arrays provide for an efficient implementation of many" "data structures in particular heaps, stacks and sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18097,10 +18800,10 @@ Value = NIL \end{chunk} \subsection{IndexedList} -\index{IndexedList!Domain} -\index{Domain!IndexedList} -\index{ILIST} -\begin{chunk}{sane} +\index[dom]{IndexedList!Domain} +\index[dom]{Domain!IndexedList} +\index[dom]{ILIST} +\begin{chunk}{defclass IndexedListType} (defclass |IndexedListType| (|ListAggregateType|) ((parents :initform '(|ListAggregate|)) (name :initform "IndexedList") @@ -18115,7 +18818,7 @@ Value = NIL "is probably best viewed as the implementation of singly-linked" "lists that are addressable by index rather than as a mere wrapper" "for LISP lists.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18129,10 +18832,10 @@ Value = NIL \end{chunk} \subsection{IndexedMatrix} -\index{IndexedMatrix!Domain} -\index{Domain!IndexedMatrix} -\index{IMATRIX} -\begin{chunk}{sane} +\index[dom]{IndexedMatrix!Domain} +\index[dom]{Domain!IndexedMatrix} +\index[dom]{IMATRIX} +\begin{chunk}{defclass IndexedMatrixType} (defclass |IndexedMatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "IndexedMatrix") @@ -18147,7 +18850,7 @@ Value = NIL "be obtained by calling the function minColIndex. The index of" "the first element of a 'Row' is the same as the index of the" "first column in a matrix and vice versa.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18161,10 +18864,10 @@ Value = NIL \end{chunk} \subsection{IndexedOneDimensionalArray} -\index{IndexedOneDimensionalArray!Domain} -\index{Domain!IndexedOneDimensionalArray} -\index{IARRAY1} -\begin{chunk}{sane} +\index[dom]{IndexedOneDimensionalArray!Domain} +\index[dom]{Domain!IndexedOneDimensionalArray} +\index[dom]{IARRAY1} +\begin{chunk}{defclass IndexedOneDimensionalArrayType} (defclass |IndexedOneDimensionalArrayType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "IndexedOneDimensionalArray") @@ -18172,7 +18875,7 @@ Value = NIL (abbreviation :initform 'IARRAY1) (comment :initform (list "This is the basic one dimensional array data type.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18186,10 +18889,10 @@ Value = NIL \end{chunk} \subsection{IndexedString} -\index{IndexedString!Domain} -\index{Domain!IndexedString} -\index{ISTRING} -\begin{chunk}{sane} +\index[dom]{IndexedString!Domain} +\index[dom]{Domain!IndexedString} +\index[dom]{ISTRING} +\begin{chunk}{defclass IndexedStringType} (defclass |IndexedStringType| (|StringAggregateType|) ((parents :initform '(|StringAggregate|)) (name :initform "IndexedString") @@ -18197,7 +18900,7 @@ Value = NIL (abbreviation :initform 'ISTRING) (comment :initform (list "This domain implements low-level strings")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18211,10 +18914,10 @@ Value = NIL \end{chunk} \subsection{IndexedTwoDimensionalArray} -\index{IndexedTwoDimensionalArray!Domain} -\index{Domain!IndexedTwoDimensionalArray} -\index{IARRAY2} -\begin{chunk}{sane} +\index[dom]{IndexedTwoDimensionalArray!Domain} +\index[dom]{Domain!IndexedTwoDimensionalArray} +\index[dom]{IARRAY2} +\begin{chunk}{defclass IndexedTwoDimensionalArrayType} (defclass |IndexedTwoDimensionalArrayType| (|TwoDimensionalArrayCategoryType|) ((parents :initform '(|TwoDimensionalArrayCategory|)) (name :initform "IndexedTwoDimensionalArray") @@ -18222,7 +18925,7 @@ Value = NIL (abbreviation :initform 'IARRAY2) (comment :initform (list "This domain implements two dimensional arrays")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18236,10 +18939,10 @@ Value = NIL \end{chunk} \subsection{IndexedVector} -\index{IndexedVector!Domain} -\index{Domain!IndexedVector} -\index{IVECTOR} -\begin{chunk}{sane} +\index[dom]{IndexedVector!Domain} +\index[dom]{Domain!IndexedVector} +\index[dom]{IVECTOR} +\begin{chunk}{defclass IndexedVectorType} (defclass |IndexedVectorType| (|VectorCategoryType|) ((parents :initform '(|VectorCategory|)) (name :initform "IndexedVector") @@ -18248,7 +18951,7 @@ Value = NIL (comment :initform (list "This type represents vector like objects with varying lengths" "and a user-specified initial index.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18262,10 +18965,10 @@ Value = NIL \end{chunk} \subsection{InfiniteTuple} -\index{InfiniteTuple!Domain} -\index{Domain!InfiniteTuple} -\index{ITUPLE} -\begin{chunk}{sane} +\index[dom]{InfiniteTuple!Domain} +\index[dom]{Domain!InfiniteTuple} +\index[dom]{ITUPLE} +\begin{chunk}{defclass InfiniteTupleType} (defclass |InfiniteTupleType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "InfiniteTuple") @@ -18274,7 +18977,7 @@ Value = NIL (comment :initform (list "This package implements 'infinite tuples' for the interpreter." "The representation is a stream.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18288,10 +18991,10 @@ Value = NIL \end{chunk} \subsection{InfinitlyClosePoint} -\index{InfinitlyClosePoint!Domain} -\index{Domain!InfinitlyClosePoint} -\index{INFCLSPT} -\begin{chunk}{sane} +\index[dom]{InfinitlyClosePoint!Domain} +\index[dom]{Domain!InfinitlyClosePoint} +\index[dom]{INFCLSPT} +\begin{chunk}{defclass InfinitlyClosePointType} (defclass |InfinitlyClosePointType| (|InfinitlyClosePointCategoryType|) ((parents :initform '(|InfinitlyClosePointCategory|)) (name :initform "InfinitlyClosePoint") @@ -18299,7 +19002,7 @@ Value = NIL (abbreviation :initform 'INFCLSPT) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18313,10 +19016,10 @@ Value = NIL \end{chunk} \subsection{InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField} -\index{InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField!Domain} -\index{Domain!InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField} -\index{INFCLSPS} -\begin{chunk}{sane} +\index[dom]{InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField!Domain} +\index[dom]{Domain!InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField} +\index[dom]{INFCLSPS} +\begin{chunk}{defclass InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteFieldType} (defclass |InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteFieldType| (|InfinitlyClosePointCategoryType|) ((parents :initform '(|InfinitlyClosePointCategory|)) (name :initform "InfinitlyClosePointOverPseudoAlgebraicClosureOfFiniteField") @@ -18324,7 +19027,7 @@ Value = NIL (abbreviation :initform 'INFCLSPS) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18338,10 +19041,10 @@ Value = NIL \end{chunk} \subsection{InnerAlgebraicNumber} -\index{InnerAlgebraicNumber!Domain} -\index{Domain!InnerAlgebraicNumber} -\index{IAN} -\begin{chunk}{sane} +\index[dom]{InnerAlgebraicNumber!Domain} +\index[dom]{Domain!InnerAlgebraicNumber} +\index[dom]{IAN} +\begin{chunk}{defclass InnerAlgebraicNumberType} (defclass |InnerAlgebraicNumberType| (|AlgebraicallyClosedFieldType| |CharacteristicZeroType| |DifferentialRingType| @@ -18359,7 +19062,7 @@ Value = NIL (abbreviation :initform 'IAN) (comment :initform (list "Algebraic closure of the rational numbers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18373,10 +19076,10 @@ Value = NIL \end{chunk} \subsection{InnerFiniteField} -\index{InnerFiniteField!Domain} -\index{Domain!InnerFiniteField} -\index{IFF} -\begin{chunk}{sane} +\index[dom]{InnerFiniteField!Domain} +\index[dom]{Domain!InnerFiniteField} +\index[dom]{IFF} +\begin{chunk}{defclass InnerFiniteFieldType} (defclass |InnerFiniteFieldType| (|FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|FiniteAlgebraicExtensionField|)) (name :initform "InnerFiniteField") @@ -18386,7 +19089,7 @@ Value = NIL "InnerFiniteField(p,n) implements finite fields with p**n elements" "where p is assumed prime but does not check." "For a version which checks that p is prime, see FiniteField.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18400,10 +19103,10 @@ Value = NIL \end{chunk} \subsection{InnerFreeAbelianMonoid} -\index{InnerFreeAbelianMonoid!Domain} -\index{Domain!InnerFreeAbelianMonoid} -\index{IFAMON} -\begin{chunk}{sane} +\index[dom]{InnerFreeAbelianMonoid!Domain} +\index[dom]{Domain!InnerFreeAbelianMonoid} +\index[dom]{IFAMON} +\begin{chunk}{defclass InnerFreeAbelianMonoidType} (defclass |InnerFreeAbelianMonoidType| (|FreeAbelianMonoidCategoryType|) ((parents :initform '(|FreeAbelianMonoidCategory|)) (name :initform "InnerFreeAbelianMonoid") @@ -18411,7 +19114,7 @@ Value = NIL (abbreviation :initform 'IFAMON) (comment :initform (list "Internal implementation of a free abelian monoid on any set of generators")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18425,10 +19128,10 @@ Value = NIL \end{chunk} \subsection{InnerIndexedTwoDimensionalArray} -\index{InnerIndexedTwoDimensionalArray!Domain} -\index{Domain!InnerIndexedTwoDimensionalArray} -\index{IIARRAY2} -\begin{chunk}{sane} +\index[dom]{InnerIndexedTwoDimensionalArray!Domain} +\index[dom]{Domain!InnerIndexedTwoDimensionalArray} +\index[dom]{IIARRAY2} +\begin{chunk}{defclass InnerIndexedTwoDimensionalArrayType} (defclass |InnerIndexedTwoDimensionalArrayType| (|TwoDimensionalArrayCategoryType|) ((parents :initform '(|TwoDimensionalArrayCategory|)) (name :initform "InnerIndexedTwoDimensionalArray") @@ -18436,7 +19139,7 @@ Value = NIL (abbreviation :initform 'IIARRAY2) (comment :initform (list "There is no description for this domain")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18450,10 +19153,10 @@ Value = NIL \end{chunk} \subsection{InnerPAdicInteger} -\index{InnerPAdicInteger!Domain} -\index{Domain!InnerPAdicInteger} -\index{IPADIC} -\begin{chunk}{sane} +\index[dom]{InnerPAdicInteger!Domain} +\index[dom]{Domain!InnerPAdicInteger} +\index[dom]{IPADIC} +\begin{chunk}{defclass InnerPAdicIntegerType} (defclass |InnerPAdicIntegerType| (|PAdicIntegerCategoryType|) ((parents :initform '(|PAdicIntegerCategory|)) (name :initform "InnerPAdicInteger") @@ -18462,7 +19165,7 @@ Value = NIL (comment :initform (list "This domain implements Zp, the p-adic completion of the integers." "This is an internal domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18476,10 +19179,10 @@ Value = NIL \end{chunk} \subsection{InnerPrimeField} -\index{InnerPrimeField!Domain} -\index{Domain!InnerPrimeField} -\index{IPF} -\begin{chunk}{sane} +\index[dom]{InnerPrimeField!Domain} +\index[dom]{Domain!InnerPrimeField} +\index[dom]{IPF} +\begin{chunk}{defclass InnerPrimeFieldType} (defclass |InnerPrimeFieldType| (|ConvertibleToType| |FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|ConvertibleTo| |FiniteAlgebraicExtensionField|)) @@ -18490,7 +19193,7 @@ Value = NIL "InnerPrimeField(p) implements the field with p elements." "Note: argument p MUST be a prime (this domain does not check)." "See PrimeField for a domain that does check.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18504,10 +19207,10 @@ Value = NIL \end{chunk} \subsection{InnerSparseUnivariatePowerSeries} -\index{InnerSparseUnivariatePowerSeries!Domain} -\index{Domain!InnerSparseUnivariatePowerSeries} -\index{ISUPS} -\begin{chunk}{sane} +\index[dom]{InnerSparseUnivariatePowerSeries!Domain} +\index[dom]{Domain!InnerSparseUnivariatePowerSeries} +\index[dom]{ISUPS} +\begin{chunk}{defclass InnerSparseUnivariatePowerSeriesType} (defclass |InnerSparseUnivariatePowerSeriesType| (|UnivariatePowerSeriesCategoryType|) ((parents :initform '(|UnivariatePowerSeriesCategory|)) (name :initform "InnerSparseUnivariatePowerSeries") @@ -18516,7 +19219,7 @@ Value = NIL (comment :initform (list "InnerSparseUnivariatePowerSeries is an internal domain" "used for creating sparse Taylor and Laurent series.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18530,10 +19233,10 @@ Value = NIL \end{chunk} \subsection{InnerTable} -\index{InnerTable!Domain} -\index{Domain!InnerTable} -\index{INTABL} -\begin{chunk}{sane} +\index[dom]{InnerTable!Domain} +\index[dom]{Domain!InnerTable} +\index[dom]{INTABL} +\begin{chunk}{defclass InnerTableType} (defclass |InnerTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "InnerTable") @@ -18542,7 +19245,7 @@ Value = NIL (comment :initform (list "This domain is used to provide a conditional 'add' domain" "for the implementation of Table.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18556,10 +19259,10 @@ Value = NIL \end{chunk} \subsection{InnerTaylorSeries} -\index{InnerTaylorSeries!Domain} -\index{Domain!InnerTaylorSeries} -\index{ITAYLOR} -\begin{chunk}{sane} +\index[dom]{InnerTaylorSeries!Domain} +\index[dom]{Domain!InnerTaylorSeries} +\index[dom]{ITAYLOR} +\begin{chunk}{defclass InnerTaylorSeriesType} (defclass |InnerTaylorSeriesType| (|IntegralDomainType|) ((parents :initform '(|IntegralDomain|)) (name :initform "InnerTaylorSeries") @@ -18571,7 +19274,7 @@ Value = NIL "For univariate series, the Stream elements are the Taylor" "coefficients. For multivariate series, the nth Stream element" "is a form of degree n in the power series variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18585,10 +19288,10 @@ Value = NIL \end{chunk} \subsection{InputForm} -\index{InputForm!Domain} -\index{Domain!InputForm} -\index{INFORM} -\begin{chunk}{sane} +\index[dom]{InputForm!Domain} +\index[dom]{Domain!InputForm} +\index[dom]{INFORM} +\begin{chunk}{defclass InputFormType} (defclass |InputFormType| (|ConvertibleToType| |SExpressionCategoryType|) ((parents :initform '(|ConvertibleTo| |SExpressionCategory|)) (name :initform "InputForm") @@ -18598,7 +19301,7 @@ Value = NIL "Domain of parsed forms which can be passed to the interpreter." "This is also the interface between algebra code and facilities" "in the interpreter.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18612,10 +19315,10 @@ Value = NIL \end{chunk} \subsection{Integer} -\index{Integer!Domain} -\index{Domain!Integer} -\index{INT} -\begin{chunk}{sane} +\index[dom]{Integer!Domain} +\index[dom]{Domain!Integer} +\index[dom]{INT} +\begin{chunk}{defclass IntegerType} (defclass |IntegerType| (|IntegerNumberSystemType| |OpenMathType|) ((parents :initform '(|IntegerNumberSystem| |OpenMath|)) (name :initform "Integer") @@ -18623,7 +19326,7 @@ Value = NIL (abbreviation :initform 'INT) (comment :initform (list "Integer provides the domain of arbitrary precision integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18637,10 +19340,10 @@ Value = NIL \end{chunk} \subsection{IntegerMod} -\index{IntegerMod!Domain} -\index{Domain!IntegerMod} -\index{ZMOD} -\begin{chunk}{sane} +\index[dom]{IntegerMod!Domain} +\index[dom]{Domain!IntegerMod} +\index[dom]{ZMOD} +\begin{chunk}{defclass IntegerModType} (defclass |IntegerModType| (|StepThroughType| |FiniteType| |ConvertibleToType| @@ -18654,7 +19357,7 @@ Value = NIL (abbreviation :initform 'ZMOD) (comment :initform (list "IntegerMod(n) creates the ring of integers reduced modulo the integer n.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18668,10 +19371,10 @@ Value = NIL \end{chunk} \subsection{IntegrationFunctionsTable} -\index{IntegrationFunctionsTable!Domain} -\index{Domain!IntegrationFunctionsTable} -\index{INTFTBL} -\begin{chunk}{sane} +\index[dom]{IntegrationFunctionsTable!Domain} +\index[dom]{Domain!IntegrationFunctionsTable} +\index[dom]{INTFTBL} +\begin{chunk}{defclass IntegrationFunctionsTableType} (defclass |IntegrationFunctionsTableType| (|AxiomClass|) ((parents :initform '()) (name :initform "IntegrationFunctionsTable") @@ -18679,7 +19382,7 @@ Value = NIL (abbreviation :initform 'INTFTBL) (comment :initform (list "There is no description for this domain")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18693,10 +19396,10 @@ Value = NIL \end{chunk} \subsection{IntegrationResult} -\index{IntegrationResult!Domain} -\index{Domain!IntegrationResult} -\index{IR} -\begin{chunk}{sane} +\index[dom]{IntegrationResult!Domain} +\index[dom]{Domain!IntegrationResult} +\index[dom]{IR} +\begin{chunk}{defclass IntegrationResultType} (defclass |IntegrationResultType| (|RetractableToType| |ModuleType|) ((parents :initform '(|RetractableTo| |Module|)) (name :initform "IntegrationResult") @@ -18711,7 +19414,7 @@ Value = NIL "logarithmic part of the integral. This domain manipulates integrals" "represented in that form, by keeping both parts separately. The logs" "are not explicitly computed.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18725,10 +19428,10 @@ Value = NIL \end{chunk} \subsection{Interval} -\index{Interval!Domain} -\index{Domain!Interval} -\index{INTRVL} -\begin{chunk}{sane} +\index[dom]{Interval!Domain} +\index[dom]{Domain!Interval} +\index[dom]{INTRVL} +\begin{chunk}{defclass IntervalType} (defclass |IntervalType| (|IntervalCategoryType|) ((parents :initform '(|IntervalCategory|)) (name :initform "Interval") @@ -18737,7 +19440,7 @@ Value = NIL (comment :initform (list "This domain is an implementation of interval arithmetic and transcendental" "functions over intervals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18753,10 +19456,10 @@ Value = NIL \section{K} \subsection{Kernel} -\index{Kernel!Domain} -\index{Domain!Kernel} -\index{KERNEL} -\begin{chunk}{sane} +\index[dom]{Kernel!Domain} +\index[dom]{Domain!Kernel} +\index[dom]{KERNEL} +\begin{chunk}{defclass KernelType} (defclass |KernelType| (|CachableSetType| |PatternableType|) ((parents :initform '(|CachableSet| |Patternable|)) (name :initform "Kernel") @@ -18765,7 +19468,7 @@ Value = NIL (comment :initform (list "A kernel over a set S is an operator applied to a given list" "of arguments from S.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18779,10 +19482,10 @@ Value = NIL \end{chunk} \subsection{KeyedAccessFile} -\index{KeyedAccessFile!Domain} -\index{Domain!KeyedAccessFile} -\index{KAFILE} -\begin{chunk}{sane} +\index[dom]{KeyedAccessFile!Domain} +\index[dom]{Domain!KeyedAccessFile} +\index[dom]{KAFILE} +\begin{chunk}{defclass KeyedAccessFileType} (defclass |KeyedAccessFileType| (|TableAggregateType| |FileCategoryType|) ((parents :initform '(|TableAggregate| |FileCategory|)) (name :initform "KeyedAccessFile") @@ -18798,7 +19501,7 @@ Value = NIL "((key . byteoffset) (key . byteoffset)...)" "where the byte offset is the number of bytes from the beginning of" "the file. This offset contains an s-expression for the value of the key.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18814,10 +19517,10 @@ Value = NIL \section{L} \subsection{LaurentPolynomial} -\index{LaurentPolynomial!Domain} -\index{Domain!LaurentPolynomial} -\index{LAUPOL} -\begin{chunk}{sane} +\index[dom]{LaurentPolynomial!Domain} +\index[dom]{Domain!LaurentPolynomial} +\index[dom]{LAUPOL} +\begin{chunk}{defclass LaurentPolynomialType} (defclass |LaurentPolynomialType| (|FullyRetractableToType| |EuclideanDomainType| |DifferentialExtensionType| @@ -18835,7 +19538,7 @@ Value = NIL (abbreviation :initform 'LAUPOL) (comment :initform (list "Univariate polynomials with negative and positive exponents.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18849,10 +19552,10 @@ Value = NIL \end{chunk} \subsection{Library} -\index{Library!Domain} -\index{Domain!Library} -\index{LIB} -\begin{chunk}{sane} +\index[dom]{Library!Domain} +\index[dom]{Domain!Library} +\index[dom]{LIB} +\begin{chunk}{defclass LibraryType} (defclass |LibraryType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "Library") @@ -18860,7 +19563,7 @@ Value = NIL (abbreviation :initform 'LIB) (comment :initform (list "This domain provides a simple way to save values in files.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18874,10 +19577,10 @@ Value = NIL \end{chunk} \subsection{LieExponentials} -\index{LieExponentials!Domain} -\index{Domain!LieExponentials} -\index{LEXP} -\begin{chunk}{sane} +\index[dom]{LieExponentials!Domain} +\index[dom]{Domain!LieExponentials} +\index[dom]{LEXP} +\begin{chunk}{defclass LieExponentialsType} (defclass |LieExponentialsType| (|GroupType|) ((parents :initform '(|Group|)) (name :initform "LieExponentials") @@ -18890,7 +19593,7 @@ Value = NIL "The implementation inherits from the XPBWPolynomial" "domain constructor: Lyndon coordinates are exponential coordinates" "of the second kind. ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18904,10 +19607,10 @@ Value = NIL \end{chunk} \subsection{LiePolynomial} -\index{LiePolynomial!Domain} -\index{Domain!LiePolynomial} -\index{LPOLY} -\begin{chunk}{sane} +\index[dom]{LiePolynomial!Domain} +\index[dom]{Domain!LiePolynomial} +\index[dom]{LPOLY} +\begin{chunk}{defclass LiePolynomialType} (defclass |LiePolynomialType| (|FreeLieAlgebraType| |FreeModuleCatType|) ((parents :initform '(|FreeLieAlgebra| |FreeModuleCat|)) (name :initform "LiePolynomial") @@ -18916,7 +19619,7 @@ Value = NIL (comment :initform (list "This type supports Lie polynomials in Lyndon basis" "see Free Lie Algebras by C. Reutenauer")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18930,10 +19633,10 @@ Value = NIL \end{chunk} \subsection{LieSquareMatrix} -\index{LieSquareMatrix!Domain} -\index{Domain!LieSquareMatrix} -\index{LSQM} -\begin{chunk}{sane} +\index[dom]{LieSquareMatrix!Domain} +\index[dom]{Domain!LieSquareMatrix} +\index[dom]{LSQM} +\begin{chunk}{defclass LieSquareMatrixType} (defclass |LieSquareMatrixType| (|FramedNonAssociativeAlgebraType| |SquareMatrixCategoryType|) ((parents :initform '(|FramedNonAssociativeAlgebra| |SquareMatrixCategory|)) @@ -18946,7 +19649,7 @@ Value = NIL "The Lie bracket (commutator) of the algebra is given by" "a*b := (a *$SQMATRIX(n,R) b - b *$SQMATRIX(n,R) a)," "where *$SQMATRIX(n,R) is the usual matrix multiplication.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18960,10 +19663,10 @@ Value = NIL \end{chunk} \subsection{LinearOrdinaryDifferentialOperator} -\index{LinearOrdinaryDifferentialOperator!Domain} -\index{Domain!LinearOrdinaryDifferentialOperator} -\index{LODO} -\begin{chunk}{sane} +\index[dom]{LinearOrdinaryDifferentialOperator!Domain} +\index[dom]{Domain!LinearOrdinaryDifferentialOperator} +\index[dom]{LODO} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperatorType} (defclass |LinearOrdinaryDifferentialOperatorType| (|LinearOrdinaryDifferentialOperatorCategoryType|) ((parents :initform '(|LinearOrdinaryDifferentialOperatorCategory|)) (name :initform "LinearOrdinaryDifferentialOperator") @@ -18975,7 +19678,7 @@ Value = NIL "derivation." "Multiplication of operators corresponds to functional composition:" "(L1 * L2).(f) = L1 L2 f")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -18989,10 +19692,10 @@ Value = NIL \end{chunk} \subsection{LinearOrdinaryDifferentialOperator1} -\index{LinearOrdinaryDifferentialOperator1!Domain} -\index{Domain!LinearOrdinaryDifferentialOperator1} -\index{LODO1} -\begin{chunk}{sane} +\index[dom]{LinearOrdinaryDifferentialOperator1!Domain} +\index[dom]{Domain!LinearOrdinaryDifferentialOperator1} +\index[dom]{LODO1} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperator1Type} (defclass |LinearOrdinaryDifferentialOperator1Type| (|LinearOrdinaryDifferentialOperatorCategoryType|) ((parents :initform '(|LinearOrdinaryDifferentialOperatorCategory|)) (name :initform "LinearOrdinaryDifferentialOperator1") @@ -19003,7 +19706,7 @@ Value = NIL "differential operators with coefficients in a differential ring A" "Multiplication of operators corresponds to functional composition:" "(L1 * L2).(f) = L1 L2 f")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19017,10 +19720,10 @@ Value = NIL \end{chunk} \subsection{LinearOrdinaryDifferentialOperator2} -\index{LinearOrdinaryDifferentialOperator2!Domain} -\index{Domain!LinearOrdinaryDifferentialOperator2} -\index{LODO2} -\begin{chunk}{sane} +\index[dom]{LinearOrdinaryDifferentialOperator2!Domain} +\index[dom]{Domain!LinearOrdinaryDifferentialOperator2} +\index[dom]{LODO2} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperator2Type} (defclass |LinearOrdinaryDifferentialOperator2Type| (|LinearOrdinaryDifferentialOperatorCategoryType|) ((parents :initform '(|LinearOrdinaryDifferentialOperatorCategory|)) (name :initform "LinearOrdinaryDifferentialOperator2") @@ -19032,7 +19735,7 @@ Value = NIL "and acting on an A-module M." "Multiplication of operators corresponds to functional composition:" "(L1 * L2).(f) = L1 L2 f")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19046,10 +19749,10 @@ Value = NIL \end{chunk} \subsection{List} -\index{List!Domain} -\index{Domain!List} -\index{LIST} -\begin{chunk}{sane} +\index[dom]{List!Domain} +\index[dom]{Domain!List} +\index[dom]{LIST} +\begin{chunk}{defclass ListType} (defclass |ListType| (|OpenMathType| |ListAggregateType|) ((parents :initform '(|OpenMath| |ListAggregate|)) (name :initform "List") @@ -19061,7 +19764,7 @@ Value = NIL "is 1. In addition to the operations provided by" "IndexedList, this constructor provides some" "LISP-like functions such as null and cons.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19075,10 +19778,10 @@ Value = NIL \end{chunk} \subsection{ListMonoidOps} -\index{ListMonoidOps!Domain} -\index{Domain!ListMonoidOps} -\index{LMOPS} -\begin{chunk}{sane} +\index[dom]{ListMonoidOps!Domain} +\index[dom]{Domain!ListMonoidOps} +\index[dom]{LMOPS} +\begin{chunk}{defclass ListMonoidOpsType} (defclass |ListMonoidOpsType| (|SetCategoryType| |RetractableToType|) ((parents :initform '(|SetCategory| |RetractableTo|)) (name :initform "ListMonoidOps") @@ -19088,7 +19791,7 @@ Value = NIL "This internal package represents monoid (abelian or not, with or" "without inverses) as lists and provides some common operations" "to the various flavors of monoids.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19102,10 +19805,10 @@ Value = NIL \end{chunk} \subsection{ListMultiDictionary} -\index{ListMultiDictionary!Domain} -\index{Domain!ListMultiDictionary} -\index{LMDICT} -\begin{chunk}{sane} +\index[dom]{ListMultiDictionary!Domain} +\index[dom]{Domain!ListMultiDictionary} +\index[dom]{LMDICT} +\begin{chunk}{defclass ListMultiDictionaryType} (defclass |ListMultiDictionaryType| (|MultiDictionaryType|) ((parents :initform '(|MultiDictionary|)) (name :initform "ListMultiDictionary") @@ -19119,7 +19822,7 @@ Value = NIL "when the number of entries in the dictionary becomes large." "If the objects in the dictionary belong to an ordered set," "the entries are maintained in ascending order.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19133,10 +19836,10 @@ Value = NIL \end{chunk} \subsection{LocalAlgebra} -\index{LocalAlgebra!Domain} -\index{Domain!LocalAlgebra} -\index{LA} -\begin{chunk}{sane} +\index[dom]{LocalAlgebra!Domain} +\index[dom]{Domain!LocalAlgebra} +\index[dom]{LA} +\begin{chunk}{defclass LocalAlgebraType} (defclass |LocalAlgebraType| (|AlgebraType| |OrderedRingType|) ((parents :initform '(|Algebra| |OrderedRing|)) (name :initform "LocalAlgebra") @@ -19145,7 +19848,7 @@ Value = NIL (comment :initform (list "LocalAlgebra produces the localization of an algebra," "fractions whose numerators come from some R algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19159,10 +19862,10 @@ Value = NIL \end{chunk} \subsection{Localize} -\index{Localize!Domain} -\index{Domain!Localize} -\index{LO} -\begin{chunk}{sane} +\index[dom]{Localize!Domain} +\index[dom]{Domain!Localize} +\index[dom]{LO} +\begin{chunk}{defclass LocalizeType} (defclass |LocalizeType| (|ModuleType| |OrderedAbelianGroupType|) ((parents :initform '(|Module| |OrderedAbelianGroup|)) (name :initform "Localize") @@ -19171,7 +19874,7 @@ Value = NIL (comment :initform (list "Localize(M,R,S) produces fractions with numerators" "from an R module M and denominators from some multiplicative subset D of R.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19185,10 +19888,10 @@ Value = NIL \end{chunk} \subsection{LyndonWord} -\index{LyndonWord!Domain} -\index{Domain!LyndonWord} -\index{LWORD} -\begin{chunk}{sane} +\index[dom]{LyndonWord!Domain} +\index[dom]{Domain!LyndonWord} +\index[dom]{LWORD} +\begin{chunk}{defclass LyndonWordType} (defclass |LyndonWordType| (|OrderedSetType| |RetractableToType|) ((parents :initform '(|OrderedSet| |RetractableTo|)) (name :initform "LyndonWord") @@ -19208,7 +19911,7 @@ Value = NIL "Magma domain constructor." "Two ordering are provided: lexicographic and" "length-lexicographic. ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19225,9 +19928,9 @@ Value = NIL %TPDHERE class precedence error \subsection{MachineComplex} -\index{MachineComplex!Domain} -\index{Domain!MachineComplex} -\index{MCMPLX} +\index[dom]{MachineComplex!Domain} +\index[dom]{Domain!MachineComplex} +\index[dom]{MCMPLX} \begin{chunk}{insane} (defclass |MachineComplexType| (|ComplexCategoryType| |FortranMachineTypeCategoryType|) ((parents :initform '(|ComplexCategory| |FortranMachineTypeCategory|)) @@ -19237,7 +19940,7 @@ Value = NIL (comment :initform (list "A domain which models the complex number representation" "used by machines in the AXIOM-NAG link.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19252,9 +19955,9 @@ Value = NIL %TPDHERE class precedence error \subsection{MachineFloat} -\index{MachineFloat!Domain} -\index{Domain!MachineFloat} -\index{MFLOAT} +\index[dom]{MachineFloat!Domain} +\index[dom]{Domain!MachineFloat} +\index[dom]{MFLOAT} \begin{chunk}{insane} (defclass |MachineFloatType| (|FloatingPointSystemType| |FortranMachineTypeCategoryType|) ((parents :initform '(|FloatingPointSystem| |FortranMachineTypeCategory|)) @@ -19264,7 +19967,7 @@ Value = NIL (comment :initform (list "A domain which models the floating point representation" " used by machines in the AXIOM-NAG link.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19279,10 +19982,10 @@ Value = NIL %TPDHERE class precedence failure \subsection{MachineInteger} -\index{MachineInteger!Domain} -\index{Domain!MachineInteger} -\index{MINT} -\begin{chunk}{sane} +\index[dom]{MachineInteger!Domain} +\index[dom]{Domain!MachineInteger} +\index[dom]{MINT} +\begin{chunk}{defclass MachineIntegerType} (defclass |MachineIntegerType| (|IntegerNumberSystemType|); |FortranMachineTypeCategoryType|) ((parents :initform '(|IntegerNumberSystem| |FortranMachineTypeCategory|)) (name :initform "MachineInteger") @@ -19291,7 +19994,7 @@ Value = NIL (comment :initform (list "A domain which models the integer representation" " used by machines in the AXIOM-NAG link.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19305,10 +20008,10 @@ Value = NIL \end{chunk} \subsection{Magma} -\index{Magma!Domain} -\index{Domain!Magma} -\index{MAGMA} -\begin{chunk}{sane} +\index[dom]{Magma!Domain} +\index[dom]{Domain!Magma} +\index[dom]{MAGMA} +\begin{chunk}{defclass MagmaType} (defclass |MagmaType| (|OrderedSetType| |RetractableToType|) ((parents :initform '(|OrderedSet| |RetractableTo|)) (name :initform "Magma") @@ -19318,7 +20021,7 @@ Value = NIL "This type is the basic representation of" "parenthesized words (binary trees over arbitrary symbols)" "useful in LiePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19332,10 +20035,10 @@ Value = NIL \end{chunk} \subsection{MakeCachableSet} -\index{MakeCachableSet!Domain} -\index{Domain!MakeCachableSet} -\index{MKCHSET} -\begin{chunk}{sane} +\index[dom]{MakeCachableSet!Domain} +\index[dom]{Domain!MakeCachableSet} +\index[dom]{MKCHSET} +\begin{chunk}{defclass MakeCachableSetType} (defclass |MakeCachableSetType| (|CachableSetType|) ((parents :initform '(|CachableSet|)) (name :initform "MakeCachableSet") @@ -19343,7 +20046,7 @@ Value = NIL (abbreviation :initform 'MKCHSET) (comment :initform (list "MakeCachableSet(S) returns a cachable set which is equal to S as a set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19357,10 +20060,10 @@ Value = NIL \end{chunk} \subsection{MathMLFormat} -\index{MathMLFormat!Domain} -\index{Domain!MathMLFormat} -\index{MMLFORM} -\begin{chunk}{sane} +\index[dom]{MathMLFormat!Domain} +\index[dom]{Domain!MathMLFormat} +\index[dom]{MMLFORM} +\begin{chunk}{defclass MathMLFormatType} (defclass |MathMLFormatType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "MathMLFormat") @@ -19370,7 +20073,7 @@ Value = NIL "This package is based on the TeXFormat domain by Robert S. Sutor" "MathMLFormat provides a coercion from OutputForm" "to MathML format.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19384,10 +20087,10 @@ Value = NIL \end{chunk} \subsection{Matrix} -\index{Matrix!Domain} -\index{Domain!Matrix} -\index{MATRIX} -\begin{chunk}{sane} +\index[dom]{Matrix!Domain} +\index[dom]{Domain!Matrix} +\index[dom]{MATRIX} +\begin{chunk}{defclass MatrixType} (defclass |MatrixType| (|ConvertibleToType| |MatrixCategoryType|) ((parents :initform '(|ConvertibleTo| |MatrixCategory|)) (name :initform "Matrix") @@ -19396,7 +20099,7 @@ Value = NIL (comment :initform (list "Matrix is a matrix domain where 1-based indexing is used" "for both rows and columns.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19410,10 +20113,10 @@ Value = NIL \end{chunk} \subsection{ModMonic} -\index{ModMonic!Domain} -\index{Domain!ModMonic} -\index{MODMON} -\begin{chunk}{sane} +\index[dom]{ModMonic!Domain} +\index[dom]{Domain!ModMonic} +\index[dom]{MODMON} +\begin{chunk}{defclass ModMonicType} (defclass |ModMonicType| (|UnivariatePolynomialCategoryType| |FiniteType|) ((parents :initform '(|UnivariatePolynomialCategory| |Finite|)) (name :initform "ModMonic") @@ -19421,7 +20124,7 @@ Value = NIL (abbreviation :initform 'MODMON) (comment :initform (list "This package has not been documented")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19435,10 +20138,10 @@ Value = NIL \end{chunk} \subsection{ModularField} -\index{ModularField!Domain} -\index{Domain!ModularField} -\index{MODFIELD} -\begin{chunk}{sane} +\index[dom]{ModularField!Domain} +\index[dom]{Domain!ModularField} +\index[dom]{MODFIELD} +\begin{chunk}{defclass ModularFieldType} (defclass |ModularFieldType| (|FieldType|) ((parents :initform '(|Field|)) (name :initform "ModularField") @@ -19449,7 +20152,7 @@ Value = NIL "of univariate polynomials over the integers in order to work modulo" "different primes." "See ModularRing, EuclideanModularRing")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19463,10 +20166,10 @@ Value = NIL \end{chunk} \subsection{ModularRing} -\index{ModularRing!Domain} -\index{Domain!ModularRing} -\index{MODRING} -\begin{chunk}{sane} +\index[dom]{ModularRing!Domain} +\index[dom]{Domain!ModularRing} +\index[dom]{MODRING} +\begin{chunk}{defclass ModularRingType} (defclass |ModularRingType| (|RingType|) ((parents :initform '(|Ring|)) (name :initform "ModularRing") @@ -19477,7 +20180,7 @@ Value = NIL "of univariate polynomials over the integers in order to work modulo" "different primes." "See EuclideanModularRing ,ModularField")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19491,10 +20194,10 @@ Value = NIL \end{chunk} \subsection{ModuleMonomial} -\index{ModuleMonomial!Domain} -\index{Domain!ModuleMonomial} -\index{MODMONOM} -\begin{chunk}{sane} +\index[dom]{ModuleMonomial!Domain} +\index[dom]{Domain!ModuleMonomial} +\index[dom]{MODMONOM} +\begin{chunk}{defclass ModuleMonomialType} (defclass |ModuleMonomialType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "ModuleMonomial") @@ -19502,7 +20205,7 @@ Value = NIL (abbreviation :initform 'MODMONOM) (comment :initform (list "This package has no documentation")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19516,10 +20219,10 @@ Value = NIL \end{chunk} \subsection{ModuleOperator} -\index{ModuleOperator!Domain} -\index{Domain!ModuleOperator} -\index{MODOP} -\begin{chunk}{sane} +\index[dom]{ModuleOperator!Domain} +\index[dom]{Domain!ModuleOperator} +\index[dom]{MODOP} +\begin{chunk}{defclass ModuleOperatorType} (defclass |ModuleOperatorType| (|AlgebraType| |CharacteristicNonZeroType| |CharacteristicZeroType| @@ -19535,7 +20238,7 @@ Value = NIL (abbreviation :initform 'MODOP) (comment :initform (list "Algebra of ADDITIVE operators on a module.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19549,10 +20252,10 @@ Value = NIL \end{chunk} \subsection{MoebiusTransform} -\index{MoebiusTransform!Domain} -\index{Domain!MoebiusTransform} -\index{MOEBIUS} -\begin{chunk}{sane} +\index[dom]{MoebiusTransform!Domain} +\index[dom]{Domain!MoebiusTransform} +\index[dom]{MOEBIUS} +\begin{chunk}{defclass MoebiusTransformType} (defclass |MoebiusTransformType| (|GroupType|) ((parents :initform '(|Group|)) (name :initform "MoebiusTransform") @@ -19561,7 +20264,7 @@ Value = NIL (comment :initform (list "MoebiusTransform(F) is the domain of fractional linear (Moebius)" "transformations over F. This a domain of 2-by-2 matrices acting on P1(F).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19575,10 +20278,10 @@ Value = NIL \end{chunk} \subsection{MonoidRing} -\index{MonoidRing!Domain} -\index{Domain!MonoidRing} -\index{MRING} -\begin{chunk}{sane} +\index[dom]{MonoidRing!Domain} +\index[dom]{Domain!MonoidRing} +\index[dom]{MRING} +\begin{chunk}{defclass MonoidRingType} (defclass |MonoidRingType| (|RetractableToType| |FiniteType| |CharacteristicZeroType| @@ -19608,7 +20311,7 @@ Value = NIL "in infinitely many non-commuting variables. Another application" "area is representation theory of finite groups G, where modules" "over MonoidRing(R,G) are studied.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19622,10 +20325,10 @@ Value = NIL \end{chunk} \subsection{Multiset} -\index{Multiset!Domain} -\index{Domain!Multiset} -\index{MSET} -\begin{chunk}{sane} +\index[dom]{Multiset!Domain} +\index[dom]{Domain!Multiset} +\index[dom]{MSET} +\begin{chunk}{defclass MultisetType} (defclass |MultisetType| (|MultisetAggregateType|) ((parents :initform '(|MultisetAggregate|)) (name :initform "Multiset") @@ -19633,7 +20336,7 @@ Value = NIL (abbreviation :initform 'MSET) (comment :initform (list "A multiset is a set with multiplicities.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19647,10 +20350,10 @@ Value = NIL \end{chunk} \subsection{MultivariatePolynomial} -\index{MultivariatePolynomial!Domain} -\index{Domain!MultivariatePolynomial} -\index{MPOLY} -\begin{chunk}{sane} +\index[dom]{MultivariatePolynomial!Domain} +\index[dom]{Domain!MultivariatePolynomial} +\index[dom]{MPOLY} +\begin{chunk}{defclass MultivariatePolynomialType} (defclass |MultivariatePolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "MultivariatePolynomial") @@ -19662,7 +20365,7 @@ Value = NIL "The ordering is specified by the position of the variable in the list." "The coefficient ring may be non commutative," "but the variables are assumed to commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19676,10 +20379,10 @@ Value = NIL \end{chunk} \subsection{MyExpression} -\index{MyExpression!Domain} -\index{Domain!MyExpression} -\index{MYEXPR} -\begin{chunk}{sane} +\index[dom]{MyExpression!Domain} +\index[dom]{Domain!MyExpression} +\index[dom]{MYEXPR} +\begin{chunk}{defclass MyExpressionType} (defclass |MyExpressionType| (|FunctionSpaceType| |CombinatorialOpsCategoryType|) ((parents :initform '(|FunctionSpace| |CombinatorialOpsCategory|)) (name :initform "MyExpression") @@ -19687,7 +20390,7 @@ Value = NIL (abbreviation :initform 'MYEXPR) (comment :initform (list "This domain has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19701,10 +20404,10 @@ Value = NIL \end{chunk} \subsection{MyUnivariatePolynomial} -\index{MyUnivariatePolynomial!Domain} -\index{Domain!MyUnivariatePolynomial} -\index{MYUP} -\begin{chunk}{sane} +\index[dom]{MyUnivariatePolynomial!Domain} +\index[dom]{Domain!MyUnivariatePolynomial} +\index[dom]{MYUP} +\begin{chunk}{defclass MyUnivariatePolynomialType} (defclass |MyUnivariatePolynomialType| (|UnivariatePolynomialCategoryType|) ((parents :initform '(|UnivariatePolynomialCategory|)) (name :initform "MyUnivariatePolynomial") @@ -19712,7 +20415,7 @@ Value = NIL (abbreviation :initform 'MYUP) (comment :initform (list "This domain has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19728,10 +20431,10 @@ Value = NIL \section{N} \subsection{NeitherSparseOrDensePowerSeries} -\index{NeitherSparseOrDensePowerSeries!Domain} -\index{Domain!NeitherSparseOrDensePowerSeries} -\index{NSDPS} -\begin{chunk}{sane} +\index[dom]{NeitherSparseOrDensePowerSeries!Domain} +\index[dom]{Domain!NeitherSparseOrDensePowerSeries} +\index[dom]{NSDPS} +\begin{chunk}{defclass NeitherSparseOrDensePowerSeriesType} (defclass |NeitherSparseOrDensePowerSeriesType| (|LocalPowerSeriesCategoryType| |LazyStreamAggregateType|) ((parents :initform '(|LocalPowerSeriesCategory| |LazyStreamAggregate|)) @@ -19740,7 +20443,7 @@ Value = NIL (abbreviation :initform 'NSDPS) (comment :initform (list "This domain is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19754,10 +20457,10 @@ Value = NIL \end{chunk} \subsection{NewSparseMultivariatePolynomial} -\index{NewSparseMultivariatePolynomial!Domain} -\index{Domain!NewSparseMultivariatePolynomial} -\index{NSMP} -\begin{chunk}{sane} +\index[dom]{NewSparseMultivariatePolynomial!Domain} +\index[dom]{Domain!NewSparseMultivariatePolynomial} +\index[dom]{NSMP} +\begin{chunk}{defclass NewSparseMultivariatePolynomialType} (defclass |NewSparseMultivariatePolynomialType| (|RecursivePolynomialCategoryType|) ((parents :initform '(|RecursivePolynomialCategory|)) (name :initform "NewSparseMultivariatePolynomial") @@ -19768,7 +20471,7 @@ Value = NIL "to speed up operations related to pseudo-division and gcd." "This domain is based on the NSUP constructor which is" "itself a post-facto extension of the SUP constructor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19782,10 +20485,10 @@ Value = NIL \end{chunk} \subsection{NewSparseUnivariatePolynomial} -\index{NewSparseUnivariatePolynomial!Domain} -\index{Domain!NewSparseUnivariatePolynomial} -\index{NSUP} -\begin{chunk}{sane} +\index[dom]{NewSparseUnivariatePolynomial!Domain} +\index[dom]{Domain!NewSparseUnivariatePolynomial} +\index[dom]{NSUP} +\begin{chunk}{defclass NewSparseUnivariatePolynomialType} (defclass |NewSparseUnivariatePolynomialType| (|UnivariatePolynomialCategoryType|) ((parents :initform '(|UnivariatePolynomialCategory|)) (name :initform "NewSparseUnivariatePolynomial") @@ -19795,7 +20498,7 @@ Value = NIL "A post-facto extension for SUP in order" "to speed up operations related to pseudo-division and gcd for" "both SUP and, consequently, NSMP.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19809,10 +20512,10 @@ Value = NIL \end{chunk} \subsection{None} -\index{None!Domain} -\index{Domain!None} -\index{NONE} -\begin{chunk}{sane} +\index[dom]{None!Domain} +\index[dom]{Domain!None} +\index[dom]{NONE} +\begin{chunk}{defclass NoneType} (defclass |NoneType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "None") @@ -19822,7 +20525,7 @@ Value = NIL "None implements a type with no objects. It is mainly" "used in technical situations where such a thing is needed (for example," "the interpreter and some of the internal Expression code).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19836,10 +20539,10 @@ Value = NIL \end{chunk} \subsection{NonNegativeInteger} -\index{NonNegativeInteger!Domain} -\index{Domain!NonNegativeInteger} -\index{NNI} -\begin{chunk}{sane} +\index[dom]{NonNegativeInteger!Domain} +\index[dom]{Domain!NonNegativeInteger} +\index[dom]{NNI} +\begin{chunk}{defclass NonNegativeIntegerType} (defclass |NonNegativeIntegerType| (|OrderedAbelianMonoidSupType| |MonoidType|) ((parents :initform '(|OrderedAbelianMonoidSup| |Monoid|)) (name :initform "NonNegativeInteger") @@ -19847,7 +20550,7 @@ Value = NIL (abbreviation :initform 'NNI) (comment :initform (list "NonNegativeInteger provides functions for non negative integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19861,10 +20564,10 @@ Value = NIL \end{chunk} \subsection{NottinghamGroup} -\index{NottinghamGroup!Domain} -\index{Domain!NottinghamGroup} -\index{NOTTING} -\begin{chunk}{sane} +\index[dom]{NottinghamGroup!Domain} +\index[dom]{Domain!NottinghamGroup} +\index[dom]{NOTTING} +\begin{chunk}{defclass NottinghamGroupType} (defclass |NottinghamGroupType| (|GroupType|) ((parents :initform '(|Group|)) (name :initform "NottinghamGroup") @@ -19872,7 +20575,7 @@ Value = NIL (abbreviation :initform 'NOTTING) (comment :initform (list "This is an implmenentation of the Nottingham Group")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19886,10 +20589,10 @@ Value = NIL \end{chunk} \subsection{NumericalIntegrationProblem} -\index{NumericalIntegrationProblem!Domain} -\index{Domain!NumericalIntegrationProblem} -\index{NIPROB} -\begin{chunk}{sane} +\index[dom]{NumericalIntegrationProblem!Domain} +\index[dom]{Domain!NumericalIntegrationProblem} +\index[dom]{NIPROB} +\begin{chunk}{defclass NumericalIntegrationProblemType} (defclass |NumericalIntegrationProblemType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalIntegrationProblem") @@ -19915,7 +20618,7 @@ Value = NIL "range:List Segment OrderedCompletion DoubleFloat," "abserr:DoubleFloat," "relerr:DoubleFloat,).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19929,10 +20632,10 @@ Value = NIL \end{chunk} \subsection{NumericalODEProblem} -\index{NumericalODEProblem!Domain} -\index{Domain!NumericalODEProblem} -\index{ODEPROB} -\begin{chunk}{sane} +\index[dom]{NumericalODEProblem!Domain} +\index[dom]{Domain!NumericalODEProblem} +\index[dom]{ODEPROB} +\begin{chunk}{defclass NumericalODEProblemType} (defclass |NumericalODEProblemType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalODEProblem") @@ -19951,7 +20654,7 @@ Value = NIL "yinit:List DoubleFloat,intvals:List DoubleFloat," "g:Expression DoubleFloat,abserr:DoubleFloat," "relerr:DoubleFloat)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -19965,10 +20668,10 @@ Value = NIL \end{chunk} \subsection{NumericalOptimizationProblem} -\index{NumericalOptimizationProblem!Domain} -\index{Domain!NumericalOptimizationProblem} -\index{OPTPROB} -\begin{chunk}{sane} +\index[dom]{NumericalOptimizationProblem!Domain} +\index[dom]{Domain!NumericalOptimizationProblem} +\index[dom]{OPTPROB} +\begin{chunk}{defclass NumericalOptimizationProblemType} (defclass |NumericalOptimizationProblemType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalOptimizationProblem") @@ -19994,7 +20697,7 @@ Value = NIL " " "Record(lfn:List Expression DoubleFloat," "init:List DoubleFloat).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20008,10 +20711,10 @@ Value = NIL \end{chunk} \subsection{NumericalPDEProblem} -\index{NumericalPDEProblem!Domain} -\index{Domain!NumericalPDEProblem} -\index{PDEPROB} -\begin{chunk}{sane} +\index[dom]{NumericalPDEProblem!Domain} +\index[dom]{Domain!NumericalPDEProblem} +\index[dom]{PDEPROB} +\begin{chunk}{defclass NumericalPDEProblemType} (defclass |NumericalPDEProblemType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "NumericalPDEProblem") @@ -20038,7 +20741,7 @@ Value = NIL "boundaryType:Integer," "dStart:Matrix DoubleFloat," "dFinish:Matrix DoubleFloat)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20054,10 +20757,10 @@ Value = NIL \section{O} \subsection{Octonion} -\index{Octonion!Domain} -\index{Domain!Octonion} -\index{OCT} -\begin{chunk}{sane} +\index[dom]{Octonion!Domain} +\index[dom]{Domain!Octonion} +\index[dom]{OCT} +\begin{chunk}{defclass OctonionType} (defclass |OctonionType| (|OctonionCategoryType|) ((parents :initform '(|OctonionCategory|)) (name :initform "Octonion") @@ -20072,7 +20775,7 @@ Value = NIL "arguments: the real part, the i imaginary part, the j" "imaginary part, the k imaginary part, (as with quaternions)" "and in addition the imaginary parts E, I, J, K.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20086,10 +20789,10 @@ Value = NIL \end{chunk} \subsection{ODEIntensityFunctionsTable} -\index{ODEIntensityFunctionsTable!Domain} -\index{Domain!ODEIntensityFunctionsTable} -\index{ODEIFTBL} -\begin{chunk}{sane} +\index[dom]{ODEIntensityFunctionsTable!Domain} +\index[dom]{Domain!ODEIntensityFunctionsTable} +\index[dom]{ODEIFTBL} +\begin{chunk}{defclass ODEIntensityFunctionsTableType} (defclass |ODEIntensityFunctionsTableType| (|AxiomClass|) ((parents :initform '()) (name :initform "ODEIntensityFunctionsTable") @@ -20098,7 +20801,7 @@ Value = NIL (comment :initform (list "ODEIntensityFunctionsTable() provides a dynamic table and a set of" "functions to store details found out about sets of ODE's.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20112,10 +20815,10 @@ Value = NIL \end{chunk} \subsection{OneDimensionalArray} -\index{OneDimensionalArray!Domain} -\index{Domain!OneDimensionalArray} -\index{ARRAY1} -\begin{chunk}{sane} +\index[dom]{OneDimensionalArray!Domain} +\index[dom]{Domain!OneDimensionalArray} +\index[dom]{ARRAY1} +\begin{chunk}{defclass OneDimensionalArrayType} (defclass |OneDimensionalArrayType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "OneDimensionalArray") @@ -20123,7 +20826,7 @@ Value = NIL (abbreviation :initform 'ARRAY1) (comment :initform (list "This is the domain of 1-based one dimensional arrays")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20137,10 +20840,10 @@ Value = NIL \end{chunk} \subsection{OnePointCompletion} -\index{OnePointCompletion!Domain} -\index{Domain!OnePointCompletion} -\index{ONECOMP} -\begin{chunk}{sane} +\index[dom]{OnePointCompletion!Domain} +\index[dom]{Domain!OnePointCompletion} +\index[dom]{ONECOMP} +\begin{chunk}{defclass OnePointCompletionType} (defclass |OnePointCompletionType| (|OrderedRingType| |FullyRetractableToType|) ((parents :initform '(|OrderedRing| |FullyRetractableTo|)) (name :initform "OnePointCompletion") @@ -20149,7 +20852,7 @@ Value = NIL (comment :initform (list "Completion with infinity." "Adjunction of a complex infinity to a set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20163,10 +20866,10 @@ Value = NIL \end{chunk} \subsection{OpenMathConnection} -\index{OpenMathConnection!Domain} -\index{Domain!OpenMathConnection} -\index{OMCONN} -\begin{chunk}{sane} +\index[dom]{OpenMathConnection!Domain} +\index[dom]{Domain!OpenMathConnection} +\index[dom]{OMCONN} +\begin{chunk}{defclass OpenMathConnectionType} (defclass |OpenMathConnectionType| (|AxiomClass|) ((parents :initform '()) (name :initform "OpenMathConnection") @@ -20175,7 +20878,7 @@ Value = NIL (comment :initform (list "OpenMathConnection provides low-level functions" "for handling connections to and from OpenMathDevices.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20189,10 +20892,10 @@ Value = NIL \end{chunk} \subsection{OpenMathDevice} -\index{OpenMathDevice!Domain} -\index{Domain!OpenMathDevice} -\index{OMDEV} -\begin{chunk}{sane} +\index[dom]{OpenMathDevice!Domain} +\index[dom]{Domain!OpenMathDevice} +\index[dom]{OMDEV} +\begin{chunk}{defclass OpenMathDeviceType} (defclass |OpenMathDeviceType| (|AxiomClass|) ((parents :initform '()) (name :initform "OpenMathDevice") @@ -20202,7 +20905,7 @@ Value = NIL "OpenMathDevice provides support for reading" "and writing openMath objects to files, strings etc. It also provides" "access to low-level operations from within the interpreter.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20216,10 +20919,10 @@ Value = NIL \end{chunk} \subsection{OpenMathEncoding} -\index{OpenMathEncoding!Domain} -\index{Domain!OpenMathEncoding} -\index{OMENC} -\begin{chunk}{sane} +\index[dom]{OpenMathEncoding!Domain} +\index[dom]{Domain!OpenMathEncoding} +\index[dom]{OMENC} +\begin{chunk}{defclass OpenMathEncodingType} (defclass |OpenMathEncodingType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "OpenMathEncoding") @@ -20227,7 +20930,7 @@ Value = NIL (abbreviation :initform 'OMENC) (comment :initform (list "OpenMathEncoding is the set of valid OpenMath encodings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20241,10 +20944,10 @@ Value = NIL \end{chunk} \subsection{OpenMathError} -\index{OpenMathError!Domain} -\index{Domain!OpenMathError} -\index{OMERR} -\begin{chunk}{sane} +\index[dom]{OpenMathError!Domain} +\index[dom]{Domain!OpenMathError} +\index[dom]{OMERR} +\begin{chunk}{defclass OpenMathErrorType} (defclass |OpenMathErrorType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "OpenMathError") @@ -20252,7 +20955,7 @@ Value = NIL (abbreviation :initform 'OMERR) (comment :initform (list "OpenMathError is the domain of OpenMath errors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20266,10 +20969,10 @@ Value = NIL \end{chunk} \subsection{OpenMathErrorKind} -\index{OpenMathErrorKind!Domain} -\index{Domain!OpenMathErrorKind} -\index{OMERRK} -\begin{chunk}{sane} +\index[dom]{OpenMathErrorKind!Domain} +\index[dom]{Domain!OpenMathErrorKind} +\index[dom]{OMERRK} +\begin{chunk}{defclass OpenMathErrorKindType} (defclass |OpenMathErrorKindType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "OpenMathErrorKind") @@ -20279,7 +20982,7 @@ Value = NIL "OpenMathErrorKind represents different kinds" "of OpenMath errors: specifically parse errors, unknown CD or symbol" "errors, and read errors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20293,10 +20996,10 @@ Value = NIL \end{chunk} \subsection{Operator} -\index{Operator!Domain} -\index{Domain!Operator} -\index{OP} -\begin{chunk}{sane} +\index[dom]{Operator!Domain} +\index[dom]{Domain!Operator} +\index[dom]{OP} +\begin{chunk}{defclass OperatorType} (defclass |OperatorType| (|AlgebraType| |CharacteristicNonZeroType| |CharacteristicZeroType| @@ -20312,7 +21015,7 @@ Value = NIL (abbreviation :initform 'OP) (comment :initform (list "Algebra of ADDITIVE operators over a ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20326,10 +21029,10 @@ Value = NIL \end{chunk} \subsection{OppositeMonogenicLinearOperator} -\index{OppositeMonogenicLinearOperator!Domain} -\index{Domain!OppositeMonogenicLinearOperator} -\index{OMLO} -\begin{chunk}{sane} +\index[dom]{OppositeMonogenicLinearOperator!Domain} +\index[dom]{Domain!OppositeMonogenicLinearOperator} +\index[dom]{OMLO} +\begin{chunk}{defclass OppositeMonogenicLinearOperatorType} (defclass |OppositeMonogenicLinearOperatorType| (|DifferentialRingType| |MonogenicLinearOperatorType|) ((parents :initform '(|DifferentialRing| |MonogenicLinearOperator|)) @@ -20341,7 +21044,7 @@ Value = NIL "which is 'opposite' in the ring sense to P." "That is, as sets P = $ but a * b in $ is equal to" "b * a in P.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20355,10 +21058,10 @@ Value = NIL \end{chunk} \subsection{OrderedCompletion} -\index{OrderedCompletion!Domain} -\index{Domain!OrderedCompletion} -\index{ORDCOMP} -\begin{chunk}{sane} +\index[dom]{OrderedCompletion!Domain} +\index[dom]{Domain!OrderedCompletion} +\index[dom]{ORDCOMP} +\begin{chunk}{defclass OrderedCompletionType} (defclass |OrderedCompletionType| (|OrderedRingType| |FullyRetractableToType|) ((parents :initform '(|OrderedRing| |FullyRetractableTo|)) (name :initform "OrderedCompletion") @@ -20367,7 +21070,7 @@ Value = NIL (comment :initform (list "Completion with + and - infinity." "Adjunction of two real infinites quantities to a set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20381,17 +21084,17 @@ Value = NIL \end{chunk} \subsection{OrderedDirectProduct} -\index{OrderedDirectProduct!Domain} -\index{Domain!OrderedDirectProduct} -\index{ODP} -\begin{chunk}{sane} +\index[dom]{OrderedDirectProduct!Domain} +\index[dom]{Domain!OrderedDirectProduct} +\index[dom]{ODP} +\begin{chunk}{defclass OrderedDirectProductType} (defclass |OrderedDirectProductType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "OrderedDirectProduct") (marker :initform 'domain) (abbreviation :initform 'ODP) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20405,10 +21108,10 @@ Value = NIL \end{chunk} \subsection{OrderedFreeMonoid} -\index{OrderedFreeMonoid!Domain} -\index{Domain!OrderedFreeMonoid} -\index{OFMONOID} -\begin{chunk}{sane} +\index[dom]{OrderedFreeMonoid!Domain} +\index[dom]{Domain!OrderedFreeMonoid} +\index[dom]{OFMONOID} +\begin{chunk}{defclass OrderedFreeMonoidType} (defclass |OrderedFreeMonoidType| (|RetractableToType| |OrderedMonoidType|) ((parents :initform '(|RetractableTo| |OrderedMonoid|)) (name :initform "OrderedFreeMonoid") @@ -20423,7 +21126,7 @@ Value = NIL "are equal and if x is smaller than y w.r.t. the" "lexicographical ordering induced by S." "This domain inherits implementation from FreeMonoid.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20437,10 +21140,10 @@ Value = NIL \end{chunk} \subsection{OrderedVariableList} -\index{OrderedVariableList!Domain} -\index{Domain!OrderedVariableList} -\index{OVAR} -\begin{chunk}{sane} +\index[dom]{OrderedVariableList!Domain} +\index[dom]{Domain!OrderedVariableList} +\index[dom]{OVAR} +\begin{chunk}{defclass OrderedVariableListType} (defclass |OrderedVariableListType| (|ConvertibleToType| |OrderedFiniteType|) ((parents :initform '(|ConvertibleTo| |OrderedFinite|)) (name :initform "OrderedVariableList") @@ -20448,7 +21151,7 @@ Value = NIL (abbreviation :initform 'OVAR) (comment :initform (list "This domain implements ordered variables")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20462,10 +21165,10 @@ Value = NIL \end{chunk} \subsection{OrderlyDifferentialPolynomial} -\index{OrderlyDifferentialPolynomial!Domain} -\index{Domain!OrderlyDifferentialPolynomial} -\index{ODPOL} -\begin{chunk}{sane} +\index[dom]{OrderlyDifferentialPolynomial!Domain} +\index[dom]{Domain!OrderlyDifferentialPolynomial} +\index[dom]{ODPOL} +\begin{chunk}{defclass OrderlyDifferentialPolynomialType} (defclass |OrderlyDifferentialPolynomialType| (|DifferentialPolynomialCategoryType|) ((parents :initform '(|DifferentialPolynomialCategory|)) (name :initform "OrderlyDifferentialPolynomial") @@ -20477,7 +21180,7 @@ Value = NIL "of differential indeterminates, with coefficients in a" "ring. The ranking on the differential indeterminate is orderly." "This is analogous to the domain Polynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20491,10 +21194,10 @@ Value = NIL \end{chunk} \subsection{OrderlyDifferentialVariable} -\index{OrderlyDifferentialVariable!Domain} -\index{Domain!OrderlyDifferentialVariable} -\index{ODVAR} -\begin{chunk}{sane} +\index[dom]{OrderlyDifferentialVariable!Domain} +\index[dom]{Domain!OrderlyDifferentialVariable} +\index[dom]{ODVAR} +\begin{chunk}{defclass OrderlyDifferentialVariableType} (defclass |OrderlyDifferentialVariableType| (|DifferentialVariableCategoryType|) ((parents :initform '(|DifferentialVariableCategory|)) (name :initform "OrderlyDifferentialVariable") @@ -20511,7 +21214,7 @@ Value = NIL "defines an orderly ranking < on derivatives u via the" "lexicographic order on the pair" "(order(u), variable}(u).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20525,10 +21228,10 @@ Value = NIL \end{chunk} \subsection{OrdinaryDifferentialRing} -\index{OrdinaryDifferentialRing!Domain} -\index{Domain!OrdinaryDifferentialRing} -\index{ODR} -\begin{chunk}{sane} +\index[dom]{OrdinaryDifferentialRing!Domain} +\index[dom]{Domain!OrdinaryDifferentialRing} +\index[dom]{ODR} +\begin{chunk}{defclass OrdinaryDifferentialRingType} (defclass |OrdinaryDifferentialRingType| (|FieldType| |DifferentialRingType|) ((parents :initform '(|Field| |DifferentialRing|)) (name :initform "OrdinaryDifferentialRing") @@ -20537,7 +21240,7 @@ Value = NIL (comment :initform (list "This constructor produces an ordinary differential ring from" "a partial differential ring by specifying a variable.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20551,10 +21254,10 @@ Value = NIL \end{chunk} \subsection{OrdinaryWeightedPolynomials} -\index{OrdinaryWeightedPolynomials!Domain} -\index{Domain!OrdinaryWeightedPolynomials} -\index{OWP} -\begin{chunk}{sane} +\index[dom]{OrdinaryWeightedPolynomials!Domain} +\index[dom]{Domain!OrdinaryWeightedPolynomials} +\index[dom]{OWP} +\begin{chunk}{defclass OrdinaryWeightedPolynomialsType} (defclass |OrdinaryWeightedPolynomialsType| (|AlgebraType|) ((parents :initform '(|Algebra|)) (name :initform "OrdinaryWeightedPolynomials") @@ -20566,7 +21269,7 @@ Value = NIL "specified, as must the weights." "The representation is sparse" "in the sense that only non-zero terms are represented.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20580,10 +21283,10 @@ Value = NIL \end{chunk} \subsection{OrdSetInts} -\index{OrdSetInts!Domain} -\index{Domain!OrdSetInts} -\index{OSI} -\begin{chunk}{sane} +\index[dom]{OrdSetInts!Domain} +\index[dom]{Domain!OrdSetInts} +\index[dom]{OSI} +\begin{chunk}{defclass OrdSetIntsType} (defclass |OrdSetIntsType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "OrdSetInts") @@ -20593,7 +21296,7 @@ Value = NIL "A domain used in order to take the free R-module on the" "Integers I. This is actually the forgetful functor from OrderedRings" "to OrderedSets applied to I")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20607,10 +21310,10 @@ Value = NIL \end{chunk} \subsection{OutputForm} -\index{OutputForm!Domain} -\index{Domain!OutputForm} -\index{OUTFORM} -\begin{chunk}{sane} +\index[dom]{OutputForm!Domain} +\index[dom]{Domain!OutputForm} +\index[dom]{OUTFORM} +\begin{chunk}{defclass OutputFormType} (defclass |OutputFormType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "OutputForm") @@ -20621,7 +21324,7 @@ Value = NIL "for output. It is intended to provide an insulating layer between" "the expression rendering software (for example, FORTRAN or TeX) and" "the output coercions in the various domains.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20637,10 +21340,10 @@ Value = NIL \section{P} \subsection{PAdicInteger} -\index{PAdicInteger!Domain} -\index{Domain!PAdicInteger} -\index{PADIC} -\begin{chunk}{sane} +\index[dom]{PAdicInteger!Domain} +\index[dom]{Domain!PAdicInteger} +\index[dom]{PADIC} +\begin{chunk}{defclass PAdicIntegerType} (defclass |PAdicIntegerType| (|PAdicIntegerCategoryType|) ((parents :initform '(|PAdicIntegerCategory|)) (name :initform "PAdicInteger") @@ -20649,7 +21352,7 @@ Value = NIL (comment :initform (list "Stream-based implementation of Zp: p-adic numbers are represented as" "sum(i = 0.., a[i] * p^i), where the a[i] lie in 0,1,...,(p - 1).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20663,10 +21366,10 @@ Value = NIL \end{chunk} \subsection{PAdicRational} -\index{PAdicRational!Domain} -\index{Domain!PAdicRational} -\index{PADICRAT} -\begin{chunk}{sane} +\index[dom]{PAdicRational!Domain} +\index[dom]{Domain!PAdicRational} +\index[dom]{PADICRAT} +\begin{chunk}{defclass PAdicRationalType} (defclass |PAdicRationalType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "PAdicRational") @@ -20675,7 +21378,7 @@ Value = NIL (comment :initform (list "Stream-based implementation of Qp: numbers are represented as" " sum(i = k.., a[i] * p^i) where the a[i] lie in 0,1,...,(p - 1).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20689,10 +21392,10 @@ Value = NIL \end{chunk} \subsection{PAdicRationalConstructor} -\index{PAdicRationalConstructor!Domain} -\index{Domain!PAdicRationalConstructor} -\index{PADICRC} -\begin{chunk}{sane} +\index[dom]{PAdicRationalConstructor!Domain} +\index[dom]{Domain!PAdicRationalConstructor} +\index[dom]{PADICRC} +\begin{chunk}{defclass PAdicRationalConstructorType} (defclass |PAdicRationalConstructorType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "PAdicRationalConstructor") @@ -20700,7 +21403,7 @@ Value = NIL (abbreviation :initform 'PADICRC) (comment :initform (list "This is the category of stream-based representations of Qp.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20714,10 +21417,10 @@ Value = NIL \end{chunk} \subsection{Palette} -\index{Palette!Domain} -\index{Domain!Palette} -\index{PALETTE} -\begin{chunk}{sane} +\index[dom]{Palette!Domain} +\index[dom]{Domain!Palette} +\index[dom]{PALETTE} +\begin{chunk}{defclass PaletteType} (defclass |PaletteType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Palette") @@ -20725,7 +21428,7 @@ Value = NIL (abbreviation :initform 'PALETTE) (comment :initform (list "This domain describes four groups of color shades (palettes).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20739,10 +21442,10 @@ Value = NIL \end{chunk} \subsection{ParametricPlaneCurve} -\index{ParametricPlaneCurve!Domain} -\index{Domain!ParametricPlaneCurve} -\index{PARPCURV} -\begin{chunk}{sane} +\index[dom]{ParametricPlaneCurve!Domain} +\index[dom]{Domain!ParametricPlaneCurve} +\index[dom]{PARPCURV} +\begin{chunk}{defclass ParametricPlaneCurveType} (defclass |ParametricPlaneCurveType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricPlaneCurve") @@ -20751,7 +21454,7 @@ Value = NIL (comment :initform (list "ParametricPlaneCurve is used for plotting parametric plane" "curves in the affine plane.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20765,10 +21468,10 @@ Value = NIL \end{chunk} \subsection{ParametricSpaceCurve} -\index{ParametricSpaceCurve!Domain} -\index{Domain!ParametricSpaceCurve} -\index{PARSCURV} -\begin{chunk}{sane} +\index[dom]{ParametricSpaceCurve!Domain} +\index[dom]{Domain!ParametricSpaceCurve} +\index[dom]{PARSCURV} +\begin{chunk}{defclass ParametricSpaceCurveType} (defclass |ParametricSpaceCurveType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricSpaceCurve") @@ -20777,7 +21480,7 @@ Value = NIL (comment :initform (list "ParametricSpaceCurve is used for plotting parametric space" "curves in affine 3-space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20791,10 +21494,10 @@ Value = NIL \end{chunk} \subsection{ParametricSurface} -\index{ParametricSurface!Domain} -\index{Domain!ParametricSurface} -\index{PARSURF} -\begin{chunk}{sane} +\index[dom]{ParametricSurface!Domain} +\index[dom]{Domain!ParametricSurface} +\index[dom]{PARSURF} +\begin{chunk}{defclass ParametricSurfaceType} (defclass |ParametricSurfaceType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricSurface") @@ -20803,7 +21506,7 @@ Value = NIL (comment :initform (list "ParametricSurface is used for plotting parametric surfaces in" "affine 3-space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20817,10 +21520,10 @@ Value = NIL \end{chunk} \subsection{PartialFraction} -\index{PartialFraction!Domain} -\index{Domain!PartialFraction} -\index{PFR} -\begin{chunk}{sane} +\index[dom]{PartialFraction!Domain} +\index[dom]{Domain!PartialFraction} +\index[dom]{PFR} +\begin{chunk}{defclass PartialFractionType} (defclass |PartialFractionType| (|FieldType|) ((parents :initform '(|Field|)) (name :initform "PartialFraction") @@ -20839,7 +21542,7 @@ Value = NIL "general euclidean domain, it is not known how to factor the" "denominator. Thus the function partialFraction takes as its" "second argument an element of Factored(R).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20853,10 +21556,10 @@ Value = NIL \end{chunk} \subsection{Partition} -\index{Partition!Domain} -\index{Domain!Partition} -\index{PRTITION} -\begin{chunk}{sane} +\index[dom]{Partition!Domain} +\index[dom]{Domain!Partition} +\index[dom]{PRTITION} +\begin{chunk}{defclass PartitionType} (defclass |PartitionType| (|ConvertibleToType| |OrderedCancellationAbelianMonoidType|) ((parents :initform '(|ConvertibleTo| |OrderedCancellationAbelianMonoid|)) (name :initform "Partition") @@ -20867,7 +21570,7 @@ Value = NIL "as the basis for symmetric polynomial representation of the" "sums of powers in SymmetricPolynomial. Thus, (5 2 2 1) will" "represent s5 * s2**2 * s1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20881,10 +21584,10 @@ Value = NIL \end{chunk} \subsection{Pattern} -\index{Pattern!Domain} -\index{Domain!Pattern} -\index{PATTERN} -\begin{chunk}{sane} +\index[dom]{Pattern!Domain} +\index[dom]{Domain!Pattern} +\index[dom]{PATTERN} +\begin{chunk}{defclass PatternType} (defclass |PatternType| (|SetCategoryType| |RetractableToType|) ((parents :initform '(|SetCategory| |RetractableTo|)) (name :initform "Pattern") @@ -20892,7 +21595,7 @@ Value = NIL (abbreviation :initform 'PATTERN) (comment :initform (list "Patterns for use by the pattern matcher.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20906,10 +21609,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchListResult} -\index{PatternMatchListResult!Domain} -\index{Domain!PatternMatchListResult} -\index{PATLRES} -\begin{chunk}{sane} +\index[dom]{PatternMatchListResult!Domain} +\index[dom]{Domain!PatternMatchListResult} +\index[dom]{PATLRES} +\begin{chunk}{defclass PatternMatchListResultType} (defclass |PatternMatchListResultType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "PatternMatchListResult") @@ -20920,7 +21623,7 @@ Value = NIL "pattern matcher when matching on lists." "It is either a failed match, or a pair of PatternMatchResult," "one for atoms (elements of the list), and one for lists.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20934,10 +21637,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchResult} -\index{PatternMatchResult!Domain} -\index{Domain!PatternMatchResult} -\index{PATRES} -\begin{chunk}{sane} +\index[dom]{PatternMatchResult!Domain} +\index[dom]{Domain!PatternMatchResult} +\index[dom]{PATRES} +\begin{chunk}{defclass PatternMatchResultType} (defclass |PatternMatchResultType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "PatternMatchResult") @@ -20948,7 +21651,7 @@ Value = NIL "pattern matcher; It is either a failed match, or a list of" "matches of the form (var, expr) meaning that the variable var" "matches the expression expr.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20962,10 +21665,10 @@ Value = NIL \end{chunk} \subsection{PendantTree} -\index{PendantTree!Domain} -\index{Domain!PendantTree} -\index{PENDTREE} -\begin{chunk}{sane} +\index[dom]{PendantTree!Domain} +\index[dom]{Domain!PendantTree} +\index[dom]{PENDTREE} +\begin{chunk}{defclass PendantTreeType} (defclass |PendantTreeType| (|BinaryRecursiveAggregateType|) ((parents :initform '(|BinaryRecursiveAggregate|)) (name :initform "PendantTree") @@ -20974,7 +21677,7 @@ Value = NIL (comment :initform (list "A PendantTree(S) is either a leaf? and is an S or has" "a left and a right both PendantTree(S)'s")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -20988,10 +21691,10 @@ Value = NIL \end{chunk} \subsection{Permutation} -\index{Permutation!Domain} -\index{Domain!Permutation} -\index{PERM} -\begin{chunk}{sane} +\index[dom]{Permutation!Domain} +\index[dom]{Domain!Permutation} +\index[dom]{PERM} +\begin{chunk}{defclass PermutationType} (defclass |PermutationType| (|PermutationCategoryType|) ((parents :initform '(|PermutationCategory|)) (name :initform "Permutation") @@ -21005,7 +21708,7 @@ Value = NIL "pi1 * pi2 = pi1 o pi2." "The internal representation of permuatations are two lists" "of equal length representing preimages and images.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21019,10 +21722,10 @@ Value = NIL \end{chunk} \subsection{PermutationGroup} -\index{PermutationGroup!Domain} -\index{Domain!PermutationGroup} -\index{PERMGRP} -\begin{chunk}{sane} +\index[dom]{PermutationGroup!Domain} +\index[dom]{Domain!PermutationGroup} +\index[dom]{PERMGRP} +\begin{chunk}{defclass PermutationGroupType} (defclass |PermutationGroupType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "PermutationGroup") @@ -21038,7 +21741,7 @@ Value = NIL "basic routines and algorithms" "are implemented so that the word problem for" "permutation groups can be solved.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21052,10 +21755,10 @@ Value = NIL \end{chunk} \subsection{Pi} -\index{Pi!Domain} -\index{Domain!Pi} -\index{HACKPI} -\begin{chunk}{sane} +\index[dom]{Pi!Domain} +\index[dom]{Domain!Pi} +\index[dom]{HACKPI} +\begin{chunk}{defclass PiType} (defclass |PiType| (|CharacteristicZeroType| |FieldType| |RealConstantType| @@ -21071,7 +21774,7 @@ Value = NIL "Symbolic fractions in %pi with integer coefficients;" "The point for using Pi as the default domain for those fractions" "is that Pi is coercible to the float types, and not Expression.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21085,10 +21788,10 @@ Value = NIL \end{chunk} \subsection{PlaneAlgebraicCurvePlot} -\index{PlaneAlgebraicCurvePlot!Domain} -\index{Domain!PlaneAlgebraicCurvePlot} -\index{ACPLOT} -\begin{chunk}{sane} +\index[dom]{PlaneAlgebraicCurvePlot!Domain} +\index[dom]{Domain!PlaneAlgebraicCurvePlot} +\index[dom]{ACPLOT} +\begin{chunk}{defclass PlaneAlgebraicCurvePlotType} (defclass |PlaneAlgebraicCurvePlotType| (|PlottablePlaneCurveCategoryType|) ((parents :initform '(|PlottablePlaneCurveCategory|)) (name :initform "PlaneAlgebraicCurvePlot") @@ -21096,7 +21799,7 @@ Value = NIL (abbreviation :initform 'ACPLOT) (comment :initform (list "Plot a NON-SINGULAR plane algebraic curve p(x,y) = 0.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21110,10 +21813,10 @@ Value = NIL \end{chunk} \subsection{Places} -\index{Places!Domain} -\index{Domain!Places} -\index{PLACES} -\begin{chunk}{sane} +\index[dom]{Places!Domain} +\index[dom]{Domain!Places} +\index[dom]{PLACES} +\begin{chunk}{defclass PlacesType} (defclass |PlacesType| (|PlacesCategoryType|) ((parents :initform '(|PlacesCategory|)) (name :initform "Places") @@ -21121,7 +21824,7 @@ Value = NIL (abbreviation :initform 'PLACES) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21135,10 +21838,10 @@ Value = NIL \end{chunk} \subsection{PlacesOverPseudoAlgebraicClosureOfFiniteField} -\index{PlacesOverPseudoAlgebraicClosureOfFiniteField!Domain} -\index{Domain!PlacesOverPseudoAlgebraicClosureOfFiniteField} -\index{PLACESPS} -\begin{chunk}{sane} +\index[dom]{PlacesOverPseudoAlgebraicClosureOfFiniteField!Domain} +\index[dom]{Domain!PlacesOverPseudoAlgebraicClosureOfFiniteField} +\index[dom]{PLACESPS} +\begin{chunk}{defclass PlacesOverPseudoAlgebraicClosureOfFiniteFieldType} (defclass |PlacesOverPseudoAlgebraicClosureOfFiniteFieldType| (|PlacesCategoryType|) ((parents :initform '(|PlacesCategory|)) (name :initform "PlacesOverPseudoAlgebraicClosureOfFiniteField") @@ -21146,7 +21849,7 @@ Value = NIL (abbreviation :initform 'PLACESPS) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21160,10 +21863,10 @@ Value = NIL \end{chunk} \subsection{Plcs} -\index{Plcs!Domain} -\index{Domain!Plcs} -\index{PLCS} -\begin{chunk}{sane} +\index[dom]{Plcs!Domain} +\index[dom]{Domain!Plcs} +\index[dom]{PLCS} +\begin{chunk}{defclass PlcsType} (defclass |PlcsType| (|PlacesCategoryType|) ((parents :initform '(|PlacesCategory|)) (name :initform "Plcs") @@ -21171,7 +21874,7 @@ Value = NIL (abbreviation :initform 'PLCS) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21185,10 +21888,10 @@ Value = NIL \end{chunk} \subsection{Plot} -\index{Plot!Domain} -\index{Domain!Plot} -\index{PLOT} -\begin{chunk}{sane} +\index[dom]{Plot!Domain} +\index[dom]{Domain!Plot} +\index[dom]{PLOT} +\begin{chunk}{defclass PlotType} (defclass |PlotType| (|PlottablePlaneCurveCategoryType|) ((parents :initform '(|PlottablePlaneCurveCategory|)) (name :initform "Plot") @@ -21201,7 +21904,7 @@ Value = NIL "floating point numbers and infinite continued fractions." "The facilities at this point are limited to 2-dimensional plots" "or either a single function or a parametric function.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21215,10 +21918,10 @@ Value = NIL \end{chunk} \subsection{Plot3D} -\index{Plot3D!Domain} -\index{Domain!Plot3D} -\index{PLOT3D} -\begin{chunk}{sane} +\index[dom]{Plot3D!Domain} +\index[dom]{Domain!Plot3D} +\index[dom]{PLOT3D} +\begin{chunk}{defclass Plot3DType} (defclass |Plot3DType| (|PlottableSpaceCurveCategoryType|) ((parents :initform '(|PlottableSpaceCurveCategory|)) (name :initform "Plot3D") @@ -21231,7 +21934,7 @@ Value = NIL "floating point numbers and infinite continued fractions are" "real number systems. The facilities at this point are limited" "to 3-dimensional parametric plots.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21245,10 +21948,10 @@ Value = NIL \end{chunk} \subsection{PoincareBirkhoffWittLyndonBasis} -\index{PoincareBirkhoffWittLyndonBasis!Domain} -\index{Domain!PoincareBirkhoffWittLyndonBasis} -\index{PBWLB} -\begin{chunk}{sane} +\index[dom]{PoincareBirkhoffWittLyndonBasis!Domain} +\index[dom]{Domain!PoincareBirkhoffWittLyndonBasis} +\index[dom]{PBWLB} +\begin{chunk}{defclass PoincareBirkhoffWittLyndonBasisType} (defclass |PoincareBirkhoffWittLyndonBasisType| (|OrderedSetType| |RetractableToType|) ((parents :initform '(|OrderedSet| |RetractableTo|)) (name :initform "PoincareBirkhoffWittLyndonBasis") @@ -21260,7 +21963,7 @@ Value = NIL "over the Poincare-Birkhoff-Witt basis." "See the XPBWPolynomial domain constructor." "See Free Lie Algebras by C. Reutenauer ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21274,10 +21977,10 @@ Value = NIL \end{chunk} \subsection{Point} -\index{Point!Domain} -\index{Domain!Point} -\index{POINT} -\begin{chunk}{sane} +\index[dom]{Point!Domain} +\index[dom]{Domain!Point} +\index[dom]{POINT} +\begin{chunk}{defclass PointType} (defclass |PointType| (|PointCategoryType|) ((parents :initform '(|PointCategory|)) (name :initform "Point") @@ -21285,7 +21988,7 @@ Value = NIL (abbreviation :initform 'POINT) (comment :initform (list "This domain implements points in coordinate space")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21299,10 +22002,10 @@ Value = NIL \end{chunk} \subsection{Polynomial} -\index{Polynomial!Domain} -\index{Domain!Polynomial} -\index{POLY} -\begin{chunk}{sane} +\index[dom]{Polynomial!Domain} +\index[dom]{Domain!Polynomial} +\index[dom]{POLY} +\begin{chunk}{defclass PolynomialType} (defclass |PolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "Polynomial") @@ -21314,7 +22017,7 @@ Value = NIL "is alphabetic determined by the Symbol type." "The coefficient ring may be non commutative," "but the variables are assumed to commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21328,10 +22031,10 @@ Value = NIL \end{chunk} \subsection{PolynomialIdeals} -\index{PolynomialIdeals!Domain} -\index{Domain!PolynomialIdeals} -\index{IDEAL} -\begin{chunk}{sane} +\index[dom]{PolynomialIdeals!Domain} +\index[dom]{Domain!PolynomialIdeals} +\index[dom]{IDEAL} +\begin{chunk}{defclass PolynomialIdealsType} (defclass |PolynomialIdealsType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "PolynomialIdeals") @@ -21347,7 +22050,7 @@ Value = NIL "The algorithms used are based on Groebner basis computations. The" "ordering is determined by the datatype of the input polynomials." "Users may use refinements of total degree orderings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21361,10 +22064,10 @@ Value = NIL \end{chunk} \subsection{PolynomialRing} -\index{PolynomialRing!Domain} -\index{Domain!PolynomialRing} -\index{PR} -\begin{chunk}{sane} +\index[dom]{PolynomialRing!Domain} +\index[dom]{Domain!PolynomialRing} +\index[dom]{PR} +\begin{chunk}{defclass PolynomialRingType} (defclass |PolynomialRingType| (|FiniteAbelianMonoidRingType|) ((parents :initform '(|FiniteAbelianMonoidRing|)) (name :initform "PolynomialRing") @@ -21377,7 +22080,7 @@ Value = NIL "This type is used, for example," "by the DistributedMultivariatePolynomial domain where" "the exponent domain is a direct product of non negative integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21391,10 +22094,10 @@ Value = NIL \end{chunk} \subsection{PositiveInteger} -\index{PositiveInteger!Domain} -\index{Domain!PositiveInteger} -\index{PI} -\begin{chunk}{sane} +\index[dom]{PositiveInteger!Domain} +\index[dom]{Domain!PositiveInteger} +\index[dom]{PI} +\begin{chunk}{defclass PositiveIntegerType} (defclass |PositiveIntegerType| (|OrderedSetType| |MonoidType| |AbelianSemiGroupType|) ((parents :initform '(|OrderedSet| |Monoid| |AbelianSemiGroup|)) (name :initform "PositiveInteger") @@ -21402,7 +22105,7 @@ Value = NIL (abbreviation :initform 'PI) (comment :initform (list "PositiveInteger provides functions for positive integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21416,10 +22119,10 @@ Value = NIL \end{chunk} \subsection{PrimeField} -\index{PrimeField!Domain} -\index{Domain!PrimeField} -\index{PF} -\begin{chunk}{sane} +\index[dom]{PrimeField!Domain} +\index[dom]{Domain!PrimeField} +\index[dom]{PF} +\begin{chunk}{defclass PrimeFieldType} (defclass |PrimeFieldType| (|ConvertibleToType| |FiniteAlgebraicExtensionFieldType|) ((parents :initform '(|ConvertibleTo| @@ -21431,7 +22134,7 @@ Value = NIL "PrimeField(p) implements the field with p elements if p is a prime number." "Error: if p is not prime." "Note: this domain does not check that argument is a prime.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21445,10 +22148,10 @@ Value = NIL \end{chunk} \subsection{PrimitiveArray} -\index{PrimitiveArray!Domain} -\index{Domain!PrimitiveArray} -\index{PRIMARR} -\begin{chunk}{sane} +\index[dom]{PrimitiveArray!Domain} +\index[dom]{Domain!PrimitiveArray} +\index[dom]{PRIMARR} +\begin{chunk}{defclass PrimitiveArrayType} (defclass |PrimitiveArrayType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "PrimitiveArray") @@ -21457,7 +22160,7 @@ Value = NIL (comment :initform (list "This provides a fast array type with no bound checking on elt's." "Minimum index is 0 in this type, cannot be changed")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21471,10 +22174,10 @@ Value = NIL \end{chunk} \subsection{Product} -\index{Product!Domain} -\index{Domain!Product} -\index{PRODUCT} -\begin{chunk}{sane} +\index[dom]{Product!Domain} +\index[dom]{Domain!Product} +\index[dom]{PRODUCT} +\begin{chunk}{defclass ProductType} (defclass |ProductType| (|AbelianGroupType| |FiniteType| |GroupType| @@ -21485,7 +22188,7 @@ Value = NIL (abbreviation :initform 'PRODUCT) (comment :initform (list "This domain implements cartesian product")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21499,10 +22202,10 @@ Value = NIL \end{chunk} \subsection{ProjectivePlane} -\index{ProjectivePlane!Domain} -\index{Domain!ProjectivePlane} -\index{PROJPL} -\begin{chunk}{sane} +\index[dom]{ProjectivePlane!Domain} +\index[dom]{Domain!ProjectivePlane} +\index[dom]{PROJPL} +\begin{chunk}{defclass ProjectivePlaneType} (defclass |ProjectivePlaneType| (|ProjectiveSpaceCategoryType|) ((parents :initform '(|ProjectiveSpaceCategory|)) (name :initform "ProjectivePlane") @@ -21510,7 +22213,7 @@ Value = NIL (abbreviation :initform 'PROJPL) (comment :initform (list "This is part of the PAFF package, related to projective space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21524,10 +22227,10 @@ Value = NIL \end{chunk} \subsection{ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField} -\index{ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField!Domain} -\index{Domain!ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField} -\index{PROJPLPS} -\begin{chunk}{sane} +\index[dom]{ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField!Domain} +\index[dom]{Domain!ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField} +\index[dom]{PROJPLPS} +\begin{chunk}{defclass ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteFieldType} (defclass |ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteFieldType| (|ProjectiveSpaceCategoryType|) ((parents :initform '(|ProjectiveSpaceCategory|)) (name :initform "ProjectivePlaneOverPseudoAlgebraicClosureOfFiniteField") @@ -21535,7 +22238,7 @@ Value = NIL (abbreviation :initform 'PROJPLPS) (comment :initform (list "This is part of the PAFF package, related to projective space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21549,10 +22252,10 @@ Value = NIL \end{chunk} \subsection{ProjectiveSpace} -\index{ProjectiveSpace!Domain} -\index{Domain!ProjectiveSpace} -\index{PROJSP} -\begin{chunk}{sane} +\index[dom]{ProjectiveSpace!Domain} +\index[dom]{Domain!ProjectiveSpace} +\index[dom]{PROJSP} +\begin{chunk}{defclass ProjectiveSpaceType} (defclass |ProjectiveSpaceType| (|ProjectiveSpaceCategoryType|) ((parents :initform '(|ProjectiveSpaceCategory|)) (name :initform "ProjectiveSpace") @@ -21560,7 +22263,7 @@ Value = NIL (abbreviation :initform 'PROJSP) (comment :initform (list "This is part of the PAFF package, related to projective space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21574,10 +22277,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfAlgExtOfRationalNumber} -\index{PseudoAlgebraicClosureOfAlgExtOfRationalNumber!Domain} -\index{Domain!PseudoAlgebraicClosureOfAlgExtOfRationalNumber} -\index{PACEXT} -\begin{chunk}{sane} +\index[dom]{PseudoAlgebraicClosureOfAlgExtOfRationalNumber!Domain} +\index[dom]{Domain!PseudoAlgebraicClosureOfAlgExtOfRationalNumber} +\index[dom]{PACEXT} +\begin{chunk}{defclass PseudoAlgebraicClosureOfAlgExtOfRationalNumberType} (defclass |PseudoAlgebraicClosureOfAlgExtOfRationalNumberType| ( |PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategoryType|) ((parents :initform '(|PseudoAlgebraicClosureOfAlgExtOfRationalNumberCategory|)) @@ -21598,7 +22301,7 @@ Value = NIL "(or i=1,2,...,n2). Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21612,10 +22315,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfFiniteField} -\index{PseudoAlgebraicClosureOfFiniteField!Domain} -\index{Domain!PseudoAlgebraicClosureOfFiniteField} -\index{PACOFF} -\begin{chunk}{sane} +\index[dom]{PseudoAlgebraicClosureOfFiniteField!Domain} +\index[dom]{Domain!PseudoAlgebraicClosureOfFiniteField} +\index[dom]{PACOFF} +\begin{chunk}{defclass PseudoAlgebraicClosureOfFiniteFieldType} (defclass |PseudoAlgebraicClosureOfFiniteFieldType| (|PseudoAlgebraicClosureOfFiniteFieldCategoryType| |ExtensionFieldType|) ((parents :initform '(|PseudoAlgebraicClosureOfFiniteFieldCategory| |ExtensionField|)) @@ -21634,7 +22337,7 @@ Value = NIL "(or i=1,2,...,n2). Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21648,10 +22351,10 @@ Value = NIL \end{chunk} \subsection{PseudoAlgebraicClosureOfRationalNumber} -\index{PseudoAlgebraicClosureOfRationalNumber!Domain} -\index{Domain!PseudoAlgebraicClosureOfRationalNumber} -\index{PACRAT} -\begin{chunk}{sane} +\index[dom]{PseudoAlgebraicClosureOfRationalNumber!Domain} +\index[dom]{Domain!PseudoAlgebraicClosureOfRationalNumber} +\index[dom]{PACRAT} +\begin{chunk}{defclass PseudoAlgebraicClosureOfRationalNumberType} (defclass |PseudoAlgebraicClosureOfRationalNumberType| ( |PseudoAlgebraicClosureOfRationalNumberCategoryType|) ((parents :initform '(|PseudoAlgebraicClosureOfRationalNumberCategory|)) @@ -21670,7 +22373,7 @@ Value = NIL "(or i=1,2,...,n2). Any algebraic operations defined for several elements" "are only defined if all of the concerned elements are comming from" "a set of related tour extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21686,10 +22389,10 @@ Value = NIL \section{Q} \subsection{QuadraticForm} -\index{QuadraticForm!Domain} -\index{Domain!QuadraticForm} -\index{QFORM} -\begin{chunk}{sane} +\index[dom]{QuadraticForm!Domain} +\index[dom]{Domain!QuadraticForm} +\index[dom]{QFORM} +\begin{chunk}{defclass QuadraticFormType} (defclass |QuadraticFormType| (|AbelianGroupType|) ((parents :initform '(|AbelianGroup|)) (name :initform "QuadraticForm") @@ -21697,7 +22400,7 @@ Value = NIL (abbreviation :initform 'QFORM) (comment :initform (list "This domain provides modest support for quadratic forms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21711,10 +22414,10 @@ Value = NIL \end{chunk} \subsection{QuasiAlgebraicSet} -\index{QuasiAlgebraicSet!Domain} -\index{Domain!QuasiAlgebraicSet} -\index{QALGSET} -\begin{chunk}{sane} +\index[dom]{QuasiAlgebraicSet!Domain} +\index[dom]{Domain!QuasiAlgebraicSet} +\index[dom]{QALGSET} +\begin{chunk}{defclass QuasiAlgebraicSetType} (defclass |QuasiAlgebraicSetType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "QuasiAlgebraicSet") @@ -21751,7 +22454,7 @@ Value = NIL "The ordering in groebner basis computation is determined by" "the data type of the input polynomials. If it is possible" "we suggest to use refinements of total degree orderings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21765,10 +22468,10 @@ Value = NIL \end{chunk} \subsection{Quaternion} -\index{Quaternion!Domain} -\index{Domain!Quaternion} -\index{QUAT} -\begin{chunk}{sane} +\index[dom]{Quaternion!Domain} +\index[dom]{Domain!Quaternion} +\index[dom]{QUAT} +\begin{chunk}{defclass QuaternionType} (defclass |QuaternionType| (|QuaternionCategoryType|) ((parents :initform '(|QuaternionCategory|)) (name :initform "Quaternion") @@ -21779,7 +22482,7 @@ Value = NIL "commutative ring. The main constructor function is quatern" "which takes 4 arguments: the real part, the i imaginary part, the j" "imaginary part and the k imaginary part.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21793,10 +22496,10 @@ Value = NIL \end{chunk} \subsection{QueryEquation} -\index{QueryEquation!Domain} -\index{Domain!QueryEquation} -\index{QEQUAT} -\begin{chunk}{sane} +\index[dom]{QueryEquation!Domain} +\index[dom]{Domain!QueryEquation} +\index[dom]{QEQUAT} +\begin{chunk}{defclass QueryEquationType} (defclass |QueryEquationType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "QueryEquation") @@ -21804,7 +22507,7 @@ Value = NIL (abbreviation :initform 'QEQUAT) (comment :initform (list "This domain implements simple database queries")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21818,10 +22521,10 @@ Value = NIL \end{chunk} \subsection{Queue} -\index{Queue!Domain} -\index{Domain!Queue} -\index{QUEUE} -\begin{chunk}{sane} +\index[dom]{Queue!Domain} +\index[dom]{Domain!Queue} +\index[dom]{QUEUE} +\begin{chunk}{defclass QueueType} (defclass |QueueType| (|QueueAggregateType|) ((parents :initform '(|QueueAggregate|)) (name :initform "Queue") @@ -21829,7 +22532,7 @@ Value = NIL (abbreviation :initform 'QUEUE) (comment :initform (list "Linked List implementation of a Queue")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21845,10 +22548,10 @@ Value = NIL \section{R} \subsection{RadicalFunctionField} -\index{RadicalFunctionField!Domain} -\index{Domain!RadicalFunctionField} -\index{RADFF} -\begin{chunk}{sane} +\index[dom]{RadicalFunctionField!Domain} +\index[dom]{Domain!RadicalFunctionField} +\index[dom]{RADFF} +\begin{chunk}{defclass RadicalFunctionFieldType} (defclass |RadicalFunctionFieldType| (|FunctionFieldCategoryType|) ((parents :initform '(|FunctionFieldCategory|)) (name :initform "RadicalFunctionField") @@ -21856,7 +22559,7 @@ Value = NIL (abbreviation :initform 'RADFF) (comment :initform (list "Function field defined by y**n = f(x)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21870,10 +22573,10 @@ Value = NIL \end{chunk} \subsection{RadixExpansion} -\index{RadixExpansion!Domain} -\index{Domain!RadixExpansion} -\index{RADIX} -\begin{chunk}{sane} +\index[dom]{RadixExpansion!Domain} +\index[dom]{Domain!RadixExpansion} +\index[dom]{RADIX} +\begin{chunk}{defclass RadixExpansionType} (defclass |RadixExpansionType| (|QuotientFieldCategoryType|) ((parents :initform '(|QuotientFieldCategory|)) (name :initform "RadixExpansion") @@ -21882,7 +22585,7 @@ Value = NIL (comment :initform (list "This domain allows rational numbers to be presented as repeating" "decimal expansions or more generally as repeating expansions in any base.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21896,10 +22599,10 @@ Value = NIL \end{chunk} \subsection{RealClosure} -\index{RealClosure!Domain} -\index{Domain!RealClosure} -\index{RECLOS} -\begin{chunk}{sane} +\index[dom]{RealClosure!Domain} +\index[dom]{Domain!RealClosure} +\index[dom]{RECLOS} +\begin{chunk}{defclass RealClosureType} (defclass |RealClosureType| (|RealClosedFieldType|) ((parents :initform '(|RealClosedField|)) (name :initform "RealClosure") @@ -21912,7 +22615,7 @@ Value = NIL "are done. The two macros PME and SEG should be passed as functorial" "arguments to the domain. It does not help much to write a category" "since non trivial methods cannot be placed there either.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21926,10 +22629,10 @@ Value = NIL \end{chunk} \subsection{RectangularMatrix} -\index{RectangularMatrix!Domain} -\index{Domain!RectangularMatrix} -\index{RMATRIX} -\begin{chunk}{sane} +\index[dom]{RectangularMatrix!Domain} +\index[dom]{Domain!RectangularMatrix} +\index[dom]{RMATRIX} +\begin{chunk}{defclass RectangularMatrixType} (defclass |RectangularMatrixType| (|ConvertibleToType| |RectangularMatrixCategoryType| |VectorSpaceType|) @@ -21942,7 +22645,7 @@ Value = NIL (comment :initform (list "RectangularMatrix is a matrix domain where the number of rows" "and the number of columns are parameters of the domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21956,10 +22659,10 @@ Value = NIL \end{chunk} \subsection{Reference} -\index{Reference!Domain} -\index{Domain!Reference} -\index{REF} -\begin{chunk}{sane} +\index[dom]{Reference!Domain} +\index[dom]{Domain!Reference} +\index[dom]{REF} +\begin{chunk}{defclass ReferenceType} (defclass |ReferenceType| (|TypeType| |SetCategoryType|) ((parents :initform '(|Type| |SetCategory|)) (name :initform "Reference") @@ -21967,7 +22670,7 @@ Value = NIL (abbreviation :initform 'REF) (comment :initform (list "Reference is for making a changeable instance of something.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -21981,10 +22684,10 @@ Value = NIL \end{chunk} \subsection{RegularChain} -\index{RegularChain!Domain} -\index{Domain!RegularChain} -\index{RGCHAIN} -\begin{chunk}{sane} +\index[dom]{RegularChain!Domain} +\index[dom]{Domain!RegularChain} +\index[dom]{RGCHAIN} +\begin{chunk}{defclass RegularChainType} (defclass |RegularChainType| (|RegularTriangularSetCategoryType|) ((parents :initform '(|RegularTriangularSetCategory|)) (name :initform "RegularChain") @@ -21995,7 +22698,7 @@ Value = NIL "a Gcd-Domain and with a fix list of variables." "This is just a front-end for the RegularTriangularSet" "domain constructor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22009,10 +22712,10 @@ Value = NIL \end{chunk} \subsection{RegularTriangularSet} -\index{RegularTriangularSet!Domain} -\index{Domain!RegularTriangularSet} -\index{REGSET} -\begin{chunk}{sane} +\index[dom]{RegularTriangularSet!Domain} +\index[dom]{Domain!RegularTriangularSet} +\index[dom]{REGSET} +\begin{chunk}{defclass RegularTriangularSetType} (defclass |RegularTriangularSetType| (|RegularTriangularSetCategoryType|) ((parents :initform '(|RegularTriangularSetCategory|)) (name :initform "RegularTriangularSet") @@ -22022,7 +22725,7 @@ Value = NIL "This domain provides an implementation of regular chains." "Moreover, the operation zeroSetSplit is an implementation of a new" "algorithm for solving polynomial systems by means of regular chains.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22036,10 +22739,10 @@ Value = NIL \end{chunk} \subsection{ResidueRing} -\index{ResidueRing!Domain} -\index{Domain!ResidueRing} -\index{RESRING} -\begin{chunk}{sane} +\index[dom]{ResidueRing!Domain} +\index[dom]{Domain!ResidueRing} +\index[dom]{RESRING} +\begin{chunk}{defclass ResidueRingType} (defclass |ResidueRingType| (|CommutativeRingType| |AlgebraType|) ((parents :initform '(|CommutativeRing| |Algebra|)) (name :initform "ResidueRing") @@ -22049,7 +22752,7 @@ Value = NIL "ResidueRing is the quotient of a polynomial ring by an ideal." "The ideal is given as a list of generators. The elements of the domain" "are equivalence classes expressed in terms of reduced elements")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22063,10 +22766,10 @@ Value = NIL \end{chunk} \subsection{Result} -\index{Result!Domain} -\index{Domain!Result} -\index{RESULT} -\begin{chunk}{sane} +\index[dom]{Result!Domain} +\index[dom]{Domain!Result} +\index[dom]{RESULT} +\begin{chunk}{defclass ResultType} (defclass |ResultType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "Result") @@ -22076,7 +22779,7 @@ Value = NIL "A domain used to return the results from a call to the NAG" "Library. It prints as a list of names and types, though the user may" "choose to display values automatically if he or she wishes.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22090,10 +22793,10 @@ Value = NIL \end{chunk} \subsection{RewriteRule} -\index{RewriteRule!Domain} -\index{Domain!RewriteRule} -\index{RULE} -\begin{chunk}{sane} +\index[dom]{RewriteRule!Domain} +\index[dom]{Domain!RewriteRule} +\index[dom]{RULE} +\begin{chunk}{defclass RewriteRuleType} (defclass |RewriteRuleType| (|SetCategoryType| |RetractableToType| |EltableType|) ((parents :initform '(|SetCategory| |RetractableTo| |Eltable|)) (name :initform "RewriteRule") @@ -22101,7 +22804,7 @@ Value = NIL (abbreviation :initform 'RULE) (comment :initform (list "Rules for the pattern matcher")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22115,10 +22818,10 @@ Value = NIL \end{chunk} \subsection{RightOpenIntervalRootCharacterization} -\index{RightOpenIntervalRootCharacterization!Domain} -\index{Domain!RightOpenIntervalRootCharacterization} -\index{ROIRC} -\begin{chunk}{sane} +\index[dom]{RightOpenIntervalRootCharacterization!Domain} +\index[dom]{Domain!RightOpenIntervalRootCharacterization} +\index[dom]{ROIRC} +\begin{chunk}{defclass RightOpenIntervalRootCharacterizationType} (defclass |RightOpenIntervalRootCharacterizationType| (|RealRootCharacterizationCategoryType|) ((parents :initform '(|RealRootCharacterizationCategory|)) (name :initform "RightOpenIntervalRootCharacterization") @@ -22127,7 +22830,7 @@ Value = NIL (comment :initform (list "RightOpenIntervalRootCharacterization provides work with" "interval root coding.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22141,10 +22844,10 @@ Value = NIL \end{chunk} \subsection{RomanNumeral} -\index{RomanNumeral!Domain} -\index{Domain!RomanNumeral} -\index{ROMAN} -\begin{chunk}{sane} +\index[dom]{RomanNumeral!Domain} +\index[dom]{Domain!RomanNumeral} +\index[dom]{ROMAN} +\begin{chunk}{defclass RomanNumeralType} (defclass |RomanNumeralType| (|IntegerNumberSystemType|) ((parents :initform '(|IntegerNumberSystem|)) (name :initform "RomanNumeral") @@ -22153,7 +22856,7 @@ Value = NIL (comment :initform (list "RomanNumeral provides functions for converting" "integers to roman numerals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22167,10 +22870,10 @@ Value = NIL \end{chunk} \subsection{RoutinesTable} -\index{RoutinesTable!Domain} -\index{Domain!RoutinesTable} -\index{ROUTINE} -\begin{chunk}{sane} +\index[dom]{RoutinesTable!Domain} +\index[dom]{Domain!RoutinesTable} +\index[dom]{ROUTINE} +\begin{chunk}{defclass RoutinesTableType} (defclass |RoutinesTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "RoutinesTable") @@ -22179,7 +22882,7 @@ Value = NIL (comment :initform (list "RoutinesTable implements a database and associated tuning" "mechanisms for a set of known NAG routines")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22193,10 +22896,10 @@ Value = NIL \end{chunk} \subsection{RuleCalled} -\index{RuleCalled!Domain} -\index{Domain!RuleCalled} -\index{RULECOLD} -\begin{chunk}{sane} +\index[dom]{RuleCalled!Domain} +\index[dom]{Domain!RuleCalled} +\index[dom]{RULECOLD} +\begin{chunk}{defclass RuleCalledType} (defclass |RuleCalledType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "RuleCalled") @@ -22204,7 +22907,7 @@ Value = NIL (abbreviation :initform 'RULECOLD) (comment :initform (list "This domain implements named rules ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22218,10 +22921,10 @@ Value = NIL \end{chunk} \subsection{Ruleset} -\index{Ruleset!Domain} -\index{Domain!Ruleset} -\index{RULESET} -\begin{chunk}{sane} +\index[dom]{Ruleset!Domain} +\index[dom]{Domain!Ruleset} +\index[dom]{RULESET} +\begin{chunk}{defclass RulesetType} (defclass |RulesetType| (|SetCategoryType| |EltableType|) ((parents :initform '(|SetCategory| |Eltable|)) (name :initform "Ruleset") @@ -22230,7 +22933,7 @@ Value = NIL (comment :initform (list "Sets of rules for the pattern matcher." "A ruleset is a set of pattern matching rules grouped together.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22246,10 +22949,10 @@ Value = NIL \section{S} \subsection{ScriptFormulaFormat} -\index{ScriptFormulaFormat!Domain} -\index{Domain!ScriptFormulaFormat} -\index{FORMULA} -\begin{chunk}{sane} +\index[dom]{ScriptFormulaFormat!Domain} +\index[dom]{Domain!ScriptFormulaFormat} +\index[dom]{FORMULA} +\begin{chunk}{defclass ScriptFormulaFormatType} (defclass |ScriptFormulaFormatType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "ScriptFormulaFormat") @@ -22267,7 +22970,7 @@ Value = NIL "appropriate tags for printing. For example, the prologue and" "epilogue might simply contain ':df.' and ':edf.' so that the" "formula section will be printed in display math mode.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22281,10 +22984,10 @@ Value = NIL \end{chunk} \subsection{Segment} -\index{Segment!Domain} -\index{Domain!Segment} -\index{SEG} -\begin{chunk}{sane} +\index[dom]{Segment!Domain} +\index[dom]{Domain!Segment} +\index[dom]{SEG} +\begin{chunk}{defclass SegmentType} (defclass |SegmentType| (|SetCategoryType| |SegmentExpansionCategoryType|) ((parents :initform '(|SetCategory| |SegmentExpansionCategory|)) (name :initform "Segment") @@ -22292,7 +22995,7 @@ Value = NIL (abbreviation :initform 'SEG) (comment :initform (list "This type is used to specify a range of values from type S.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22306,10 +23009,10 @@ Value = NIL \end{chunk} \subsection{SegmentBinding} -\index{SegmentBinding!Domain} -\index{Domain!SegmentBinding} -\index{SEGBIND} -\begin{chunk}{sane} +\index[dom]{SegmentBinding!Domain} +\index[dom]{Domain!SegmentBinding} +\index[dom]{SEGBIND} +\begin{chunk}{defclass SegmentBindingType} (defclass |SegmentBindingType| (|TypeType| |SetCategoryType|) ((parents :initform '(|Type| |SetCategory|)) (name :initform "SegmentBinding") @@ -22318,7 +23021,7 @@ Value = NIL (comment :initform (list "This domain is used to provide the function argument syntax v=a..b." "This is used, for example, by the top-level draw functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22332,10 +23035,10 @@ Value = NIL \end{chunk} \subsection{Set} -\index{Set!Domain} -\index{Domain!Set} -\index{SET} -\begin{chunk}{sane} +\index[dom]{Set!Domain} +\index[dom]{Domain!Set} +\index[dom]{SET} +\begin{chunk}{defclass SetType} (defclass |SetType| (|FiniteSetAggregateType|) ((parents :initform '(|FiniteSetAggregate|)) (name :initform "Set") @@ -22361,7 +23064,7 @@ Value = NIL " symmetricDifference(s,t) is O(max(n,m)" " member(x,t) is O(n log n)" " insert(x,t) and remove(x,t) is O(n)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22375,10 +23078,10 @@ Value = NIL \end{chunk} \subsection{SetOfMIntegersInOneToN} -\index{SetOfMIntegersInOneToN!Domain} -\index{Domain!SetOfMIntegersInOneToN} -\index{SETMN} -\begin{chunk}{sane} +\index[dom]{SetOfMIntegersInOneToN!Domain} +\index[dom]{Domain!SetOfMIntegersInOneToN} +\index[dom]{SETMN} +\begin{chunk}{defclass SetOfMIntegersInOneToNType} (defclass |SetOfMIntegersInOneToNType| (|FiniteType|) ((parents :initform '(|Finite|)) (name :initform "SetOfMIntegersInOneToN") @@ -22387,7 +23090,7 @@ Value = NIL (comment :initform (list "SetOfMIntegersInOneToN implements the subsets of M integers" "in the interval [1..n]")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22401,10 +23104,10 @@ Value = NIL \end{chunk} \subsection{SequentialDifferentialPolynomial} -\index{SequentialDifferentialPolynomial!Domain} -\index{Domain!SequentialDifferentialPolynomial} -\index{SDPOL} -\begin{chunk}{sane} +\index[dom]{SequentialDifferentialPolynomial!Domain} +\index[dom]{Domain!SequentialDifferentialPolynomial} +\index[dom]{SDPOL} +\begin{chunk}{defclass SequentialDifferentialPolynomialType} (defclass |SequentialDifferentialPolynomialType| (|DifferentialPolynomialCategoryType|) ((parents :initform '(|DifferentialPolynomialCategory|)) (name :initform "SequentialDifferentialPolynomial") @@ -22415,7 +23118,7 @@ Value = NIL "an ordinary differential polynomial ring in arbitrary number" "of differential indeterminates, with coefficients in a" "ring. The ranking on the differential indeterminate is sequential.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22429,10 +23132,10 @@ Value = NIL \end{chunk} \subsection{SequentialDifferentialVariable} -\index{SequentialDifferentialVariable!Domain} -\index{Domain!SequentialDifferentialVariable} -\index{SDVAR} -\begin{chunk}{sane} +\index[dom]{SequentialDifferentialVariable!Domain} +\index[dom]{Domain!SequentialDifferentialVariable} +\index[dom]{SDVAR} +\begin{chunk}{defclass SequentialDifferentialVariableType} (defclass |SequentialDifferentialVariableType| (|DifferentialVariableCategoryType|) ((parents :initform '(|DifferentialVariableCategory|)) (name :initform "SequentialDifferentialVariable") @@ -22449,7 +23152,7 @@ Value = NIL "defines a sequential ranking < on derivatives u by the" "lexicographic order on the pair" "(variable(u), order(u)).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22463,10 +23166,10 @@ Value = NIL \end{chunk} \subsection{SExpression} -\index{SExpression!Domain} -\index{Domain!SExpression} -\index{SEX} -\begin{chunk}{sane} +\index[dom]{SExpression!Domain} +\index[dom]{Domain!SExpression} +\index[dom]{SEX} +\begin{chunk}{defclass SExpressionType} (defclass |SExpressionType| (|SExpressionCategoryType|) ((parents :initform '(|SExpressionCategory|)) (name :initform "SExpression") @@ -22474,7 +23177,7 @@ Value = NIL (abbreviation :initform 'SEX) (comment :initform (list "This domain allows the manipulation of the usual Lisp values")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22488,10 +23191,10 @@ Value = NIL \end{chunk} \subsection{SExpressionOf} -\index{SExpressionOf!Domain} -\index{Domain!SExpressionOf} -\index{SEXOF} -\begin{chunk}{sane} +\index[dom]{SExpressionOf!Domain} +\index[dom]{Domain!SExpressionOf} +\index[dom]{SEXOF} +\begin{chunk}{defclass SExpressionOfType} (defclass |SExpressionOfType| (|SExpressionCategoryType|) ((parents :initform '(|SExpressionCategory|)) (name :initform "SExpressionOf") @@ -22503,7 +23206,7 @@ Value = NIL "Allows the names of the atomic types to be chosen." "Warning: Although the parameters are declared only to be Sets," "they must have the appropriate representations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22517,10 +23220,10 @@ Value = NIL \end{chunk} \subsection{SimpleAlgebraicExtension} -\index{SimpleAlgebraicExtension!Domain} -\index{Domain!SimpleAlgebraicExtension} -\index{SAE} -\begin{chunk}{sane} +\index[dom]{SimpleAlgebraicExtension!Domain} +\index[dom]{Domain!SimpleAlgebraicExtension} +\index[dom]{SAE} +\begin{chunk}{defclass SimpleAlgebraicExtensionType} (defclass |SimpleAlgebraicExtensionType| (|MonogenicAlgebraType|) ((parents :initform '(|MonogenicAlgebra|)) (name :initform "SimpleAlgebraicExtension") @@ -22536,7 +23239,7 @@ Value = NIL "of degree less than that of the minimal polynomial with coefficients" "in R. The second argument is both the type of the third argument and" "the underlying representation used by SAE itself.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22550,17 +23253,17 @@ Value = NIL \end{chunk} \subsection{SimpleCell} -\index{SimpleCell!Domain} -\index{Domain!SimpleCell} -\index{SCELL} -\begin{chunk}{sane} +\index[dom]{SimpleCell!Domain} +\index[dom]{Domain!SimpleCell} +\index[dom]{SCELL} +\begin{chunk}{defclass SimpleCellType} (defclass |SimpleCellType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "SimpleCell") (marker :initform 'domain) (abbreviation :initform 'SCELL) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22574,10 +23277,10 @@ Value = NIL \end{chunk} \subsection{SimpleFortranProgram} -\index{SimpleFortranProgram!Domain} -\index{Domain!SimpleFortranProgram} -\index{SFORT} -\begin{chunk}{sane} +\index[dom]{SimpleFortranProgram!Domain} +\index[dom]{Domain!SimpleFortranProgram} +\index[dom]{SFORT} +\begin{chunk}{defclass SimpleFortranProgramType} (defclass |SimpleFortranProgramType| (|FortranProgramCategoryType|) ((parents :initform '(|FortranProgramCategory|)) (name :initform "SimpleFortranProgram") @@ -22588,7 +23291,7 @@ Value = NIL "FORTRAN subprograms, making it possible to coerce objects of various" "domains into a FORTRAN subprogram called f." "These can then be translated into legal FORTRAN code.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22602,10 +23305,10 @@ Value = NIL \end{chunk} \subsection{SingleInteger} -\index{SingleInteger!Domain} -\index{Domain!SingleInteger} -\index{SINT} -\begin{chunk}{sane} +\index[dom]{SingleInteger!Domain} +\index[dom]{Domain!SingleInteger} +\index[dom]{SINT} +\begin{chunk}{defclass SingleIntegerType} (defclass |SingleIntegerType| (|OpenMathType| |LogicType| |IntegerNumberSystemType|) ((parents :initform '(|OpenMath| |Logic| |IntegerNumberSystem|)) (name :initform "SingleInteger") @@ -22613,7 +23316,7 @@ Value = NIL (abbreviation :initform 'SINT) (comment :initform (list "SingleInteger is intended to support machine integer arithmetic.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22627,10 +23330,10 @@ Value = NIL \end{chunk} \subsection{SingletonAsOrderedSet} -\index{SingletonAsOrderedSet!Domain} -\index{Domain!SingletonAsOrderedSet} -\index{SAOS} -\begin{chunk}{sane} +\index[dom]{SingletonAsOrderedSet!Domain} +\index[dom]{Domain!SingletonAsOrderedSet} +\index[dom]{SAOS} +\begin{chunk}{defclass SingletonAsOrderedSetType} (defclass |SingletonAsOrderedSetType| (|OrderedSetType|) ((parents :initform '(|OrderedSet|)) (name :initform "SingletonAsOrderedSet") @@ -22639,7 +23342,7 @@ Value = NIL (comment :initform (list "This trivial domain lets us build Univariate Polynomials" "in an anonymous variable")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22653,10 +23356,10 @@ Value = NIL \end{chunk} \subsection{SparseEchelonMatrix} -\index{SparseEchelonMatrix!Domain} -\index{Domain!SparseEchelonMatrix} -\index{SEM} -\begin{chunk}{sane} +\index[dom]{SparseEchelonMatrix!Domain} +\index[dom]{Domain!SparseEchelonMatrix} +\index[dom]{SEM} +\begin{chunk}{defclass SparseEchelonMatrixType} (defclass |SparseEchelonMatrixType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "SparseEchelonMatrix") @@ -22669,7 +23372,7 @@ Value = NIL "this domain is the computation of an row echelon form. The used algorithm" "tries to maintain the sparsity and is especially adapted to matrices who" "are already close to a row echelon form.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22683,10 +23386,10 @@ Value = NIL \end{chunk} \subsection{SparseMultivariatePolynomial} -\index{SparseMultivariatePolynomial!Domain} -\index{Domain!SparseMultivariatePolynomial} -\index{SMP} -\begin{chunk}{sane} +\index[dom]{SparseMultivariatePolynomial!Domain} +\index[dom]{Domain!SparseMultivariatePolynomial} +\index[dom]{SMP} +\begin{chunk}{defclass SparseMultivariatePolynomialType} (defclass |SparseMultivariatePolynomialType| (|PolynomialCategoryType|) ((parents :initform '(|PolynomialCategory|)) (name :initform "SparseMultivariatePolynomial") @@ -22698,7 +23401,7 @@ Value = NIL "variable set which may be infinite. The variable ordering is determined" "by the variable set parameter. The coefficient ring may be non-commutative," "but the variables are assumed to commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22712,10 +23415,10 @@ Value = NIL \end{chunk} \subsection{SparseMultivariateTaylorSeries} -\index{SparseMultivariateTaylorSeries!Domain} -\index{Domain!SparseMultivariateTaylorSeries} -\index{SMTS} -\begin{chunk}{sane} +\index[dom]{SparseMultivariateTaylorSeries!Domain} +\index[dom]{Domain!SparseMultivariateTaylorSeries} +\index[dom]{SMTS} +\begin{chunk}{defclass SparseMultivariateTaylorSeriesType} (defclass |SparseMultivariateTaylorSeriesType| (|MultivariateTaylorSeriesCategoryType|) ((parents :initform '(|MultivariateTaylorSeriesCategory|)) (name :initform "SparseMultivariateTaylorSeries") @@ -22727,7 +23430,7 @@ Value = NIL "by a stream of polynomials from the polynomial domain SMP." "The nth element of the stream is a form of degree n. SMTS is an" "internal domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22741,10 +23444,10 @@ Value = NIL \end{chunk} \subsection{SparseTable} -\index{SparseTable!Domain} -\index{Domain!SparseTable} -\index{STBL} -\begin{chunk}{sane} +\index[dom]{SparseTable!Domain} +\index[dom]{Domain!SparseTable} +\index[dom]{STBL} +\begin{chunk}{defclass SparseTableType} (defclass |SparseTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "SparseTable") @@ -22753,7 +23456,7 @@ Value = NIL (comment :initform (list "A sparse table has a default entry, which is returned if no other" "value has been explicitly stored for a key.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22767,10 +23470,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariateLaurentSeries} -\index{SparseUnivariateLaurentSeries!Domain} -\index{Domain!SparseUnivariateLaurentSeries} -\index{SULS} -\begin{chunk}{sane} +\index[dom]{SparseUnivariateLaurentSeries!Domain} +\index[dom]{Domain!SparseUnivariateLaurentSeries} +\index[dom]{SULS} +\begin{chunk}{defclass SparseUnivariateLaurentSeriesType} (defclass |SparseUnivariateLaurentSeriesType| (|UnivariateLaurentSeriesConstructorCategoryType|) ((parents :initform '(|UnivariateLaurentSeriesConstructorCategory|)) (name :initform "SparseUnivariateLaurentSeries") @@ -22783,7 +23486,7 @@ Value = NIL "variable, and the center of the power series expansion. For example," "SparseUnivariateLaurentSeries(Integer,x,3) represents Laurent" "series in (x - 3) with integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22797,10 +23500,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariatePolynomial} -\index{SparseUnivariatePolynomial!Domain} -\index{Domain!SparseUnivariatePolynomial} -\index{SUP} -\begin{chunk}{sane} +\index[dom]{SparseUnivariatePolynomial!Domain} +\index[dom]{Domain!SparseUnivariatePolynomial} +\index[dom]{SUP} +\begin{chunk}{defclass SparseUnivariatePolynomialType} (defclass |SparseUnivariatePolynomialType| (|UnivariatePolynomialCategoryType|) ((parents :initform '(|UnivariatePolynomialCategory|)) (name :initform "SparseUnivariatePolynomial") @@ -22815,7 +23518,7 @@ Value = NIL "in the sense that only non-zero terms are represented." "Note that if the coefficient ring is a field," "this domain forms a euclidean domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22829,10 +23532,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariatePolynomialExpressions} -\index{SparseUnivariatePolynomialExpressions!Domain} -\index{Domain!SparseUnivariatePolynomialExpressions} -\index{SUPEXPR} -\begin{chunk}{sane} +\index[dom]{SparseUnivariatePolynomialExpressions!Domain} +\index[dom]{Domain!SparseUnivariatePolynomialExpressions} +\index[dom]{SUPEXPR} +\begin{chunk}{defclass SparseUnivariatePolynomialExpressionsType} (defclass |SparseUnivariatePolynomialExpressionsType| (|UnivariatePolynomialCategoryType| |TranscendentalFunctionCategoryType|) ((parents :initform '(|UnivariatePolynomialCategory| |TranscendentalFunctionCategory|)) @@ -22841,7 +23544,7 @@ Value = NIL (abbreviation :initform 'SUPEXPR) (comment :initform (list "This domain has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22855,10 +23558,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariatePuiseuxSeries} -\index{SparseUnivariatePuiseuxSeries!Domain} -\index{Domain!SparseUnivariatePuiseuxSeries} -\index{SUPXS} -\begin{chunk}{sane} +\index[dom]{SparseUnivariatePuiseuxSeries!Domain} +\index[dom]{Domain!SparseUnivariatePuiseuxSeries} +\index[dom]{SUPXS} +\begin{chunk}{defclass SparseUnivariatePuiseuxSeriesType} (defclass |SparseUnivariatePuiseuxSeriesType| (|UnivariatePuiseuxSeriesConstructorCategoryType|) ((parents :initform '(|UnivariatePuiseuxSeriesConstructorCategory|)) (name :initform "SparseUnivariatePuiseuxSeries") @@ -22872,7 +23575,7 @@ Value = NIL "variable, and the center of the power series expansion. For example," "SparseUnivariatePuiseuxSeries(Integer,x,3) represents Puiseux" "series in (x - 3) with Integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22886,10 +23589,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariateSkewPolynomial} -\index{SparseUnivariateSkewPolynomial!Domain} -\index{Domain!SparseUnivariateSkewPolynomial} -\index{ORESUP} -\begin{chunk}{sane} +\index[dom]{SparseUnivariateSkewPolynomial!Domain} +\index[dom]{Domain!SparseUnivariateSkewPolynomial} +\index[dom]{ORESUP} +\begin{chunk}{defclass SparseUnivariateSkewPolynomialType} (defclass |SparseUnivariateSkewPolynomialType| (|UnivariateSkewPolynomialCategoryType|) ((parents :initform '(|UnivariateSkewPolynomialCategory|)) (name :initform "SparseUnivariateSkewPolynomial") @@ -22899,7 +23602,7 @@ Value = NIL "This is the domain of sparse univariate skew polynomials over an Ore" "coefficient field." "The multiplication is given by x a = sigma(a) x + delta a.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22913,10 +23616,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariateTaylorSeries} -\index{SparseUnivariateTaylorSeries!Domain} -\index{Domain!SparseUnivariateTaylorSeries} -\index{SUTS} -\begin{chunk}{sane} +\index[dom]{SparseUnivariateTaylorSeries!Domain} +\index[dom]{Domain!SparseUnivariateTaylorSeries} +\index[dom]{SUTS} +\begin{chunk}{defclass SparseUnivariateTaylorSeriesType} (defclass |SparseUnivariateTaylorSeriesType| (|UnivariateTaylorSeriesCategoryType|) ((parents :initform '(|UnivariateTaylorSeriesCategory|)) (name :initform "SparseUnivariateTaylorSeries") @@ -22929,7 +23632,7 @@ Value = NIL "variable, and the center of the power series expansion. For example," "SparseUnivariateTaylorSeries(Integer,x,3) represents Taylor" "series in (x - 3) with Integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22943,10 +23646,10 @@ Value = NIL \end{chunk} \subsection{SplitHomogeneousDirectProduct} -\index{SplitHomogeneousDirectProduct!Domain} -\index{Domain!SplitHomogeneousDirectProduct} -\index{SHDP} -\begin{chunk}{sane} +\index[dom]{SplitHomogeneousDirectProduct!Domain} +\index[dom]{Domain!SplitHomogeneousDirectProduct} +\index[dom]{SHDP} +\begin{chunk}{defclass SplitHomogeneousDirectProductType} (defclass |SplitHomogeneousDirectProductType| (|DirectProductCategoryType|) ((parents :initform '(|DirectProductCategory|)) (name :initform "SplitHomogeneousDirectProduct") @@ -22960,7 +23663,7 @@ Value = NIL "the blocks but acts like HomogeneousDirectProduct" "within each block. This type is a suitable third argument for" "GeneralDistributedMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -22974,10 +23677,10 @@ Value = NIL \end{chunk} \subsection{SplittingNode} -\index{SplittingNode!Domain} -\index{Domain!SplittingNode} -\index{SPLNODE} -\begin{chunk}{sane} +\index[dom]{SplittingNode!Domain} +\index[dom]{Domain!SplittingNode} +\index[dom]{SPLNODE} +\begin{chunk}{defclass SplittingNodeType} (defclass |SplittingNodeType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "SplittingNode") @@ -22995,7 +23698,7 @@ Value = NIL "evaluation under its condition. Two splitting vertices" "are equal iff they have the sane values and the same" "conditions (so their status do not matter).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23009,10 +23712,10 @@ Value = NIL \end{chunk} \subsection{SplittingTree} -\index{SplittingTree!Domain} -\index{Domain!SplittingTree} -\index{SPLTREE} -\begin{chunk}{sane} +\index[dom]{SplittingTree!Domain} +\index[dom]{Domain!SplittingTree} +\index[dom]{SPLTREE} +\begin{chunk}{defclass SplittingTreeType} (defclass |SplittingTreeType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "SplittingTree") @@ -23040,7 +23743,7 @@ Value = NIL "splitNodeOf! and if construct" "is only used to create the root of a" "with no children.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23054,10 +23757,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeRegularTriangularSet} -\index{SquareFreeRegularTriangularSet!Domain} -\index{Domain!SquareFreeRegularTriangularSet} -\index{SREGSET} -\begin{chunk}{sane} +\index[dom]{SquareFreeRegularTriangularSet!Domain} +\index[dom]{Domain!SquareFreeRegularTriangularSet} +\index[dom]{SREGSET} +\begin{chunk}{defclass SquareFreeRegularTriangularSetType} (defclass |SquareFreeRegularTriangularSetType| (|SquareFreeRegularTriangularSetCategoryType|) ((parents :initform '(|SquareFreeRegularTriangularSetCategory|)) (name :initform "SquareFreeRegularTriangularSet") @@ -23068,7 +23771,7 @@ Value = NIL "Moreover, the operation zeroSetSplit" "is an implementation of a new algorithm for solving polynomial systems by" "means of regular chains.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23082,10 +23785,10 @@ Value = NIL \end{chunk} \subsection{SquareMatrix} -\index{SquareMatrix!Domain} -\index{Domain!SquareMatrix} -\index{SQMATRIX} -\begin{chunk}{sane} +\index[dom]{SquareMatrix!Domain} +\index[dom]{Domain!SquareMatrix} +\index[dom]{SQMATRIX} +\begin{chunk}{defclass SquareMatrixType} (defclass |SquareMatrixType| (|SquareMatrixCategoryType| |ConvertibleToType|) ((parents :initform '(|SquareMatrixCategory| |ConvertibleTo|)) (name :initform "SquareMatrix") @@ -23094,7 +23797,7 @@ Value = NIL (comment :initform (list "SquareMatrix is a matrix domain of square matrices, where the" "number of rows (= number of columns) is a parameter of the type.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23108,10 +23811,10 @@ Value = NIL \end{chunk} \subsection{Stack} -\index{Stack!Domain} -\index{Domain!Stack} -\index{STACK} -\begin{chunk}{sane} +\index[dom]{Stack!Domain} +\index[dom]{Domain!Stack} +\index[dom]{STACK} +\begin{chunk}{defclass StackType} (defclass |StackType| (|StackAggregateType|) ((parents :initform '(|StackAggregate|)) (name :initform "Stack") @@ -23119,7 +23822,7 @@ Value = NIL (abbreviation :initform 'STACK) (comment :initform (list "Linked List implementation of a Stack")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23133,10 +23836,10 @@ Value = NIL \end{chunk} \subsection{StochasticDifferential} -\index{StochasticDifferential!Domain} -\index{Domain!StochasticDifferential} -\index{SD} -\begin{chunk}{sane} +\index[dom]{StochasticDifferential!Domain} +\index[dom]{Domain!StochasticDifferential} +\index[dom]{SD} +\begin{chunk}{defclass StochasticDifferentialType} (defclass |StochasticDifferentialType| (|RngType| |RetractableToType| |ModuleType|) ((parents :initform '(|Rng| |RetractableTo| |Module|)) (name :initform "StochasticDifferential") @@ -23150,7 +23853,7 @@ Value = NIL "(AXIOM term is 'Rng'). Note that separate instances, for example" "using R=Integer and R=Float, have different hidden structure" "(multiplication and drift tables).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23164,10 +23867,10 @@ Value = NIL \end{chunk} \subsection{Stream} -\index{Stream!Domain} -\index{Domain!Stream} -\index{STREAM} -\begin{chunk}{sane} +\index[dom]{Stream!Domain} +\index[dom]{Domain!Stream} +\index[dom]{STREAM} +\begin{chunk}{defclass StreamType} (defclass |StreamType| (|LazyStreamAggregateType|) ((parents :initform '(|LazyStreamAggregate|)) (name :initform "Stream") @@ -23177,7 +23880,7 @@ Value = NIL "A stream is an implementation of an infinite sequence using" "a list of terms that have been computed and a function closure" "to compute additional terms when needed.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23191,10 +23894,10 @@ Value = NIL \end{chunk} \subsection{String} -\index{String!Domain} -\index{Domain!String} -\index{STRING} -\begin{chunk}{sane} +\index[dom]{String!Domain} +\index[dom]{Domain!String} +\index[dom]{STRING} +\begin{chunk}{defclass StringType} (defclass |StringType| (|StringCategoryType|) ((parents :initform '(|StringCategory|)) (name :initform "String") @@ -23202,7 +23905,7 @@ Value = NIL (abbreviation :initform 'STRING) (comment :initform (list "This is the domain of character strings. Strings are 1 based.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23216,10 +23919,10 @@ Value = NIL \end{chunk} \subsection{StringTable} -\index{StringTable!Domain} -\index{Domain!StringTable} -\index{STRTBL} -\begin{chunk}{sane} +\index[dom]{StringTable!Domain} +\index[dom]{Domain!StringTable} +\index[dom]{STRTBL} +\begin{chunk}{defclass StringTableType} (defclass |StringTableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "StringTable") @@ -23228,7 +23931,7 @@ Value = NIL (comment :initform (list "This domain provides tables where the keys are strings." "A specialized hash function for strings is used.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23242,10 +23945,10 @@ Value = NIL \end{chunk} \subsection{SubSpace} -\index{SubSpace!Domain} -\index{Domain!SubSpace} -\index{SUBSPACE} -\begin{chunk}{sane} +\index[dom]{SubSpace!Domain} +\index[dom]{Domain!SubSpace} +\index[dom]{SUBSPACE} +\begin{chunk}{defclass SubSpaceType} (defclass |SubSpaceType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "SubSpace") @@ -23253,7 +23956,7 @@ Value = NIL (abbreviation :initform 'SUBSPACE) (comment :initform (list "This domain is not documented")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23267,10 +23970,10 @@ Value = NIL \end{chunk} \subsection{SubSpaceComponentProperty} -\index{SubSpaceComponentProperty!Domain} -\index{Domain!SubSpaceComponentProperty} -\index{COMPPROP} -\begin{chunk}{sane} +\index[dom]{SubSpaceComponentProperty!Domain} +\index[dom]{Domain!SubSpaceComponentProperty} +\index[dom]{COMPPROP} +\begin{chunk}{defclass SubSpaceComponentPropertyType} (defclass |SubSpaceComponentPropertyType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "SubSpaceComponentProperty") @@ -23278,7 +23981,7 @@ Value = NIL (abbreviation :initform 'COMPPROP) (comment :initform (list "This domain implements some global properties of subspaces.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23292,10 +23995,10 @@ Value = NIL \end{chunk} \subsection{SuchThat} -\index{SuchThat!Domain} -\index{Domain!SuchThat} -\index{SUCH} -\begin{chunk}{sane} +\index[dom]{SuchThat!Domain} +\index[dom]{Domain!SuchThat} +\index[dom]{SUCH} +\begin{chunk}{defclass SuchThatType} (defclass |SuchThatType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "SuchThat") @@ -23303,7 +24006,7 @@ Value = NIL (abbreviation :initform 'SUCH) (comment :initform (list "This domain implements 'such that' forms")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23317,10 +24020,10 @@ Value = NIL \end{chunk} \subsection{Switch} -\index{Switch!Domain} -\index{Domain!Switch} -\index{SWITCH} -\begin{chunk}{sane} +\index[dom]{Switch!Domain} +\index[dom]{Domain!Switch} +\index[dom]{SWITCH} +\begin{chunk}{defclass SwitchType} (defclass |SwitchType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "Switch") @@ -23329,7 +24032,7 @@ Value = NIL (comment :initform (list "This domain builds representations of boolean expressions for use with" "the FortranCode domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23343,10 +24046,10 @@ Value = NIL \end{chunk} \subsection{Symbol} -\index{Symbol!Domain} -\index{Domain!Symbol} -\index{SYMBOL} -\begin{chunk}{sane} +\index[dom]{Symbol!Domain} +\index[dom]{Domain!Symbol} +\index[dom]{SYMBOL} +\begin{chunk}{defclass SymbolType} (defclass |SymbolType| (|PatternMatchableType| |OrderedSetType| |OpenMathType| @@ -23360,7 +24063,7 @@ Value = NIL (abbreviation :initform 'SYMBOL) (comment :initform (list "Basic and scripted symbols.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23374,10 +24077,10 @@ Value = NIL \end{chunk} \subsection{SymbolTable} -\index{SymbolTable!Domain} -\index{Domain!SymbolTable} -\index{SYMTAB} -\begin{chunk}{sane} +\index[dom]{SymbolTable!Domain} +\index[dom]{Domain!SymbolTable} +\index[dom]{SYMTAB} +\begin{chunk}{defclass SymbolTableType} (defclass |SymbolTableType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "SymbolTable") @@ -23385,7 +24088,7 @@ Value = NIL (abbreviation :initform 'SYMTAB) (comment :initform (list "Create and manipulate a symbol table for generated FORTRAN code")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23399,10 +24102,10 @@ Value = NIL \end{chunk} \subsection{SymmetricPolynomial} -\index{SymmetricPolynomial!Domain} -\index{Domain!SymmetricPolynomial} -\index{SYMPOLY} -\begin{chunk}{sane} +\index[dom]{SymmetricPolynomial!Domain} +\index[dom]{Domain!SymmetricPolynomial} +\index[dom]{SYMPOLY} +\begin{chunk}{defclass SymmetricPolynomialType} (defclass |SymmetricPolynomialType| (|FiniteAbelianMonoidRingType|) ((parents :initform '(|FiniteAbelianMonoidRing|)) (name :initform "SymmetricPolynomial") @@ -23410,7 +24113,7 @@ Value = NIL (abbreviation :initform 'SYMPOLY) (comment :initform (list "This domain implements symmetric polynomial")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23426,10 +24129,10 @@ Value = NIL \section{T} \subsection{Table} -\index{Table!Domain} -\index{Domain!Table} -\index{TABLE} -\begin{chunk}{sane} +\index[dom]{Table!Domain} +\index[dom]{Domain!Table} +\index[dom]{TABLE} +\begin{chunk}{defclass TableType} (defclass |TableType| (|TableAggregateType|) ((parents :initform '(|TableAggregate|)) (name :initform "Table") @@ -23441,7 +24144,7 @@ Value = NIL "This creates a HashTable if equal for the Key" "domain is consistent with Lisp EQUAL otherwise an" "AssociationList")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23455,10 +24158,10 @@ Value = NIL \end{chunk} \subsection{Tableau} -\index{Tableau!Domain} -\index{Domain!Tableau} -\index{TABLEAU} -\begin{chunk}{sane} +\index[dom]{Tableau!Domain} +\index[dom]{Domain!Tableau} +\index[dom]{TABLEAU} +\begin{chunk}{defclass TableauType} (defclass |TableauType| (|AxiomClass|) ((parents :initform ()) (name :initform "Tableau") @@ -23467,7 +24170,7 @@ Value = NIL (comment :initform (list "The tableau domain is for printing Young tableaux, and" "coercions to and from List List S where S is a set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23481,10 +24184,10 @@ Value = NIL \end{chunk} \subsection{TaylorSerieso} -\index{TaylorSerieso!Domain} -\index{Domain!TaylorSerieso} -\index{TS} -\begin{chunk}{sane} +\index[dom]{TaylorSerieso!Domain} +\index[dom]{Domain!TaylorSerieso} +\index[dom]{TS} +\begin{chunk}{defclass TaylorSeriesoType} (defclass |TaylorSeriesoType| (|MultivariateTaylorSeriesCategoryType|) ((parents :initform '(|MultivariateTaylorSeriesCategory|)) (name :initform "TaylorSerieso") @@ -23493,7 +24196,7 @@ Value = NIL (comment :initform (list "TaylorSeries is a general multivariate Taylor series domain" "over the ring Coef and with variables of type Symbol.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23507,10 +24210,10 @@ Value = NIL \end{chunk} \subsection{TexFormat} -\index{TexFormat!Domain} -\index{Domain!TexFormat} -\index{TEX} -\begin{chunk}{sane} +\index[dom]{TexFormat!Domain} +\index[dom]{Domain!TexFormat} +\index[dom]{TEX} +\begin{chunk}{defclass TexFormatType} (defclass |TexFormatType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "TexFormat") @@ -23528,7 +24231,7 @@ Value = NIL "printing. For example, the prologue and epilogue might simply" "contain '\\verb+\\[+' and '\\verb+\\]+', respectively, so that" "the TeX section will be printed in LaTeX display math mode.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23542,10 +24245,10 @@ Value = NIL \end{chunk} \subsection{TextFile} -\index{TextFile!Domain} -\index{Domain!TextFile} -\index{TEXTFILE} -\begin{chunk}{sane} +\index[dom]{TextFile!Domain} +\index[dom]{Domain!TextFile} +\index[dom]{TEXTFILE} +\begin{chunk}{defclass TextFileType} (defclass |TextFileType| (|FileCategoryType|) ((parents :initform '(|FileCategory|)) (name :initform "TextFile") @@ -23554,7 +24257,7 @@ Value = NIL (comment :initform (list "This domain provides an implementation of text files. Text is stored" "in these files using the native character set of the computer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23568,10 +24271,10 @@ Value = NIL \end{chunk} \subsection{TheSymbolTable} -\index{TheSymbolTable!Domain} -\index{Domain!TheSymbolTable} -\index{SYMS} -\begin{chunk}{sane} +\index[dom]{TheSymbolTable!Domain} +\index[dom]{Domain!TheSymbolTable} +\index[dom]{SYMS} +\begin{chunk}{defclass TheSymbolTableType} (defclass |TheSymbolTableType| (|CoercibleToType|) ((parents :initform '(|CoercibleTo|)) (name :initform "TheSymbolTable") @@ -23581,7 +24284,7 @@ Value = NIL "Creates and manipulates one global symbol table for FORTRAN" "code generation, containing details of types, dimensions, and argument" "lists.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23595,10 +24298,10 @@ Value = NIL \end{chunk} \subsection{ThreeDimensionalMatrix} -\index{ThreeDimensionalMatrix!Domain} -\index{Domain!ThreeDimensionalMatrix} -\index{M3D} -\begin{chunk}{sane} +\index[dom]{ThreeDimensionalMatrix!Domain} +\index[dom]{Domain!ThreeDimensionalMatrix} +\index[dom]{M3D} +\begin{chunk}{defclass ThreeDimensionalMatrixType} (defclass |ThreeDimensionalMatrixType| (|HomogeneousAggregateType|) ((parents :initform '(|HomogeneousAggregate|)) (name :initform "ThreeDimensionalMatrix") @@ -23606,7 +24309,7 @@ Value = NIL (abbreviation :initform 'M3D) (comment :initform (list "This domain represents three dimensional matrices over a general object type")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23620,10 +24323,10 @@ Value = NIL \end{chunk} \subsection{ThreeDimensionalViewport} -\index{ThreeDimensionalViewport!Domain} -\index{Domain!ThreeDimensionalViewport} -\index{VIEW3D} -\begin{chunk}{sane} +\index[dom]{ThreeDimensionalViewport!Domain} +\index[dom]{Domain!ThreeDimensionalViewport} +\index[dom]{VIEW3D} +\begin{chunk}{defclass ThreeDimensionalViewportType} (defclass |ThreeDimensionalViewportType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "ThreeDimensionalViewport") @@ -23631,7 +24334,7 @@ Value = NIL (abbreviation :initform 'VIEW3D) (comment :initform (list "ThreeDimensionalViewport creates viewports to display graphs")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23645,10 +24348,10 @@ Value = NIL \end{chunk} \subsection{ThreeSpace} -\index{ThreeSpace!Domain} -\index{Domain!ThreeSpace} -\index{SPACE3} -\begin{chunk}{sane} +\index[dom]{ThreeSpace!Domain} +\index[dom]{Domain!ThreeSpace} +\index[dom]{SPACE3} +\begin{chunk}{defclass ThreeSpaceType} (defclass |ThreeSpaceType| (|ThreeSpaceCategoryType|) ((parents :initform '(|ThreeSpaceCategory|)) (name :initform "ThreeSpace") @@ -23658,7 +24361,7 @@ Value = NIL "The domain ThreeSpace is used for creating three dimensional" "objects using functions for defining points, curves, polygons, constructs" "and the subspaces containing them.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23672,10 +24375,10 @@ Value = NIL \end{chunk} \subsection{Tree} -\index{Tree!Domain} -\index{Domain!Tree} -\index{TREE} -\begin{chunk}{sane} +\index[dom]{Tree!Domain} +\index[dom]{Domain!Tree} +\index[dom]{TREE} +\begin{chunk}{defclass TreeType} (defclass |TreeType| (|RecursiveAggregateType|) ((parents :initform '(|RecursiveAggregate|)) (name :initform "Tree") @@ -23685,7 +24388,7 @@ Value = NIL "Tree(S) is a basic domains of tree structures." "Each tree is either empty or else is a node consisting of a value and" "a list of (sub)trees.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23699,10 +24402,10 @@ Value = NIL \end{chunk} \subsection{TubePlot} -\index{TubePlot!Domain} -\index{Domain!TubePlot} -\index{TUBE} -\begin{chunk}{sane} +\index[dom]{TubePlot!Domain} +\index[dom]{Domain!TubePlot} +\index[dom]{TUBE} +\begin{chunk}{defclass TubePlotType} (defclass |TubePlotType| (|AxiomClass|) ((parents :initform ()) (name :initform "TubePlot") @@ -23711,7 +24414,7 @@ Value = NIL (comment :initform (list "Package for constructing tubes around 3-dimensional parametric curves." "Domain of tubes around 3-dimensional parametric curves.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23725,10 +24428,10 @@ Value = NIL \end{chunk} \subsection{Tuple} -\index{Tuple!Domain} -\index{Domain!Tuple} -\index{TUPLE} -\begin{chunk}{sane} +\index[dom]{Tuple!Domain} +\index[dom]{Domain!Tuple} +\index[dom]{TUPLE} +\begin{chunk}{defclass TupleType} (defclass |TupleType| (|AxiomClass|) ((parents :initform ()) (name :initform "Tuple") @@ -23737,7 +24440,7 @@ Value = NIL (comment :initform (list "This domain is used to interface with the interpreter's notion" "of comma-delimited sequences of values.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23751,10 +24454,10 @@ Value = NIL \end{chunk} \subsection{TwoDimensionalArray} -\index{TwoDimensionalArray!Domain} -\index{Domain!TwoDimensionalArray} -\index{ARRAY2} -\begin{chunk}{sane} +\index[dom]{TwoDimensionalArray!Domain} +\index[dom]{Domain!TwoDimensionalArray} +\index[dom]{ARRAY2} +\begin{chunk}{defclass TwoDimensionalArrayType} (defclass |TwoDimensionalArrayType| (|TwoDimensionalArrayCategoryType|) ((parents :initform '(|TwoDimensionalArrayCategory|)) (name :initform "TwoDimensionalArray") @@ -23763,7 +24466,7 @@ Value = NIL (comment :initform (list "A TwoDimensionalArray is a two dimensional array with" "1-based indexing for both rows and columns.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23777,10 +24480,10 @@ Value = NIL \end{chunk} \subsection{TwoDimensionalViewport} -\index{TwoDimensionalViewport!Domain} -\index{Domain!TwoDimensionalViewport} -\index{VIEW2D} -\begin{chunk}{sane} +\index[dom]{TwoDimensionalViewport!Domain} +\index[dom]{Domain!TwoDimensionalViewport} +\index[dom]{VIEW2D} +\begin{chunk}{defclass TwoDimensionalViewportType} (defclass |TwoDimensionalViewportType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "TwoDimensionalViewport") @@ -23788,7 +24491,7 @@ Value = NIL (abbreviation :initform 'VIEW2D) (comment :initform (list "TwoDimensionalViewport creates viewports to display graphs.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23804,10 +24507,10 @@ Value = NIL \section{U} \subsection{UnivariateFormalPowerSeries} -\index{UnivariateFormalPowerSeries!Domain} -\index{Domain!UnivariateFormalPowerSeries} -\index{UFPS} -\begin{chunk}{sane} +\index[dom]{UnivariateFormalPowerSeries!Domain} +\index[dom]{Domain!UnivariateFormalPowerSeries} +\index[dom]{UFPS} +\begin{chunk}{defclass UnivariateFormalPowerSeriesType} (defclass |UnivariateFormalPowerSeriesType| (|UnivariateTaylorSeriesCategoryType|) ((parents :initform '(|UnivariateTaylorSeriesCategory|)) (name :initform "UnivariateFormalPowerSeries") @@ -23815,7 +24518,7 @@ Value = NIL (abbreviation :initform 'UFPS) (comment :initform (list "This domain has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23829,10 +24532,10 @@ Value = NIL \end{chunk} \subsection{UnivariateLaurentSeries} -\index{UnivariateLaurentSeries!Domain} -\index{Domain!UnivariateLaurentSeries} -\index{ULS} -\begin{chunk}{sane} +\index[dom]{UnivariateLaurentSeries!Domain} +\index[dom]{Domain!UnivariateLaurentSeries} +\index[dom]{ULS} +\begin{chunk}{defclass UnivariateLaurentSeriesType} (defclass |UnivariateLaurentSeriesType| (|UnivariateLaurentSeriesConstructorCategoryType|) ((parents :initform '(|UnivariateLaurentSeriesConstructorCategory|)) (name :initform "UnivariateLaurentSeries") @@ -23845,7 +24548,7 @@ Value = NIL "variable, and the center of the power series expansion. For example," "UnivariateLaurentSeries(Integer,x,3) represents Laurent series in" "(x - 3) with integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23859,10 +24562,10 @@ Value = NIL \end{chunk} \subsection{UnivariateLaurentSeriesConstructor} -\index{UnivariateLaurentSeriesConstructor!Domain} -\index{Domain!UnivariateLaurentSeriesConstructor} -\index{ULSCONS} -\begin{chunk}{sane} +\index[dom]{UnivariateLaurentSeriesConstructor!Domain} +\index[dom]{Domain!UnivariateLaurentSeriesConstructor} +\index[dom]{ULSCONS} +\begin{chunk}{defclass UnivariateLaurentSeriesConstructorType} (defclass |UnivariateLaurentSeriesConstructorType| (|UnivariateLaurentSeriesConstructorCategoryType|) ((parents :initform '(|UnivariateLaurentSeriesConstructorCategory|)) (name :initform "UnivariateLaurentSeriesConstructor") @@ -23874,7 +24577,7 @@ Value = NIL "Laurent series are represented by a pair [n,f(x)], where n is" "an arbitrary integer and f(x)} is a Taylor series. This pair" "represents the Laurent series x**n * f(x).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23888,10 +24591,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomial} -\index{UnivariatePolynomial!Domain} -\index{Domain!UnivariatePolynomial} -\index{UP} -\begin{chunk}{sane} +\index[dom]{UnivariatePolynomial!Domain} +\index[dom]{Domain!UnivariatePolynomial} +\index[dom]{UP} +\begin{chunk}{defclass UnivariatePolynomialType} (defclass |UnivariatePolynomialType| (|UnivariatePolynomialCategoryType|) ((parents :initform '(|UnivariatePolynomialCategory|)) (name :initform "UnivariatePolynomial") @@ -23904,7 +24607,7 @@ Value = NIL "in the sense that only non-zero terms are represented." "Note that if the coefficient ring is a field, then this domain" "forms a euclidean domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23918,10 +24621,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePuiseuxSeries} -\index{UnivariatePuiseuxSeries!Domain} -\index{Domain!UnivariatePuiseuxSeries} -\index{UPXS} -\begin{chunk}{sane} +\index[dom]{UnivariatePuiseuxSeries!Domain} +\index[dom]{Domain!UnivariatePuiseuxSeries} +\index[dom]{UPXS} +\begin{chunk}{defclass UnivariatePuiseuxSeriesType} (defclass |UnivariatePuiseuxSeriesType| (|UnivariatePuiseuxSeriesConstructorCategoryType|) ((parents :initform '(|UnivariatePuiseuxSeriesConstructorCategory|)) (name :initform "UnivariatePuiseuxSeries") @@ -23929,7 +24632,7 @@ Value = NIL (abbreviation :initform 'UPXS) (comment :initform (list "Dense Puiseux series in one variable")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23943,10 +24646,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePuiseuxSeriesConstructor} -\index{UnivariatePuiseuxSeriesConstructor!Domain} -\index{Domain!UnivariatePuiseuxSeriesConstructor} -\index{UPXSCONS} -\begin{chunk}{sane} +\index[dom]{UnivariatePuiseuxSeriesConstructor!Domain} +\index[dom]{Domain!UnivariatePuiseuxSeriesConstructor} +\index[dom]{UPXSCONS} +\begin{chunk}{defclass UnivariatePuiseuxSeriesConstructorType} (defclass |UnivariatePuiseuxSeriesConstructorType| (|UnivariatePuiseuxSeriesConstructorCategoryType|) ((parents :initform '(|UnivariatePuiseuxSeriesConstructorCategory|)) (name :initform "UnivariatePuiseuxSeriesConstructor") @@ -23958,7 +24661,7 @@ Value = NIL "Puiseux series are represented by a pair [r,f(x)], where r is" "a positive rational number and f(x) is a Laurent series." "This pair represents the Puiseux series f(x^r).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -23972,10 +24675,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePuiseuxSeriesWithExponentialSingularity} -\index{UnivariatePuiseuxSeriesWithExponentialSingularity!Domain} -\index{Domain!UnivariatePuiseuxSeriesWithExponentialSingularity} -\index{UPXSSING} -\begin{chunk}{sane} +\index[dom]{UnivariatePuiseuxSeriesWithExponentialSingularity!Domain} +\index[dom]{Domain!UnivariatePuiseuxSeriesWithExponentialSingularity} +\index[dom]{UPXSSING} +\begin{chunk}{defclass UnivariatePuiseuxSeriesWithExponentialSingularityType} (defclass |UnivariatePuiseuxSeriesWithExponentialSingularityType| (|FiniteAbelianMonoidRingType|) ((parents :initform '(|FiniteAbelianMonoidRing|)) (name :initform "UnivariatePuiseuxSeriesWithExponentialSingularity") @@ -23990,7 +24693,7 @@ Value = NIL "g(x) * exp(f(x)), where g(x) is a univariate Puiseux series" "and f(x) is a univariate Puiseux series with no terms of non-negative" "degree.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24004,10 +24707,10 @@ Value = NIL \end{chunk} \subsection{UnivariateSkewPolynomial} -\index{UnivariateSkewPolynomial!Domain} -\index{Domain!UnivariateSkewPolynomial} -\index{OREUP} -\begin{chunk}{sane} +\index[dom]{UnivariateSkewPolynomial!Domain} +\index[dom]{Domain!UnivariateSkewPolynomial} +\index[dom]{OREUP} +\begin{chunk}{defclass UnivariateSkewPolynomialType} (defclass |UnivariateSkewPolynomialType| (|UnivariateSkewPolynomialCategoryType|) ((parents :initform '(|UnivariateSkewPolynomialCategory|)) (name :initform "UnivariateSkewPolynomial") @@ -24017,7 +24720,7 @@ Value = NIL "This is the domain of univariate skew polynomials over an Ore" "coefficient field in a named variable." "The multiplication is given by x a = sigma(a) x + delta a.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24031,10 +24734,10 @@ Value = NIL \end{chunk} \subsection{UnivariateTaylorSeries} -\index{UnivariateTaylorSeries!Domain} -\index{Domain!UnivariateTaylorSeries} -\index{UTS} -\begin{chunk}{sane} +\index[dom]{UnivariateTaylorSeries!Domain} +\index[dom]{Domain!UnivariateTaylorSeries} +\index[dom]{UTS} +\begin{chunk}{defclass UnivariateTaylorSeriesType} (defclass |UnivariateTaylorSeriesType| (|UnivariateTaylorSeriesCategoryType|) ((parents :initform '(|UnivariateTaylorSeriesCategory|)) (name :initform "UnivariateTaylorSeries") @@ -24050,7 +24753,7 @@ Value = NIL "UnivariateTaylorSeries(Integer,x,3) represents" "Taylor series in" "(x - 3) with Integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24064,10 +24767,10 @@ Value = NIL \end{chunk} \subsection{UnivariateTaylorSeriesCZero} -\index{UnivariateTaylorSeriesCZero!Domain} -\index{Domain!UnivariateTaylorSeriesCZero} -\index{UTSZ} -\begin{chunk}{sane} +\index[dom]{UnivariateTaylorSeriesCZero!Domain} +\index[dom]{Domain!UnivariateTaylorSeriesCZero} +\index[dom]{UTSZ} +\begin{chunk}{defclass UnivariateTaylorSeriesCZeroType} (defclass |UnivariateTaylorSeriesCZeroType| (|UnivariateTaylorSeriesCategoryType|) ((parents :initform '(|UnivariateTaylorSeriesCategory|)) (name :initform "UnivariateTaylorSeriesCZero") @@ -24075,7 +24778,7 @@ Value = NIL (abbreviation :initform 'UTSZ) (comment :initform (list "Part of the Package for Algebraic Function Fields in one variable PAFF")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24089,10 +24792,10 @@ Value = NIL \end{chunk} \subsection{UniversalSegment} -\index{UniversalSegment!Domain} -\index{Domain!UniversalSegment} -\index{UNISEG} -\begin{chunk}{sane} +\index[dom]{UniversalSegment!Domain} +\index[dom]{Domain!UniversalSegment} +\index[dom]{UNISEG} +\begin{chunk}{defclass UniversalSegmentType} (defclass |UniversalSegmentType| (|SetCategoryType| |SegmentExpansionCategoryType|) ((parents :initform '(|SetCategory| |SegmentExpansionCategory|)) (name :initform "UniversalSegment") @@ -24100,7 +24803,7 @@ Value = NIL (abbreviation :initform 'UNISEG) (comment :initform (list "Part of the Package for Algebraic Function Fields in one variable PAFF")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24114,10 +24817,10 @@ Value = NIL \end{chunk} \subsection{U8Matrix} -\index{U8Matrix!Domain} -\index{Domain!U8Matrix} -\index{U8MAT} -\begin{chunk}{sane} +\index[dom]{U8Matrix!Domain} +\index[dom]{Domain!U8Matrix} +\index[dom]{U8MAT} +\begin{chunk}{defclass U8MatrixType} (defclass |U8MatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "U8Matrix") @@ -24128,7 +24831,7 @@ Value = NIL "(two dimensional arrays) of 8-bit integers." "Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24142,10 +24845,10 @@ Value = NIL \end{chunk} \subsection{U16Matrix} -\index{U16Matrix!Domain} -\index{Domain!U16Matrix} -\index{U16MAT} -\begin{chunk}{sane} +\index[dom]{U16Matrix!Domain} +\index[dom]{Domain!U16Matrix} +\index[dom]{U16MAT} +\begin{chunk}{defclass U16MatrixType} (defclass |U16MatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "U16Matrix") @@ -24156,7 +24859,7 @@ Value = NIL "(two dimensional arrays) of 16-bit integers." "Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24170,10 +24873,10 @@ Value = NIL \end{chunk} \subsection{U32Matrix} -\index{U32Matrix!Domain} -\index{Domain!U32Matrix} -\index{U32MAT} -\begin{chunk}{sane} +\index[dom]{U32Matrix!Domain} +\index[dom]{Domain!U32Matrix} +\index[dom]{U32MAT} +\begin{chunk}{defclass U32MatrixType} (defclass |U32MatrixType| (|MatrixCategoryType|) ((parents :initform '(|MatrixCategory|)) (name :initform "U32Matrix") @@ -24184,7 +24887,7 @@ Value = NIL "(two dimensional arrays) of 32-bit integers." "Indexing is 0 based, there is no bound checking (unless" "provided by lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24198,10 +24901,10 @@ Value = NIL \end{chunk} \subsection{U8Vector} -\index{U8Vector!Domain} -\index{Domain!U8Vector} -\index{U8VEC} -\begin{chunk}{sane} +\index[dom]{U8Vector!Domain} +\index[dom]{Domain!U8Vector} +\index[dom]{U8VEC} +\begin{chunk}{defclass U8VectorType} (defclass |U8VectorType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "U8Vector") @@ -24212,7 +24915,7 @@ Value = NIL "(one dimensional arrays) of unsigned 8-bit numbers. Indexing" "is 0 based, there is no bound checking (unless provided by" "lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24226,10 +24929,10 @@ Value = NIL \end{chunk} \subsection{U16Vector} -\index{U16Vector!Domain} -\index{Domain!U16Vector} -\index{U16VEC} -\begin{chunk}{sane} +\index[dom]{U16Vector!Domain} +\index[dom]{Domain!U16Vector} +\index[dom]{U16VEC} +\begin{chunk}{defclass U16VectorType} (defclass |U16VectorType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "U16Vector") @@ -24240,7 +24943,7 @@ Value = NIL "(one dimensional arrays) of unsigned 16-bit numbers. Indexing" "is 0 based, there is no bound checking (unless provided by" "lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24254,10 +24957,10 @@ Value = NIL \end{chunk} \subsection{U32Vector} -\index{U32Vector!Domain} -\index{Domain!U32Vector} -\index{U32VEC} -\begin{chunk}{sane} +\index[dom]{U32Vector!Domain} +\index[dom]{Domain!U32Vector} +\index[dom]{U32VEC} +\begin{chunk}{defclass U32VectorType} (defclass |U32VectorType| (|OneDimensionalArrayAggregateType|) ((parents :initform '(|OneDimensionalArrayAggregate|)) (name :initform "U32Vector") @@ -24268,7 +24971,7 @@ Value = NIL "(one dimensional arrays) of unsigned 32-bit numbers. Indexing" "is 0 based, there is no bound checking (unless provided by" "lower level).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24284,10 +24987,10 @@ Value = NIL \section{V} \subsection{Variable} -\index{Variable!Domain} -\index{Domain!Variable} -\index{VARIABLE} -\begin{chunk}{sane} +\index[dom]{Variable!Domain} +\index[dom]{Domain!Variable} +\index[dom]{VARIABLE} +\begin{chunk}{defclass VariableType} (defclass |VariableType| (|SetCategoryType|) ((parents :initform '(|SetCategory|)) (name :initform "Variable") @@ -24295,7 +24998,7 @@ Value = NIL (abbreviation :initform 'VARIABLE) (comment :initform (list "This domain implements variables")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24309,10 +25012,10 @@ Value = NIL \end{chunk} \subsection{Vector} -\index{Vector!Domain} -\index{Domain!Vector} -\index{VECTOR} -\begin{chunk}{sane} +\index[dom]{Vector!Domain} +\index[dom]{Domain!Vector} +\index[dom]{VECTOR} +\begin{chunk}{defclass VectorType} (defclass |VectorType| (|VectorCategoryType|) ((parents :initform '(|VectorCategory|)) (name :initform "Vector") @@ -24321,7 +25024,7 @@ Value = NIL (comment :initform (list "This type represents vector like objects with varying lengths" "and indexed by a finite segment of integers starting at 1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24335,10 +25038,10 @@ Value = NIL \end{chunk} \subsection{Void} -\index{Void!Domain} -\index{Domain!Void} -\index{VOID} -\begin{chunk}{sane} +\index[dom]{Void!Domain} +\index[dom]{Domain!Void} +\index[dom]{VOID} +\begin{chunk}{defclass VoidType} (defclass |VoidType| (|AxiomClass|) ((parents :initform ()) (name :initform "Void") @@ -24349,7 +25052,7 @@ Value = NIL "part of a one armed if." "All values can be coerced to type Void. Once a value has been coerced" "to Void, it cannot be recovered.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24365,10 +25068,10 @@ Value = NIL \section{W} \subsection{WeightedPolynomials} -\index{WeightedPolynomials!Domain} -\index{Domain!WeightedPolynomials} -\index{WP} -\begin{chunk}{sane} +\index[dom]{WeightedPolynomials!Domain} +\index[dom]{Domain!WeightedPolynomials} +\index[dom]{WP} +\begin{chunk}{defclass WeightedPolynomialsType} (defclass |WeightedPolynomialsType| (|AlgebraType|) ((parents :initform '(|Algebra|)) (name :initform "WeightedPolynomials") @@ -24380,7 +25083,7 @@ Value = NIL "specified, as must the weights." "The representation is sparse" "in the sense that only non-zero terms are represented.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24394,10 +25097,10 @@ Value = NIL \end{chunk} \subsection{WuWenTsunTriangularSet} -\index{WuWenTsunTriangularSet!Domain} -\index{Domain!WuWenTsunTriangularSet} -\index{WUTSET} -\begin{chunk}{sane} +\index[dom]{WuWenTsunTriangularSet!Domain} +\index[dom]{Domain!WuWenTsunTriangularSet} +\index[dom]{WUTSET} +\begin{chunk}{defclass WuWenTsunTriangularSetType} (defclass |WuWenTsunTriangularSetType| (|TriangularSetCategoryType|) ((parents :initform '(|TriangularSetCategory|)) (name :initform "WuWenTsunTriangularSet") @@ -24414,7 +25117,7 @@ Value = NIL "Furthermore, this domain exports operations dealing with the" "characteristic set method of Wu Wen Tsun and some optimizations" "mainly proposed by Dong Ming Wang.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24430,10 +25133,10 @@ Value = NIL \section{X} \subsection{XDistributedPolynomial} -\index{XDistributedPolynomial!Domain} -\index{Domain!XDistributedPolynomial} -\index{XDPOLY} -\begin{chunk}{sane} +\index[dom]{XDistributedPolynomial!Domain} +\index[dom]{Domain!XDistributedPolynomial} +\index[dom]{XDPOLY} +\begin{chunk}{defclass XDistributedPolynomialType} (defclass |XDistributedPolynomialType| (|FreeModuleCatType| |XPolynomialsCatType|) ((parents :initform '(|FreeModuleCat| |XPolynomialsCat|)) (name :initform "XDistributedPolynomial") @@ -24444,7 +25147,7 @@ Value = NIL "whose variables do not commute." "The coefficient ring may be non-commutative too." "However, coefficients and variables commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24458,10 +25161,10 @@ Value = NIL \end{chunk} \subsection{XPBWPolynomial} -\index{XPBWPolynomial!Domain} -\index{Domain!XPBWPolynomial} -\index{XPBWPOLY} -\begin{chunk}{sane} +\index[dom]{XPBWPolynomial!Domain} +\index[dom]{Domain!XPBWPolynomial} +\index[dom]{XPBWPOLY} +\begin{chunk}{defclass XPBWPolynomialType} (defclass |XPBWPolynomialType| (|FreeModuleCatType| |XPolynomialsCatType|) ((parents :initform '(|FreeModuleCat| |XPolynomialsCat|)) (name :initform "XPBWPolynomial") @@ -24473,7 +25176,7 @@ Value = NIL "Lyndon basis." "These polynomials can be used to compute Baker-Campbell-Hausdorff" "relations. ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24487,10 +25190,10 @@ Value = NIL \end{chunk} \subsection{XPolynomial} -\index{XPolynomial!Domain} -\index{Domain!XPolynomial} -\index{XPOLY} -\begin{chunk}{sane} +\index[dom]{XPolynomial!Domain} +\index[dom]{Domain!XPolynomial} +\index[dom]{XPOLY} +\begin{chunk}{defclass XPolynomialType} (defclass |XPolynomialType| (|XPolynomialsCatType|) ((parents :initform '(|XPolynomialsCat|)) (name :initform "XPolynomial") @@ -24501,7 +25204,7 @@ Value = NIL "is Symbol. The representation is recursive." "The coefficient ring may be non-commutative and the variables" "do not commute. However, coefficients and variables commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24515,10 +25218,10 @@ Value = NIL \end{chunk} \subsection{XPolynomialRing} -\index{XPolynomialRing!Domain} -\index{Domain!XPolynomialRing} -\index{XPR} -\begin{chunk}{sane} +\index[dom]{XPolynomialRing!Domain} +\index[dom]{Domain!XPolynomialRing} +\index[dom]{XPR} +\begin{chunk}{defclass XPolynomialRingType} (defclass |XPolynomialRingType| (|FreeModuleCatType| |XAlgebraType|) ((parents :initform '(|FreeModuleCat| |XAlgebra|)) (name :initform "XPolynomialRing") @@ -24530,7 +25233,7 @@ Value = NIL "belonging to an arbitrary OrderedMonoid." "This type is used, for instance, by the XDistributedPolynomial" "domain constructor where the Monoid is free.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24544,10 +25247,10 @@ Value = NIL \end{chunk} \subsection{XRecursivePolynomial} -\index{XRecursivePolynomial!Domain} -\index{Domain!XRecursivePolynomial} -\index{XRPOLY} -\begin{chunk}{sane} +\index[dom]{XRecursivePolynomial!Domain} +\index[dom]{Domain!XRecursivePolynomial} +\index[dom]{XRPOLY} +\begin{chunk}{defclass XRecursivePolynomialType} (defclass |XRecursivePolynomialType| (|XPolynomialsCatType|) ((parents :initform '(|XPolynomialsCat|)) (name :initform "XRecursivePolynomial") @@ -24557,7 +25260,7 @@ Value = NIL "This type supports multivariate polynomials whose variables do not commute." "The representation is recursive. The coefficient ring may be" "non-commutative. Coefficients and variables commute.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24575,10 +25278,10 @@ Value = NIL \section{A} \subsection{AffineAlgebraicSetComputeWithGroebnerBasis} -\index{AffineAlgebraicSetComputeWithGroebnerBasis!Domain} -\index{Domain!AffineAlgebraicSetComputeWithGroebnerBasis} -\index{AFALGGRO} -\begin{chunk}{sane} +\index[pkg]{AffineAlgebraicSetComputeWithGroebnerBasis!Domain} +\index[pkg]{Domain!AffineAlgebraicSetComputeWithGroebnerBasis} +\index[pkg]{AFALGGRO} +\begin{chunk}{defclass AffineAlgebraicSetComputeWithGroebnerBasisType} (defclass |AffineAlgebraicSetComputeWithGroebnerBasisType| (|AxiomClass|) ((parents :initform '()) (name :initform "AffineAlgebraicSetComputeWithGroebnerBasis") @@ -24586,7 +25289,7 @@ Value = NIL (abbreviation :initform 'AFALGGRO) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24600,10 +25303,10 @@ Value = NIL \end{chunk} \subsection{AffineAlgebraicSetComputeWithResultant} -\index{AffineAlgebraicSetComputeWithResultant!Domain} -\index{Domain!AffineAlgebraicSetComputeWithResultant} -\index{AFALGRES} -\begin{chunk}{sane} +\index[pkg]{AffineAlgebraicSetComputeWithResultant!Domain} +\index[pkg]{Domain!AffineAlgebraicSetComputeWithResultant} +\index[pkg]{AFALGRES} +\begin{chunk}{defclass AffineAlgebraicSetComputeWithResultantType} (defclass |AffineAlgebraicSetComputeWithResultantType| (|AxiomClass|) ((parents :initform ()) (name :initform "AffineAlgebraicSetComputeWithResultant") @@ -24611,7 +25314,7 @@ Value = NIL (abbreviation :initform 'AFALGRES) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24625,10 +25328,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicFunction} -\index{AlgebraicFunction!Domain} -\index{Domain!AlgebraicFunction} -\index{AF} -\begin{chunk}{sane} +\index[pkg]{AlgebraicFunction!Domain} +\index[pkg]{Domain!AlgebraicFunction} +\index[pkg]{AF} +\begin{chunk}{(defclass AlgebraicFunctionType} (defclass |AlgebraicFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicFunction") @@ -24636,7 +25339,7 @@ Value = NIL (abbreviation :initform 'AF) (comment :initform (list "This package provides algebraic functions over an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24650,10 +25353,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicHermiteIntegration} -\index{AlgebraicHermiteIntegration!Domain} -\index{Domain!AlgebraicHermiteIntegration} -\index{INTHERAL} -\begin{chunk}{sane} +\index[pkg]{AlgebraicHermiteIntegration!Domain} +\index[pkg]{Domain!AlgebraicHermiteIntegration} +\index[pkg]{INTHERAL} +\begin{chunk}{defclass AlgebraicHermiteIntegrationType} (defclass |AlgebraicHermiteIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicHermiteIntegration") @@ -24661,7 +25364,7 @@ Value = NIL (abbreviation :initform 'INTHERAL) (comment :initform (list "Algebraic Hermite reduction.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24675,10 +25378,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicIntegrate} -\index{AlgebraicIntegrate!Domain} -\index{Domain!AlgebraicIntegrate} -\index{INTALG} -\begin{chunk}{sane} +\index[pkg]{AlgebraicIntegrate!Domain} +\index[pkg]{Domain!AlgebraicIntegrate} +\index[pkg]{INTALG} +\begin{chunk}{defclass AlgebraicIntegrateType} (defclass |AlgebraicIntegrateType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicIntegrate") @@ -24687,7 +25390,7 @@ Value = NIL (comment :initform (list "This package provides functions for integrating a function" "on an algebraic curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24701,10 +25404,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicIntegration} -\index{AlgebraicIntegration!Domain} -\index{Domain!AlgebraicIntegration} -\index{INTAF} -\begin{chunk}{sane} +\index[pkg]{AlgebraicIntegration!Domain} +\index[pkg]{Domain!AlgebraicIntegration} +\index[pkg]{INTAF} +\begin{chunk}{defclass AlgebraicIntegrationType} (defclass |AlgebraicIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicIntegration") @@ -24713,7 +25416,7 @@ Value = NIL (comment :initform (list "This package provides functions for the integration of" "algebraic integrands over transcendental functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24727,10 +25430,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicManipulations} -\index{AlgebraicManipulations!Domain} -\index{Domain!AlgebraicManipulations} -\index{ALGMANIP} -\begin{chunk}{sane} +\index[pkg]{AlgebraicManipulations!Domain} +\index[pkg]{Domain!AlgebraicManipulations} +\index[pkg]{ALGMANIP} +\begin{chunk}{defclass AlgebraicManipulationsType} (defclass |AlgebraicManipulationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicManipulations") @@ -24739,7 +25442,7 @@ Value = NIL (comment :initform (list "AlgebraicManipulations provides functions to simplify and expand" "expressions involving algebraic operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24753,10 +25456,10 @@ Value = NIL \end{chunk} \subsection{AlgebraicMultFact} -\index{AlgebraicMultFact!Domain} -\index{Domain!AlgebraicMultFact} -\index{ALGMFACT} -\begin{chunk}{sane} +\index[pkg]{AlgebraicMultFact!Domain} +\index[pkg]{Domain!AlgebraicMultFact} +\index[pkg]{ALGMFACT} +\begin{chunk}{defclass AlgebraicMultFactType} (defclass |AlgebraicMultFactType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraicMultFact") @@ -24767,7 +25470,7 @@ Value = NIL "domain of AlgebraicNumber by allowing the user" "to specify a list of algebraic numbers generating the particular" "extension to factor over.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24781,10 +25484,10 @@ Value = NIL \end{chunk} \subsection{AlgebraPackage} -\index{AlgebraPackage!Domain} -\index{Domain!AlgebraPackage} -\index{ALGPKG} -\begin{chunk}{sane} +\index[pkg]{AlgebraPackage!Domain} +\index[pkg]{Domain!AlgebraPackage} +\index[pkg]{ALGPKG} +\begin{chunk}{defclass AlgebraPackageType} (defclass |AlgebraPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgebraPackage") @@ -24793,7 +25496,7 @@ Value = NIL (comment :initform (list "AlgebraPackage assembles a variety of useful functions for" "general algebras.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24807,10 +25510,10 @@ Value = NIL \end{chunk} \subsection{AlgFactor} -\index{AlgFactor!Domain} -\index{Domain!AlgFactor} -\index{ALGFACT} -\begin{chunk}{sane} +\index[pkg]{AlgFactor!Domain} +\index[pkg]{Domain!AlgFactor} +\index[pkg]{ALGFACT} +\begin{chunk}{defclass AlgFactorType} (defclass |AlgFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "AlgFactor") @@ -24819,7 +25522,7 @@ Value = NIL (comment :initform (list "Factorization of univariate polynomials with coefficients in" "AlgebraicNumber.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24833,10 +25536,10 @@ Value = NIL \end{chunk} \subsection{AnnaNumericalIntegrationPackage} -\index{AnnaNumericalIntegrationPackage!Domain} -\index{Domain!AnnaNumericalIntegrationPackage} -\index{INTPACK} -\begin{chunk}{sane} +\index[pkg]{AnnaNumericalIntegrationPackage!Domain} +\index[pkg]{Domain!AnnaNumericalIntegrationPackage} +\index[pkg]{INTPACK} +\begin{chunk}{defclass AnnaNumericalIntegrationPackageType} (defclass |AnnaNumericalIntegrationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "AnnaNumericalIntegrationPackage") @@ -24847,7 +25550,7 @@ Value = NIL "of functions for the category" "NumericalIntegrationCategory" "with measure, and integrate.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24861,10 +25564,10 @@ Value = NIL \end{chunk} \subsection{AnnaNumericalOptimizationPackage} -\index{AnnaNumericalOptimizationPackage!Domain} -\index{Domain!AnnaNumericalOptimizationPackage} -\index{OPTPACK} -\begin{chunk}{sane} +\index[pkg]{AnnaNumericalOptimizationPackage!Domain} +\index[pkg]{Domain!AnnaNumericalOptimizationPackage} +\index[pkg]{OPTPACK} +\begin{chunk}{defclass AnnaNumericalOptimizationPackageType} (defclass |AnnaNumericalOptimizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "AnnaNumericalOptimizationPackage") @@ -24874,7 +25577,7 @@ Value = NIL "AnnaNumericalOptimizationPackage is a package of" "functions for the NumericalOptimizationCategory" "with measure and optimize.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24888,10 +25591,10 @@ Value = NIL \end{chunk} \subsection{AnnaOrdinaryDifferentialEquationPackage} -\index{AnnaOrdinaryDifferentialEquationPackage!Domain} -\index{Domain!AnnaOrdinaryDifferentialEquationPackage} -\index{ODEPACK} -\begin{chunk}{sane} +\index[pkg]{AnnaOrdinaryDifferentialEquationPackage!Domain} +\index[pkg]{Domain!AnnaOrdinaryDifferentialEquationPackage} +\index[pkg]{ODEPACK} +\begin{chunk}{defclass AnnaOrdinaryDifferentialEquationPackageType} (defclass |AnnaOrdinaryDifferentialEquationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "AnnaOrdinaryDifferentialEquationPackage") @@ -24902,7 +25605,7 @@ Value = NIL "of functions for the category" "OrdinaryDifferentialEquationsSolverCategory" "with measure, and solve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24916,10 +25619,10 @@ Value = NIL \end{chunk} \subsection{AnnaPartialDifferentialEquationPackage} -\index{AnnaPartialDifferentialEquationPackage!Domain} -\index{Domain!AnnaPartialDifferentialEquationPackage} -\index{PDEPACK} -\begin{chunk}{sane} +\index[pkg]{AnnaPartialDifferentialEquationPackage!Domain} +\index[pkg]{Domain!AnnaPartialDifferentialEquationPackage} +\index[pkg]{PDEPACK} +\begin{chunk}{defclass AnnaPartialDifferentialEquationPackageType} (defclass |AnnaPartialDifferentialEquationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "AnnaPartialDifferentialEquationPackage") @@ -24929,7 +25632,7 @@ Value = NIL "AnnaPartialDifferentialEquationPackage is an uncompleted" "package for the interface to NAG PDE routines. It has been realised that" "a new approach to solving PDEs will need to be created.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24943,10 +25646,10 @@ Value = NIL \end{chunk} \subsection{AnyFunctions1} -\index{AnyFunctions1!Domain} -\index{Domain!AnyFunctions1} -\index{ANY1} -\begin{chunk}{sane} +\index[pkg]{AnyFunctions1!Domain} +\index[pkg]{Domain!AnyFunctions1} +\index[pkg]{ANY1} +\begin{chunk}{defclass AnyFunctions1Type} (defclass |AnyFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "AnyFunctions1") @@ -24957,7 +25660,7 @@ Value = NIL "working with Any. These functions are used to go back" "and forth between objects of Any and objects of other" "types.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24971,10 +25674,10 @@ Value = NIL \end{chunk} \subsection{ApplicationProgramInterface} -\index{ApplicationProgramInterface!Domain} -\index{Domain!ApplicationProgramInterface} -\index{API} -\begin{chunk}{sane} +\index[pkg]{ApplicationProgramInterface!Domain} +\index[pkg]{Domain!ApplicationProgramInterface} +\index[pkg]{API} +\begin{chunk}{defclass ApplicationProgramInterfaceType} (defclass |ApplicationProgramInterfaceType| (|AxiomClass|) ((parents :initform ()) (name :initform "ApplicationProgramInterface") @@ -24982,7 +25685,7 @@ Value = NIL (abbreviation :initform 'API) (comment :initform (list "This package contains useful functions that expose Axiom system internals")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -24996,10 +25699,10 @@ Value = NIL \end{chunk} \subsection{ApplyRules} -\index{ApplyRules!Domain} -\index{Domain!ApplyRules} -\index{APPRULE} -\begin{chunk}{sane} +\index[pkg]{ApplyRules!Domain} +\index[pkg]{Domain!ApplyRules} +\index[pkg]{APPRULE} +\begin{chunk}{defclass ApplyRulesType} (defclass |ApplyRulesType| (|AxiomClass|) ((parents :initform ()) (name :initform "ApplyRules") @@ -25008,7 +25711,7 @@ Value = NIL (comment :initform (list "This package apply rewrite rules to expressions, calling" "the pattern matcher.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25022,10 +25725,10 @@ Value = NIL \end{chunk} \subsection{ApplyUnivariateSkewPolynomial} -\index{ApplyUnivariateSkewPolynomial!Domain} -\index{Domain!ApplyUnivariateSkewPolynomial} -\index{APPLYORE} -\begin{chunk}{sane} +\index[pkg]{ApplyUnivariateSkewPolynomial!Domain} +\index[pkg]{Domain!ApplyUnivariateSkewPolynomial} +\index[pkg]{APPLYORE} +\begin{chunk}{defclass ApplyUnivariateSkewPolynomialType} (defclass |ApplyUnivariateSkewPolynomialType| (|AxiomClass|) ((parents :initform ()) (name :initform "ApplyUnivariateSkewPolynomial") @@ -25034,7 +25737,7 @@ Value = NIL (comment :initform (list "ApplyUnivariateSkewPolynomial (internal) allows univariate" "skew polynomials to be applied to appropriate modules.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25048,10 +25751,10 @@ Value = NIL \end{chunk} \subsection{AssociatedEquations} -\index{AssociatedEquations!Domain} -\index{Domain!AssociatedEquations} -\index{ASSOCEQ} -\begin{chunk}{sane} +\index[pkg]{AssociatedEquations!Domain} +\index[pkg]{Domain!AssociatedEquations} +\index[pkg]{ASSOCEQ} +\begin{chunk}{defclass AssociatedEquationsType} (defclass |AssociatedEquationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "AssociatedEquations") @@ -25060,7 +25763,7 @@ Value = NIL (comment :initform (list "AssociatedEquations provides functions to compute the" "associated equations needed for factoring operators")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25074,10 +25777,10 @@ Value = NIL \end{chunk} \subsection{AttachPredicates} -\index{AttachPredicates!Domain} -\index{Domain!AttachPredicates} -\index{PMPRED} -\begin{chunk}{sane} +\index[pkg]{AttachPredicates!Domain} +\index[pkg]{Domain!AttachPredicates} +\index[pkg]{PMPRED} +\begin{chunk}{defclass AttachPredicatesType} (defclass |AttachPredicatesType| (|AxiomClass|) ((parents :initform ()) (name :initform "AttachPredicates") @@ -25085,7 +25788,7 @@ Value = NIL (abbreviation :initform 'PMPRED) (comment :initform (list "Attaching predicates to symbols for pattern matching.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25099,10 +25802,10 @@ Value = NIL \end{chunk} \subsection{AxiomServer} -\index{AxiomServer!Domain} -\index{Domain!AxiomServer} -\index{AXSERV} -\begin{chunk}{sane} +\index[pkg]{AxiomServer!Domain} +\index[pkg]{Domain!AxiomServer} +\index[pkg]{AXSERV} +\begin{chunk}{defclass AxiomServerType} (defclass |AxiomServerType| (|AxiomClass|) ((parents :initform ()) (name :initform "AxiomServer") @@ -25111,7 +25814,7 @@ Value = NIL (comment :initform (list "This package provides a functions to support a web server for the" "new Axiom Browser functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25127,10 +25830,10 @@ Value = NIL \section{B} \subsection{BalancedFactorisation} -\index{BalancedFactorisation!Domain} -\index{Domain!BalancedFactorisation} -\index{BALFACT} -\begin{chunk}{sane} +\index[pkg]{BalancedFactorisation!Domain} +\index[pkg]{Domain!BalancedFactorisation} +\index[pkg]{BALFACT} +\begin{chunk}{defclass BalancedFactorisationType} (defclass |BalancedFactorisationType| (|AxiomClass|) ((parents :initform ()) (name :initform "BalancedFactorisation") @@ -25138,7 +25841,7 @@ Value = NIL (abbreviation :initform 'BALFACT) (comment :initform (list "This package provides balanced factorisations of polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25152,10 +25855,10 @@ Value = NIL \end{chunk} \subsection{BasicOperatorFunctions1} -\index{BasicOperatorFunctions1!Domain} -\index{Domain!BasicOperatorFunctions1} -\index{BOP1} -\begin{chunk}{sane} +\index[pkg]{BasicOperatorFunctions1!Domain} +\index[pkg]{Domain!BasicOperatorFunctions1} +\index[pkg]{BOP1} +\begin{chunk}{defclass BasicOperatorFunctions1Type} (defclass |BasicOperatorFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "BasicOperatorFunctions1") @@ -25164,7 +25867,7 @@ Value = NIL (comment :initform (list "This package exports functions to set some commonly used properties" "of operators, including properties which contain functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25178,10 +25881,10 @@ Value = NIL \end{chunk} \subsection{Bezier} -\index{Bezier!Domain} -\index{Domain!Bezier} -\index{BEZIER} -\begin{chunk}{sane} +\index[pkg]{Bezier!Domain} +\index[pkg]{Domain!Bezier} +\index[pkg]{BEZIER} +\begin{chunk}{defclass BezierType} (defclass |BezierType| (|AxiomClass|) ((parents :initform ()) (name :initform "Bezier") @@ -25189,7 +25892,7 @@ Value = NIL (abbreviation :initform 'BEZIER) (comment :initform (list "Provide linear, quadratic, and cubic spline bezier curves")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25203,10 +25906,10 @@ Value = NIL \end{chunk} \subsection{BezoutMatrix} -\index{BezoutMatrix!Domain} -\index{Domain!BezoutMatrix} -\index{BEZOUT} -\begin{chunk}{sane} +\index[pkg]{BezoutMatrix!Domain} +\index[pkg]{Domain!BezoutMatrix} +\index[pkg]{BEZOUT} +\begin{chunk}{defclass BezoutMatrixType} (defclass |BezoutMatrixType| (|AxiomClass|) ((parents :initform ()) (name :initform "BezoutMatrix") @@ -25215,7 +25918,7 @@ Value = NIL (comment :initform (list "BezoutMatrix contains functions for computing resultants and" "discriminants using Bezout matrices.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25229,10 +25932,10 @@ Value = NIL \end{chunk} \subsection{BlowUpPackage} -\index{BlowUpPackage!Domain} -\index{Domain!BlowUpPackage} -\index{BLUPPACK} -\begin{chunk}{sane} +\index[pkg]{BlowUpPackage!Domain} +\index[pkg]{Domain!BlowUpPackage} +\index[pkg]{BLUPPACK} +\begin{chunk}{defclass BlowUpPackageType} (defclass |BlowUpPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "BlowUpPackage") @@ -25240,7 +25943,7 @@ Value = NIL (abbreviation :initform 'BLUPPACK) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25254,10 +25957,10 @@ Value = NIL \end{chunk} \subsection{BoundIntegerRoots} -\index{BoundIntegerRoots!Domain} -\index{Domain!BoundIntegerRoots} -\index{BOUNDZRO} -\begin{chunk}{sane} +\index[pkg]{BoundIntegerRoots!Domain} +\index[pkg]{Domain!BoundIntegerRoots} +\index[pkg]{BOUNDZRO} +\begin{chunk}{defclass BoundIntegerRootsType} (defclass |BoundIntegerRootsType| (|AxiomClass|) ((parents :initform ()) (name :initform "BoundIntegerRoots") @@ -25266,7 +25969,7 @@ Value = NIL (comment :initform (list "BoundIntegerRoots provides functions to" "find lower bounds on the integer roots of a polynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25280,10 +25983,10 @@ Value = NIL \end{chunk} \subsection{BrillhartTests} -\index{BrillhartTests!Domain} -\index{Domain!BrillhartTests} -\index{BRILL} -\begin{chunk}{sane} +\index[pkg]{BrillhartTests!Domain} +\index[pkg]{Domain!BrillhartTests} +\index[pkg]{BRILL} +\begin{chunk}{defclass BrillhartTestsType} (defclass |BrillhartTestsType| (|AxiomClass|) ((parents :initform ()) (name :initform "BrillhartTests") @@ -25291,7 +25994,7 @@ Value = NIL (abbreviation :initform 'BRILL) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25307,10 +26010,10 @@ Value = NIL \section{C} \subsection{CartesianTensorFunctions2} -\index{CartesianTensorFunctions2!Domain} -\index{Domain!CartesianTensorFunctions2} -\index{CARTEN2} -\begin{chunk}{sane} +\index[pkg]{CartesianTensorFunctions2!Domain} +\index[pkg]{Domain!CartesianTensorFunctions2} +\index[pkg]{CARTEN2} +\begin{chunk}{defclass CartesianTensorFunctions2Type} (defclass |CartesianTensorFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "CartesianTensorFunctions2") @@ -25319,7 +26022,7 @@ Value = NIL (comment :initform (list "This package provides functions to enable conversion of tensors" "given conversion of the components.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25333,10 +26036,10 @@ Value = NIL \end{chunk} \subsection{ChangeOfVariable} -\index{ChangeOfVariable!Domain} -\index{Domain!ChangeOfVariable} -\index{CHVAR} -\begin{chunk}{sane} +\index[pkg]{ChangeOfVariable!Domain} +\index[pkg]{Domain!ChangeOfVariable} +\index[pkg]{CHVAR} +\begin{chunk}{defclass ChangeOfVariableType} (defclass |ChangeOfVariableType| (|AxiomClass|) ((parents :initform ()) (name :initform "ChangeOfVariable") @@ -25344,7 +26047,7 @@ Value = NIL (abbreviation :initform 'CHVAR) (comment :initform (list "Tools to send a point to infinity on an algebraic curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25358,10 +26061,10 @@ Value = NIL \end{chunk} \subsection{CharacteristicPolynomialInMonogenicalAlgebra} -\index{CharacteristicPolynomialInMonogenicalAlgebra!Domain} -\index{Domain!CharacteristicPolynomialInMonogenicalAlgebra} -\index{CPIMA} -\begin{chunk}{sane} +\index[pkg]{CharacteristicPolynomialInMonogenicalAlgebra!Domain} +\index[pkg]{Domain!CharacteristicPolynomialInMonogenicalAlgebra} +\index[pkg]{CPIMA} +\begin{chunk}{defclass CharacteristicPolynomialInMonogenicalAlgebraType} (defclass |CharacteristicPolynomialInMonogenicalAlgebraType| (|AxiomClass|) ((parents :initform ()) (name :initform "CharacteristicPolynomialInMonogenicalAlgebra") @@ -25370,7 +26073,7 @@ Value = NIL (comment :initform (list "This package implements characteristicPolynomials for monogenic algebras" "using resultants")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25384,10 +26087,10 @@ Value = NIL \end{chunk} \subsection{CharacteristicPolynomialPackage} -\index{CharacteristicPolynomialPackage!Domain} -\index{Domain!CharacteristicPolynomialPackage} -\index{CHARPOL} -\begin{chunk}{sane} +\index[pkg]{CharacteristicPolynomialPackage!Domain} +\index[pkg]{Domain!CharacteristicPolynomialPackage} +\index[pkg]{CHARPOL} +\begin{chunk}{defclass CharacteristicPolynomialPackageType} (defclass |CharacteristicPolynomialPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "CharacteristicPolynomialPackage") @@ -25396,7 +26099,7 @@ Value = NIL (comment :initform (list "This package provides a characteristicPolynomial function" "for any matrix over a commutative ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25410,10 +26113,10 @@ Value = NIL \end{chunk} \subsection{ChineseRemainderToolsForIntegralBases} -\index{ChineseRemainderToolsForIntegralBases!Domain} -\index{Domain!ChineseRemainderToolsForIntegralBases} -\index{IBACHIN} -\begin{chunk}{sane} +\index[pkg]{ChineseRemainderToolsForIntegralBases!Domain} +\index[pkg]{Domain!ChineseRemainderToolsForIntegralBases} +\index[pkg]{IBACHIN} +\begin{chunk}{defclass ChineseRemainderToolsForIntegralBasesType} (defclass |ChineseRemainderToolsForIntegralBasesType| (|AxiomClass|) ((parents :initform ()) (name :initform "ChineseRemainderToolsForIntegralBases") @@ -25421,7 +26124,7 @@ Value = NIL (abbreviation :initform 'IBACHIN) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25435,10 +26138,10 @@ Value = NIL \end{chunk} \subsection{CoerceVectorMatrixPackage} -\index{CoerceVectorMatrixPackage!Domain} -\index{Domain!CoerceVectorMatrixPackage} -\index{CVMP} -\begin{chunk}{sane} +\index[pkg]{CoerceVectorMatrixPackage!Domain} +\index[pkg]{Domain!CoerceVectorMatrixPackage} +\index[pkg]{CVMP} +\begin{chunk}{defclass CoerceVectorMatrixPackageType} (defclass |CoerceVectorMatrixPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "CoerceVectorMatrixPackage") @@ -25447,7 +26150,7 @@ Value = NIL (comment :initform (list "CoerceVectorMatrixPackage is an unexposed, technical package" "for data conversions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25461,10 +26164,10 @@ Value = NIL \end{chunk} \subsection{CombinatorialFunction} -\index{CombinatorialFunction!Domain} -\index{Domain!CombinatorialFunction} -\index{COMBF} -\begin{chunk}{sane} +\index[pkg]{CombinatorialFunction!Domain} +\index[pkg]{Domain!CombinatorialFunction} +\index[pkg]{COMBF} +\begin{chunk}{defclass CombinatorialFunctionType} (defclass |CombinatorialFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "CombinatorialFunction") @@ -25472,7 +26175,7 @@ Value = NIL (abbreviation :initform 'COMBF) (comment :initform (list "Provides combinatorial functions over an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25486,10 +26189,10 @@ Value = NIL \end{chunk} \subsection{CommonDenominator} -\index{CommonDenominator!Domain} -\index{Domain!CommonDenominator} -\index{CDEN} -\begin{chunk}{sane} +\index[pkg]{CommonDenominator!Domain} +\index[pkg]{Domain!CommonDenominator} +\index[pkg]{CDEN} +\begin{chunk}{defclass CommonDenominatorType} (defclass |CommonDenominatorType| (|AxiomClass|) ((parents :initform ()) (name :initform "CommonDenominator") @@ -25499,7 +26202,7 @@ Value = NIL "CommonDenominator provides functions to compute the" "common denominator of a finite linear aggregate of elements of" "the quotient field of an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25513,10 +26216,10 @@ Value = NIL \end{chunk} \subsection{CommonOperators} -\index{CommonOperators!Domain} -\index{Domain!CommonOperators} -\index{COMMONOP} -\begin{chunk}{sane} +\index[pkg]{CommonOperators!Domain} +\index[pkg]{Domain!CommonOperators} +\index[pkg]{COMMONOP} +\begin{chunk}{defclass CommonOperatorsType} (defclass |CommonOperatorsType| (|AxiomClass|) ((parents :initform ()) (name :initform "CommonOperators") @@ -25526,7 +26229,7 @@ Value = 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25540,10 +26243,10 @@ Value = NIL \end{chunk} \subsection{CommuteUnivariatePolynomialCategory} -\index{CommuteUnivariatePolynomialCategory!Domain} -\index{Domain!CommuteUnivariatePolynomialCategory} -\index{COMMUPC} -\begin{chunk}{sane} +\index[pkg]{CommuteUnivariatePolynomialCategory!Domain} +\index[pkg]{Domain!CommuteUnivariatePolynomialCategory} +\index[pkg]{COMMUPC} +\begin{chunk}{defclass CommuteUnivariatePolynomialCategoryType} (defclass |CommuteUnivariatePolynomialCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "CommuteUnivariatePolynomialCategory") @@ -25552,7 +26255,7 @@ Value = NIL (comment :initform (list "A package for swapping the order of two variables in a tower of two" "UnivariatePolynomialCategory extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25566,10 +26269,10 @@ Value = NIL \end{chunk} \subsection{ComplexFactorization} -\index{ComplexFactorization!Domain} -\index{Domain!ComplexFactorization} -\index{COMPFACT} -\begin{chunk}{sane} +\index[pkg]{ComplexFactorization!Domain} +\index[pkg]{Domain!ComplexFactorization} +\index[pkg]{COMPFACT} +\begin{chunk}{defclass ComplexFactorizationType} (defclass |ComplexFactorizationType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexFactorization") @@ -25577,7 +26280,7 @@ Value = NIL (abbreviation :initform 'COMPFACT) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25591,10 +26294,10 @@ Value = NIL \end{chunk} \subsection{ComplexFunctions2} -\index{ComplexFunctions2!Domain} -\index{Domain!ComplexFunctions2} -\index{COMPLEX2} -\begin{chunk}{sane} +\index[pkg]{ComplexFunctions2!Domain} +\index[pkg]{Domain!ComplexFunctions2} +\index[pkg]{COMPLEX2} +\begin{chunk}{defclass ComplexFunctions2Type} (defclass |ComplexFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexFunctions2") @@ -25603,7 +26306,7 @@ Value = NIL (comment :initform (list "This package extends maps from underlying rings to maps between" "complex over those rings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25617,10 +26320,10 @@ Value = NIL \end{chunk} \subsection{ComplexIntegerSolveLinearPolynomialEquation} -\index{ComplexIntegerSolveLinearPolynomialEquation!Domain} -\index{Domain!ComplexIntegerSolveLinearPolynomialEquation} -\index{CINTSLPE} -\begin{chunk}{sane} +\index[pkg]{ComplexIntegerSolveLinearPolynomialEquation!Domain} +\index[pkg]{Domain!ComplexIntegerSolveLinearPolynomialEquation} +\index[pkg]{CINTSLPE} +\begin{chunk}{defclass ComplexIntegerSolveLinearPolynomialEquationType} (defclass |ComplexIntegerSolveLinearPolynomialEquationType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexIntegerSolveLinearPolynomialEquation") @@ -25629,7 +26332,7 @@ Value = NIL (comment :initform (list "This package provides the generalized euclidean algorithm which is" "needed as the basic step for factoring polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25643,10 +26346,10 @@ Value = NIL \end{chunk} \subsection{ComplexPattern} -\index{ComplexPattern!Domain} -\index{Domain!ComplexPattern} -\index{COMPLPAT} -\begin{chunk}{sane} +\index[pkg]{ComplexPattern!Domain} +\index[pkg]{Domain!ComplexPattern} +\index[pkg]{COMPLPAT} +\begin{chunk}{defclass ComplexPatternType} (defclass |ComplexPatternType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexPattern") @@ -25654,7 +26357,7 @@ Value = NIL (abbreviation :initform 'COMPLPAT) (comment :initform (list "This package supports converting complex expressions to patterns")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25668,10 +26371,10 @@ Value = NIL \end{chunk} \subsection{ComplexPatternMatch} -\index{ComplexPatternMatch!Domain} -\index{Domain!ComplexPatternMatch} -\index{CPMATCH} -\begin{chunk}{sane} +\index[pkg]{ComplexPatternMatch!Domain} +\index[pkg]{Domain!ComplexPatternMatch} +\index[pkg]{CPMATCH} +\begin{chunk}{defclass ComplexPatternMatchType} (defclass |ComplexPatternMatchType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexPatternMatch") @@ -25679,7 +26382,7 @@ Value = NIL (abbreviation :initform 'CPMATCH) (comment :initform (list "This package supports matching patterns involving complex expressions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25693,10 +26396,10 @@ Value = NIL \end{chunk} \subsection{ComplexRootFindingPackage} -\index{ComplexRootFindingPackage!Domain} -\index{Domain!ComplexRootFindingPackage} -\index{CRFP} -\begin{chunk}{sane} +\index[pkg]{ComplexRootFindingPackage!Domain} +\index[pkg]{Domain!ComplexRootFindingPackage} +\index[pkg]{CRFP} +\begin{chunk}{defclass ComplexRootFindingPackageType} (defclass |ComplexRootFindingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexRootFindingPackage") @@ -25716,7 +26419,7 @@ Value = NIL "Also note that evaluating the zeros is not necessarily a good check" "whether the result is correct: already evaluation can cause" "rounding errors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25730,10 +26433,10 @@ Value = NIL \end{chunk} \subsection{ComplexRootPackage} -\index{ComplexRootPackage!Domain} -\index{Domain!ComplexRootPackage} -\index{CMPLXRT} -\begin{chunk}{sane} +\index[pkg]{ComplexRootPackage!Domain} +\index[pkg]{Domain!ComplexRootPackage} +\index[pkg]{CMPLXRT} +\begin{chunk}{defclass ComplexRootPackageType} (defclass |ComplexRootPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexRootPackage") @@ -25747,7 +26450,7 @@ Value = NIL "as either complex rational number or complex floating point numbers" "depending on the type of the second argument which specifies the" "precision.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25761,10 +26464,10 @@ Value = NIL \end{chunk} \subsection{ComplexTrigonometricManipulations} -\index{ComplexTrigonometricManipulations!Domain} -\index{Domain!ComplexTrigonometricManipulations} -\index{CTRIGMNP} -\begin{chunk}{sane} +\index[pkg]{ComplexTrigonometricManipulations!Domain} +\index[pkg]{Domain!ComplexTrigonometricManipulations} +\index[pkg]{CTRIGMNP} +\begin{chunk}{defclass ComplexTrigonometricManipulationsType} (defclass |ComplexTrigonometricManipulationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ComplexTrigonometricManipulations") @@ -25773,7 +26476,7 @@ Value = NIL (comment :initform (list "ComplexTrigonometricManipulations provides function that" "compute the real and imaginary parts of complex functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25787,10 +26490,10 @@ Value = NIL \end{chunk} \subsection{ConstantLODE} -\index{ConstantLODE!Domain} -\index{Domain!ConstantLODE} -\index{ODECONST} -\begin{chunk}{sane} +\index[pkg]{ConstantLODE!Domain} +\index[pkg]{Domain!ConstantLODE} +\index[pkg]{ODECONST} +\begin{chunk}{defclass ConstantLODEType} (defclass |ConstantLODEType| (|AxiomClass|) ((parents :initform ()) (name :initform "ConstantLODE") @@ -25799,7 +26502,7 @@ Value = NIL (comment :initform (list "Solution of linear ordinary differential equations," "constant coefficient case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25813,10 +26516,10 @@ Value = NIL \end{chunk} \subsection{CoordinateSystems} -\index{CoordinateSystems!Domain} -\index{Domain!CoordinateSystems} -\index{COORDSYS} -\begin{chunk}{sane} +\index[pkg]{CoordinateSystems!Domain} +\index[pkg]{Domain!CoordinateSystems} +\index[pkg]{COORDSYS} +\begin{chunk}{defclass CoordinateSystemsType} (defclass |CoordinateSystemsType| (|AxiomClass|) ((parents :initform ()) (name :initform "CoordinateSystems") @@ -25827,7 +26530,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25841,10 +26544,10 @@ Value = NIL \end{chunk} \subsection{CRApackage} -\index{CRApackage!Domain} -\index{Domain!CRApackage} -\index{CRAPACK} -\begin{chunk}{sane} +\index[pkg]{CRApackage!Domain} +\index[pkg]{Domain!CRApackage} +\index[pkg]{CRAPACK} +\begin{chunk}{defclass CRApackageType} (defclass |CRApackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "CRApackage") @@ -25852,7 +26555,7 @@ Value = NIL (abbreviation :initform 'CRAPACK) (comment :initform (list "This package has no documentation")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25866,10 +26569,10 @@ Value = NIL \end{chunk} \subsection{CycleIndicators} -\index{CycleIndicators!Domain} -\index{Domain!CycleIndicators} -\index{CYCLES} -\begin{chunk}{sane} +\index[pkg]{CycleIndicators!Domain} +\index[pkg]{Domain!CycleIndicators} +\index[pkg]{CYCLES} +\begin{chunk}{defclass CycleIndicatorsType} (defclass |CycleIndicatorsType| (|AxiomClass|) ((parents :initform ()) (name :initform "CycleIndicators") @@ -25877,7 +26580,7 @@ Value = NIL (abbreviation :initform 'CYCLES) (comment :initform (list "Polya-Redfield enumeration by cycle indices.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25891,10 +26594,10 @@ Value = NIL \end{chunk} \subsection{CyclicStreamTools} -\index{CyclicStreamTools!Domain} -\index{Domain!CyclicStreamTools} -\index{CSTTOOLS} -\begin{chunk}{sane} +\index[pkg]{CyclicStreamTools!Domain} +\index[pkg]{Domain!CyclicStreamTools} +\index[pkg]{CSTTOOLS} +\begin{chunk}{defclass CyclicStreamToolsType} (defclass |CyclicStreamToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "CyclicStreamTools") @@ -25902,7 +26605,7 @@ Value = NIL (abbreviation :initform 'CSTTOOLS) (comment :initform (list "This package provides tools for working with cyclic streams.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25916,10 +26619,10 @@ Value = NIL \end{chunk} \subsection{CyclotomicPolynomialPackage} -\index{CyclotomicPolynomialPackage!Domain} -\index{Domain!CyclotomicPolynomialPackage} -\index{CYCLOTOM} -\begin{chunk}{sane} +\index[pkg]{CyclotomicPolynomialPackage!Domain} +\index[pkg]{Domain!CyclotomicPolynomialPackage} +\index[pkg]{CYCLOTOM} +\begin{chunk}{defclass CyclotomicPolynomialPackageType} (defclass |CyclotomicPolynomialPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "CyclotomicPolynomialPackage") @@ -25927,7 +26630,7 @@ Value = NIL (abbreviation :initform 'CYCLOTOM) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25941,17 +26644,17 @@ Value = NIL \end{chunk} \subsection{CylindricalAlgebraicDecompositionPackage} -\index{CylindricalAlgebraicDecompositionPackage!Domain} -\index{Domain!CylindricalAlgebraicDecompositionPackage} -\index{CAD} -\begin{chunk}{sane} +\index[pkg]{CylindricalAlgebraicDecompositionPackage!Domain} +\index[pkg]{Domain!CylindricalAlgebraicDecompositionPackage} +\index[pkg]{CAD} +\begin{chunk}{defclass CylindricalAlgebraicDecompositionPackageType} (defclass |CylindricalAlgebraicDecompositionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "CylindricalAlgebraicDecompositionPackage") (marker :initform 'package) (abbreviation :initform 'CAD) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25965,17 +26668,17 @@ Value = NIL \end{chunk} \subsection{CylindricalAlgebraicDecompositionUtilities} -\index{CylindricalAlgebraicDecompositionUtilities!Domain} -\index{Domain!CylindricalAlgebraicDecompositionUtilities} -\index{CADU} -\begin{chunk}{sane} +\index[pkg]{CylindricalAlgebraicDecompositionUtilities!Domain} +\index[pkg]{Domain!CylindricalAlgebraicDecompositionUtilities} +\index[pkg]{CADU} +\begin{chunk}{defclass CylindricalAlgebraicDecompositionUtilitiesType} (defclass |CylindricalAlgebraicDecompositionUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "CylindricalAlgebraicDecompositionUtilities") (marker :initform 'package) (abbreviation :initform 'CADU) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -25991,10 +26694,10 @@ Value = NIL \section{D} \subsection{DefiniteIntegrationTools} -\index{DefiniteIntegrationTools!Domain} -\index{Domain!DefiniteIntegrationTools} -\index{DFINTTLS} -\begin{chunk}{sane} +\index[pkg]{DefiniteIntegrationTools!Domain} +\index[pkg]{Domain!DefiniteIntegrationTools} +\index[pkg]{DFINTTLS} +\begin{chunk}{defclass DefiniteIntegrationToolsType} (defclass |DefiniteIntegrationToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "DefiniteIntegrationTools") @@ -26003,7 +26706,7 @@ Value = NIL (comment :initform (list "DefiniteIntegrationTools provides common tools used" "by the definite integration of both rational and elementary functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26017,10 +26720,10 @@ Value = NIL \end{chunk} \subsection{DegreeReductionPackage} -\index{DegreeReductionPackage!Domain} -\index{Domain!DegreeReductionPackage} -\index{DEGRED} -\begin{chunk}{sane} +\index[pkg]{DegreeReductionPackage!Domain} +\index[pkg]{Domain!DegreeReductionPackage} +\index[pkg]{DEGRED} +\begin{chunk}{defclass DegreeReductionPackageType} (defclass |DegreeReductionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DegreeReductionPackage") @@ -26028,7 +26731,7 @@ Value = NIL (abbreviation :initform 'DEGRED) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26042,10 +26745,10 @@ Value = NIL \end{chunk} \subsection{DesingTreePackage} -\index{DesingTreePackage!Domain} -\index{Domain!DesingTreePackage} -\index{DTP} -\begin{chunk}{sane} +\index[pkg]{DesingTreePackage!Domain} +\index[pkg]{Domain!DesingTreePackage} +\index[pkg]{DTP} +\begin{chunk}{defclass DesingTreePackageType} (defclass |DesingTreePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DesingTreePackage") @@ -26055,7 +26758,7 @@ Value = NIL "The following is all the categories, domains and package" "used for the desingularisation be means of" "monoidal transformation (Blowing-up)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26069,10 +26772,10 @@ Value = NIL \end{chunk} \subsection{DiophantineSolutionPackage} -\index{DiophantineSolutionPackage!Domain} -\index{Domain!DiophantineSolutionPackage} -\index{DIOSP} -\begin{chunk}{sane} +\index[pkg]{DiophantineSolutionPackage!Domain} +\index[pkg]{Domain!DiophantineSolutionPackage} +\index[pkg]{DIOSP} +\begin{chunk}{defclass DiophantineSolutionPackageType} (defclass |DiophantineSolutionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DiophantineSolutionPackage") @@ -26093,7 +26796,7 @@ Value = NIL "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")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26107,10 +26810,10 @@ Value = NIL \end{chunk} \subsection{DirectProductFunctions2} -\index{DirectProductFunctions2!Domain} -\index{Domain!DirectProductFunctions2} -\index{DIRPROD2} -\begin{chunk}{sane} +\index[pkg]{DirectProductFunctions2!Domain} +\index[pkg]{Domain!DirectProductFunctions2} +\index[pkg]{DIRPROD2} +\begin{chunk}{defclass DirectProductFunctions2Type} (defclass |DirectProductFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "DirectProductFunctions2") @@ -26121,7 +26824,7 @@ Value = NIL "products of elements of some type A and functions from A" "to another type B. The operations all iterate over their vector argument" "and either return a value of type B or a direct product over B.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26135,10 +26838,10 @@ Value = NIL \end{chunk} \subsection{DiscreteLogarithmPackage} -\index{DiscreteLogarithmPackage!Domain} -\index{Domain!DiscreteLogarithmPackage} -\index{DLP} -\begin{chunk}{sane} +\index[pkg]{DiscreteLogarithmPackage!Domain} +\index[pkg]{Domain!DiscreteLogarithmPackage} +\index[pkg]{DLP} +\begin{chunk}{defclass DiscreteLogarithmPackageType} (defclass |DiscreteLogarithmPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DiscreteLogarithmPackage") @@ -26147,7 +26850,7 @@ Value = NIL (comment :initform (list "DiscreteLogarithmPackage implements help functions for discrete logarithms" "in monoids using small cyclic groups.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26161,10 +26864,10 @@ Value = NIL \end{chunk} \subsection{DisplayPackage} -\index{DisplayPackage!Domain} -\index{Domain!DisplayPackage} -\index{DISPLAY} -\begin{chunk}{sane} +\index[pkg]{DisplayPackage!Domain} +\index[pkg]{Domain!DisplayPackage} +\index[pkg]{DISPLAY} +\begin{chunk}{defclass DisplayPackageType} (defclass |DisplayPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DisplayPackage") @@ -26173,7 +26876,7 @@ Value = NIL (comment :initform (list "DisplayPackage allows one to print strings in a nice manner," "including highlighting substrings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26187,10 +26890,10 @@ Value = NIL \end{chunk} \subsection{DistinctDegreeFactorize} -\index{DistinctDegreeFactorize!Domain} -\index{Domain!DistinctDegreeFactorize} -\index{DDFACT} -\begin{chunk}{sane} +\index[pkg]{DistinctDegreeFactorize!Domain} +\index[pkg]{Domain!DistinctDegreeFactorize} +\index[pkg]{DDFACT} +\begin{chunk}{defclass DistinctDegreeFactorizeType} (defclass |DistinctDegreeFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "DistinctDegreeFactorize") @@ -26202,7 +26905,7 @@ Value = NIL "'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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26216,11 +26919,11 @@ Value = NIL \end{chunk} \subsection{DoubleFloatSpecialFunctions} -\index{DoubleFloatSpecialFunctions!Domain} -\index{Domain!DoubleFloatSpecialFunctions} -\index{DFSFUN} +\index[pkg]{DoubleFloatSpecialFunctions!Domain} +\index[pkg]{Domain!DoubleFloatSpecialFunctions} +\index[pkg]{DFSFUN} \label{package DFSFUN DoubleFloatSpecialFunctions} -\begin{chunk}{sane} +\begin{chunk}{defclass DoubleFloatSpecialFunctionsType} (defclass |DoubleFloatSpecialFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "DoubleFloatSpecialFunctions") @@ -26229,7 +26932,7 @@ Value = NIL (comment :initform (list "This package provides special functions for double precision" "real and complex floating point.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26243,10 +26946,10 @@ Value = NIL \end{chunk} \subsection{DoubleResultantPackage} -\index{DoubleResultantPackage!Domain} -\index{Domain!DoubleResultantPackage} -\index{DBLRESP} -\begin{chunk}{sane} +\index[pkg]{DoubleResultantPackage!Domain} +\index[pkg]{Domain!DoubleResultantPackage} +\index[pkg]{DBLRESP} +\begin{chunk}{defclass DoubleResultantPackageType} (defclass |DoubleResultantPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "DoubleResultantPackage") @@ -26255,7 +26958,7 @@ Value = NIL (comment :initform (list "This package provides functions for computing the residues" "of a function on an algebraic curve.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26269,10 +26972,10 @@ Value = NIL \end{chunk} \subsection{DrawComplex} -\index{DrawComplex!Domain} -\index{Domain!DrawComplex} -\index{DRAWCX} -\begin{chunk}{sane} +\index[pkg]{DrawComplex!Domain} +\index[pkg]{Domain!DrawComplex} +\index[pkg]{DRAWCX} +\begin{chunk}{defclass DrawComplexType} (defclass |DrawComplexType| (|AxiomClass|) ((parents :initform ()) (name :initform "DrawComplex") @@ -26281,7 +26984,7 @@ Value = NIL (comment :initform (list "DrawComplex provides some facilities" "for drawing complex functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26295,10 +26998,10 @@ Value = NIL \end{chunk} \subsection{DrawNumericHack} -\index{DrawNumericHack!Domain} -\index{Domain!DrawNumericHack} -\index{DRAWHACK} -\begin{chunk}{sane} +\index[pkg]{DrawNumericHack!Domain} +\index[pkg]{Domain!DrawNumericHack} +\index[pkg]{DRAWHACK} +\begin{chunk}{defclass DrawNumericHackType} (defclass |DrawNumericHackType| (|AxiomClass|) ((parents :initform ()) (name :initform "DrawNumericHack") @@ -26313,7 +27016,7 @@ Value = NIL "a and b contains symbolic variables, but is meant for expressions" "involving %pi." "Note that this package is meant for internal use only.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26327,10 +27030,10 @@ Value = NIL \end{chunk} \subsection{DrawOptionFunctions0} -\index{DrawOptionFunctions0!Domain} -\index{Domain!DrawOptionFunctions0} -\index{DROPT0} -\begin{chunk}{sane} +\index[pkg]{DrawOptionFunctions0!Domain} +\index[pkg]{Domain!DrawOptionFunctions0} +\index[pkg]{DROPT0} +\begin{chunk}{defclass DrawOptionFunctions0Type} (defclass |DrawOptionFunctions0Type| (|AxiomClass|) ((parents :initform ()) (name :initform "DrawOptionFunctions0") @@ -26338,7 +27041,7 @@ Value = NIL (abbreviation :initform 'DROPT0) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26352,10 +27055,10 @@ Value = NIL \end{chunk} \subsection{DrawOptionFunctions1} -\index{DrawOptionFunctions1!Domain} -\index{Domain!DrawOptionFunctions1} -\index{DROPT1} -\begin{chunk}{sane} +\index[pkg]{DrawOptionFunctions1!Domain} +\index[pkg]{Domain!DrawOptionFunctions1} +\index[pkg]{DROPT1} +\begin{chunk}{defclass DrawOptionFunctions1Type} (defclass |DrawOptionFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "DrawOptionFunctions1") @@ -26363,7 +27066,7 @@ Value = NIL (abbreviation :initform 'DROPT1) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26377,10 +27080,10 @@ Value = NIL \end{chunk} \subsection{d01AgentsPackage} -\index{d01AgentsPackage!Domain} -\index{Domain!d01AgentsPackage} -\index{D01AGNT} -\begin{chunk}{sane} +\index[pkg]{d01AgentsPackage!Domain} +\index[pkg]{Domain!d01AgentsPackage} +\index[pkg]{D01AGNT} +\begin{chunk}{defclass d01AgentsPackageType} (defclass |d01AgentsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "d01AgentsPackage") @@ -26393,7 +27096,7 @@ Value = NIL "It contains functions rangeIsFinite to test the input range and" "functionIsContinuousAtEndPoints to check for continuity at" "the end points of the range.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26407,10 +27110,10 @@ Value = NIL \end{chunk} \subsection{d01WeightsPackage} -\index{d01WeightsPackage!Domain} -\index{Domain!d01WeightsPackage} -\index{D01WGTS} -\begin{chunk}{sane} +\index[pkg]{d01WeightsPackage!Domain} +\index[pkg]{Domain!d01WeightsPackage} +\index[pkg]{D01WGTS} +\begin{chunk}{defclass d01WeightsPackageType} (defclass |d01WeightsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "d01WeightsPackage") @@ -26422,7 +27125,7 @@ Value = NIL "function. The types of weights investigated are those giving rise to" "end-point singularities of the algebraico-logarithmic type, and" "trigonometric weights.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26436,17 +27139,17 @@ Value = NIL \end{chunk} \subsection{d02AgentsPackage} -\index{d02AgentsPackage!Domain} -\index{Domain!d02AgentsPackage} -\index{D02AGNT} -\begin{chunk}{sane} +\index[pkg]{d02AgentsPackage!Domain} +\index[pkg]{Domain!d02AgentsPackage} +\index[pkg]{D02AGNT} +\begin{chunk}{defclass d02AgentsPackageType} (defclass |d02AgentsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "d02AgentsPackage") (marker :initform 'package) (abbreviation :initform 'D02AGNT) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26460,10 +27163,10 @@ Value = NIL \end{chunk} \subsection{d03AgentsPackage} -\index{d03AgentsPackage!Domain} -\index{Domain!d03AgentsPackage} -\index{D03AGNT} -\begin{chunk}{sane} +\index[pkg]{d03AgentsPackage!Domain} +\index[pkg]{Domain!d03AgentsPackage} +\index[pkg]{D03AGNT} +\begin{chunk}{defclass d03AgentsPackageType} (defclass |d03AgentsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "d03AgentsPackage") @@ -26472,7 +27175,7 @@ Value = NIL (comment :initform (list "d03AgentsPackage contains a set of computational agents" "for use with Partial Differential Equation solvers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26488,10 +27191,10 @@ Value = NIL \section{E} \subsection{EigenPackage} -\index{EigenPackage!Domain} -\index{Domain!EigenPackage} -\index{EP} -\begin{chunk}{sane} +\index[pkg]{EigenPackage!Domain} +\index[pkg]{Domain!EigenPackage} +\index[pkg]{EP} +\begin{chunk}{defclass EigenPackageType} (defclass |EigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "EigenPackage") @@ -26503,7 +27206,7 @@ Value = NIL "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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26517,10 +27220,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunction} -\index{ElementaryFunction!Domain} -\index{Domain!ElementaryFunction} -\index{EF} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunction!Domain} +\index[pkg]{Domain!ElementaryFunction} +\index[pkg]{EF} +\begin{chunk}{defclass ElementaryFunctionType} (defclass |ElementaryFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunction") @@ -26528,7 +27231,7 @@ Value = NIL (abbreviation :initform 'EF) (comment :initform (list "Provides elementary functions over an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26542,10 +27245,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionDefiniteIntegration} -\index{ElementaryFunctionDefiniteIntegration!Domain} -\index{Domain!ElementaryFunctionDefiniteIntegration} -\index{DEFINTEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunctionDefiniteIntegration!Domain} +\index[pkg]{Domain!ElementaryFunctionDefiniteIntegration} +\index[pkg]{DEFINTEF} +\begin{chunk}{defclass ElementaryFunctionDefiniteIntegrationType} (defclass |ElementaryFunctionDefiniteIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionDefiniteIntegration") @@ -26554,7 +27257,7 @@ Value = NIL (comment :initform (list "RationalFunctionDefiniteIntegration provides functions to" "compute definite integrals of rational functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26568,10 +27271,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionLODESolver} -\index{ElementaryFunctionLODESolver!Domain} -\index{Domain!ElementaryFunctionLODESolver} -\index{LODEEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunctionLODESolver!Domain} +\index[pkg]{Domain!ElementaryFunctionLODESolver} +\index[pkg]{LODEEF} +\begin{chunk}{defclass ElementaryFunctionLODESolverType} (defclass |ElementaryFunctionLODESolverType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionLODESolver") @@ -26581,7 +27284,7 @@ Value = NIL "ElementaryFunctionLODESolver provides the top-level" "functions for finding closed form solutions of linear ordinary" "differential equations and initial value problems.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26595,10 +27298,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionODESolver} -\index{ElementaryFunctionODESolver!Domain} -\index{Domain!ElementaryFunctionODESolver} -\index{ODEEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunctionODESolver!Domain} +\index[pkg]{Domain!ElementaryFunctionODESolver} +\index[pkg]{ODEEF} +\begin{chunk}{defclass ElementaryFunctionODESolverType} (defclass |ElementaryFunctionODESolverType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionODESolver") @@ -26608,7 +27311,7 @@ Value = NIL "ElementaryFunctionODESolver provides the top-level" "functions for finding closed form solutions of ordinary" "differential equations and initial value problems.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26622,10 +27325,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionSign} -\index{ElementaryFunctionSign!Domain} -\index{Domain!ElementaryFunctionSign} -\index{SIGNEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunctionSign!Domain} +\index[pkg]{Domain!ElementaryFunctionSign} +\index[pkg]{SIGNEF} +\begin{chunk}{defclass ElementaryFunctionSignType} (defclass |ElementaryFunctionSignType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionSign") @@ -26634,7 +27337,7 @@ Value = NIL (comment :initform (list "This package provides functions to determine the sign of an" "elementary function around a point or infinity.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26648,10 +27351,10 @@ Value = NIL \end{chunk} \subsection{ElementaryFunctionStructurePackage} -\index{ElementaryFunctionStructurePackage!Domain} -\index{Domain!ElementaryFunctionStructurePackage} -\index{EFSTRUC} -\begin{chunk}{sane} +\index[pkg]{ElementaryFunctionStructurePackage!Domain} +\index[pkg]{Domain!ElementaryFunctionStructurePackage} +\index[pkg]{EFSTRUC} +\begin{chunk}{defclass ElementaryFunctionStructurePackageType} (defclass |ElementaryFunctionStructurePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryFunctionStructurePackage") @@ -26663,7 +27366,7 @@ Value = NIL "Risch structure theorem (real and complex versions)." "It also provides transformations on elementary functions" "which are not considered simplifications.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26677,10 +27380,10 @@ Value = NIL \end{chunk} \subsection{ElementaryIntegration} -\index{ElementaryIntegration!Domain} -\index{Domain!ElementaryIntegration} -\index{INTEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryIntegration!Domain} +\index[pkg]{Domain!ElementaryIntegration} +\index[pkg]{INTEF} +\begin{chunk}{defclass ElementaryIntegrationType} (defclass |ElementaryIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryIntegration") @@ -26690,7 +27393,7 @@ Value = NIL "This package provides functions for integration, limited integration," "extended integration and the risch differential equation for" "elementary functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26704,10 +27407,10 @@ Value = NIL \end{chunk} \subsection{ElementaryRischDE} -\index{ElementaryRischDE!Domain} -\index{Domain!ElementaryRischDE} -\index{RDEEF} -\begin{chunk}{sane} +\index[pkg]{ElementaryRischDE!Domain} +\index[pkg]{Domain!ElementaryRischDE} +\index[pkg]{RDEEF} +\begin{chunk}{defclass ElementaryRischDEType} (defclass |ElementaryRischDEType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryRischDE") @@ -26715,7 +27418,7 @@ Value = NIL (abbreviation :initform 'RDEEF) (comment :initform (list "Risch differential equation, elementary case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26729,10 +27432,10 @@ Value = NIL \end{chunk} \subsection{ElementaryRischDESystem} -\index{ElementaryRischDESystem!Domain} -\index{Domain!ElementaryRischDESystem} -\index{RDEEFS} -\begin{chunk}{sane} +\index[pkg]{ElementaryRischDESystem!Domain} +\index[pkg]{Domain!ElementaryRischDESystem} +\index[pkg]{RDEEFS} +\begin{chunk}{defclass ElementaryRischDESystemType} (defclass |ElementaryRischDESystemType| (|AxiomClass|) ((parents :initform ()) (name :initform "ElementaryRischDESystem") @@ -26740,7 +27443,7 @@ Value = NIL (abbreviation :initform 'RDEEFS) (comment :initform (list "Risch differential equation, elementary case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26754,10 +27457,10 @@ Value = NIL \end{chunk} \subsection{EllipticFunctionsUnivariateTaylorSeries} -\index{EllipticFunctionsUnivariateTaylorSeries!Domain} -\index{Domain!EllipticFunctionsUnivariateTaylorSeries} -\index{ELFUTS} -\begin{chunk}{sane} +\index[pkg]{EllipticFunctionsUnivariateTaylorSeries!Domain} +\index[pkg]{Domain!EllipticFunctionsUnivariateTaylorSeries} +\index[pkg]{ELFUTS} +\begin{chunk}{defclass EllipticFunctionsUnivariateTaylorSeriesType} (defclass |EllipticFunctionsUnivariateTaylorSeriesType| (|AxiomClass|) ((parents :initform ()) (name :initform "EllipticFunctionsUnivariateTaylorSeries") @@ -26765,7 +27468,7 @@ Value = NIL (abbreviation :initform 'ELFUTS) (comment :initform (list "The elliptic functions sn, sc and dn are expanded as Taylor series.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26779,10 +27482,10 @@ Value = NIL \end{chunk} \subsection{EquationFunctions2} -\index{EquationFunctions2!Domain} -\index{Domain!EquationFunctions2} -\index{EQ2} -\begin{chunk}{sane} +\index[pkg]{EquationFunctions2!Domain} +\index[pkg]{Domain!EquationFunctions2} +\index[pkg]{EQ2} +\begin{chunk}{defclass EquationFunctions2Type} (defclass |EquationFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "EquationFunctions2") @@ -26790,7 +27493,7 @@ Value = NIL (abbreviation :initform 'EQ2) (comment :initform (list "This package provides operations for mapping the sides of equations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26804,10 +27507,10 @@ Value = NIL \end{chunk} \subsection{ErrorFunctions} -\index{ErrorFunctions!Domain} -\index{Domain!ErrorFunctions} -\index{ERROR} -\begin{chunk}{sane} +\index[pkg]{ErrorFunctions!Domain} +\index[pkg]{Domain!ErrorFunctions} +\index[pkg]{ERROR} +\begin{chunk}{defclass ErrorFunctionsType} (defclass |ErrorFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ErrorFunctions") @@ -26847,7 +27550,7 @@ Value = NIL "1.error 'Whoops, you made a %l %ceon big %ceoff %l mistake!'" "2.error ['Whoops, you made a','%l %ceon ','big'," " '%d %ceoff %l','mistake!']")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26861,10 +27564,10 @@ Value = NIL \end{chunk} \subsection{EuclideanGroebnerBasisPackage} -\index{EuclideanGroebnerBasisPackage!Domain} -\index{Domain!EuclideanGroebnerBasisPackage} -\index{GBEUCLID} -\begin{chunk}{sane} +\index[pkg]{EuclideanGroebnerBasisPackage!Domain} +\index[pkg]{Domain!EuclideanGroebnerBasisPackage} +\index[pkg]{GBEUCLID} +\begin{chunk}{defclass EuclideanGroebnerBasisPackageType} (defclass |EuclideanGroebnerBasisPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "EuclideanGroebnerBasisPackage") @@ -26885,7 +27588,7 @@ Value = NIL "DistributedMultivariatePolynomial," "HomogeneousDistributedMultivariatePolynomial," "GeneralDistributedMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26899,10 +27602,10 @@ Value = NIL \end{chunk} \subsection{EvaluateCycleIndicators} -\index{EvaluateCycleIndicators!Domain} -\index{Domain!EvaluateCycleIndicators} -\index{EVALCYC} -\begin{chunk}{sane} +\index[pkg]{EvaluateCycleIndicators!Domain} +\index[pkg]{Domain!EvaluateCycleIndicators} +\index[pkg]{EVALCYC} +\begin{chunk}{defclass EvaluateCycleIndicatorsType} (defclass |EvaluateCycleIndicatorsType| (|AxiomClass|) ((parents :initform ()) (name :initform "EvaluateCycleIndicators") @@ -26911,7 +27614,7 @@ Value = NIL (comment :initform (list "This package is to be used in conjuction with the CycleIndicators package." "It provides an evaluation function for SymmetricPolynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26925,10 +27628,10 @@ Value = NIL \end{chunk} \subsection{ExpertSystemContinuityPackage} -\index{ExpertSystemContinuityPackage!Domain} -\index{Domain!ExpertSystemContinuityPackage} -\index{ESCONT} -\begin{chunk}{sane} +\index[pkg]{ExpertSystemContinuityPackage!Domain} +\index[pkg]{Domain!ExpertSystemContinuityPackage} +\index[pkg]{ESCONT} +\begin{chunk}{defclass ExpertSystemContinuityPackageType} (defclass |ExpertSystemContinuityPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpertSystemContinuityPackage") @@ -26937,7 +27640,7 @@ Value = NIL (comment :initform (list "ExpertSystemContinuityPackage is a package of functions for the use of" "domains belonging to the category NumericalIntegration.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26951,10 +27654,10 @@ Value = NIL \end{chunk} \subsection{ExpertSystemContinuityPackage1} -\index{ExpertSystemContinuityPackage1!Domain} -\index{Domain!ExpertSystemContinuityPackage1} -\index{ESCONT1} -\begin{chunk}{sane} +\index[pkg]{ExpertSystemContinuityPackage1!Domain} +\index[pkg]{Domain!ExpertSystemContinuityPackage1} +\index[pkg]{ESCONT1} +\begin{chunk}{defclass ExpertSystemContinuityPackage1Type} (defclass |ExpertSystemContinuityPackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpertSystemContinuityPackage1") @@ -26962,7 +27665,7 @@ Value = NIL (abbreviation :initform 'ESCONT1) (comment :initform (list "ExpertSystemContinuityPackage1 exports a function to check range inclusion")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -26976,10 +27679,10 @@ Value = NIL \end{chunk} \subsection{ExpertSystemToolsPackage} -\index{ExpertSystemToolsPackage!Domain} -\index{Domain!ExpertSystemToolsPackage} -\index{ESTOOLS} -\begin{chunk}{sane} +\index[pkg]{ExpertSystemToolsPackage!Domain} +\index[pkg]{Domain!ExpertSystemToolsPackage} +\index[pkg]{ESTOOLS} +\begin{chunk}{defclass ExpertSystemToolsPackageType} (defclass |ExpertSystemToolsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpertSystemToolsPackage") @@ -26988,7 +27691,7 @@ Value = NIL (comment :initform (list "ExpertSystemToolsPackage contains some useful functions for use" "by the computational agents of numerical solvers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27002,10 +27705,10 @@ Value = NIL \end{chunk} \subsection{ExpertSystemToolsPackage1} -\index{ExpertSystemToolsPackage1!Domain} -\index{Domain!ExpertSystemToolsPackage1} -\index{ESTOOLS1} -\begin{chunk}{sane} +\index[pkg]{ExpertSystemToolsPackage1!Domain} +\index[pkg]{Domain!ExpertSystemToolsPackage1} +\index[pkg]{ESTOOLS1} +\begin{chunk}{defclass ExpertSystemToolsPackage1Type} (defclass |ExpertSystemToolsPackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpertSystemToolsPackage1") @@ -27014,7 +27717,7 @@ Value = NIL (comment :initform (list "ExpertSystemToolsPackage1 contains some useful functions for use" "by the computational agents of Ordinary Differential Equation solvers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27028,10 +27731,10 @@ Value = NIL \end{chunk} \subsection{ExpertSystemToolsPackage2} -\index{ExpertSystemToolsPackage2!Domain} -\index{Domain!ExpertSystemToolsPackage2} -\index{ESTOOLS2} -\begin{chunk}{sane} +\index[pkg]{ExpertSystemToolsPackage2!Domain} +\index[pkg]{Domain!ExpertSystemToolsPackage2} +\index[pkg]{ESTOOLS2} +\begin{chunk}{defclass ExpertSystemToolsPackage2Type} (defclass |ExpertSystemToolsPackage2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpertSystemToolsPackage2") @@ -27040,7 +27743,7 @@ Value = NIL (comment :initform (list "ExpertSystemToolsPackage2 contains some useful functions for use" "by the computational agents of Ordinary Differential Equation solvers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27054,10 +27757,10 @@ Value = NIL \end{chunk} \subsection{ExpressionFunctions2} -\index{ExpressionFunctions2!Domain} -\index{Domain!ExpressionFunctions2} -\index{EXPR2} -\begin{chunk}{sane} +\index[pkg]{ExpressionFunctions2!Domain} +\index[pkg]{Domain!ExpressionFunctions2} +\index[pkg]{EXPR2} +\begin{chunk}{defclass ExpressionFunctions2Type} (defclass |ExpressionFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionFunctions2") @@ -27065,7 +27768,7 @@ Value = NIL (abbreviation :initform 'EXPR2) (comment :initform (list "Lifting of maps to Expressions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27079,10 +27782,10 @@ Value = NIL \end{chunk} \subsection{ExpressionSolve} -\index{ExpressionSolve!Domain} -\index{Domain!ExpressionSolve} -\index{EXPRSOL} -\begin{chunk}{sane} +\index[pkg]{ExpressionSolve!Domain} +\index[pkg]{Domain!ExpressionSolve} +\index[pkg]{EXPRSOL} +\begin{chunk}{defclass ExpressionSolveType} (defclass |ExpressionSolveType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionSolve") @@ -27090,7 +27793,7 @@ Value = NIL (abbreviation :initform 'EXPRSOL) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27104,10 +27807,10 @@ Value = NIL \end{chunk} \subsection{ExpressionSpaceFunctions1} -\index{ExpressionSpaceFunctions1!Domain} -\index{Domain!ExpressionSpaceFunctions1} -\index{ES1} -\begin{chunk}{sane} +\index[pkg]{ExpressionSpaceFunctions1!Domain} +\index[pkg]{Domain!ExpressionSpaceFunctions1} +\index[pkg]{ES1} +\begin{chunk}{defclass ExpressionSpaceFunctions1Type} (defclass |ExpressionSpaceFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionSpaceFunctions1") @@ -27117,7 +27820,7 @@ Value = 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.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27131,10 +27834,10 @@ Value = NIL \end{chunk} \subsection{ExpressionSpaceFunctions2} -\index{ExpressionSpaceFunctions2!Domain} -\index{Domain!ExpressionSpaceFunctions2} -\index{ES2} -\begin{chunk}{sane} +\index[pkg]{ExpressionSpaceFunctions2!Domain} +\index[pkg]{Domain!ExpressionSpaceFunctions2} +\index[pkg]{ES2} +\begin{chunk}{defclass ExpressionSpaceFunctions2Type} (defclass |ExpressionSpaceFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionSpaceFunctions2") @@ -27145,7 +27848,7 @@ Value = NIL "This lifting can fail if the operator of the kernel cannot be applied" "in F; Do not use this package with E = F, since this may" "drop some properties of the operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27159,10 +27862,10 @@ Value = NIL \end{chunk} \subsection{ExpressionSpaceODESolver} -\index{ExpressionSpaceODESolver!Domain} -\index{Domain!ExpressionSpaceODESolver} -\index{EXPRODE} -\begin{chunk}{sane} +\index[pkg]{ExpressionSpaceODESolver!Domain} +\index[pkg]{Domain!ExpressionSpaceODESolver} +\index[pkg]{EXPRODE} +\begin{chunk}{defclass ExpressionSpaceODESolverType} (defclass |ExpressionSpaceODESolverType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionSpaceODESolver") @@ -27170,7 +27873,7 @@ Value = NIL (abbreviation :initform 'EXPRODE) (comment :initform (list "Taylor series solutions of explicit ODE's")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27184,10 +27887,10 @@ Value = NIL \end{chunk} \subsection{ExpressionToOpenMath} -\index{ExpressionToOpenMath!Domain} -\index{Domain!ExpressionToOpenMath} -\index{OMEXPR} -\begin{chunk}{sane} +\index[pkg]{ExpressionToOpenMath!Domain} +\index[pkg]{Domain!ExpressionToOpenMath} +\index[pkg]{OMEXPR} +\begin{chunk}{defclass ExpressionToOpenMathType} (defclass |ExpressionToOpenMathType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionToOpenMath") @@ -27196,7 +27899,7 @@ Value = NIL (comment :initform (list "ExpressionToOpenMath provides support for" "converting objects of type Expression into OpenMath.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27210,10 +27913,10 @@ Value = NIL \end{chunk} \subsection{ExpressionToUnivariatePowerSeries} -\index{ExpressionToUnivariatePowerSeries!Domain} -\index{Domain!ExpressionToUnivariatePowerSeries} -\index{EXPR2UPS} -\begin{chunk}{sane} +\index[pkg]{ExpressionToUnivariatePowerSeries!Domain} +\index[pkg]{Domain!ExpressionToUnivariatePowerSeries} +\index[pkg]{EXPR2UPS} +\begin{chunk}{defclass ExpressionToUnivariatePowerSeriesType} (defclass |ExpressionToUnivariatePowerSeriesType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionToUnivariatePowerSeries") @@ -27222,7 +27925,7 @@ Value = NIL (comment :initform (list "This package provides functions to convert functional expressions" "to power series.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27236,10 +27939,10 @@ Value = NIL \end{chunk} \subsection{ExpressionTubePlot} -\index{ExpressionTubePlot!Domain} -\index{Domain!ExpressionTubePlot} -\index{EXPRTUBE} -\begin{chunk}{sane} +\index[pkg]{ExpressionTubePlot!Domain} +\index[pkg]{Domain!ExpressionTubePlot} +\index[pkg]{EXPRTUBE} +\begin{chunk}{defclass ExpressionTubePlotType} (defclass |ExpressionTubePlotType| (|AxiomClass|) ((parents :initform ()) (name :initform "ExpressionTubePlot") @@ -27247,7 +27950,7 @@ Value = NIL (abbreviation :initform 'EXPRTUBE) (comment :initform (list "Package for constructing tubes around 3-dimensional parametric curves.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27261,10 +27964,10 @@ Value = NIL \end{chunk} \subsection{Export3D} -\index{Export3D!Domain} -\index{Domain!Export3D} -\index{EXP3D} -\begin{chunk}{sane} +\index[pkg]{Export3D!Domain} +\index[pkg]{Domain!Export3D} +\index[pkg]{EXP3D} +\begin{chunk}{defclass Export3DType} (defclass |Export3DType| (|AxiomClass|) ((parents :initform ()) (name :initform "Export3D") @@ -27273,7 +27976,7 @@ Value = NIL (comment :initform (list "This package provides support for exporting SubSpace and" "ThreeSpace structures to files.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27287,10 +27990,10 @@ Value = NIL \end{chunk} \subsection{e04AgentsPackage} -\index{e04AgentsPackage!Domain} -\index{Domain!e04AgentsPackage} -\index{E04AGNT} -\begin{chunk}{sane} +\index[pkg]{e04AgentsPackage!Domain} +\index[pkg]{Domain!e04AgentsPackage} +\index[pkg]{E04AGNT} +\begin{chunk}{defclass e04AgentsPackageType} (defclass |e04AgentsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "e04AgentsPackage") @@ -27300,7 +28003,7 @@ Value = NIL "e04AgentsPackage is a package of numerical agents to be used" "to investigate attributes of an input function so as to decide the" "measure of an appropriate numerical optimization routine.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27316,10 +28019,10 @@ Value = NIL \section{F} \subsection{FactoredFunctions} -\index{FactoredFunctions!Domain} -\index{Domain!FactoredFunctions} -\index{FACTFUNC} -\begin{chunk}{sane} +\index[pkg]{FactoredFunctions!Domain} +\index[pkg]{Domain!FactoredFunctions} +\index[pkg]{FACTFUNC} +\begin{chunk}{defclass FactoredFunctionsType} (defclass |FactoredFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FactoredFunctions") @@ -27327,7 +28030,7 @@ Value = NIL (abbreviation :initform 'FACTFUNC) (comment :initform (list "Computes various functions on factored arguments.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27341,10 +28044,10 @@ Value = NIL \end{chunk} \subsection{FactoredFunctions2} -\index{FactoredFunctions2!Domain} -\index{Domain!FactoredFunctions2} -\index{FR2} -\begin{chunk}{sane} +\index[pkg]{FactoredFunctions2!Domain} +\index[pkg]{Domain!FactoredFunctions2} +\index[pkg]{FR2} +\begin{chunk}{defclass FactoredFunctions2Type} (defclass |FactoredFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FactoredFunctions2") @@ -27355,7 +28058,7 @@ Value = NIL "factored objects whose underlying domains may not be the same." "For example, map might be used to coerce an object of" "type Factored(Integer) to Factored(Complex(Integer)).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27369,10 +28072,10 @@ Value = NIL \end{chunk} \subsection{FactoredFunctionUtilities} -\index{FactoredFunctionUtilities!Domain} -\index{Domain!FactoredFunctionUtilities} -\index{FRUTIL} -\begin{chunk}{sane} +\index[pkg]{FactoredFunctionUtilities!Domain} +\index[pkg]{Domain!FactoredFunctionUtilities} +\index[pkg]{FRUTIL} +\begin{chunk}{defclass FactoredFunctionUtilitiesType} (defclass |FactoredFunctionUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "FactoredFunctionUtilities") @@ -27381,7 +28084,7 @@ Value = NIL (comment :initform (list "FactoredFunctionUtilities implements some utility" "functions for manipulating factored objects.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27395,10 +28098,10 @@ Value = NIL \end{chunk} \subsection{FactoringUtilities} -\index{FactoringUtilities!Domain} -\index{Domain!FactoringUtilities} -\index{FACUTIL} -\begin{chunk}{sane} +\index[pkg]{FactoringUtilities!Domain} +\index[pkg]{Domain!FactoringUtilities} +\index[pkg]{FACUTIL} +\begin{chunk}{defclass FactoringUtilitiesType} (defclass |FactoringUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "FactoringUtilities") @@ -27408,7 +28111,7 @@ Value = NIL "This package provides utilities used by the factorizers" "which operate on polynomials represented as univariate polynomials" "with multivariate coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27422,10 +28125,10 @@ Value = NIL \end{chunk} \subsection{FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber} -\index{FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber!Domain} -\index{Domain!FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber} -\index{FACTEXT} -\begin{chunk}{sane} +\index[pkg]{FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber!Domain} +\index[pkg]{Domain!FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber} +\index[pkg]{FACTEXT} +\begin{chunk}{defclass FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumberType} (defclass |FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumberType| (|AxiomClass|) ((parents :initform ()) (name :initform "FactorisationOverPseudoAlgebraicClosureOfAlgExtOfRationalNumber") @@ -27433,7 +28136,7 @@ Value = NIL (abbreviation :initform 'FACTEXT) (comment :initform (list "Part of the Package for Algebraic Function Fields in one variable PAFF")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27447,10 +28150,10 @@ Value = NIL \end{chunk} \subsection{FactorisationOverPseudoAlgebraicClosureOfRationalNumber} -\index{FactorisationOverPseudoAlgebraicClosureOfRationalNumber!Domain} -\index{Domain!FactorisationOverPseudoAlgebraicClosureOfRationalNumber} -\index{FACTRN} -\begin{chunk}{sane} +\index[pkg]{FactorisationOverPseudoAlgebraicClosureOfRationalNumber!Domain} +\index[pkg]{Domain!FactorisationOverPseudoAlgebraicClosureOfRationalNumber} +\index[pkg]{FACTRN} +\begin{chunk}{defclass FactorisationOverPseudoAlgebraicClosureOfRationalNumberType} (defclass |FactorisationOverPseudoAlgebraicClosureOfRationalNumberType| (|AxiomClass|) ((parents :initform ()) (name :initform "FactorisationOverPseudoAlgebraicClosureOfRationalNumber") @@ -27458,7 +28161,7 @@ Value = NIL (abbreviation :initform 'FACTRN) (comment :initform (list "Part of the Package for Algebraic Function Fields in one variable PAFF")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27472,10 +28175,10 @@ Value = NIL \end{chunk} \subsection{FGLMIfCanPackage} -\index{FGLMIfCanPackage!Domain} -\index{Domain!FGLMIfCanPackage} -\index{FGLMICPK} -\begin{chunk}{sane} +\index[pkg]{FGLMIfCanPackage!Domain} +\index[pkg]{Domain!FGLMIfCanPackage} +\index[pkg]{FGLMICPK} +\begin{chunk}{defclass FGLMIfCanPackageType} (defclass |FGLMIfCanPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FGLMIfCanPackage") @@ -27487,7 +28190,7 @@ Value = NIL "of sets of polynomial with type Polynomial R" "by the FGLM algorithm if this is possible" "(if the input system generates a zero-dimensional ideal).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27501,10 +28204,10 @@ Value = NIL \end{chunk} \subsection{FindOrderFinite} -\index{FindOrderFinite!Domain} -\index{Domain!FindOrderFinite} -\index{FORDER} -\begin{chunk}{sane} +\index[pkg]{FindOrderFinite!Domain} +\index[pkg]{Domain!FindOrderFinite} +\index[pkg]{FORDER} +\begin{chunk}{defclass FindOrderFiniteType} (defclass |FindOrderFiniteType| (|AxiomClass|) ((parents :initform ()) (name :initform "FindOrderFinite") @@ -27512,7 +28215,7 @@ Value = NIL (abbreviation :initform 'FORDER) (comment :initform (list "Finds the order of a divisor over a finite field")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27526,10 +28229,10 @@ Value = NIL \end{chunk} \subsection{FiniteAbelianMonoidRingFunctions2} -\index{FiniteAbelianMonoidRingFunctions2!Domain} -\index{Domain!FiniteAbelianMonoidRingFunctions2} -\index{FAMR2} -\begin{chunk}{sane} +\index[pkg]{FiniteAbelianMonoidRingFunctions2!Domain} +\index[pkg]{Domain!FiniteAbelianMonoidRingFunctions2} +\index[pkg]{FAMR2} +\begin{chunk}{defclass FiniteAbelianMonoidRingFunctions2Type} (defclass |FiniteAbelianMonoidRingFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteAbelianMonoidRingFunctions2") @@ -27539,7 +28242,7 @@ Value = NIL "This package provides a mapping function for FiniteAbelianMonoidRing" "The packages defined in this file provide fast fraction free rational" "interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27553,10 +28256,10 @@ Value = NIL \end{chunk} \subsection{FiniteDivisorFunctions2} -\index{FiniteDivisorFunctions2!Domain} -\index{Domain!FiniteDivisorFunctions2} -\index{FDIV2} -\begin{chunk}{sane} +\index[pkg]{FiniteDivisorFunctions2!Domain} +\index[pkg]{Domain!FiniteDivisorFunctions2} +\index[pkg]{FDIV2} +\begin{chunk}{defclass FiniteDivisorFunctions2Type} (defclass |FiniteDivisorFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteDivisorFunctions2") @@ -27564,7 +28267,7 @@ Value = NIL (abbreviation :initform 'FDIV2) (comment :initform (list "Lift a map to finite divisors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27578,10 +28281,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldFactorization} -\index{FiniteFieldFactorization!Domain} -\index{Domain!FiniteFieldFactorization} -\index{FFFACTOR} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldFactorization!Domain} +\index[pkg]{Domain!FiniteFieldFactorization} +\index[pkg]{FFFACTOR} +\begin{chunk}{defclass FiniteFieldFactorizationType} (defclass |FiniteFieldFactorizationType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldFactorization") @@ -27589,7 +28292,7 @@ Value = NIL (abbreviation :initform 'FFFACTOR) (comment :initform (list "Part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27603,10 +28306,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldFactorizationWithSizeParseBySideEffect} -\index{FiniteFieldFactorizationWithSizeParseBySideEffect!Domain} -\index{Domain!FiniteFieldFactorizationWithSizeParseBySideEffect} -\index{FFFACTSE} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldFactorizationWithSizeParseBySideEffect!Domain} +\index[pkg]{Domain!FiniteFieldFactorizationWithSizeParseBySideEffect} +\index[pkg]{FFFACTSE} +\begin{chunk}{defclass FiniteFieldFactorizationWithSizeParseBySideEffectType} (defclass |FiniteFieldFactorizationWithSizeParseBySideEffectType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldFactorizationWithSizeParseBySideEffect") @@ -27621,7 +28324,7 @@ Value = NIL "fixed but set before calling the 'factor' function and which is" "parse by side effect to this package via the function 'size'. See" "the local function initialize' of this package.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27635,10 +28338,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldFunctions} -\index{FiniteFieldFunctions!Domain} -\index{Domain!FiniteFieldFunctions} -\index{FFF} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldFunctions!Domain} +\index[pkg]{Domain!FiniteFieldFunctions} +\index[pkg]{FFF} +\begin{chunk}{defclass FiniteFieldFunctionsType} (defclass |FiniteFieldFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldFunctions") @@ -27648,7 +28351,7 @@ Value = NIL "FiniteFieldFunctions(GF) is a package with functions" "concerning finite extension fields of the finite ground field GF," "for example, Zech logarithms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27662,10 +28365,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldHomomorphisms} -\index{FiniteFieldHomomorphisms!Domain} -\index{Domain!FiniteFieldHomomorphisms} -\index{FFHOM} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldHomomorphisms!Domain} +\index[pkg]{Domain!FiniteFieldHomomorphisms} +\index[pkg]{FFHOM} +\begin{chunk}{defclass FiniteFieldHomomorphismsType} (defclass |FiniteFieldHomomorphismsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldHomomorphisms") @@ -27675,7 +28378,7 @@ Value = NIL "FiniteFieldHomomorphisms(F1,GF,F2) exports coercion functions of" "elements between the fields F1 and F2, which both must be" "finite simple algebraic extensions of the finite ground field GF.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27689,10 +28392,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldPolynomialPackage} -\index{FiniteFieldPolynomialPackage!Domain} -\index{Domain!FiniteFieldPolynomialPackage} -\index{FFPOLY} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldPolynomialPackage!Domain} +\index[pkg]{Domain!FiniteFieldPolynomialPackage} +\index[pkg]{FFPOLY} +\begin{chunk}{defclass FiniteFieldPolynomialPackageType} (defclass |FiniteFieldPolynomialPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldPolynomialPackage") @@ -27702,7 +28405,7 @@ Value = NIL "This package provides a number of functions for generating, counting" "and testing irreducible, normal, primitive, random polynomials" "over finite fields.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27716,10 +28419,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldPolynomialPackage2} -\index{FiniteFieldPolynomialPackage2!Domain} -\index{Domain!FiniteFieldPolynomialPackage2} -\index{FFPOLY2} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldPolynomialPackage2!Domain} +\index[pkg]{Domain!FiniteFieldPolynomialPackage2} +\index[pkg]{FFPOLY2} +\begin{chunk}{defclass FiniteFieldPolynomialPackage2Type} (defclass |FiniteFieldPolynomialPackage2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldPolynomialPackage2") @@ -27730,7 +28433,7 @@ Value = NIL "finite fields, which depend on a finite field GF and an" "algebraic extension F of GF, for example, a zero of a polynomial" "over GF in F.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27744,10 +28447,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldSolveLinearPolynomialEquation} -\index{FiniteFieldSolveLinearPolynomialEquation!Domain} -\index{Domain!FiniteFieldSolveLinearPolynomialEquation} -\index{FFSLPE} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldSolveLinearPolynomialEquation!Domain} +\index[pkg]{Domain!FiniteFieldSolveLinearPolynomialEquation} +\index[pkg]{FFSLPE} +\begin{chunk}{defclass FiniteFieldSolveLinearPolynomialEquationType} (defclass |FiniteFieldSolveLinearPolynomialEquationType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldSolveLinearPolynomialEquation") @@ -27756,7 +28459,7 @@ Value = NIL (comment :initform (list "This package solves linear diophantine equations for Bivariate polynomials" "over finite fields")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27770,10 +28473,10 @@ Value = NIL \end{chunk} \subsection{FiniteFieldSquareFreeDecomposition} -\index{FiniteFieldSquareFreeDecomposition!Domain} -\index{Domain!FiniteFieldSquareFreeDecomposition} -\index{FFSQFR} -\begin{chunk}{sane} +\index[pkg]{FiniteFieldSquareFreeDecomposition!Domain} +\index[pkg]{Domain!FiniteFieldSquareFreeDecomposition} +\index[pkg]{FFSQFR} +\begin{chunk}{defclass FiniteFieldSquareFreeDecompositionType} (defclass |FiniteFieldSquareFreeDecompositionType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteFieldSquareFreeDecomposition") @@ -27781,7 +28484,7 @@ Value = NIL (abbreviation :initform 'FFSQFR) (comment :initform (list "Part of the package for Algebraic Function Fields in one variable (PAFF)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27795,10 +28498,10 @@ Value = NIL \end{chunk} \subsection{FiniteLinearAggregateFunctions2} -\index{FiniteLinearAggregateFunctions2!Domain} -\index{Domain!FiniteLinearAggregateFunctions2} -\index{FLAGG2} -\begin{chunk}{sane} +\index[pkg]{FiniteLinearAggregateFunctions2!Domain} +\index[pkg]{Domain!FiniteLinearAggregateFunctions2} +\index[pkg]{FLAGG2} +\begin{chunk}{defclass FiniteLinearAggregateFunctions2Type} (defclass |FiniteLinearAggregateFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteLinearAggregateFunctions2") @@ -27810,7 +28513,7 @@ Value = NIL "different. An example of this might be creating a list of rational" "numbers by mapping a function across a list of integers where the" "function divides each integer by 1000.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27824,10 +28527,10 @@ Value = NIL \end{chunk} \subsection{FiniteLinearAggregateSort} -\index{FiniteLinearAggregateSort!Domain} -\index{Domain!FiniteLinearAggregateSort} -\index{FLASORT} -\begin{chunk}{sane} +\index[pkg]{FiniteLinearAggregateSort!Domain} +\index[pkg]{Domain!FiniteLinearAggregateSort} +\index[pkg]{FLASORT} +\begin{chunk}{defclass FiniteLinearAggregateSortType} (defclass |FiniteLinearAggregateSortType| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteLinearAggregateSort") @@ -27837,7 +28540,7 @@ Value = NIL "This package exports 3 sorting algorithms which work over" "FiniteLinearAggregates." "Sort package (in-place) for shallowlyMutable Finite Linear Aggregates")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27851,10 +28554,10 @@ Value = NIL \end{chunk} \subsection{FiniteSetAggregateFunctions2} -\index{FiniteSetAggregateFunctions2!Domain} -\index{Domain!FiniteSetAggregateFunctions2} -\index{FSAGG2} -\begin{chunk}{sane} +\index[pkg]{FiniteSetAggregateFunctions2!Domain} +\index[pkg]{Domain!FiniteSetAggregateFunctions2} +\index[pkg]{FSAGG2} +\begin{chunk}{defclass FiniteSetAggregateFunctions2Type} (defclass |FiniteSetAggregateFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FiniteSetAggregateFunctions2") @@ -27866,7 +28569,7 @@ Value = NIL "different. An example of this is to create a set of rational" "numbers by mapping a function across a set of integers, where the" "function divides each integer by 1000.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27880,10 +28583,10 @@ Value = NIL \end{chunk} \subsection{FloatingComplexPackage} -\index{FloatingComplexPackage!Domain} -\index{Domain!FloatingComplexPackage} -\index{FLOATCP} -\begin{chunk}{sane} +\index[pkg]{FloatingComplexPackage!Domain} +\index[pkg]{Domain!FloatingComplexPackage} +\index[pkg]{FLOATCP} +\begin{chunk}{defclass FloatingComplexPackageType} (defclass |FloatingComplexPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FloatingComplexPackage") @@ -27895,7 +28598,7 @@ Value = NIL "coefficients. The results are expressed as either complex rational" "numbers or complex floats depending on the type of the precision" "parameter which can be either a rational number or a floating point number.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27909,10 +28612,10 @@ Value = NIL \end{chunk} \subsection{FloatingRealPackage} -\index{FloatingRealPackage!Domain} -\index{Domain!FloatingRealPackage} -\index{FLOATRP} -\begin{chunk}{sane} +\index[pkg]{FloatingRealPackage!Domain} +\index[pkg]{Domain!FloatingRealPackage} +\index[pkg]{FLOATRP} +\begin{chunk}{defclass FloatingRealPackageType} (defclass |FloatingRealPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FloatingRealPackage") @@ -27924,7 +28627,7 @@ Value = NIL "The results are expressed as either rational numbers or floats" "depending on the type of the precision parameter which can be" "either a rational number or a floating point number.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27938,17 +28641,17 @@ Value = NIL \end{chunk} \subsection{FloatSpecialFunctions} -\index{FloatSpecialFunctions!Domain} -\index{Domain!FloatSpecialFunctions} -\index{FSFUN} -\begin{chunk}{sane} +\index[pkg]{FloatSpecialFunctions!Domain} +\index[pkg]{Domain!FloatSpecialFunctions} +\index[pkg]{FSFUN} +\begin{chunk}{defclass FloatSpecialFunctionsType} (defclass |FloatSpecialFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FloatSpecialFunctions") (marker :initform 'package) (abbreviation :initform 'FSFUN) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27962,10 +28665,10 @@ Value = NIL \end{chunk} \subsection{FortranCodePackage1} -\index{FortranCodePackage1!Domain} -\index{Domain!FortranCodePackage1} -\index{FCPAK1} -\begin{chunk}{sane} +\index[pkg]{FortranCodePackage1!Domain} +\index[pkg]{Domain!FortranCodePackage1} +\index[pkg]{FCPAK1} +\begin{chunk}{defclass FortranCodePackage1Type} (defclass |FortranCodePackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FortranCodePackage1") @@ -27983,7 +28686,7 @@ Value = NIL "and it is users' responsibility to check that this is sensible." "The advanced functions use SegmentBinding to allow users control" "over Fortran loop variable names.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -27997,10 +28700,10 @@ Value = NIL \end{chunk} \subsection{FortranOutputStackPackage} -\index{FortranOutputStackPackage!Domain} -\index{Domain!FortranOutputStackPackage} -\index{FOP} -\begin{chunk}{sane} +\index[pkg]{FortranOutputStackPackage!Domain} +\index[pkg]{Domain!FortranOutputStackPackage} +\index[pkg]{FOP} +\begin{chunk}{defclass FortranOutputStackPackageType} (defclass |FortranOutputStackPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FortranOutputStackPackage") @@ -28008,7 +28711,7 @@ Value = NIL (abbreviation :initform 'FOP) (comment :initform (list "Code to manipulate Fortran Output Stack")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28022,10 +28725,10 @@ Value = NIL \end{chunk} \subsection{FortranPackage} -\index{FortranPackage!Domain} -\index{Domain!FortranPackage} -\index{FORT} -\begin{chunk}{sane} +\index[pkg]{FortranPackage!Domain} +\index[pkg]{Domain!FortranPackage} +\index[pkg]{FORT} +\begin{chunk}{defclass FortranPackageType} (defclass |FortranPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "FortranPackage") @@ -28033,7 +28736,7 @@ Value = NIL (abbreviation :initform 'FORT) (comment :initform (list "Provides an interface to the boot code for calling Fortran")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28047,10 +28750,10 @@ Value = NIL \end{chunk} \subsection{FractionalIdealFunctions2} -\index{FractionalIdealFunctions2!Domain} -\index{Domain!FractionalIdealFunctions2} -\index{FRIDEAL2} -\begin{chunk}{sane} +\index[pkg]{FractionalIdealFunctions2!Domain} +\index[pkg]{Domain!FractionalIdealFunctions2} +\index[pkg]{FRIDEAL2} +\begin{chunk}{defclass FractionalIdealFunctions2Type} (defclass |FractionalIdealFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FractionalIdealFunctions2") @@ -28058,7 +28761,7 @@ Value = NIL (abbreviation :initform 'FRIDEAL2) (comment :initform (list "Lifting of morphisms to fractional ideals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28072,10 +28775,10 @@ Value = NIL \end{chunk} \subsection{FractionFreeFastGaussian} -\index{FractionFreeFastGaussian!Domain} -\index{Domain!FractionFreeFastGaussian} -\index{FFFG} -\begin{chunk}{sane} +\index[pkg]{FractionFreeFastGaussian!Domain} +\index[pkg]{Domain!FractionFreeFastGaussian} +\index[pkg]{FFFG} +\begin{chunk}{defclass FractionFreeFastGaussianType} (defclass |FractionFreeFastGaussianType| (|AxiomClass|) ((parents :initform ()) (name :initform "FractionFreeFastGaussian") @@ -28088,7 +28791,7 @@ Value = NIL "Applications 22." "The packages defined in this file provide fast fraction free rational" "interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28102,10 +28805,10 @@ Value = NIL \end{chunk} \subsection{FractionFreeFastGaussianFractions} -\index{FractionFreeFastGaussianFractions!Domain} -\index{Domain!FractionFreeFastGaussianFractions} -\index{FFFGF} -\begin{chunk}{sane} +\index[pkg]{FractionFreeFastGaussianFractions!Domain} +\index[pkg]{Domain!FractionFreeFastGaussianFractions} +\index[pkg]{FFFGF} +\begin{chunk}{defclass FractionFreeFastGaussianFractionsType} (defclass |FractionFreeFastGaussianFractionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FractionFreeFastGaussianFractions") @@ -28116,7 +28819,7 @@ Value = NIL "FractionFreeFastGaussian to fractions." "The packages defined in this file provide fast fraction free rational" "interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28130,10 +28833,10 @@ Value = NIL \end{chunk} \subsection{FractionFunctions2} -\index{FractionFunctions2!Domain} -\index{Domain!FractionFunctions2} -\index{FRAC2} -\begin{chunk}{sane} +\index[pkg]{FractionFunctions2!Domain} +\index[pkg]{Domain!FractionFunctions2} +\index[pkg]{FRAC2} +\begin{chunk}{defclass FractionFunctions2Type} (defclass |FractionFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FractionFunctions2") @@ -28143,7 +28846,7 @@ Value = NIL "This package extends a map between integral domains to" "a map between Fractions over those domains by applying the map to the" "numerators and denominators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28157,10 +28860,10 @@ Value = NIL \end{chunk} \subsection{FramedNonAssociativeAlgebraFunctions2} -\index{FramedNonAssociativeAlgebraFunctions2!Domain} -\index{Domain!FramedNonAssociativeAlgebraFunctions2} -\index{FRNAAF2} -\begin{chunk}{sane} +\index[pkg]{FramedNonAssociativeAlgebraFunctions2!Domain} +\index[pkg]{Domain!FramedNonAssociativeAlgebraFunctions2} +\index[pkg]{FRNAAF2} +\begin{chunk}{defclass FramedNonAssociativeAlgebraFunctions2Type} (defclass |FramedNonAssociativeAlgebraFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FramedNonAssociativeAlgebraFunctions2") @@ -28171,7 +28874,7 @@ Value = NIL "two framed non associative algebra domains defined over different rings." "The function map is used to coerce between algebras over different" "domains having the same structural constants.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28185,10 +28888,10 @@ Value = NIL \end{chunk} \subsection{FunctionalSpecialFunction} -\index{FunctionalSpecialFunction!Domain} -\index{Domain!FunctionalSpecialFunction} -\index{FSPECF} -\begin{chunk}{sane} +\index[pkg]{FunctionalSpecialFunction!Domain} +\index[pkg]{Domain!FunctionalSpecialFunction} +\index[pkg]{FSPECF} +\begin{chunk}{defclass FunctionalSpecialFunctionType} (defclass |FunctionalSpecialFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionalSpecialFunction") @@ -28196,7 +28899,7 @@ Value = NIL (abbreviation :initform 'FSPECF) (comment :initform (list "Provides some special functions over an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28210,10 +28913,10 @@ Value = NIL \end{chunk} \subsection{FunctionFieldCategoryFunctions2} -\index{FunctionFieldCategoryFunctions2!Domain} -\index{Domain!FunctionFieldCategoryFunctions2} -\index{FFCAT2} -\begin{chunk}{sane} +\index[pkg]{FunctionFieldCategoryFunctions2!Domain} +\index[pkg]{Domain!FunctionFieldCategoryFunctions2} +\index[pkg]{FFCAT2} +\begin{chunk}{defclass FunctionFieldCategoryFunctions2Type} (defclass |FunctionFieldCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionFieldCategoryFunctions2") @@ -28221,7 +28924,7 @@ Value = NIL (abbreviation :initform 'FFCAT2) (comment :initform (list "Lifts a map from rings to function fields over them.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28235,10 +28938,10 @@ Value = NIL \end{chunk} \subsection{FunctionFieldIntegralBasis} -\index{FunctionFieldIntegralBasis!Domain} -\index{Domain!FunctionFieldIntegralBasis} -\index{FFINTBAS} -\begin{chunk}{sane} +\index[pkg]{FunctionFieldIntegralBasis!Domain} +\index[pkg]{Domain!FunctionFieldIntegralBasis} +\index[pkg]{FFINTBAS} +\begin{chunk}{defclass FunctionFieldIntegralBasisType} (defclass |FunctionFieldIntegralBasisType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionFieldIntegralBasis") @@ -28251,7 +28954,7 @@ Value = NIL "closure of R in the quotient field of F. It is assumed that" "char(R/P) = char(R) for any prime P of R. A typical instance of" "this is when R = K[x] and F is a function field over R.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28265,10 +28968,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceAssertions} -\index{FunctionSpaceAssertions!Domain} -\index{Domain!FunctionSpaceAssertions} -\index{PMASSFS} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceAssertions!Domain} +\index[pkg]{Domain!FunctionSpaceAssertions} +\index[pkg]{PMASSFS} +\begin{chunk}{defclass FunctionSpaceAssertionsType} (defclass |FunctionSpaceAssertionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceAssertions") @@ -28276,7 +28979,7 @@ Value = NIL (abbreviation :initform 'PMASSFS) (comment :initform (list "Attaching assertions to symbols for pattern matching")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28290,10 +28993,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceAttachPredicates} -\index{FunctionSpaceAttachPredicates!Domain} -\index{Domain!FunctionSpaceAttachPredicates} -\index{PMPREDFS} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceAttachPredicates!Domain} +\index[pkg]{Domain!FunctionSpaceAttachPredicates} +\index[pkg]{PMPREDFS} +\begin{chunk}{defclass FunctionSpaceAttachPredicatesType} (defclass |FunctionSpaceAttachPredicatesType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceAttachPredicates") @@ -28301,7 +29004,7 @@ Value = NIL (abbreviation :initform 'PMPREDFS) (comment :initform (list "Attaching predicates to symbols for pattern matching.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28315,10 +29018,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceComplexIntegration} -\index{FunctionSpaceComplexIntegration!Domain} -\index{Domain!FunctionSpaceComplexIntegration} -\index{FSCINT} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceComplexIntegration!Domain} +\index[pkg]{Domain!FunctionSpaceComplexIntegration} +\index[pkg]{FSCINT} +\begin{chunk}{defclass FunctionSpaceComplexIntegrationType} (defclass |FunctionSpaceComplexIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceComplexIntegration") @@ -28327,7 +29030,7 @@ Value = NIL (comment :initform (list "FunctionSpaceComplexIntegration provides functions for the" "indefinite integration of complex-valued functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28341,10 +29044,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceFunctions2} -\index{FunctionSpaceFunctions2!Domain} -\index{Domain!FunctionSpaceFunctions2} -\index{FS2} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceFunctions2!Domain} +\index[pkg]{Domain!FunctionSpaceFunctions2} +\index[pkg]{FS2} +\begin{chunk}{defclass FunctionSpaceFunctions2Type} (defclass |FunctionSpaceFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceFunctions2") @@ -28353,7 +29056,7 @@ Value = NIL (comment :initform (list "This package allows a mapping R -> S to be lifted to a mapping" "from a function space over R to a function space over S")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28367,10 +29070,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceIntegration} -\index{FunctionSpaceIntegration!Domain} -\index{Domain!FunctionSpaceIntegration} -\index{FSINT} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceIntegration!Domain} +\index[pkg]{Domain!FunctionSpaceIntegration} +\index[pkg]{FSINT} +\begin{chunk}{defclass FunctionSpaceIntegrationType} (defclass |FunctionSpaceIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceIntegration") @@ -28380,7 +29083,7 @@ Value = NIL "Top-level real function integration" "FunctionSpaceIntegration provides functions for the" "indefinite integration of real-valued functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28394,10 +29097,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpacePrimitiveElement} -\index{FunctionSpacePrimitiveElement!Domain} -\index{Domain!FunctionSpacePrimitiveElement} -\index{FSPRMELT} -\begin{chunk}{sane} +\index[pkg]{FunctionSpacePrimitiveElement!Domain} +\index[pkg]{Domain!FunctionSpacePrimitiveElement} +\index[pkg]{FSPRMELT} +\begin{chunk}{defclass FunctionSpacePrimitiveElementType} (defclass |FunctionSpacePrimitiveElementType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpacePrimitiveElement") @@ -28406,7 +29109,7 @@ Value = NIL (comment :initform (list "FunctionsSpacePrimitiveElement provides functions to compute" "primitive elements in functions spaces")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28420,10 +29123,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceReduce} -\index{FunctionSpaceReduce!Domain} -\index{Domain!FunctionSpaceReduce} -\index{FSRED} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceReduce!Domain} +\index[pkg]{Domain!FunctionSpaceReduce} +\index[pkg]{FSRED} +\begin{chunk}{defclass FunctionSpaceReduceType} (defclass |FunctionSpaceReduceType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceReduce") @@ -28434,7 +29137,7 @@ Value = NIL "This package provides function which replaces transcendental kernels" "in a function space by random integers. The correspondence between" "the kernels and the integers is fixed between calls to new().")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28448,10 +29151,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceSum} -\index{FunctionSpaceSum!Domain} -\index{Domain!FunctionSpaceSum} -\index{SUMFS} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceSum!Domain} +\index[pkg]{Domain!FunctionSpaceSum} +\index[pkg]{SUMFS} +\begin{chunk}{defclass FunctionSpaceSumType} (defclass |FunctionSpaceSumType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceSum") @@ -28459,7 +29162,7 @@ Value = NIL (abbreviation :initform 'SUMFS) (comment :initform (list "Computes sums of top-level expressions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28473,10 +29176,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceToExponentialExpansion} -\index{FunctionSpaceToExponentialExpansion!Domain} -\index{Domain!FunctionSpaceToExponentialExpansion} -\index{FS2EXPXP} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceToExponentialExpansion!Domain} +\index[pkg]{Domain!FunctionSpaceToExponentialExpansion} +\index[pkg]{FS2EXPXP} +\begin{chunk}{defclass FunctionSpaceToExponentialExpansionType} (defclass |FunctionSpaceToExponentialExpansionType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceToExponentialExpansion") @@ -28485,7 +29188,7 @@ Value = NIL (comment :initform (list "This package converts expressions in some function space to exponential" "expansions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28499,10 +29202,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceToUnivariatePowerSeries} -\index{FunctionSpaceToUnivariatePowerSeries!Domain} -\index{Domain!FunctionSpaceToUnivariatePowerSeries} -\index{FS2UPS} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceToUnivariatePowerSeries!Domain} +\index[pkg]{Domain!FunctionSpaceToUnivariatePowerSeries} +\index[pkg]{FS2UPS} +\begin{chunk}{defclass FunctionSpaceToUnivariatePowerSeriesType} (defclass |FunctionSpaceToUnivariatePowerSeriesType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceToUnivariatePowerSeries") @@ -28515,7 +29218,7 @@ Value = NIL "whose coefficients do not contain the variable x. The function" "exprToGenUPS converts functional expressions to power series" "whose coefficients may involve functions of log(x).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28529,10 +29232,10 @@ Value = NIL \end{chunk} \subsection{FunctionSpaceUnivariatePolynomialFactor} -\index{FunctionSpaceUnivariatePolynomialFactor!Domain} -\index{Domain!FunctionSpaceUnivariatePolynomialFactor} -\index{FSUPFACT} -\begin{chunk}{sane} +\index[pkg]{FunctionSpaceUnivariatePolynomialFactor!Domain} +\index[pkg]{Domain!FunctionSpaceUnivariatePolynomialFactor} +\index[pkg]{FSUPFACT} +\begin{chunk}{defclass FunctionSpaceUnivariatePolynomialFactorType} (defclass |FunctionSpaceUnivariatePolynomialFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "FunctionSpaceUnivariatePolynomialFactor") @@ -28540,7 +29243,7 @@ Value = NIL (abbreviation :initform 'FSUPFACT) (comment :initform (list "This package is used internally by IR2F")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28556,10 +29259,10 @@ Value = NIL \section{G} \subsection{GaloisGroupFactorizationUtilities} -\index{GaloisGroupFactorizationUtilities!Domain} -\index{Domain!GaloisGroupFactorizationUtilities} -\index{GALFACTU} -\begin{chunk}{sane} +\index[pkg]{GaloisGroupFactorizationUtilities!Domain} +\index[pkg]{Domain!GaloisGroupFactorizationUtilities} +\index[pkg]{GALFACTU} +\begin{chunk}{defclass GaloisGroupFactorizationUtilitiesType} (defclass |GaloisGroupFactorizationUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "GaloisGroupFactorizationUtilities") @@ -28568,7 +29271,7 @@ Value = NIL (comment :initform (list "GaloisGroupFactorizationUtilities provides functions" "that will be used by the factorizer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28582,10 +29285,10 @@ Value = NIL \end{chunk} \subsection{GaloisGroupFactorizer} -\index{GaloisGroupFactorizer!Domain} -\index{Domain!GaloisGroupFactorizer} -\index{GALFACT} -\begin{chunk}{sane} +\index[pkg]{GaloisGroupFactorizer!Domain} +\index[pkg]{Domain!GaloisGroupFactorizer} +\index[pkg]{GALFACT} +\begin{chunk}{defclass GaloisGroupFactorizerType} (defclass |GaloisGroupFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "GaloisGroupFactorizer") @@ -28594,7 +29297,7 @@ Value = NIL (comment :initform (list "GaloisGroupFactorizationUtilities provides functions" "that will be used by the factorizer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28608,10 +29311,10 @@ Value = NIL \end{chunk} \subsection{GaloisGroupPolynomialUtilities} -\index{GaloisGroupPolynomialUtilities!Domain} -\index{Domain!GaloisGroupPolynomialUtilities} -\index{GALPOLYU} -\begin{chunk}{sane} +\index[pkg]{GaloisGroupPolynomialUtilities!Domain} +\index[pkg]{Domain!GaloisGroupPolynomialUtilities} +\index[pkg]{GALPOLYU} +\begin{chunk}{defclass GaloisGroupPolynomialUtilitiesType} (defclass |GaloisGroupPolynomialUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "GaloisGroupPolynomialUtilities") @@ -28621,7 +29324,7 @@ Value = NIL "GaloisGroupPolynomialUtilities provides useful" "functions for univariate polynomials which should be added to" "UnivariatePolynomialCategory or to Factored")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28635,10 +29338,10 @@ Value = NIL \end{chunk} \subsection{GaloisGroupUtilities} -\index{GaloisGroupUtilities!Domain} -\index{Domain!GaloisGroupUtilities} -\index{GALUTIL} -\begin{chunk}{sane} +\index[pkg]{GaloisGroupUtilities!Domain} +\index[pkg]{Domain!GaloisGroupUtilities} +\index[pkg]{GALUTIL} +\begin{chunk}{defclass GaloisGroupUtilitiesType} (defclass |GaloisGroupUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "GaloisGroupUtilities") @@ -28646,7 +29349,7 @@ Value = NIL (abbreviation :initform 'GALUTIL) (comment :initform (list "GaloisGroupUtilities provides several useful functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28660,10 +29363,10 @@ Value = NIL \end{chunk} \subsection{GaussianFactorizationPackage} -\index{GaussianFactorizationPackage!Domain} -\index{Domain!GaussianFactorizationPackage} -\index{GAUSSFAC} -\begin{chunk}{sane} +\index[pkg]{GaussianFactorizationPackage!Domain} +\index[pkg]{Domain!GaussianFactorizationPackage} +\index[pkg]{GAUSSFAC} +\begin{chunk}{defclass GaussianFactorizationPackageType} (defclass |GaussianFactorizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GaussianFactorizationPackage") @@ -28671,7 +29374,7 @@ Value = NIL (abbreviation :initform 'GAUSSFAC) (comment :initform (list "Package for the factorization of complex or gaussian integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28685,10 +29388,10 @@ Value = NIL \end{chunk} \subsection{GeneralHenselPackage} -\index{GeneralHenselPackage!Domain} -\index{Domain!GeneralHenselPackage} -\index{GHENSEL} -\begin{chunk}{sane} +\index[pkg]{GeneralHenselPackage!Domain} +\index[pkg]{Domain!GeneralHenselPackage} +\index[pkg]{GHENSEL} +\begin{chunk}{defclass GeneralHenselPackageType} (defclass |GeneralHenselPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GeneralHenselPackage") @@ -28696,7 +29399,7 @@ Value = NIL (abbreviation :initform 'GHENSEL) (comment :initform (list "Used for Factorization of bivariate polynomials over a finite field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28710,10 +29413,10 @@ Value = NIL \end{chunk} \subsection{GeneralizedMultivariateFactorize} -\index{GeneralizedMultivariateFactorize!Domain} -\index{Domain!GeneralizedMultivariateFactorize} -\index{GENMFACT} -\begin{chunk}{sane} +\index[pkg]{GeneralizedMultivariateFactorize!Domain} +\index[pkg]{Domain!GeneralizedMultivariateFactorize} +\index[pkg]{GENMFACT} +\begin{chunk}{defclass GeneralizedMultivariateFactorizeType} (defclass |GeneralizedMultivariateFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "GeneralizedMultivariateFactorize") @@ -28722,7 +29425,7 @@ Value = NIL (comment :initform (list "This is the top level package for doing multivariate factorization" "over basic domains like Integer or Fraction Integer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28736,10 +29439,10 @@ Value = NIL \end{chunk} \subsection{GeneralPackageForAlgebraicFunctionField} -\index{GeneralPackageForAlgebraicFunctionField!Domain} -\index{Domain!GeneralPackageForAlgebraicFunctionField} -\index{GPAFF} -\begin{chunk}{sane} +\index[pkg]{GeneralPackageForAlgebraicFunctionField!Domain} +\index[pkg]{Domain!GeneralPackageForAlgebraicFunctionField} +\index[pkg]{GPAFF} +\begin{chunk}{defclass GeneralPackageForAlgebraicFunctionFieldType} (defclass |GeneralPackageForAlgebraicFunctionFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "GeneralPackageForAlgebraicFunctionField") @@ -28748,7 +29451,7 @@ Value = NIL (comment :initform (list "A package that implements the Brill-Noether algorithm. Part of the" "PAFF package.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28762,17 +29465,17 @@ Value = NIL \end{chunk} \subsection{GeneralPolynomialGcdPackage} -\index{GeneralPolynomialGcdPackage!Domain} -\index{Domain!GeneralPolynomialGcdPackage} -\index{GENPGCD} -\begin{chunk}{sane} +\index[pkg]{GeneralPolynomialGcdPackage!Domain} +\index[pkg]{Domain!GeneralPolynomialGcdPackage} +\index[pkg]{GENPGCD} +\begin{chunk}{defclass GeneralPolynomialGcdPackageType} (defclass |GeneralPolynomialGcdPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GeneralPolynomialGcdPackage") (marker :initform 'package) (abbreviation :initform 'GENPGCD) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28786,10 +29489,10 @@ Value = NIL \end{chunk} \subsection{GenerateUnivariatePowerSeries} -\index{GenerateUnivariatePowerSeries!Domain} -\index{Domain!GenerateUnivariatePowerSeries} -\index{GENUPS} -\begin{chunk}{sane} +\index[pkg]{GenerateUnivariatePowerSeries!Domain} +\index[pkg]{Domain!GenerateUnivariatePowerSeries} +\index[pkg]{GENUPS} +\begin{chunk}{defclass GenerateUnivariatePowerSeriesType} (defclass |GenerateUnivariatePowerSeriesType| (|AxiomClass|) ((parents :initform ()) (name :initform "GenerateUnivariatePowerSeries") @@ -28798,7 +29501,7 @@ Value = NIL (comment :initform (list "GenerateUnivariatePowerSeries provides functions that create" "power series from explicit formulas for their nth coefficient.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28812,17 +29515,17 @@ Value = NIL \end{chunk} \subsection{GenExEuclid} -\index{GenExEuclid!Domain} -\index{Domain!GenExEuclid} -\index{GENEEZ} -\begin{chunk}{sane} +\index[pkg]{GenExEuclid!Domain} +\index[pkg]{Domain!GenExEuclid} +\index[pkg]{GENEEZ} +\begin{chunk}{defclass GenExEuclidType} (defclass |GenExEuclidType| (|AxiomClass|) ((parents :initform ()) (name :initform "GenExEuclid") (marker :initform 'package) (abbreviation :initform 'GENEEZ) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28836,10 +29539,10 @@ Value = NIL \end{chunk} \subsection{GenUFactorize} -\index{GenUFactorize!Domain} -\index{Domain!GenUFactorize} -\index{GENUFACT} -\begin{chunk}{sane} +\index[pkg]{GenUFactorize!Domain} +\index[pkg]{Domain!GenUFactorize} +\index[pkg]{GENUFACT} +\begin{chunk}{defclass GenUFactorizeType} (defclass |GenUFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "GenUFactorize") @@ -28850,7 +29553,7 @@ Value = NIL "of univariate polynomials with integer" "coefficients. The factorization is done by 'lifting' the" "finite 'berlekamp's factorization")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28864,10 +29567,10 @@ Value = NIL \end{chunk} \subsection{GenusZeroIntegration} -\index{GenusZeroIntegration!Domain} -\index{Domain!GenusZeroIntegration} -\index{INTG0} -\begin{chunk}{sane} +\index[pkg]{GenusZeroIntegration!Domain} +\index[pkg]{Domain!GenusZeroIntegration} +\index[pkg]{INTG0} +\begin{chunk}{defclass GenusZeroIntegrationType} (defclass |GenusZeroIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "GenusZeroIntegration") @@ -28881,7 +29584,7 @@ Value = NIL " f(x, y) = 0 where f has degree 1 in x" "The rationalization is done for integration, limited integration," "extended integration and the risch differential equation")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28895,10 +29598,10 @@ Value = NIL \end{chunk} \subsection{GnuDraw} -\index{GnuDraw!Domain} -\index{Domain!GnuDraw} -\index{GDRAW} -\begin{chunk}{sane} +\index[pkg]{GnuDraw!Domain} +\index[pkg]{Domain!GnuDraw} +\index[pkg]{GDRAW} +\begin{chunk}{defclass GnuDrawType} (defclass |GnuDrawType| (|AxiomClass|) ((parents :initform ()) (name :initform "GnuDraw") @@ -28910,7 +29613,7 @@ Value = NIL "processed directly by gnuplot. This is especially convenient" "in the axiom-wiki environment where gnuplot is called from" "LaTeX via gnuplottex.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28924,10 +29627,10 @@ Value = NIL \end{chunk} \subsection{GosperSummationMethod} -\index{GosperSummationMethod!Domain} -\index{Domain!GosperSummationMethod} -\index{GOSPER} -\begin{chunk}{sane} +\index[pkg]{GosperSummationMethod!Domain} +\index[pkg]{Domain!GosperSummationMethod} +\index[pkg]{GOSPER} +\begin{chunk}{defclass GosperSummationMethodType} (defclass |GosperSummationMethodType| (|AxiomClass|) ((parents :initform ()) (name :initform "GosperSummationMethod") @@ -28935,7 +29638,7 @@ Value = NIL (abbreviation :initform 'GOSPER) (comment :initform (list "Gosper's summation algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28949,10 +29652,10 @@ Value = NIL \end{chunk} \subsection{GraphicsDefaults} -\index{GraphicsDefaults!Domain} -\index{Domain!GraphicsDefaults} -\index{GRDEF} -\begin{chunk}{sane} +\index[pkg]{GraphicsDefaults!Domain} +\index[pkg]{Domain!GraphicsDefaults} +\index[pkg]{GRDEF} +\begin{chunk}{defclass GraphicsDefaultsType} (defclass |GraphicsDefaultsType| (|AxiomClass|) ((parents :initform ()) (name :initform "GraphicsDefaults") @@ -28961,7 +29664,7 @@ Value = NIL (comment :initform (list "TwoDimensionalPlotSettings sets global flags and constants" "for 2-dimensional plotting.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -28975,10 +29678,10 @@ Value = NIL \end{chunk} \subsection{Graphviz} -\index{Graphviz!Domain} -\index{Domain!Graphviz} -\index{GRAPHVIZ} -\begin{chunk}{sane} +\index[pkg]{Graphviz!Domain} +\index[pkg]{Domain!Graphviz} +\index[pkg]{GRAPHVIZ} +\begin{chunk}{defclass GraphvizType} (defclass |GraphvizType| (|AxiomClass|) ((parents :initform ()) (name :initform "Graphviz") @@ -28986,7 +29689,7 @@ Value = NIL (abbreviation :initform 'GRAPHVIZ) (comment :initform (list "Low level tools for creating and viewing graphs using graphviz")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29000,10 +29703,10 @@ Value = NIL \end{chunk} \subsection{GrayCode} -\index{GrayCode!Domain} -\index{Domain!GrayCode} -\index{GRAY} -\begin{chunk}{sane} +\index[pkg]{GrayCode!Domain} +\index[pkg]{Domain!GrayCode} +\index[pkg]{GRAY} +\begin{chunk}{defclass GrayCodeType} (defclass |GrayCodeType| (|AxiomClass|) ((parents :initform ()) (name :initform "GrayCode") @@ -29013,7 +29716,7 @@ Value = NIL "GrayCode provides a function for efficiently running" "through all subsets of a finite set, only changing one element" "by another one.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29027,10 +29730,10 @@ Value = NIL \end{chunk} \subsection{GroebnerFactorizationPackage} -\index{GroebnerFactorizationPackage!Domain} -\index{Domain!GroebnerFactorizationPackage} -\index{GBF} -\begin{chunk}{sane} +\index[pkg]{GroebnerFactorizationPackage!Domain} +\index[pkg]{Domain!GroebnerFactorizationPackage} +\index[pkg]{GBF} +\begin{chunk}{defclass GroebnerFactorizationPackageType} (defclass |GroebnerFactorizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GroebnerFactorizationPackage") @@ -29054,7 +29757,7 @@ Value = NIL "DistributedMultivariatePolynomial," "HomogeneousDistributedMultivariatePolynomial," "GeneralDistributedMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29068,10 +29771,10 @@ Value = NIL \end{chunk} \subsection{GroebnerInternalPackage} -\index{GroebnerInternalPackage!Domain} -\index{Domain!GroebnerInternalPackage} -\index{GBINTERN} -\begin{chunk}{sane} +\index[pkg]{GroebnerInternalPackage!Domain} +\index[pkg]{Domain!GroebnerInternalPackage} +\index[pkg]{GBINTERN} +\begin{chunk}{defclass GroebnerInternalPackageType} (defclass |GroebnerInternalPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GroebnerInternalPackage") @@ -29079,7 +29782,7 @@ Value = NIL (abbreviation :initform 'GBINTERN) (comment :initform (list "This package provides low level tools for Groebner basis computations")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29093,10 +29796,10 @@ Value = NIL \end{chunk} \subsection{GroebnerPackage} -\index{GroebnerPackage!Domain} -\index{Domain!GroebnerPackage} -\index{GB} -\begin{chunk}{sane} +\index[pkg]{GroebnerPackage!Domain} +\index[pkg]{Domain!GroebnerPackage} +\index[pkg]{GB} +\begin{chunk}{defclass GroebnerPackageType} (defclass |GroebnerPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "GroebnerPackage") @@ -29119,7 +29822,7 @@ Value = NIL "DistributedMultivariatePolynomial," "HomogeneousDistributedMultivariatePolynomial," "GeneralDistributedMultivariatePolynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29133,10 +29836,10 @@ Value = NIL \end{chunk} \subsection{GroebnerSolve} -\index{GroebnerSolve!Domain} -\index{Domain!GroebnerSolve} -\index{GROEBSOL} -\begin{chunk}{sane} +\index[pkg]{GroebnerSolve!Domain} +\index[pkg]{Domain!GroebnerSolve} +\index[pkg]{GROEBSOL} +\begin{chunk}{defclass GroebnerSolveType} (defclass |GroebnerSolveType| (|AxiomClass|) ((parents :initform ()) (name :initform "GroebnerSolve") @@ -29146,7 +29849,7 @@ Value = NIL "Solve systems of polynomial equations using Groebner bases" "Total order Groebner bases are computed and then converted to lex ones" "This package is mostly intended for internal use.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29160,10 +29863,10 @@ Value = NIL \end{chunk} \subsection{Guess} -\index{Guess!Domain} -\index{Domain!Guess} -\index{GUESS} -\begin{chunk}{sane} +\index[pkg]{Guess!Domain} +\index[pkg]{Domain!Guess} +\index[pkg]{GUESS} +\begin{chunk}{defclass GuessType} (defclass |GuessType| (|AxiomClass|) ((parents :initform ()) (name :initform "Guess") @@ -29173,7 +29876,7 @@ Value = NIL "This package implements guessing of sequences. Packages for the" "most common cases are provided as GuessInteger," "GuessPolynomial, etc.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29187,10 +29890,10 @@ Value = NIL \end{chunk} \subsection{GuessAlgebraicNumber} -\index{GuessAlgebraicNumber!Domain} -\index{Domain!GuessAlgebraicNumber} -\index{GUESSAN} -\begin{chunk}{sane} +\index[pkg]{GuessAlgebraicNumber!Domain} +\index[pkg]{Domain!GuessAlgebraicNumber} +\index[pkg]{GUESSAN} +\begin{chunk}{defclass GuessAlgebraicNumberType} (defclass |GuessAlgebraicNumberType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessAlgebraicNumber") @@ -29198,7 +29901,7 @@ Value = NIL (abbreviation :initform 'GUESSAN) (comment :initform (list "This package exports guessing of sequences of rational functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29212,10 +29915,10 @@ Value = NIL \end{chunk} \subsection{GuessFinite} -\index{GuessFinite!Domain} -\index{Domain!GuessFinite} -\index{GUESSF} -\begin{chunk}{sane} +\index[pkg]{GuessFinite!Domain} +\index[pkg]{Domain!GuessFinite} +\index[pkg]{GUESSF} +\begin{chunk}{defclass GuessFiniteType} (defclass |GuessFiniteType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessFinite") @@ -29223,7 +29926,7 @@ Value = NIL (abbreviation :initform 'GUESSF) (comment :initform (list "This package exports guessing of sequences of numbers in a finite field")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29237,10 +29940,10 @@ Value = NIL \end{chunk} \subsection{GuessFiniteFunctions} -\index{GuessFiniteFunctions!Domain} -\index{Domain!GuessFiniteFunctions} -\index{GUESSF1} -\begin{chunk}{sane} +\index[pkg]{GuessFiniteFunctions!Domain} +\index[pkg]{Domain!GuessFiniteFunctions} +\index[pkg]{GUESSF1} +\begin{chunk}{defclass GuessFiniteFunctionsType} (defclass |GuessFiniteFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessFiniteFunctions") @@ -29248,7 +29951,7 @@ Value = NIL (abbreviation :initform 'GUESSF1) (comment :initform (list "This package exports guessing of sequences of numbers in a finite field")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29262,10 +29965,10 @@ Value = NIL \end{chunk} \subsection{GuessInteger} -\index{GuessInteger!Domain} -\index{Domain!GuessInteger} -\index{GUESSINT} -\begin{chunk}{sane} +\index[pkg]{GuessInteger!Domain} +\index[pkg]{Domain!GuessInteger} +\index[pkg]{GUESSINT} +\begin{chunk}{defclass GuessIntegerType} (defclass |GuessIntegerType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessInteger") @@ -29273,7 +29976,7 @@ Value = NIL (abbreviation :initform 'GUESSINT) (comment :initform (list "This package exports guessing of sequences of rational numbers")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29287,10 +29990,10 @@ Value = NIL \end{chunk} \subsection{GuessPolynomial} -\index{GuessPolynomial!Domain} -\index{Domain!GuessPolynomial} -\index{GUESSP} -\begin{chunk}{sane} +\index[pkg]{GuessPolynomial!Domain} +\index[pkg]{Domain!GuessPolynomial} +\index[pkg]{GUESSP} +\begin{chunk}{defclass GuessPolynomialType} (defclass |GuessPolynomialType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessPolynomial") @@ -29298,7 +30001,7 @@ Value = NIL (abbreviation :initform 'GUESSP) (comment :initform (list "This package exports guessing of sequences of rational functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29312,10 +30015,10 @@ Value = NIL \end{chunk} \subsection{GuessUnivariatePolynomial} -\index{GuessUnivariatePolynomial!Domain} -\index{Domain!GuessUnivariatePolynomial} -\index{GUESSUP} -\begin{chunk}{sane} +\index[pkg]{GuessUnivariatePolynomial!Domain} +\index[pkg]{Domain!GuessUnivariatePolynomial} +\index[pkg]{GUESSUP} +\begin{chunk}{defclass GuessUnivariatePolynomialType} (defclass |GuessUnivariatePolynomialType| (|AxiomClass|) ((parents :initform ()) (name :initform "GuessUnivariatePolynomial") @@ -29323,7 +30026,7 @@ Value = NIL (abbreviation :initform 'GUESSUP) (comment :initform (list "This package exports guessing of sequences of univariate rational functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29339,10 +30042,10 @@ Value = NIL \section{H} \subsection{HallBasis} -\index{HallBasis!Domain} -\index{Domain!HallBasis} -\index{HB} -\begin{chunk}{sane} +\index[pkg]{HallBasis!Domain} +\index[pkg]{Domain!HallBasis} +\index[pkg]{HB} +\begin{chunk}{defclass HallBasisType} (defclass |HallBasisType| (|AxiomClass|) ((parents :initform ()) (name :initform "HallBasis") @@ -29353,7 +30056,7 @@ Value = NIL "generators over a ring R with identity up to basic commutators" "of length c using the algorithm of P. Hall as given in Serre's" "book Lie Groups -- Lie Algebras")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29367,10 +30070,10 @@ Value = NIL \end{chunk} \subsection{HeuGcd} -\index{HeuGcd!Domain} -\index{Domain!HeuGcd} -\index{HEUGCD} -\begin{chunk}{sane} +\index[pkg]{HeuGcd!Domain} +\index[pkg]{Domain!HeuGcd} +\index[pkg]{HEUGCD} +\begin{chunk}{defclass HeuGcdType} (defclass |HeuGcdType| (|AxiomClass|) ((parents :initform ()) (name :initform "HeuGcd") @@ -29379,7 +30082,7 @@ Value = NIL (comment :initform (list "This package provides the functions for the heuristic integer gcd." "Geddes's algorithm,for univariate polynomials with integer coefficients")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29395,10 +30098,10 @@ Value = NIL \section{I} \subsection{IdealDecompositionPackage} -\index{IdealDecompositionPackage!Domain} -\index{Domain!IdealDecompositionPackage} -\index{IDECOMP} -\begin{chunk}{sane} +\index[pkg]{IdealDecompositionPackage!Domain} +\index[pkg]{Domain!IdealDecompositionPackage} +\index[pkg]{IDECOMP} +\begin{chunk}{defclass IdealDecompositionPackageType} (defclass |IdealDecompositionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "IdealDecompositionPackage") @@ -29409,7 +30112,7 @@ Value = NIL "polynomial ideals over the rational numbers. The ideals are members" "of the PolynomialIdeals domain, and the polynomial generators are" "required to be from the DistributedMultivariatePolynomial domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29423,10 +30126,10 @@ Value = NIL \end{chunk} \subsection{IncrementingMaps} -\index{IncrementingMaps!Domain} -\index{Domain!IncrementingMaps} -\index{INCRMAPS} -\begin{chunk}{sane} +\index[pkg]{IncrementingMaps!Domain} +\index[pkg]{Domain!IncrementingMaps} +\index[pkg]{INCRMAPS} +\begin{chunk}{defclass IncrementingMapsType} (defclass |IncrementingMapsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IncrementingMaps") @@ -29434,7 +30137,7 @@ Value = NIL (abbreviation :initform 'INCRMAPS) (comment :initform (list "This package provides operations to create incrementing functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29448,10 +30151,10 @@ Value = NIL \end{chunk} \subsection{InfiniteProductCharacteristicZero} -\index{InfiniteProductCharacteristicZero!Domain} -\index{Domain!InfiniteProductCharacteristicZero} -\index{INFPROD0} -\begin{chunk}{sane} +\index[pkg]{InfiniteProductCharacteristicZero!Domain} +\index[pkg]{Domain!InfiniteProductCharacteristicZero} +\index[pkg]{INFPROD0} +\begin{chunk}{defclass InfiniteProductCharacteristicZeroType} (defclass |InfiniteProductCharacteristicZeroType| (|AxiomClass|) ((parents :initform ()) (name :initform "InfiniteProductCharacteristicZero") @@ -29460,7 +30163,7 @@ Value = NIL (comment :initform (list "This package computes infinite products of univariate Taylor series" "over an integral domain of characteristic 0.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29474,10 +30177,10 @@ Value = NIL \end{chunk} \subsection{InfiniteProductFiniteField} -\index{InfiniteProductFiniteField!Domain} -\index{Domain!InfiniteProductFiniteField} -\index{INPRODFF} -\begin{chunk}{sane} +\index[pkg]{InfiniteProductFiniteField!Domain} +\index[pkg]{Domain!InfiniteProductFiniteField} +\index[pkg]{INPRODFF} +\begin{chunk}{defclass InfiniteProductFiniteFieldType} (defclass |InfiniteProductFiniteFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "InfiniteProductFiniteField") @@ -29486,7 +30189,7 @@ Value = NIL (comment :initform (list "This package computes infinite products of univariate Taylor series" "over an arbitrary finite field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29500,10 +30203,10 @@ Value = NIL \end{chunk} \subsection{InfiniteProductPrimeField} -\index{InfiniteProductPrimeField!Domain} -\index{Domain!InfiniteProductPrimeField} -\index{INPRODPF} -\begin{chunk}{sane} +\index[pkg]{InfiniteProductPrimeField!Domain} +\index[pkg]{Domain!InfiniteProductPrimeField} +\index[pkg]{INPRODPF} +\begin{chunk}{defclass InfiniteProductPrimeFieldType} (defclass |InfiniteProductPrimeFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "InfiniteProductPrimeField") @@ -29512,7 +30215,7 @@ Value = NIL (comment :initform (list "This package computes infinite products of univariate Taylor series" "over a field of prime order.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29526,10 +30229,10 @@ Value = NIL \end{chunk} \subsection{InfiniteTupleFunctions2} -\index{InfiniteTupleFunctions2!Domain} -\index{Domain!InfiniteTupleFunctions2} -\index{ITFUN2} -\begin{chunk}{sane} +\index[pkg]{InfiniteTupleFunctions2!Domain} +\index[pkg]{Domain!InfiniteTupleFunctions2} +\index[pkg]{ITFUN2} +\begin{chunk}{defclass InfiniteTupleFunctions2Type} (defclass |InfiniteTupleFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "InfiniteTupleFunctions2") @@ -29537,7 +30240,7 @@ Value = NIL (abbreviation :initform 'ITFUN2) (comment :initform (list "Functions defined on streams with entries in two sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29551,10 +30254,10 @@ Value = NIL \end{chunk} \subsection{InfiniteTupleFunctions3} -\index{InfiniteTupleFunctions3!Domain} -\index{Domain!InfiniteTupleFunctions3} -\index{ITFUN3} -\begin{chunk}{sane} +\index[pkg]{InfiniteTupleFunctions3!Domain} +\index[pkg]{Domain!InfiniteTupleFunctions3} +\index[pkg]{ITFUN3} +\begin{chunk}{defclass InfiniteTupleFunctions3Type} (defclass |InfiniteTupleFunctions3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "InfiniteTupleFunctions3") @@ -29562,7 +30265,7 @@ Value = NIL (abbreviation :initform 'ITFUN3) (comment :initform (list "Functions defined on streams with entries in two sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29576,10 +30279,10 @@ Value = NIL \end{chunk} \subsection{Infinity} -\index{Infinity!Domain} -\index{Domain!Infinity} -\index{INFINITY} -\begin{chunk}{sane} +\index[pkg]{Infinity!Domain} +\index[pkg]{Domain!Infinity} +\index[pkg]{INFINITY} +\begin{chunk}{defclass InfinityType} (defclass |InfinityType| (|AxiomClass|) ((parents :initform ()) (name :initform "Infinity") @@ -29587,7 +30290,7 @@ Value = NIL (abbreviation :initform 'INFINITY) (comment :initform (list "Default infinity signatures for the interpreter")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29601,10 +30304,10 @@ Value = NIL \end{chunk} \subsection{InnerAlgFactor} -\index{InnerAlgFactor!Domain} -\index{Domain!InnerAlgFactor} -\index{IALGFACT} -\begin{chunk}{sane} +\index[pkg]{InnerAlgFactor!Domain} +\index[pkg]{Domain!InnerAlgFactor} +\index[pkg]{IALGFACT} +\begin{chunk}{defclass InnerAlgFactorType} (defclass |InnerAlgFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerAlgFactor") @@ -29614,7 +30317,7 @@ Value = NIL "Factorisation in a simple algebraic extension" "Factorization of univariate polynomials with coefficients in an" "algebraic extension of a field over which we can factor UP's")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29628,10 +30331,10 @@ Value = NIL \end{chunk} \subsection{InnerCommonDenominator} -\index{InnerCommonDenominator!Domain} -\index{Domain!InnerCommonDenominator} -\index{ICDEN} -\begin{chunk}{sane} +\index[pkg]{InnerCommonDenominator!Domain} +\index[pkg]{Domain!InnerCommonDenominator} +\index[pkg]{ICDEN} +\begin{chunk}{defclass InnerCommonDenominatorType} (defclass |InnerCommonDenominatorType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerCommonDenominator") @@ -29641,7 +30344,7 @@ Value = NIL "InnerCommonDenominator provides functions to compute" "the common denominator of a finite linear aggregate of elements" "of the quotient field of an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29655,10 +30358,10 @@ Value = NIL \end{chunk} \subsection{InnerMatrixLinearAlgebraFunctions} -\index{InnerMatrixLinearAlgebraFunctions!Domain} -\index{Domain!InnerMatrixLinearAlgebraFunctions} -\index{IMATLIN} -\begin{chunk}{sane} +\index[pkg]{InnerMatrixLinearAlgebraFunctions!Domain} +\index[pkg]{Domain!InnerMatrixLinearAlgebraFunctions} +\index[pkg]{IMATLIN} +\begin{chunk}{defclass InnerMatrixLinearAlgebraFunctionsType} (defclass |InnerMatrixLinearAlgebraFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerMatrixLinearAlgebraFunctions") @@ -29668,7 +30371,7 @@ Value = NIL "InnerMatrixLinearAlgebraFunctions is an internal package" "which provides standard linear algebra functions on domains in" "MatrixCategory")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29682,10 +30385,10 @@ Value = NIL \end{chunk} \subsection{InnerMatrixQuotientFieldFunctions} -\index{InnerMatrixQuotientFieldFunctions!Domain} -\index{Domain!InnerMatrixQuotientFieldFunctions} -\index{IMATQF} -\begin{chunk}{sane} +\index[pkg]{InnerMatrixQuotientFieldFunctions!Domain} +\index[pkg]{Domain!InnerMatrixQuotientFieldFunctions} +\index[pkg]{IMATQF} +\begin{chunk}{defclass InnerMatrixQuotientFieldFunctionsType} (defclass |InnerMatrixQuotientFieldFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerMatrixQuotientFieldFunctions") @@ -29696,7 +30399,7 @@ Value = NIL "over an integral domain which involve the quotient field of that integral" "domain. The functions rowEchelon and inverse return matrices with" "entries in the quotient field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29710,10 +30413,10 @@ Value = NIL \end{chunk} \subsection{InnerModularGcd} -\index{InnerModularGcd!Domain} -\index{Domain!InnerModularGcd} -\index{INMODGCD} -\begin{chunk}{sane} +\index[pkg]{InnerModularGcd!Domain} +\index[pkg]{Domain!InnerModularGcd} +\index[pkg]{INMODGCD} +\begin{chunk}{defclass InnerModularGcdType} (defclass |InnerModularGcdType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerModularGcd") @@ -29725,7 +30428,7 @@ Value = NIL "non-trivial euclidean domain (not a field)." "The package parametrised by the coefficient domain," "the polynomial domain, a prime, and a function for choosing the next prime")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29739,10 +30442,10 @@ Value = NIL \end{chunk} \subsection{InnerMultFact} -\index{InnerMultFact!Domain} -\index{Domain!InnerMultFact} -\index{INNMFACT} -\begin{chunk}{sane} +\index[pkg]{InnerMultFact!Domain} +\index[pkg]{Domain!InnerMultFact} +\index[pkg]{INNMFACT} +\begin{chunk}{defclass InnerMultFactType} (defclass |InnerMultFactType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerMultFact") @@ -29754,7 +30457,7 @@ Value = NIL "The univariate factor operation is passed as a parameter." "Multivariate hensel lifting is used to lift the univariate" "factorization")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29768,10 +30471,10 @@ Value = NIL \end{chunk} \subsection{InnerNormalBasisFieldFunctions} -\index{InnerNormalBasisFieldFunctions!Domain} -\index{Domain!InnerNormalBasisFieldFunctions} -\index{INBFF} -\begin{chunk}{sane} +\index[pkg]{InnerNormalBasisFieldFunctions!Domain} +\index[pkg]{Domain!InnerNormalBasisFieldFunctions} +\index[pkg]{INBFF} +\begin{chunk}{defclass InnerNormalBasisFieldFunctionsType} (defclass |InnerNormalBasisFieldFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerNormalBasisFieldFunctions") @@ -29781,7 +30484,7 @@ Value = NIL "InnerNormalBasisFieldFunctions(GF) (unexposed)" "This package has functions used by" "every normal basis finite field extension domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29795,10 +30498,10 @@ Value = NIL \end{chunk} \subsection{InnerNumericEigenPackage} -\index{InnerNumericEigenPackage!Domain} -\index{Domain!InnerNumericEigenPackage} -\index{INEP} -\begin{chunk}{sane} +\index[pkg]{InnerNumericEigenPackage!Domain} +\index[pkg]{Domain!InnerNumericEigenPackage} +\index[pkg]{INEP} +\begin{chunk}{defclass InnerNumericEigenPackageType} (defclass |InnerNumericEigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerNumericEigenPackage") @@ -29808,7 +30511,7 @@ Value = NIL "This package is the inner package to be used by NumericRealEigenPackage" "and NumericComplexEigenPackage for the computation of numeric" "eigenvalues and eigenvectors.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29822,10 +30525,10 @@ Value = NIL \end{chunk} \subsection{InnerNumericFloatSolvePackage} -\index{InnerNumericFloatSolvePackage!Domain} -\index{Domain!InnerNumericFloatSolvePackage} -\index{INFSP} -\begin{chunk}{sane} +\index[pkg]{InnerNumericFloatSolvePackage!Domain} +\index[pkg]{Domain!InnerNumericFloatSolvePackage} +\index[pkg]{INFSP} +\begin{chunk}{defclass InnerNumericFloatSolvePackageType} (defclass |InnerNumericFloatSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerNumericFloatSolvePackage") @@ -29842,7 +30545,7 @@ Value = NIL "Complex(Fraction Integer). The last parameter specifies the type" "of the precision operand and must be either Fraction(Integer) or" "Float.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29856,10 +30559,10 @@ Value = NIL \end{chunk} \subsection{InnerPolySign} -\index{InnerPolySign!Domain} -\index{Domain!InnerPolySign} -\index{INPSIGN} -\begin{chunk}{sane} +\index[pkg]{InnerPolySign!Domain} +\index[pkg]{Domain!InnerPolySign} +\index[pkg]{INPSIGN} +\begin{chunk}{defclass InnerPolySignType} (defclass |InnerPolySignType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerPolySign") @@ -29867,7 +30570,7 @@ Value = NIL (abbreviation :initform 'INPSIGN) (comment :initform (list "Find the sign of a polynomial around a point or infinity.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29881,10 +30584,10 @@ Value = NIL \end{chunk} \subsection{InnerPolySum} -\index{InnerPolySum!Domain} -\index{Domain!InnerPolySum} -\index{ISUMP} -\begin{chunk}{sane} +\index[pkg]{InnerPolySum!Domain} +\index[pkg]{Domain!InnerPolySum} +\index[pkg]{ISUMP} +\begin{chunk}{defclass InnerPolySumType} (defclass |InnerPolySumType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerPolySum") @@ -29892,7 +30595,7 @@ Value = NIL (abbreviation :initform 'ISUMP) (comment :initform (list "Tools for the summation packages of polynomials")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29906,10 +30609,10 @@ Value = NIL \end{chunk} \subsection{InnerTrigonometricManipulations} -\index{InnerTrigonometricManipulations!Domain} -\index{Domain!InnerTrigonometricManipulations} -\index{ITRIGMNP} -\begin{chunk}{sane} +\index[pkg]{InnerTrigonometricManipulations!Domain} +\index[pkg]{Domain!InnerTrigonometricManipulations} +\index[pkg]{ITRIGMNP} +\begin{chunk}{defclass InnerTrigonometricManipulationsType} (defclass |InnerTrigonometricManipulationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "InnerTrigonometricManipulations") @@ -29919,7 +30622,7 @@ Value = NIL "This package provides transformations from trigonometric functions" "to exponentials and logarithms, and back." "F and FG should be the same type of function space.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29933,10 +30636,10 @@ Value = NIL \end{chunk} \subsection{InputFormFunctions1} -\index{InputFormFunctions1!Domain} -\index{Domain!InputFormFunctions1} -\index{INFORM1} -\begin{chunk}{sane} +\index[pkg]{InputFormFunctions1!Domain} +\index[pkg]{Domain!InputFormFunctions1} +\index[pkg]{INFORM1} +\begin{chunk}{defclass InputFormFunctions1Type} (defclass |InputFormFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "InputFormFunctions1") @@ -29944,7 +30647,7 @@ Value = NIL (abbreviation :initform 'INFORM1) (comment :initform (list "Tools for manipulating input forms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29958,10 +30661,10 @@ Value = NIL \end{chunk} \subsection{InterfaceGroebnerPackage} -\index{InterfaceGroebnerPackage!Domain} -\index{Domain!InterfaceGroebnerPackage} -\index{INTERGB} -\begin{chunk}{sane} +\index[pkg]{InterfaceGroebnerPackage!Domain} +\index[pkg]{Domain!InterfaceGroebnerPackage} +\index[pkg]{INTERGB} +\begin{chunk}{defclass InterfaceGroebnerPackageType} (defclass |InterfaceGroebnerPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InterfaceGroebnerPackage") @@ -29969,7 +30672,7 @@ Value = NIL (abbreviation :initform 'INTERGB) (comment :initform (list "Part of the Package for Algebraic Function Fields in one variable PAFF")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -29983,10 +30686,10 @@ Value = NIL \end{chunk} \subsection{IntegerBits} -\index{IntegerBits!Domain} -\index{Domain!IntegerBits} -\index{INTBIT} -\begin{chunk}{sane} +\index[pkg]{IntegerBits!Domain} +\index[pkg]{Domain!IntegerBits} +\index[pkg]{INTBIT} +\begin{chunk}{defclass IntegerBitsType} (defclass |IntegerBitsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerBits") @@ -29994,7 +30697,7 @@ Value = NIL (abbreviation :initform 'INTBIT) (comment :initform (list "This package provides functions to lookup bits in integers ")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30008,10 +30711,10 @@ Value = NIL \end{chunk} \subsection{IntegerCombinatoricFunctions} -\index{IntegerCombinatoricFunctions!Domain} -\index{Domain!IntegerCombinatoricFunctions} -\index{COMBINAT} -\begin{chunk}{sane} +\index[pkg]{IntegerCombinatoricFunctions!Domain} +\index[pkg]{Domain!IntegerCombinatoricFunctions} +\index[pkg]{COMBINAT} +\begin{chunk}{defclass IntegerCombinatoricFunctionsType} (defclass |IntegerCombinatoricFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerCombinatoricFunctions") @@ -30020,7 +30723,7 @@ Value = NIL (comment :initform (list "The IntegerCombinatoricFunctions package provides some" "standard functions in combinatorics.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30034,10 +30737,10 @@ Value = NIL \end{chunk} \subsection{IntegerFactorizationPackage} -\index{IntegerFactorizationPackage!Domain} -\index{Domain!IntegerFactorizationPackage} -\index{INTFACT} -\begin{chunk}{sane} +\index[pkg]{IntegerFactorizationPackage!Domain} +\index[pkg]{Domain!IntegerFactorizationPackage} +\index[pkg]{INTFACT} +\begin{chunk}{defclass IntegerFactorizationPackageType} (defclass |IntegerFactorizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerFactorizationPackage") @@ -30050,7 +30753,7 @@ Value = NIL "rho method. Because Pollards method may fail, the result" "of factor may contain composite factors. We should also employ" "Lenstra's eliptic curve method.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30064,10 +30767,10 @@ Value = NIL \end{chunk} \subsection{IntegerLinearDependence} -\index{IntegerLinearDependence!Domain} -\index{Domain!IntegerLinearDependence} -\index{ZLINDEP} -\begin{chunk}{sane} +\index[pkg]{IntegerLinearDependence!Domain} +\index[pkg]{Domain!IntegerLinearDependence} +\index[pkg]{ZLINDEP} +\begin{chunk}{defclass IntegerLinearDependenceType} (defclass |IntegerLinearDependenceType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerLinearDependence") @@ -30075,7 +30778,7 @@ Value = NIL (abbreviation :initform 'ZLINDEP) (comment :initform (list "Test for linear dependence over the integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30089,10 +30792,10 @@ Value = NIL \end{chunk} \subsection{IntegerNumberTheoryFunctions} -\index{IntegerNumberTheoryFunctions!Domain} -\index{Domain!IntegerNumberTheoryFunctions} -\index{INTHEORY} -\begin{chunk}{sane} +\index[pkg]{IntegerNumberTheoryFunctions!Domain} +\index[pkg]{Domain!IntegerNumberTheoryFunctions} +\index[pkg]{INTHEORY} +\begin{chunk}{defclass IntegerNumberTheoryFunctionsType} (defclass |IntegerNumberTheoryFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerNumberTheoryFunctions") @@ -30100,7 +30803,7 @@ Value = NIL (abbreviation :initform 'INTHEORY) (comment :initform (list "This package provides various number theoretic functions on the integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30114,10 +30817,10 @@ Value = NIL \end{chunk} \subsection{IntegerPrimesPackage} -\index{IntegerPrimesPackage!Domain} -\index{Domain!IntegerPrimesPackage} -\index{PRIMES} -\begin{chunk}{sane} +\index[pkg]{IntegerPrimesPackage!Domain} +\index[pkg]{Domain!IntegerPrimesPackage} +\index[pkg]{PRIMES} +\begin{chunk}{defclass IntegerPrimesPackageType} (defclass |IntegerPrimesPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerPrimesPackage") @@ -30128,7 +30831,7 @@ Value = NIL "Rabin's probabilistic" "primality test and the utility functions nextPrime," "prevPrime and primes.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30142,10 +30845,10 @@ Value = NIL \end{chunk} \subsection{IntegerRetractions} -\index{IntegerRetractions!Domain} -\index{Domain!IntegerRetractions} -\index{INTRET} -\begin{chunk}{sane} +\index[pkg]{IntegerRetractions!Domain} +\index[pkg]{Domain!IntegerRetractions} +\index[pkg]{INTRET} +\begin{chunk}{defclass IntegerRetractionsType} (defclass |IntegerRetractionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerRetractions") @@ -30153,7 +30856,7 @@ Value = NIL (abbreviation :initform 'INTRET) (comment :initform (list "Provides integer testing and retraction functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30167,10 +30870,10 @@ Value = NIL \end{chunk} \subsection{IntegerRoots} -\index{IntegerRoots!Domain} -\index{Domain!IntegerRoots} -\index{IROOT} -\begin{chunk}{sane} +\index[pkg]{IntegerRoots!Domain} +\index[pkg]{Domain!IntegerRoots} +\index[pkg]{IROOT} +\begin{chunk}{defclass IntegerRootsType} (defclass |IntegerRootsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerRoots") @@ -30179,7 +30882,7 @@ Value = NIL (comment :initform (list "The IntegerRoots package computes square roots and" "nth roots of integers efficiently.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30193,10 +30896,10 @@ Value = NIL \end{chunk} \subsection{IntegerSolveLinearPolynomialEquation} -\index{IntegerSolveLinearPolynomialEquation!Domain} -\index{Domain!IntegerSolveLinearPolynomialEquation} -\index{INTSLPE} -\begin{chunk}{sane} +\index[pkg]{IntegerSolveLinearPolynomialEquation!Domain} +\index[pkg]{Domain!IntegerSolveLinearPolynomialEquation} +\index[pkg]{INTSLPE} +\begin{chunk}{defclass IntegerSolveLinearPolynomialEquationType} (defclass |IntegerSolveLinearPolynomialEquationType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegerSolveLinearPolynomialEquation") @@ -30207,7 +30910,7 @@ Value = NIL "solveLinearPolynomialEquation" "operation over the integers. It uses a lifting technique" "from the package GenExEuclid")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30221,10 +30924,10 @@ Value = NIL \end{chunk} \subsection{IntegralBasisTools} -\index{IntegralBasisTools!Domain} -\index{Domain!IntegralBasisTools} -\index{IBATOOL} -\begin{chunk}{sane} +\index[pkg]{IntegralBasisTools!Domain} +\index[pkg]{Domain!IntegralBasisTools} +\index[pkg]{IBATOOL} +\begin{chunk}{defclass IntegralBasisToolsType} (defclass |IntegralBasisToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegralBasisTools") @@ -30233,7 +30936,7 @@ Value = NIL (comment :initform (list "This package contains functions used in the packages" "FunctionFieldIntegralBasis and NumberFieldIntegralBasis.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30247,10 +30950,10 @@ Value = NIL \end{chunk} \subsection{IntegralBasisPolynomialTools} -\index{IntegralBasisPolynomialTools!Domain} -\index{Domain!IntegralBasisPolynomialTools} -\index{IBPTOOLS} -\begin{chunk}{sane} +\index[pkg]{IntegralBasisPolynomialTools!Domain} +\index[pkg]{Domain!IntegralBasisPolynomialTools} +\index[pkg]{IBPTOOLS} +\begin{chunk}{defclass IntegralBasisPolynomialToolsType} (defclass |IntegralBasisPolynomialToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegralBasisPolynomialTools") @@ -30259,7 +30962,7 @@ Value = NIL (comment :initform (list "IntegralBasisPolynomialTools provides functions for mapping functions" "on the coefficients of univariate and bivariate polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30273,10 +30976,10 @@ Value = NIL \end{chunk} \subsection{IntegrationResultFunctions2} -\index{IntegrationResultFunctions2!Domain} -\index{Domain!IntegrationResultFunctions2} -\index{IR2} -\begin{chunk}{sane} +\index[pkg]{IntegrationResultFunctions2!Domain} +\index[pkg]{Domain!IntegrationResultFunctions2} +\index[pkg]{IR2} +\begin{chunk}{defclass IntegrationResultFunctions2Type} (defclass |IntegrationResultFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegrationResultFunctions2") @@ -30284,7 +30987,7 @@ Value = NIL (abbreviation :initform 'IR2) (comment :initform (list "Internally used by the integration packages")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30298,10 +31001,10 @@ Value = NIL \end{chunk} \subsection{IntegrationResultRFToFunction} -\index{IntegrationResultRFToFunction!Domain} -\index{Domain!IntegrationResultRFToFunction} -\index{IRRF2F} -\begin{chunk}{sane} +\index[pkg]{IntegrationResultRFToFunction!Domain} +\index[pkg]{Domain!IntegrationResultRFToFunction} +\index[pkg]{IRRF2F} +\begin{chunk}{defclass IntegrationResultRFToFunctionType} (defclass |IntegrationResultRFToFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegrationResultRFToFunction") @@ -30312,7 +31015,7 @@ Value = NIL "This package allows a sum of logs over the roots of a polynomial" "to be expressed as explicit logarithms and arc tangents, provided" "that the indexing polynomial can be factored into quadratics.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30326,10 +31029,10 @@ Value = NIL \end{chunk} \subsection{IntegrationResultToFunction} -\index{IntegrationResultToFunction!Domain} -\index{Domain!IntegrationResultToFunction} -\index{IR2F} -\begin{chunk}{sane} +\index[pkg]{IntegrationResultToFunction!Domain} +\index[pkg]{Domain!IntegrationResultToFunction} +\index[pkg]{IR2F} +\begin{chunk}{defclass IntegrationResultToFunctionType} (defclass |IntegrationResultToFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegrationResultToFunction") @@ -30340,7 +31043,7 @@ Value = NIL "This package allows a sum of logs over the roots of a polynomial" "to be expressed as explicit logarithms and arc tangents, provided" "that the indexing polynomial can be factored into quadratics.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30354,10 +31057,10 @@ Value = NIL \end{chunk} \subsection{IntegrationTools} -\index{IntegrationTools!Domain} -\index{Domain!IntegrationTools} -\index{INTTOOLS} -\begin{chunk}{sane} +\index[pkg]{IntegrationTools!Domain} +\index[pkg]{Domain!IntegrationTools} +\index[pkg]{INTTOOLS} +\begin{chunk}{defclass IntegrationToolsType} (defclass |IntegrationToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntegrationTools") @@ -30365,7 +31068,7 @@ Value = NIL (abbreviation :initform 'INTTOOLS) (comment :initform (list "Tools for the integrator")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30379,10 +31082,10 @@ Value = NIL \end{chunk} \subsection{InternalPrintPackage} -\index{InternalPrintPackage!Domain} -\index{Domain!InternalPrintPackage} -\index{IPRNTPK} -\begin{chunk}{sane} +\index[pkg]{InternalPrintPackage!Domain} +\index[pkg]{Domain!InternalPrintPackage} +\index[pkg]{IPRNTPK} +\begin{chunk}{defclass InternalPrintPackageType} (defclass |InternalPrintPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InternalPrintPackage") @@ -30390,7 +31093,7 @@ Value = NIL (abbreviation :initform 'IPRNTPK) (comment :initform (list "A package to print strings without line-feed nor carriage-return.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30404,17 +31107,17 @@ Value = NIL \end{chunk} \subsection{InternalRationalUnivariateRepresentationPackage} -\index{InternalRationalUnivariateRepresentationPackage!Domain} -\index{Domain!InternalRationalUnivariateRepresentationPackage} -\index{IRURPK} -\begin{chunk}{sane} +\index[pkg]{InternalRationalUnivariateRepresentationPackage!Domain} +\index[pkg]{Domain!InternalRationalUnivariateRepresentationPackage} +\index[pkg]{IRURPK} +\begin{chunk}{defclass InternalRationalUnivariateRepresentationPackageType} (defclass |InternalRationalUnivariateRepresentationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InternalRationalUnivariateRepresentationPackage") (marker :initform 'package) (abbreviation :initform 'IRURPK) (comment :initform nil) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30428,10 +31131,10 @@ Value = NIL \end{chunk} \subsection{InterpolateFormsPackage} -\index{InterpolateFormsPackage!Domain} -\index{Domain!InterpolateFormsPackage} -\index{INTFRSP} -\begin{chunk}{sane} +\index[pkg]{InterpolateFormsPackage!Domain} +\index[pkg]{Domain!InterpolateFormsPackage} +\index[pkg]{INTFRSP} +\begin{chunk}{defclass InterpolateFormsPackageType} (defclass |InterpolateFormsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "InterpolateFormsPackage") @@ -30439,7 +31142,7 @@ Value = NIL (abbreviation :initform 'INTFRSP) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30453,10 +31156,10 @@ Value = NIL \end{chunk} \subsection{IntersectionDivisorPackage} -\index{IntersectionDivisorPackage!Domain} -\index{Domain!IntersectionDivisorPackage} -\index{INTDIVP} -\begin{chunk}{sane} +\index[pkg]{IntersectionDivisorPackage!Domain} +\index[pkg]{Domain!IntersectionDivisorPackage} +\index[pkg]{INTDIVP} +\begin{chunk}{defclass IntersectionDivisorPackageType} (defclass |IntersectionDivisorPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "IntersectionDivisorPackage") @@ -30464,7 +31167,7 @@ Value = NIL (abbreviation :initform 'INTDIVP) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30478,10 +31181,10 @@ Value = NIL \end{chunk} \subsection{IrredPolyOverFiniteField} -\index{IrredPolyOverFiniteField!Domain} -\index{Domain!IrredPolyOverFiniteField} -\index{IRREDFFX} -\begin{chunk}{sane} +\index[pkg]{IrredPolyOverFiniteField!Domain} +\index[pkg]{Domain!IrredPolyOverFiniteField} +\index[pkg]{IRREDFFX} +\begin{chunk}{defclass IrredPolyOverFiniteFieldType} (defclass |IrredPolyOverFiniteFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "IrredPolyOverFiniteField") @@ -30490,7 +31193,7 @@ Value = NIL (comment :initform (list "This package exports the function generateIrredPoly that computes" "a monic irreducible polynomial of degree n over a finite field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30504,10 +31207,10 @@ Value = NIL \end{chunk} \subsection{IrrRepSymNatPackage} -\index{IrrRepSymNatPackage!Domain} -\index{Domain!IrrRepSymNatPackage} -\index{IRSN} -\begin{chunk}{sane} +\index[pkg]{IrrRepSymNatPackage!Domain} +\index[pkg]{Domain!IrrRepSymNatPackage} +\index[pkg]{IRSN} +\begin{chunk}{defclass IrrRepSymNatPackageType} (defclass |IrrRepSymNatPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "IrrRepSymNatPackage") @@ -30522,7 +31225,7 @@ Value = NIL "example, [3,3,3,1] labels an irreducible representation for n equals 10." "Note that whenever a List Integer appears in a signature," "a partition required.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30536,10 +31239,10 @@ Value = NIL \end{chunk} \subsection{InverseLaplaceTransform} -\index{InverseLaplaceTransform!Domain} -\index{Domain!InverseLaplaceTransform} -\index{INVLAPLA} -\begin{chunk}{sane} +\index[pkg]{InverseLaplaceTransform!Domain} +\index[pkg]{Domain!InverseLaplaceTransform} +\index[pkg]{INVLAPLA} +\begin{chunk}{defclass InverseLaplaceTransformType} (defclass |InverseLaplaceTransformType| (|AxiomClass|) ((parents :initform ()) (name :initform "InverseLaplaceTransform") @@ -30547,7 +31250,7 @@ Value = NIL (abbreviation :initform 'INVLAPLA) (comment :initform (list "This package computes the inverse Laplace Transform.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30563,10 +31266,10 @@ Value = NIL \section{K} \subsection{KernelFunctions2} -\index{KernelFunctions2!Domain} -\index{Domain!KernelFunctions2} -\index{KERNEL2} -\begin{chunk}{sane} +\index[pkg]{KernelFunctions2!Domain} +\index[pkg]{Domain!KernelFunctions2} +\index[pkg]{KERNEL2} +\begin{chunk}{defclass KernelFunctions2Type} (defclass |KernelFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "KernelFunctions2") @@ -30574,7 +31277,7 @@ Value = NIL (abbreviation :initform 'KERNEL2) (comment :initform (list "This package exports some auxiliary functions on kernels")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30588,10 +31291,10 @@ Value = NIL \end{chunk} \subsection{Kovacic} -\index{Kovacic!Domain} -\index{Domain!Kovacic} -\index{KOVACIC} -\begin{chunk}{sane} +\index[pkg]{Kovacic!Domain} +\index[pkg]{Domain!Kovacic} +\index[pkg]{KOVACIC} +\begin{chunk}{defclass KovacicType} (defclass |KovacicType| (|AxiomClass|) ((parents :initform ()) (name :initform "Kovacic") @@ -30601,7 +31304,7 @@ Value = NIL "Kovacic provides a modified Kovacic's algorithm for" "solving explicitely irreducible 2nd order linear ordinary" "differential equations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30617,10 +31320,10 @@ Value = NIL \section{L} \subsection{LaplaceTransform} -\index{LaplaceTransform!Domain} -\index{Domain!LaplaceTransform} -\index{LAPLACE} -\begin{chunk}{sane} +\index[pkg]{LaplaceTransform!Domain} +\index[pkg]{Domain!LaplaceTransform} +\index[pkg]{LAPLACE} +\begin{chunk}{defclass LaplaceTransformType} (defclass |LaplaceTransformType| (|AxiomClass|) ((parents :initform ()) (name :initform "LaplaceTransform") @@ -30628,7 +31331,7 @@ Value = NIL (abbreviation :initform 'LAPLACE) (comment :initform (list "This package computes the forward Laplace Transform.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30642,10 +31345,10 @@ Value = NIL \end{chunk} \subsection{LazardSetSolvingPackage} -\index{LazardSetSolvingPackage!Domain} -\index{Domain!LazardSetSolvingPackage} -\index{LAZM3PK} -\begin{chunk}{sane} +\index[pkg]{LazardSetSolvingPackage!Domain} +\index[pkg]{Domain!LazardSetSolvingPackage} +\index[pkg]{LAZM3PK} +\begin{chunk}{defclass LazardSetSolvingPackageType} (defclass |LazardSetSolvingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LazardSetSolvingPackage") @@ -30660,7 +31363,7 @@ Value = NIL "However, only zero-dimensional regular sets are normalized, since" "normalization may be time consumming in positive dimension." "The decomposition process is that of [2].")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30674,10 +31377,10 @@ Value = NIL \end{chunk} \subsection{LeadingCoefDetermination} -\index{LeadingCoefDetermination!Domain} -\index{Domain!LeadingCoefDetermination} -\index{LEADCDET} -\begin{chunk}{sane} +\index[pkg]{LeadingCoefDetermination!Domain} +\index[pkg]{Domain!LeadingCoefDetermination} +\index[pkg]{LEADCDET} +\begin{chunk}{defclass LeadingCoefDeterminationType} (defclass |LeadingCoefDeterminationType| (|AxiomClass|) ((parents :initform ()) (name :initform "LeadingCoefDetermination") @@ -30686,7 +31389,7 @@ Value = NIL (comment :initform (list "Package for leading coefficient determination in the lifting step." "Package working for every R euclidean with property 'F'.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30700,10 +31403,10 @@ Value = NIL \end{chunk} \subsection{LexTriangularPackage} -\index{LexTriangularPackage!Domain} -\index{Domain!LexTriangularPackage} -\index{LEXTRIPK} -\begin{chunk}{sane} +\index[pkg]{LexTriangularPackage!Domain} +\index[pkg]{Domain!LexTriangularPackage} +\index[pkg]{LEXTRIPK} +\begin{chunk}{defclass LexTriangularPackageType} (defclass |LexTriangularPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LexTriangularPackage") @@ -30722,7 +31425,7 @@ Value = NIL "With the squareFreeLexTriangular operation all multiciplities are removed." "With the other operation some multiciplities may remain. Both operations" "admit an optional argument to produce normalized triangular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30736,10 +31439,10 @@ Value = NIL \end{chunk} \subsection{LinearDependence} -\index{LinearDependence!Domain} -\index{Domain!LinearDependence} -\index{LINDEP} -\begin{chunk}{sane} +\index[pkg]{LinearDependence!Domain} +\index[pkg]{Domain!LinearDependence} +\index[pkg]{LINDEP} +\begin{chunk}{defclass LinearDependenceType} (defclass |LinearDependenceType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearDependence") @@ -30747,7 +31450,7 @@ Value = NIL (abbreviation :initform 'LINDEP) (comment :initform (list "Test for linear dependence.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30761,10 +31464,10 @@ Value = NIL \end{chunk} \subsection{LinearOrdinaryDifferentialOperatorFactorizer} -\index{LinearOrdinaryDifferentialOperatorFactorizer!Domain} -\index{Domain!LinearOrdinaryDifferentialOperatorFactorizer} -\index{LODOF} -\begin{chunk}{sane} +\index[pkg]{LinearOrdinaryDifferentialOperatorFactorizer!Domain} +\index[pkg]{Domain!LinearOrdinaryDifferentialOperatorFactorizer} +\index[pkg]{LODOF} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperatorFactorizerType} (defclass |LinearOrdinaryDifferentialOperatorFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearOrdinaryDifferentialOperatorFactorizer") @@ -30774,7 +31477,7 @@ Value = NIL "LinearOrdinaryDifferentialOperatorFactorizer provides a" "factorizer for linear ordinary differential operators whose coefficients" "are rational functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30788,10 +31491,10 @@ Value = NIL \end{chunk} \subsection{LinearOrdinaryDifferentialOperatorsOps} -\index{LinearOrdinaryDifferentialOperatorsOps!Domain} -\index{Domain!LinearOrdinaryDifferentialOperatorsOps} -\index{LODOOPS} -\begin{chunk}{sane} +\index[pkg]{LinearOrdinaryDifferentialOperatorsOps!Domain} +\index[pkg]{Domain!LinearOrdinaryDifferentialOperatorsOps} +\index[pkg]{LODOOPS} +\begin{chunk}{defclass LinearOrdinaryDifferentialOperatorsOpsType} (defclass |LinearOrdinaryDifferentialOperatorsOpsType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearOrdinaryDifferentialOperatorsOps") @@ -30800,7 +31503,7 @@ Value = NIL (comment :initform (list "LinearOrdinaryDifferentialOperatorsOps provides symmetric" "products and sums for linear ordinary differential operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30814,10 +31517,10 @@ Value = NIL \end{chunk} \subsection{LinearPolynomialEquationByFractions} -\index{LinearPolynomialEquationByFractions!Domain} -\index{Domain!LinearPolynomialEquationByFractions} -\index{LPEFRAC} -\begin{chunk}{sane} +\index[pkg]{LinearPolynomialEquationByFractions!Domain} +\index[pkg]{Domain!LinearPolynomialEquationByFractions} +\index[pkg]{LPEFRAC} +\begin{chunk}{defclass LinearPolynomialEquationByFractionsType} (defclass |LinearPolynomialEquationByFractionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearPolynomialEquationByFractions") @@ -30828,7 +31531,7 @@ Value = NIL "provides a defaulting rule for the solveLinearPolynomialEquation" "operation, by moving into the field of fractions, and solving it there" "via the multiEuclidean operation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30842,10 +31545,10 @@ Value = NIL \end{chunk} \subsection{LinearSystemFromPowerSeriesPackage} -\index{LinearSystemFromPowerSeriesPackage!Domain} -\index{Domain!LinearSystemFromPowerSeriesPackage} -\index{LISYSER} -\begin{chunk}{sane} +\index[pkg]{LinearSystemFromPowerSeriesPackage!Domain} +\index[pkg]{Domain!LinearSystemFromPowerSeriesPackage} +\index[pkg]{LISYSER} +\begin{chunk}{defclass LinearSystemFromPowerSeriesPackageType} (defclass |LinearSystemFromPowerSeriesPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearSystemFromPowerSeriesPackage") @@ -30853,7 +31556,7 @@ Value = NIL (abbreviation :initform 'LISYSER) (comment :initform (list "Part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30867,10 +31570,10 @@ Value = NIL \end{chunk} \subsection{LinearSystemMatrixPackage} -\index{LinearSystemMatrixPackage!Domain} -\index{Domain!LinearSystemMatrixPackage} -\index{LSMP} -\begin{chunk}{sane} +\index[pkg]{LinearSystemMatrixPackage!Domain} +\index[pkg]{Domain!LinearSystemMatrixPackage} +\index[pkg]{LSMP} +\begin{chunk}{defclass LinearSystemMatrixPackageType} (defclass |LinearSystemMatrixPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearSystemMatrixPackage") @@ -30878,7 +31581,7 @@ Value = NIL (abbreviation :initform 'LSMP) (comment :initform (list "This package solves linear system in the matrix form AX = B.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30892,10 +31595,10 @@ Value = NIL \end{chunk} \subsection{LinearSystemMatrixPackage1} -\index{LinearSystemMatrixPackage1!Domain} -\index{Domain!LinearSystemMatrixPackage1} -\index{LSMP1} -\begin{chunk}{sane} +\index[pkg]{LinearSystemMatrixPackage1!Domain} +\index[pkg]{Domain!LinearSystemMatrixPackage1} +\index[pkg]{LSMP1} +\begin{chunk}{defclass LinearSystemMatrixPackage1Type} (defclass |LinearSystemMatrixPackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearSystemMatrixPackage1") @@ -30907,7 +31610,7 @@ Value = NIL "LinearSystemMatrixPackage for Matrix and Vector. This" "package's existence makes it easier to use solve in the" "AXIOM interpreter.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30921,10 +31624,10 @@ Value = NIL \end{chunk} \subsection{LinearSystemPolynomialPackage} -\index{LinearSystemPolynomialPackage!Domain} -\index{Domain!LinearSystemPolynomialPackage} -\index{LSPP} -\begin{chunk}{sane} +\index[pkg]{LinearSystemPolynomialPackage!Domain} +\index[pkg]{Domain!LinearSystemPolynomialPackage} +\index[pkg]{LSPP} +\begin{chunk}{defclass LinearSystemPolynomialPackageType} (defclass |LinearSystemPolynomialPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinearSystemPolynomialPackage") @@ -30933,7 +31636,7 @@ Value = NIL (comment :initform (list "This package finds the solutions of linear systems presented as a" "list of polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30947,10 +31650,10 @@ Value = NIL \end{chunk} \subsection{LinGroebnerPackage} -\index{LinGroebnerPackage!Domain} -\index{Domain!LinGroebnerPackage} -\index{LGROBP} -\begin{chunk}{sane} +\index[pkg]{LinGroebnerPackage!Domain} +\index[pkg]{Domain!LinGroebnerPackage} +\index[pkg]{LGROBP} +\begin{chunk}{defclass LinGroebnerPackageType} (defclass |LinGroebnerPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinGroebnerPackage") @@ -30961,7 +31664,7 @@ Value = NIL "a zero-dimensional ideal I, compute" "a Groebner basis with respect to the lexicographical ordering by using" "linear algebra.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -30975,10 +31678,10 @@ Value = NIL \end{chunk} \subsection{LinesOpPack} -\index{LinesOpPack!Domain} -\index{Domain!LinesOpPack} -\index{LOP} -\begin{chunk}{sane} +\index[pkg]{LinesOpPack!Domain} +\index[pkg]{Domain!LinesOpPack} +\index[pkg]{LOP} +\begin{chunk}{defclass LinesOpPackType} (defclass |LinesOpPackType| (|AxiomClass|) ((parents :initform ()) (name :initform "LinesOpPack") @@ -30987,7 +31690,7 @@ Value = NIL (comment :initform (list "A package that exports several linear algebra operations over lines" "of matrices. Part of the PAFF package.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31001,10 +31704,10 @@ Value = NIL \end{chunk} \subsection{LiouvillianFunction} -\index{LiouvillianFunction!Domain} -\index{Domain!LiouvillianFunction} -\index{LF} -\begin{chunk}{sane} +\index[pkg]{LiouvillianFunction!Domain} +\index[pkg]{Domain!LiouvillianFunction} +\index[pkg]{LF} +\begin{chunk}{defclass LiouvillianFunctionType} (defclass |LiouvillianFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "LiouvillianFunction") @@ -31012,7 +31715,7 @@ Value = NIL (abbreviation :initform 'LF) (comment :initform (list "This package provides liouvillian functions over an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31026,10 +31729,10 @@ Value = NIL \end{chunk} \subsection{ListFunctions2} -\index{ListFunctions2!Domain} -\index{Domain!ListFunctions2} -\index{LIST2} -\begin{chunk}{sane} +\index[pkg]{ListFunctions2!Domain} +\index[pkg]{Domain!ListFunctions2} +\index[pkg]{LIST2} +\begin{chunk}{defclass ListFunctions2Type} (defclass |ListFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ListFunctions2") @@ -31039,7 +31742,7 @@ Value = NIL "ListFunctions2 implements utility functions that" "operate on two kinds of lists, each with a possibly different" "type of element.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31053,10 +31756,10 @@ Value = NIL \end{chunk} \subsection{ListFunctions3} -\index{ListFunctions3!Domain} -\index{Domain!ListFunctions3} -\index{LIST3} -\begin{chunk}{sane} +\index[pkg]{ListFunctions3!Domain} +\index[pkg]{Domain!ListFunctions3} +\index[pkg]{LIST3} +\begin{chunk}{defclass ListFunctions3Type} (defclass |ListFunctions3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ListFunctions3") @@ -31066,7 +31769,7 @@ Value = NIL "ListFunctions3 implements utility functions that" "operate on three kinds of lists, each with a possibly different" "type of element.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31080,10 +31783,10 @@ Value = NIL \end{chunk} \subsection{ListToMap} -\index{ListToMap!Domain} -\index{Domain!ListToMap} -\index{LIST2MAP} -\begin{chunk}{sane} +\index[pkg]{ListToMap!Domain} +\index[pkg]{Domain!ListToMap} +\index[pkg]{LIST2MAP} +\begin{chunk}{defclass ListToMapType} (defclass |ListToMapType| (|AxiomClass|) ((parents :initform ()) (name :initform "ListToMap") @@ -31097,7 +31800,7 @@ Value = NIL "default function can be specified to be used when x" "does not appear in the first list. In the absence of defaults," "an error will occur in that case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31111,10 +31814,10 @@ Value = NIL \end{chunk} \subsection{LocalParametrizationOfSimplePointPackage} -\index{LocalParametrizationOfSimplePointPackage!Domain} -\index{Domain!LocalParametrizationOfSimplePointPackage} -\index{LPARSPT} -\begin{chunk}{sane} +\index[pkg]{LocalParametrizationOfSimplePointPackage!Domain} +\index[pkg]{Domain!LocalParametrizationOfSimplePointPackage} +\index[pkg]{LPARSPT} +\begin{chunk}{defclass LocalParametrizationOfSimplePointPackageType} (defclass |LocalParametrizationOfSimplePointPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "LocalParametrizationOfSimplePointPackage") @@ -31122,7 +31825,7 @@ Value = NIL (abbreviation :initform 'LPARSPT) (comment :initform (list "This package is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31138,10 +31841,10 @@ Value = NIL \section{M} \subsection{MakeBinaryCompiledFunction} -\index{MakeBinaryCompiledFunction!Domain} -\index{Domain!MakeBinaryCompiledFunction} -\index{MKBCFUNC} -\begin{chunk}{sane} +\index[pkg]{MakeBinaryCompiledFunction!Domain} +\index[pkg]{Domain!MakeBinaryCompiledFunction} +\index[pkg]{MKBCFUNC} +\begin{chunk}{defclass MakeBinaryCompiledFunctionType} (defclass |MakeBinaryCompiledFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "MakeBinaryCompiledFunction") @@ -31150,7 +31853,7 @@ Value = NIL (comment :initform (list "Tools and transforms for making compiled functions from" "top-level expressions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31164,10 +31867,10 @@ Value = NIL \end{chunk} \subsection{MakeFloatCompiledFunction} -\index{MakeFloatCompiledFunction!Domain} -\index{Domain!MakeFloatCompiledFunction} -\index{MKFLCFN} -\begin{chunk}{sane} +\index[pkg]{MakeFloatCompiledFunction!Domain} +\index[pkg]{Domain!MakeFloatCompiledFunction} +\index[pkg]{MKFLCFN} +\begin{chunk}{defclass MakeFloatCompiledFunctionType} (defclass |MakeFloatCompiledFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "MakeFloatCompiledFunction") @@ -31179,7 +31882,7 @@ Value = NIL "compiled Lisp functions whose arguments are Lisp floats." "This by-passes the Axiom compiler and interpreter," "thereby gaining several orders of magnitude.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31193,10 +31896,10 @@ Value = NIL \end{chunk} \subsection{MakeFunction} -\index{MakeFunction!Domain} -\index{Domain!MakeFunction} -\index{MKFUNC} -\begin{chunk}{sane} +\index[pkg]{MakeFunction!Domain} +\index[pkg]{Domain!MakeFunction} +\index[pkg]{MKFUNC} +\begin{chunk}{defclass MakeFunctionType} (defclass |MakeFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "MakeFunction") @@ -31205,7 +31908,7 @@ Value = NIL (comment :initform (list "Tools for making interpreter functions from top-level expressions" "Transforms top-level objects into interpreter functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31219,10 +31922,10 @@ Value = NIL \end{chunk} \subsection{MakeRecord} -\index{MakeRecord!Domain} -\index{Domain!MakeRecord} -\index{MKRECORD} -\begin{chunk}{sane} +\index[pkg]{MakeRecord!Domain} +\index[pkg]{Domain!MakeRecord} +\index[pkg]{MKRECORD} +\begin{chunk}{defclass MakeRecordType} (defclass |MakeRecordType| (|AxiomClass|) ((parents :initform ()) (name :initform "MakeRecord") @@ -31231,7 +31934,7 @@ Value = NIL (comment :initform (list "MakeRecord is used internally by the interpreter to create record" "types which are used for doing parallel iterations on streams.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31245,10 +31948,10 @@ Value = NIL \end{chunk} \subsection{MakeUnaryCompiledFunction} -\index{MakeUnaryCompiledFunction!Domain} -\index{Domain!MakeUnaryCompiledFunction} -\index{MKUCFUNC} -\begin{chunk}{sane} +\index[pkg]{MakeUnaryCompiledFunction!Domain} +\index[pkg]{Domain!MakeUnaryCompiledFunction} +\index[pkg]{MKUCFUNC} +\begin{chunk}{defclass MakeUnaryCompiledFunctionType} (defclass |MakeUnaryCompiledFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "MakeUnaryCompiledFunction") @@ -31257,7 +31960,7 @@ Value = NIL (comment :initform (list "Tools for making compiled functions from top-level expressions" "Transforms top-level objects into compiled functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31271,10 +31974,10 @@ Value = NIL \end{chunk} \subsection{MappingPackageInternalHacks1} -\index{MappingPackageInternalHacks1!Domain} -\index{Domain!MappingPackageInternalHacks1} -\index{MAPHACK1} -\begin{chunk}{sane} +\index[pkg]{MappingPackageInternalHacks1!Domain} +\index[pkg]{Domain!MappingPackageInternalHacks1} +\index[pkg]{MAPHACK1} +\begin{chunk}{defclass MappingPackageInternalHacks1Type} (defclass |MappingPackageInternalHacks1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackageInternalHacks1") @@ -31282,7 +31985,7 @@ Value = NIL (abbreviation :initform 'MAPHACK1) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31296,10 +31999,10 @@ Value = NIL \end{chunk} \subsection{MappingPackageInternalHacks2} -\index{MappingPackageInternalHacks2!Domain} -\index{Domain!MappingPackageInternalHacks2} -\index{MAPHACK2} -\begin{chunk}{sane} +\index[pkg]{MappingPackageInternalHacks2!Domain} +\index[pkg]{Domain!MappingPackageInternalHacks2} +\index[pkg]{MAPHACK2} +\begin{chunk}{defclass MappingPackageInternalHacks2Type} (defclass |MappingPackageInternalHacks2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackageInternalHacks2") @@ -31307,7 +32010,7 @@ Value = NIL (abbreviation :initform 'MAPHACK2) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31321,10 +32024,10 @@ Value = NIL \end{chunk} \subsection{MappingPackageInternalHacks3} -\index{MappingPackageInternalHacks3!Domain} -\index{Domain!MappingPackageInternalHacks3} -\index{MAPHACK3} -\begin{chunk}{sane} +\index[pkg]{MappingPackageInternalHacks3!Domain} +\index[pkg]{Domain!MappingPackageInternalHacks3} +\index[pkg]{MAPHACK3} +\begin{chunk}{defclass MappingPackageInternalHacks3Type} (defclass |MappingPackageInternalHacks3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackageInternalHacks3") @@ -31332,7 +32035,7 @@ Value = NIL (abbreviation :initform 'MAPHACK3) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31346,10 +32049,10 @@ Value = NIL \end{chunk} \subsection{MappingPackage1} -\index{MappingPackage1!Domain} -\index{Domain!MappingPackage1} -\index{MAPPKG1} -\begin{chunk}{sane} +\index[pkg]{MappingPackage1!Domain} +\index[pkg]{Domain!MappingPackage1} +\index[pkg]{MAPPKG1} +\begin{chunk}{defclass MappingPackage1Type} (defclass |MappingPackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackage1") @@ -31357,7 +32060,7 @@ Value = NIL (abbreviation :initform 'MAPPKG1) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31371,10 +32074,10 @@ Value = NIL \end{chunk} \subsection{MappingPackage2} -\index{MappingPackage2!Domain} -\index{Domain!MappingPackage2} -\index{MAPPKG2} -\begin{chunk}{sane} +\index[pkg]{MappingPackage2!Domain} +\index[pkg]{Domain!MappingPackage2} +\index[pkg]{MAPPKG2} +\begin{chunk}{defclass MappingPackage2Type} (defclass |MappingPackage2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackage2") @@ -31382,7 +32085,7 @@ Value = NIL (abbreviation :initform 'MAPPKG2) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31396,10 +32099,10 @@ Value = NIL \end{chunk} \subsection{MappingPackage3} -\index{MappingPackage3!Domain} -\index{Domain!MappingPackage3} -\index{MAPPKG3} -\begin{chunk}{sane} +\index[pkg]{MappingPackage3!Domain} +\index[pkg]{Domain!MappingPackage3} +\index[pkg]{MAPPKG3} +\begin{chunk}{defclass MappingPackage3Type} (defclass |MappingPackage3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackage3") @@ -31407,7 +32110,7 @@ Value = NIL (abbreviation :initform 'MAPPKG3) (comment :initform (list "Various Currying operations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31421,10 +32124,10 @@ Value = NIL \end{chunk} \subsection{MappingPackage4} -\index{MappingPackage4!Domain} -\index{Domain!MappingPackage4} -\index{MAPPKG4} -\begin{chunk}{sane} +\index[pkg]{MappingPackage4!Domain} +\index[pkg]{Domain!MappingPackage4} +\index[pkg]{MAPPKG4} +\begin{chunk}{defclass MappingPackage4Type} (defclass |MappingPackage4Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MappingPackage4") @@ -31433,7 +32136,7 @@ Value = NIL (comment :initform (list "Functional Composition." "Given functions f and g, returns the applicable closure")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31447,10 +32150,10 @@ Value = NIL \end{chunk} \subsection{MatrixCategoryFunctions2} -\index{MatrixCategoryFunctions2!Domain} -\index{Domain!MatrixCategoryFunctions2} -\index{MATCAT2} -\begin{chunk}{sane} +\index[pkg]{MatrixCategoryFunctions2!Domain} +\index[pkg]{Domain!MatrixCategoryFunctions2} +\index[pkg]{MATCAT2} +\begin{chunk}{defclass MatrixCategoryFunctions2Type} (defclass |MatrixCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MatrixCategoryFunctions2") @@ -31459,7 +32162,7 @@ Value = NIL (comment :initform (list "MatrixCategoryFunctions2 provides functions between two matrix" "domains. The functions provided are map and reduce.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31473,10 +32176,10 @@ Value = NIL \end{chunk} \subsection{MatrixCommonDenominator} -\index{MatrixCommonDenominator!Domain} -\index{Domain!MatrixCommonDenominator} -\index{MCDEN} -\begin{chunk}{sane} +\index[pkg]{MatrixCommonDenominator!Domain} +\index[pkg]{Domain!MatrixCommonDenominator} +\index[pkg]{MCDEN} +\begin{chunk}{defclass MatrixCommonDenominatorType} (defclass |MatrixCommonDenominatorType| (|AxiomClass|) ((parents :initform ()) (name :initform "MatrixCommonDenominator") @@ -31486,7 +32189,7 @@ Value = NIL "MatrixCommonDenominator provides functions to" "compute the common denominator of a matrix of elements of the" "quotient field of an integral domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31500,10 +32203,10 @@ Value = NIL \end{chunk} \subsection{MatrixLinearAlgebraFunctions} -\index{MatrixLinearAlgebraFunctions!Domain} -\index{Domain!MatrixLinearAlgebraFunctions} -\index{MATLIN} -\begin{chunk}{sane} +\index[pkg]{MatrixLinearAlgebraFunctions!Domain} +\index[pkg]{Domain!MatrixLinearAlgebraFunctions} +\index[pkg]{MATLIN} +\begin{chunk}{defclass MatrixLinearAlgebraFunctionsType} (defclass |MatrixLinearAlgebraFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "MatrixLinearAlgebraFunctions") @@ -31512,7 +32215,7 @@ Value = NIL (comment :initform (list "MatrixLinearAlgebraFunctions provides functions to compute" "inverses and canonical forms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31526,10 +32229,10 @@ Value = NIL \end{chunk} \subsection{MatrixManipulation} -\index{MatrixManipulation!Domain} -\index{Domain!MatrixManipulation} -\index{MAMA} -\begin{chunk}{sane} +\index[pkg]{MatrixManipulation!Domain} +\index[pkg]{Domain!MatrixManipulation} +\index[pkg]{MAMA} +\begin{chunk}{defclass MatrixManipulationType} (defclass |MatrixManipulationType| (|AxiomClass|) ((parents :initform ()) (name :initform "MatrixManipulation") @@ -31540,7 +32243,7 @@ Value = NIL "Supported are various kinds of slicing, splitting and stacking of" "matrices. The functions resemble operations often used in numerical" "linear algebra algorithms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31554,10 +32257,10 @@ Value = NIL \end{chunk} \subsection{MergeThing} -\index{MergeThing!Domain} -\index{Domain!MergeThing} -\index{MTHING} -\begin{chunk}{sane} +\index[pkg]{MergeThing!Domain} +\index[pkg]{Domain!MergeThing} +\index[pkg]{MTHING} +\begin{chunk}{defclass MergeThingType} (defclass |MergeThingType| (|AxiomClass|) ((parents :initform ()) (name :initform "MergeThing") @@ -31565,7 +32268,7 @@ Value = NIL (abbreviation :initform 'MTHING) (comment :initform (list "This package exports tools for merging lists")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31579,10 +32282,10 @@ Value = NIL \end{chunk} \subsection{MeshCreationRoutinesForThreeDimensions} -\index{MeshCreationRoutinesForThreeDimensions!Domain} -\index{Domain!MeshCreationRoutinesForThreeDimensions} -\index{MESH} -\begin{chunk}{sane} +\index[pkg]{MeshCreationRoutinesForThreeDimensions!Domain} +\index[pkg]{Domain!MeshCreationRoutinesForThreeDimensions} +\index[pkg]{MESH} +\begin{chunk}{defclass MeshCreationRoutinesForThreeDimensionsType} (defclass |MeshCreationRoutinesForThreeDimensionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "MeshCreationRoutinesForThreeDimensions") @@ -31590,7 +32293,7 @@ Value = NIL (abbreviation :initform 'MESH) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31604,10 +32307,10 @@ Value = NIL \end{chunk} \subsection{ModularDistinctDegreeFactorizer} -\index{ModularDistinctDegreeFactorizer!Domain} -\index{Domain!ModularDistinctDegreeFactorizer} -\index{MDDFACT} -\begin{chunk}{sane} +\index[pkg]{ModularDistinctDegreeFactorizer!Domain} +\index[pkg]{Domain!ModularDistinctDegreeFactorizer} +\index[pkg]{MDDFACT} +\begin{chunk}{defclass ModularDistinctDegreeFactorizerType} (defclass |ModularDistinctDegreeFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "ModularDistinctDegreeFactorizer") @@ -31618,7 +32321,7 @@ Value = NIL "of univariate polynomials over the integers modulo different" "primes. The inputs are given as polynomials over the integers" "with the prime passed explicitly as an extra argument.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31632,10 +32335,10 @@ Value = NIL \end{chunk} \subsection{ModularHermitianRowReduction} -\index{ModularHermitianRowReduction!Domain} -\index{Domain!ModularHermitianRowReduction} -\index{MHROWRED} -\begin{chunk}{sane} +\index[pkg]{ModularHermitianRowReduction!Domain} +\index[pkg]{Domain!ModularHermitianRowReduction} +\index[pkg]{MHROWRED} +\begin{chunk}{defclass ModularHermitianRowReductionType} (defclass |ModularHermitianRowReductionType| (|AxiomClass|) ((parents :initform ()) (name :initform "ModularHermitianRowReduction") @@ -31643,7 +32346,7 @@ Value = NIL (abbreviation :initform 'MHROWRED) (comment :initform (list "Modular hermitian row reduction.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31657,10 +32360,10 @@ Value = NIL \end{chunk} \subsection{MonoidRingFunctions2} -\index{MonoidRingFunctions2!Domain} -\index{Domain!MonoidRingFunctions2} -\index{MRF2} -\begin{chunk}{sane} +\index[pkg]{MonoidRingFunctions2!Domain} +\index[pkg]{Domain!MonoidRingFunctions2} +\index[pkg]{MRF2} +\begin{chunk}{defclass MonoidRingFunctions2Type} (defclass |MonoidRingFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MonoidRingFunctions2") @@ -31669,7 +32372,7 @@ Value = NIL (comment :initform (list "MonoidRingFunctions2 implements functions between" "two monoid rings defined with the same monoid over different rings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31683,10 +32386,10 @@ Value = NIL \end{chunk} \subsection{MonomialExtensionTools} -\index{MonomialExtensionTools!Domain} -\index{Domain!MonomialExtensionTools} -\index{MONOTOOL} -\begin{chunk}{sane} +\index[pkg]{MonomialExtensionTools!Domain} +\index[pkg]{Domain!MonomialExtensionTools} +\index[pkg]{MONOTOOL} +\begin{chunk}{defclass MonomialExtensionToolsType} (defclass |MonomialExtensionToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "MonomialExtensionTools") @@ -31694,7 +32397,7 @@ Value = NIL (abbreviation :initform 'MONOTOOL) (comment :initform (list "Tools for handling monomial extensions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31708,10 +32411,10 @@ Value = NIL \end{chunk} \subsection{MoreSystemCommands} -\index{MoreSystemCommands!Domain} -\index{Domain!MoreSystemCommands} -\index{MSYSCMD} -\begin{chunk}{sane} +\index[pkg]{MoreSystemCommands!Domain} +\index[pkg]{Domain!MoreSystemCommands} +\index[pkg]{MSYSCMD} +\begin{chunk}{defclass MoreSystemCommandsType} (defclass |MoreSystemCommandsType| (|AxiomClass|) ((parents :initform ()) (name :initform "MoreSystemCommands") @@ -31722,7 +32425,7 @@ Value = NIL "system command facility. These are the commands that are issued" "from source files or the system interpreter and they start with" "a close parenthesis, for example, the 'what' commands.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31736,10 +32439,10 @@ Value = NIL \end{chunk} \subsection{MPolyCatPolyFactorizer} -\index{MPolyCatPolyFactorizer!Domain} -\index{Domain!MPolyCatPolyFactorizer} -\index{MPCPF} -\begin{chunk}{sane} +\index[pkg]{MPolyCatPolyFactorizer!Domain} +\index[pkg]{Domain!MPolyCatPolyFactorizer} +\index[pkg]{MPCPF} +\begin{chunk}{defclass MPolyCatPolyFactorizerType} (defclass |MPolyCatPolyFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "MPolyCatPolyFactorizer") @@ -31752,7 +32455,7 @@ Value = NIL "such as the solve package which need to work with polynomials in a specific" "set of variables with coefficients which are polynomials in all the other" "variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31766,10 +32469,10 @@ Value = NIL \end{chunk} \subsection{MPolyCatRationalFunctionFactorizer} -\index{MPolyCatRationalFunctionFactorizer!Domain} -\index{Domain!MPolyCatRationalFunctionFactorizer} -\index{MPRFF} -\begin{chunk}{sane} +\index[pkg]{MPolyCatRationalFunctionFactorizer!Domain} +\index[pkg]{Domain!MPolyCatRationalFunctionFactorizer} +\index[pkg]{MPRFF} +\begin{chunk}{defclass MPolyCatRationalFunctionFactorizerType} (defclass |MPolyCatRationalFunctionFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "MPolyCatRationalFunctionFactorizer") @@ -31782,7 +32485,7 @@ Value = NIL "such as primary decomposition which need to work with polynomials" "with rational function coefficients, themselves fractions of" "polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31796,10 +32499,10 @@ Value = NIL \end{chunk} \subsection{MPolyCatFunctions2} -\index{MPolyCatFunctions2!Domain} -\index{Domain!MPolyCatFunctions2} -\index{MPC2} -\begin{chunk}{sane} +\index[pkg]{MPolyCatFunctions2!Domain} +\index[pkg]{Domain!MPolyCatFunctions2} +\index[pkg]{MPC2} +\begin{chunk}{defclass MPolyCatFunctions2Type} (defclass |MPolyCatFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MPolyCatFunctions2") @@ -31807,7 +32510,7 @@ Value = NIL (abbreviation :initform 'MPC2) (comment :initform (list "Utilities for MPolyCat")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31821,10 +32524,10 @@ Value = NIL \end{chunk} \subsection{MPolyCatFunctions3} -\index{MPolyCatFunctions3!Domain} -\index{Domain!MPolyCatFunctions3} -\index{MPC3} -\begin{chunk}{sane} +\index[pkg]{MPolyCatFunctions3!Domain} +\index[pkg]{Domain!MPolyCatFunctions3} +\index[pkg]{MPC3} +\begin{chunk}{defclass MPolyCatFunctions3Type} (defclass |MPolyCatFunctions3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "MPolyCatFunctions3") @@ -31832,7 +32535,7 @@ Value = NIL (abbreviation :initform 'MPC3) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31846,10 +32549,10 @@ Value = NIL \end{chunk} \subsection{MRationalFactorize} -\index{MRationalFactorize!Domain} -\index{Domain!MRationalFactorize} -\index{MRATFAC} -\begin{chunk}{sane} +\index[pkg]{MRationalFactorize!Domain} +\index[pkg]{Domain!MRationalFactorize} +\index[pkg]{MRATFAC} +\begin{chunk}{defclass MRationalFactorizeType} (defclass |MRationalFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "MRationalFactorize") @@ -31859,7 +32562,7 @@ Value = NIL "MRationalFactorize contains the factor function for multivariate" "polynomials over the quotient field of a ring R such that the package" "MultivariateFactorize can factor multivariate polynomials over R.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31873,10 +32576,10 @@ Value = NIL \end{chunk} \subsection{MultFiniteFactorize} -\index{MultFiniteFactorize!Domain} -\index{Domain!MultFiniteFactorize} -\index{MFINFACT} -\begin{chunk}{sane} +\index[pkg]{MultFiniteFactorize!Domain} +\index[pkg]{Domain!MultFiniteFactorize} +\index[pkg]{MFINFACT} +\begin{chunk}{defclass MultFiniteFactorizeType} (defclass |MultFiniteFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultFiniteFactorize") @@ -31884,7 +32587,7 @@ Value = NIL (abbreviation :initform 'MFINFACT) (comment :initform (list "Package for factorization of multivariate polynomials over finite fields.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31898,10 +32601,10 @@ Value = NIL \end{chunk} \subsection{MultipleMap} -\index{MultipleMap!Domain} -\index{Domain!MultipleMap} -\index{MMAP} -\begin{chunk}{sane} +\index[pkg]{MultipleMap!Domain} +\index[pkg]{Domain!MultipleMap} +\index[pkg]{MMAP} +\begin{chunk}{defclass MultipleMapType} (defclass |MultipleMapType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultipleMap") @@ -31909,7 +32612,7 @@ Value = NIL (abbreviation :initform 'MMAP) (comment :initform (list "Lifting of a map through 2 levels of polynomials")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31923,10 +32626,10 @@ Value = NIL \end{chunk} \subsection{MultiVariableCalculusFunctions} -\index{MultiVariableCalculusFunctions!Domain} -\index{Domain!MultiVariableCalculusFunctions} -\index{MCALCFN} -\begin{chunk}{sane} +\index[pkg]{MultiVariableCalculusFunctions!Domain} +\index[pkg]{Domain!MultiVariableCalculusFunctions} +\index[pkg]{MCALCFN} +\begin{chunk}{defclass MultiVariableCalculusFunctionsType} (defclass |MultiVariableCalculusFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultiVariableCalculusFunctions") @@ -31937,7 +32640,7 @@ Value = NIL "functions for multivariable calculus." "These include gradient, hessian and jacobian, divergence and laplacian." "Various forms for banded and sparse storage of matrices are included.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31951,10 +32654,10 @@ Value = NIL \end{chunk} \subsection{MultivariateFactorize} -\index{MultivariateFactorize!Domain} -\index{Domain!MultivariateFactorize} -\index{MULTFACT} -\begin{chunk}{sane} +\index[pkg]{MultivariateFactorize!Domain} +\index[pkg]{Domain!MultivariateFactorize} +\index[pkg]{MULTFACT} +\begin{chunk}{defclass MultivariateFactorizeType} (defclass |MultivariateFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultivariateFactorize") @@ -31963,7 +32666,7 @@ Value = NIL (comment :initform (list "This is the top level package for doing multivariate factorization" "over basic domains like Integer or Fraction Integer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -31977,10 +32680,10 @@ Value = NIL \end{chunk} \subsection{MultivariateLifting} -\index{MultivariateLifting!Domain} -\index{Domain!MultivariateLifting} -\index{MLIFT} -\begin{chunk}{sane} +\index[pkg]{MultivariateLifting!Domain} +\index[pkg]{Domain!MultivariateLifting} +\index[pkg]{MLIFT} +\begin{chunk}{defclass MultivariateLiftingType} (defclass |MultivariateLiftingType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultivariateLifting") @@ -31991,7 +32694,7 @@ Value = NIL "an algorithm of Paul Wang." "This package will work for every euclidean domain R which has property" "F, there exists a factor operation in R[x].")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32005,10 +32708,10 @@ Value = NIL \end{chunk} \subsection{MultivariateSquareFree} -\index{MultivariateSquareFree!Domain} -\index{Domain!MultivariateSquareFree} -\index{MULTSQFR} -\begin{chunk}{sane} +\index[pkg]{MultivariateSquareFree!Domain} +\index[pkg]{Domain!MultivariateSquareFree} +\index[pkg]{MULTSQFR} +\begin{chunk}{defclass MultivariateSquareFreeType} (defclass |MultivariateSquareFreeType| (|AxiomClass|) ((parents :initform ()) (name :initform "MultivariateSquareFree") @@ -32021,7 +32724,7 @@ Value = NIL "the equation Af + Bg = h and its generalization to n polynomials" "over an integral domain and the package MultivariateLifting" "for the 'multivariate' lifting.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32037,10 +32740,10 @@ Value = NIL \section{N} \subsection{NagEigenPackage} -\index{NagEigenPackage!Domain} -\index{Domain!NagEigenPackage} -\index{NAGF02} -\begin{chunk}{sane} +\index[pkg]{NagEigenPackage!Domain} +\index[pkg]{Domain!NagEigenPackage} +\index[pkg]{NAGF02} +\begin{chunk}{defclass NagEigenPackageType} (defclass |NagEigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagEigenPackage") @@ -32052,7 +32755,7 @@ Value = NIL " eigenvalues and eigenvectors of generalized matrix" "eigenvalue problems" " singular values and singular vectors of a matrix.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32066,10 +32769,10 @@ Value = NIL \end{chunk} \subsection{NagFittingPackage} -\index{NagFittingPackage!Domain} -\index{Domain!NagFittingPackage} -\index{NAGE02} -\begin{chunk}{sane} +\index[pkg]{NagFittingPackage!Domain} +\index[pkg]{Domain!NagFittingPackage} +\index[pkg]{NAGE02} +\begin{chunk}{defclass NagFittingPackageType} (defclass |NagFittingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagFittingPackage") @@ -32099,7 +32802,7 @@ Value = NIL "differentiating and integrating polynomial and spline curves and" "surfaces, once the numerical values of their coefficients have" "been determined.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32113,10 +32816,10 @@ Value = NIL \end{chunk} \subsection{NagLinearEquationSolvingPackage} -\index{NagLinearEquationSolvingPackage!Domain} -\index{Domain!NagLinearEquationSolvingPackage} -\index{NAGF04} -\begin{chunk}{sane} +\index[pkg]{NagLinearEquationSolvingPackage!Domain} +\index[pkg]{Domain!NagLinearEquationSolvingPackage} +\index[pkg]{NAGF04} +\begin{chunk}{defclass NagLinearEquationSolvingPackageType} (defclass |NagLinearEquationSolvingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagLinearEquationSolvingPackage") @@ -32129,7 +32832,7 @@ Value = NIL "The matrix A may be real, complex, symmetric, Hermitian positive-" "definite, or sparse. It may also be rectangular, in which case a" "least-squares solution is obtained.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32143,10 +32846,10 @@ Value = NIL \end{chunk} \subsection{NAGLinkSupportPackage} -\index{NAGLinkSupportPackage!Domain} -\index{Domain!NAGLinkSupportPackage} -\index{NAGSP} -\begin{chunk}{sane} +\index[pkg]{NAGLinkSupportPackage!Domain} +\index[pkg]{Domain!NAGLinkSupportPackage} +\index[pkg]{NAGSP} +\begin{chunk}{defclass NAGLinkSupportPackageType} (defclass |NAGLinkSupportPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NAGLinkSupportPackage") @@ -32154,7 +32857,7 @@ Value = NIL (abbreviation :initform 'NAGSP) (comment :initform (list "Support functions for the NAG Library Link functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32168,10 +32871,10 @@ Value = NIL \end{chunk} \subsection{NagIntegrationPackage} -\index{NagIntegrationPackage!Domain} -\index{Domain!NagIntegrationPackage} -\index{NAGD01} -\begin{chunk}{sane} +\index[pkg]{NagIntegrationPackage!Domain} +\index[pkg]{Domain!NagIntegrationPackage} +\index[pkg]{NAGD01} +\begin{chunk}{defclass NagIntegrationPackageType} (defclass |NagIntegrationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagIntegrationPackage") @@ -32181,7 +32884,7 @@ Value = NIL "This package uses the NAG Library to calculate the numerical value of" "definite integrals in one or more dimensions and to evaluate" "weights and abscissae of integration rules.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32195,10 +32898,10 @@ Value = NIL \end{chunk} \subsection{NagInterpolationPackage} -\index{NagInterpolationPackage!Domain} -\index{Domain!NagInterpolationPackage} -\index{NAGE01} -\begin{chunk}{sane} +\index[pkg]{NagInterpolationPackage!Domain} +\index[pkg]{Domain!NagInterpolationPackage} +\index[pkg]{NAGE01} +\begin{chunk}{defclass NagInterpolationPackageType} (defclass |NagInterpolationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagInterpolationPackage") @@ -32213,7 +32916,7 @@ Value = NIL "interpolated value. For some of the interpolating functions," "there are supporting routines to evaluate, differentiate or" "integrate them.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32227,10 +32930,10 @@ Value = NIL \end{chunk} \subsection{NagLapack} -\index{NagLapack!Domain} -\index{Domain!NagLapack} -\index{NAGF07} -\begin{chunk}{sane} +\index[pkg]{NagLapack!Domain} +\index[pkg]{Domain!NagLapack} +\index[pkg]{NAGF07} +\begin{chunk}{defclass NagLapackType} (defclass |NagLapackType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagLapack") @@ -32240,7 +32943,7 @@ Value = NIL "This package uses the NAG Library to compute matrix" "factorizations, and to solve systems of linear equations" "following the matrix factorizations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32254,10 +32957,10 @@ Value = NIL \end{chunk} \subsection{NagMatrixOperationsPackage} -\index{NagMatrixOperationsPackage!Domain} -\index{Domain!NagMatrixOperationsPackage} -\index{NAGF01} -\begin{chunk}{sane} +\index[pkg]{NagMatrixOperationsPackage!Domain} +\index[pkg]{Domain!NagMatrixOperationsPackage} +\index[pkg]{NAGF01} +\begin{chunk}{defclass NagMatrixOperationsPackageType} (defclass |NagMatrixOperationsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagMatrixOperationsPackage") @@ -32266,7 +32969,7 @@ Value = NIL (comment :initform (list "This package uses the NAG Library to provide facilities for matrix" "factorizations and associated transformations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32280,10 +32983,10 @@ Value = NIL \end{chunk} \subsection{NagOptimisationPackage} -\index{NagOptimisationPackage!Domain} -\index{Domain!NagOptimisationPackage} -\index{NAGE04} -\begin{chunk}{sane} +\index[pkg]{NagOptimisationPackage!Domain} +\index[pkg]{Domain!NagOptimisationPackage} +\index[pkg]{NAGE04} +\begin{chunk}{defclass NagOptimisationPackageType} (defclass |NagOptimisationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagOptimisationPackage") @@ -32298,7 +33001,7 @@ Value = NIL "are concerned with function minimization only, since the problem" "of maximizing a given function can be transformed into a" "minimization problem simply by multiplying the function by -1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32312,10 +33015,10 @@ Value = NIL \end{chunk} \subsection{NagOrdinaryDifferentialEquationsPackage} -\index{NagOrdinaryDifferentialEquationsPackage!Domain} -\index{Domain!NagOrdinaryDifferentialEquationsPackage} -\index{NAGD02} -\begin{chunk}{sane} +\index[pkg]{NagOrdinaryDifferentialEquationsPackage!Domain} +\index[pkg]{Domain!NagOrdinaryDifferentialEquationsPackage} +\index[pkg]{NAGD02} +\begin{chunk}{defclass NagOrdinaryDifferentialEquationsPackageType} (defclass |NagOrdinaryDifferentialEquationsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagOrdinaryDifferentialEquationsPackage") @@ -32330,7 +33033,7 @@ Value = NIL "value problems and eigenvalue problems). Routines are available" "for initial-value problems, two-point boundary-value problems and" "Sturm-Liouville eigenvalue problems.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32344,10 +33047,10 @@ Value = NIL \end{chunk} \subsection{NagPartialDifferentialEquationsPackage} -\index{NagPartialDifferentialEquationsPackage!Domain} -\index{Domain!NagPartialDifferentialEquationsPackage} -\index{NAGD03} -\begin{chunk}{sane} +\index[pkg]{NagPartialDifferentialEquationsPackage!Domain} +\index[pkg]{Domain!NagPartialDifferentialEquationsPackage} +\index[pkg]{NAGD03} +\begin{chunk}{defclass NagPartialDifferentialEquationsPackageType} (defclass |NagPartialDifferentialEquationsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagPartialDifferentialEquationsPackage") @@ -32356,7 +33059,7 @@ Value = NIL (comment :initform (list "This package uses the NAG Library to solve partial" "differential equations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32370,10 +33073,10 @@ Value = NIL \end{chunk} \subsection{NagPolynomialRootsPackage} -\index{NagPolynomialRootsPackage!Domain} -\index{Domain!NagPolynomialRootsPackage} -\index{NAGC02} -\begin{chunk}{sane} +\index[pkg]{NagPolynomialRootsPackage!Domain} +\index[pkg]{Domain!NagPolynomialRootsPackage} +\index[pkg]{NAGC02} +\begin{chunk}{defclass NagPolynomialRootsPackageType} (defclass |NagPolynomialRootsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagPolynomialRootsPackage") @@ -32382,7 +33085,7 @@ Value = NIL (comment :initform (list "This package uses the NAG Library to compute the zeros of a" "polynomial with real or complex coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32396,10 +33099,10 @@ Value = NIL \end{chunk} \subsection{NagRootFindingPackage} -\index{NagRootFindingPackage!Domain} -\index{Domain!NagRootFindingPackage} -\index{NAGC05} -\begin{chunk}{sane} +\index[pkg]{NagRootFindingPackage!Domain} +\index[pkg]{Domain!NagRootFindingPackage} +\index[pkg]{NAGC05} +\begin{chunk}{defclass NagRootFindingPackageType} (defclass |NagRootFindingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagRootFindingPackage") @@ -32410,7 +33113,7 @@ Value = NIL "continuous real functions of one or more variables. (Complex" "equations must be expressed in terms of the equivalent larger" "system of real equations.)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32424,10 +33127,10 @@ Value = NIL \end{chunk} \subsection{NagSeriesSummationPackage} -\index{NagSeriesSummationPackage!Domain} -\index{Domain!NagSeriesSummationPackage} -\index{NAGC06} -\begin{chunk}{sane} +\index[pkg]{NagSeriesSummationPackage!Domain} +\index[pkg]{Domain!NagSeriesSummationPackage} +\index[pkg]{NAGC06} +\begin{chunk}{defclass NagSeriesSummationPackageType} (defclass |NagSeriesSummationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagSeriesSummationPackage") @@ -32437,7 +33140,7 @@ Value = NIL "This package uses the NAG Library to calculate the discrete Fourier" "transform of a sequence of real or complex data values, and" "applies it to calculate convolutions and correlations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32451,10 +33154,10 @@ Value = NIL \end{chunk} \subsection{NagSpecialFunctionsPackage} -\index{NagSpecialFunctionsPackage!Domain} -\index{Domain!NagSpecialFunctionsPackage} -\index{NAGS} -\begin{chunk}{sane} +\index[pkg]{NagSpecialFunctionsPackage!Domain} +\index[pkg]{Domain!NagSpecialFunctionsPackage} +\index[pkg]{NAGS} +\begin{chunk}{defclass NagSpecialFunctionsPackageType} (defclass |NagSpecialFunctionsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NagSpecialFunctionsPackage") @@ -32463,7 +33166,7 @@ Value = NIL (comment :initform (list "This package uses the NAG Library to compute some commonly" "occurring physical and mathematical functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32477,10 +33180,10 @@ Value = NIL \end{chunk} \subsection{NewSparseUnivariatePolynomialFunctions2} -\index{NewSparseUnivariatePolynomialFunctions2!Domain} -\index{Domain!NewSparseUnivariatePolynomialFunctions2} -\index{NSUP2} -\begin{chunk}{sane} +\index[pkg]{NewSparseUnivariatePolynomialFunctions2!Domain} +\index[pkg]{Domain!NewSparseUnivariatePolynomialFunctions2} +\index[pkg]{NSUP2} +\begin{chunk}{defclass NewSparseUnivariatePolynomialFunctions2Type} (defclass |NewSparseUnivariatePolynomialFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "NewSparseUnivariatePolynomialFunctions2") @@ -32493,7 +33196,7 @@ Value = NIL "Note that the mapping is assumed" "to send zero to zero, since it will only be applied to the non-zero" "coefficients of the polynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32507,10 +33210,10 @@ Value = NIL \end{chunk} \subsection{NewtonInterpolation} -\index{NewtonInterpolation!Domain} -\index{Domain!NewtonInterpolation} -\index{NEWTON} -\begin{chunk}{sane} +\index[pkg]{NewtonInterpolation!Domain} +\index[pkg]{Domain!NewtonInterpolation} +\index[pkg]{NEWTON} +\begin{chunk}{defclass NewtonInterpolationType} (defclass |NewtonInterpolationType| (|AxiomClass|) ((parents :initform ()) (name :initform "NewtonInterpolation") @@ -32521,7 +33224,7 @@ Value = NIL "result is known to be in the original integral domain" "The packages defined in this file provide fast fraction free rational" "interpolation algorithms. (see FAMR2, FFFG, FFFGF, NEWTON)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32535,10 +33238,10 @@ Value = NIL \end{chunk} \subsection{NewtonPolygon} -\index{NewtonPolygon!Domain} -\index{Domain!NewtonPolygon} -\index{NPOLYGON} -\begin{chunk}{sane} +\index[pkg]{NewtonPolygon!Domain} +\index[pkg]{Domain!NewtonPolygon} +\index[pkg]{NPOLYGON} +\begin{chunk}{defclass NewtonPolygonType} (defclass |NewtonPolygonType| (|AxiomClass|) ((parents :initform ()) (name :initform "NewtonPolygon") @@ -32546,7 +33249,7 @@ Value = NIL (abbreviation :initform 'NPOLYGON) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32560,10 +33263,10 @@ Value = NIL \end{chunk} \subsection{NonCommutativeOperatorDivision} -\index{NonCommutativeOperatorDivision!Domain} -\index{Domain!NonCommutativeOperatorDivision} -\index{NCODIV} -\begin{chunk}{sane} +\index[pkg]{NonCommutativeOperatorDivision!Domain} +\index[pkg]{Domain!NonCommutativeOperatorDivision} +\index[pkg]{NCODIV} +\begin{chunk}{defclass NonCommutativeOperatorDivisionType} (defclass |NonCommutativeOperatorDivisionType| (|AxiomClass|) ((parents :initform ()) (name :initform "NonCommutativeOperatorDivision") @@ -32576,7 +33279,7 @@ Value = NIL "these operations all have left- and right-hand versions." "This package provides the operations based on left-division." " [q,r] = leftDivide(a,b) means a=b*q+r")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32590,10 +33293,10 @@ Value = NIL \end{chunk} \subsection{NoneFunctions1} -\index{NoneFunctions1!Domain} -\index{Domain!NoneFunctions1} -\index{NONE1} -\begin{chunk}{sane} +\index[pkg]{NoneFunctions1!Domain} +\index[pkg]{Domain!NoneFunctions1} +\index[pkg]{NONE1} +\begin{chunk}{defclass NoneFunctions1Type} (defclass |NoneFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "NoneFunctions1") @@ -32603,7 +33306,7 @@ Value = NIL "NoneFunctions1 implements functions on None." "It particular it includes a particulary dangerous coercion from" "any other type to None.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32617,10 +33320,10 @@ Value = NIL \end{chunk} \subsection{NonLinearFirstOrderODESolver} -\index{NonLinearFirstOrderODESolver!Domain} -\index{Domain!NonLinearFirstOrderODESolver} -\index{NODE1} -\begin{chunk}{sane} +\index[pkg]{NonLinearFirstOrderODESolver!Domain} +\index[pkg]{Domain!NonLinearFirstOrderODESolver} +\index[pkg]{NODE1} +\begin{chunk}{defclass NonLinearFirstOrderODESolverType} (defclass |NonLinearFirstOrderODESolverType| (|AxiomClass|) ((parents :initform ()) (name :initform "NonLinearFirstOrderODESolver") @@ -32630,7 +33333,7 @@ Value = NIL "NonLinearFirstOrderODESolver provides a function" "for finding closed form first integrals of nonlinear ordinary" "differential equations of order 1.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32644,10 +33347,10 @@ Value = NIL \end{chunk} \subsection{NonLinearSolvePackage} -\index{NonLinearSolvePackage!Domain} -\index{Domain!NonLinearSolvePackage} -\index{NLINSOL} -\begin{chunk}{sane} +\index[pkg]{NonLinearSolvePackage!Domain} +\index[pkg]{Domain!NonLinearSolvePackage} +\index[pkg]{NLINSOL} +\begin{chunk}{defclass NonLinearSolvePackageType} (defclass |NonLinearSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NonLinearSolvePackage") @@ -32658,7 +33361,7 @@ Value = NIL "that attempts to retract the coefficients of the equations before" "solving. The solutions are given in the algebraic closure of R whenever" "possible.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32672,10 +33375,10 @@ Value = NIL \end{chunk} \subsection{NormalizationPackage} -\index{NormalizationPackage!Domain} -\index{Domain!NormalizationPackage} -\index{NORMPK} -\begin{chunk}{sane} +\index[pkg]{NormalizationPackage!Domain} +\index[pkg]{Domain!NormalizationPackage} +\index[pkg]{NORMPK} +\begin{chunk}{defclass NormalizationPackageType} (defclass |NormalizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NormalizationPackage") @@ -32684,7 +33387,7 @@ Value = NIL (comment :initform (list "A package for computing normalized assocites of univariate polynomials" "with coefficients in a tower of simple extensions of a field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32698,10 +33401,10 @@ Value = NIL \end{chunk} \subsection{NormInMonogenicAlgebra} -\index{NormInMonogenicAlgebra!Domain} -\index{Domain!NormInMonogenicAlgebra} -\index{NORMMA} -\begin{chunk}{sane} +\index[pkg]{NormInMonogenicAlgebra!Domain} +\index[pkg]{Domain!NormInMonogenicAlgebra} +\index[pkg]{NORMMA} +\begin{chunk}{defclass NormInMonogenicAlgebraType} (defclass |NormInMonogenicAlgebraType| (|AxiomClass|) ((parents :initform ()) (name :initform "NormInMonogenicAlgebra") @@ -32710,7 +33413,7 @@ Value = NIL (comment :initform (list "This package implements the norm of a polynomial with coefficients" "in a monogenic algebra (using resultants)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32724,10 +33427,10 @@ Value = NIL \end{chunk} \subsection{NormRetractPackage} -\index{NormRetractPackage!Domain} -\index{Domain!NormRetractPackage} -\index{NORMRETR} -\begin{chunk}{sane} +\index[pkg]{NormRetractPackage!Domain} +\index[pkg]{Domain!NormRetractPackage} +\index[pkg]{NORMRETR} +\begin{chunk}{defclass NormRetractPackageType} (defclass |NormRetractPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NormRetractPackage") @@ -32735,7 +33438,7 @@ Value = NIL (abbreviation :initform 'NORMRETR) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32749,10 +33452,10 @@ Value = NIL \end{chunk} \subsection{NPCoef} -\index{NPCoef!Domain} -\index{Domain!NPCoef} -\index{NPCOEF} -\begin{chunk}{sane} +\index[pkg]{NPCoef!Domain} +\index[pkg]{Domain!NPCoef} +\index[pkg]{NPCOEF} +\begin{chunk}{defclass NPCoefType} (defclass |NPCoefType| (|AxiomClass|) ((parents :initform ()) (name :initform "NPCoef") @@ -32763,7 +33466,7 @@ Value = NIL "process. Used by MultivariateLifting." "This package will work for every euclidean domain R which has property" "F, there exists a factor operation in R[x].")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32777,10 +33480,10 @@ Value = NIL \end{chunk} \subsection{NumberFieldIntegralBasis} -\index{NumberFieldIntegralBasis!Domain} -\index{Domain!NumberFieldIntegralBasis} -\index{NFINTBAS} -\begin{chunk}{sane} +\index[pkg]{NumberFieldIntegralBasis!Domain} +\index[pkg]{Domain!NumberFieldIntegralBasis} +\index[pkg]{NFINTBAS} +\begin{chunk}{defclass NumberFieldIntegralBasisType} (defclass |NumberFieldIntegralBasisType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumberFieldIntegralBasis") @@ -32791,7 +33494,7 @@ Value = NIL "F = Z[a] for some algebraic integer a). The package provides" "functions to compute the integral closure of Z in the quotient" "quotient field of F.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32805,10 +33508,10 @@ Value = NIL \end{chunk} \subsection{NumberFormats} -\index{NumberFormats!Domain} -\index{Domain!NumberFormats} -\index{NUMFMT} -\begin{chunk}{sane} +\index[pkg]{NumberFormats!Domain} +\index[pkg]{Domain!NumberFormats} +\index[pkg]{NUMFMT} +\begin{chunk}{defclass NumberFormatsType} (defclass |NumberFormatsType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumberFormats") @@ -32818,7 +33521,7 @@ Value = NIL "NumberFormats provides function to format and read arabic and" "roman numbers, to convert numbers to strings and to read" "floating-point numbers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32832,10 +33535,10 @@ Value = NIL \end{chunk} \subsection{NumberTheoreticPolynomialFunctions} -\index{NumberTheoreticPolynomialFunctions!Domain} -\index{Domain!NumberTheoreticPolynomialFunctions} -\index{NTPOLFN} -\begin{chunk}{sane} +\index[pkg]{NumberTheoreticPolynomialFunctions!Domain} +\index[pkg]{Domain!NumberTheoreticPolynomialFunctions} +\index[pkg]{NTPOLFN} +\begin{chunk}{defclass NumberTheoreticPolynomialFunctionsType} (defclass |NumberTheoreticPolynomialFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumberTheoreticPolynomialFunctions") @@ -32843,7 +33546,7 @@ Value = NIL (abbreviation :initform 'NTPOLFN) (comment :initform (list "This package provides polynomials as functions on a ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32857,10 +33560,10 @@ Value = NIL \end{chunk} \subsection{Numeric} -\index{Numeric!Domain} -\index{Domain!Numeric} -\index{NUMERIC} -\begin{chunk}{sane} +\index[pkg]{Numeric!Domain} +\index[pkg]{Domain!Numeric} +\index[pkg]{NUMERIC} +\begin{chunk}{defclass NumericType} (defclass |NumericType| (|AxiomClass|) ((parents :initform ()) (name :initform "Numeric") @@ -32869,7 +33572,7 @@ Value = NIL (comment :initform (list "Numeric provides real and complex numerical evaluation" "functions for various symbolic types.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32883,10 +33586,10 @@ Value = NIL \end{chunk} \subsection{NumericalOrdinaryDifferentialEquations} -\index{NumericalOrdinaryDifferentialEquations!Domain} -\index{Domain!NumericalOrdinaryDifferentialEquations} -\index{NUMODE} -\begin{chunk}{sane} +\index[pkg]{NumericalOrdinaryDifferentialEquations!Domain} +\index[pkg]{Domain!NumericalOrdinaryDifferentialEquations} +\index[pkg]{NUMODE} +\begin{chunk}{defclass NumericalOrdinaryDifferentialEquationsType} (defclass |NumericalOrdinaryDifferentialEquationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericalOrdinaryDifferentialEquations") @@ -32976,7 +33679,7 @@ Value = NIL "Argument x2 is the final point," "eps is local truncation," "ns is the maximum number of call to rk4qc to use.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -32990,10 +33693,10 @@ Value = NIL \end{chunk} \subsection{NumericalQuadrature} -\index{NumericalQuadrature!Domain} -\index{Domain!NumericalQuadrature} -\index{NUMQUAD} -\begin{chunk}{sane} +\index[pkg]{NumericalQuadrature!Domain} +\index[pkg]{Domain!NumericalQuadrature} +\index[pkg]{NUMQUAD} +\begin{chunk}{defclass NumericalQuadratureType} (defclass |NumericalQuadratureType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericalQuadrature") @@ -33065,7 +33768,7 @@ Value = NIL "Notes:" "Closed family level i uses 1 + 2**i points." "Open family level i uses 1 + 3**i points.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33079,10 +33782,10 @@ Value = NIL \end{chunk} \subsection{NumericComplexEigenPackage} -\index{NumericComplexEigenPackage!Domain} -\index{Domain!NumericComplexEigenPackage} -\index{NCEP} -\begin{chunk}{sane} +\index[pkg]{NumericComplexEigenPackage!Domain} +\index[pkg]{Domain!NumericComplexEigenPackage} +\index[pkg]{NCEP} +\begin{chunk}{defclass NumericComplexEigenPackageType} (defclass |NumericComplexEigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericComplexEigenPackage") @@ -33093,7 +33796,7 @@ Value = NIL "matrices with entries over the complex rational numbers." "The results are expressed either as complex floating numbers or as" "complex rational numbers depending on the type of the precision parameter.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33107,10 +33810,10 @@ Value = NIL \end{chunk} \subsection{NumericContinuedFraction} -\index{NumericContinuedFraction!Domain} -\index{Domain!NumericContinuedFraction} -\index{NCNTFRAC} -\begin{chunk}{sane} +\index[pkg]{NumericContinuedFraction!Domain} +\index[pkg]{Domain!NumericContinuedFraction} +\index[pkg]{NCNTFRAC} +\begin{chunk}{defclass NumericContinuedFractionType} (defclass |NumericContinuedFractionType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericContinuedFraction") @@ -33119,7 +33822,7 @@ Value = NIL (comment :initform (list "NumericContinuedFraction provides functions" "for converting floating point numbers to continued fractions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33133,10 +33836,10 @@ Value = NIL \end{chunk} \subsection{NumericRealEigenPackage} -\index{NumericRealEigenPackage!Domain} -\index{Domain!NumericRealEigenPackage} -\index{NREP} -\begin{chunk}{sane} +\index[pkg]{NumericRealEigenPackage!Domain} +\index[pkg]{Domain!NumericRealEigenPackage} +\index[pkg]{NREP} +\begin{chunk}{defclass NumericRealEigenPackageType} (defclass |NumericRealEigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericRealEigenPackage") @@ -33147,7 +33850,7 @@ Value = NIL "matrices with entries over the Rational Numbers." "The results are expressed as floating numbers or as rational numbers" "depending on the type of the parameter Par.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33161,10 +33864,10 @@ Value = NIL \end{chunk} \subsection{NumericTubePlot} -\index{NumericTubePlot!Domain} -\index{Domain!NumericTubePlot} -\index{NUMTUBE} -\begin{chunk}{sane} +\index[pkg]{NumericTubePlot!Domain} +\index[pkg]{Domain!NumericTubePlot} +\index[pkg]{NUMTUBE} +\begin{chunk}{defclass NumericTubePlotType} (defclass |NumericTubePlotType| (|AxiomClass|) ((parents :initform ()) (name :initform "NumericTubePlot") @@ -33172,7 +33875,7 @@ Value = NIL (abbreviation :initform 'NUMTUBE) (comment :initform (list "Package for constructing tubes around 3-dimensional parametric curves.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33188,10 +33891,10 @@ Value = NIL \section{O} \subsection{OctonionCategoryFunctions2} -\index{OctonionCategoryFunctions2!Domain} -\index{Domain!OctonionCategoryFunctions2} -\index{OCTCT2} -\begin{chunk}{sane} +\index[pkg]{OctonionCategoryFunctions2!Domain} +\index[pkg]{Domain!OctonionCategoryFunctions2} +\index[pkg]{OCTCT2} +\begin{chunk}{defclass OctonionCategoryFunctions2Type} (defclass |OctonionCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "OctonionCategoryFunctions2") @@ -33201,7 +33904,7 @@ Value = NIL "OctonionCategoryFunctions2 implements functions between" "two octonion domains defined over different rings." "The function map is used to coerce between octonion types.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33215,10 +33918,10 @@ Value = NIL \end{chunk} \subsection{ODEIntegration} -\index{ODEIntegration!Domain} -\index{Domain!ODEIntegration} -\index{ODEINT} -\begin{chunk}{sane} +\index[pkg]{ODEIntegration!Domain} +\index[pkg]{Domain!ODEIntegration} +\index[pkg]{ODEINT} +\begin{chunk}{defclass ODEIntegrationType} (defclass |ODEIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "ODEIntegration") @@ -33228,7 +33931,7 @@ Value = NIL "ODEIntegration provides an interface to the integrator." "This package is intended for use" "by the differential equations solver but not at top-level.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33242,10 +33945,10 @@ Value = NIL \end{chunk} \subsection{ODETools} -\index{ODETools!Domain} -\index{Domain!ODETools} -\index{ODETOOLS} -\begin{chunk}{sane} +\index[pkg]{ODETools!Domain} +\index[pkg]{Domain!ODETools} +\index[pkg]{ODETOOLS} +\begin{chunk}{defclass ODEToolsType} (defclass |ODEToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ODETools") @@ -33253,7 +33956,7 @@ Value = NIL (abbreviation :initform 'ODETOOLS) (comment :initform (list "ODETools provides tools for the linear ODE solver.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33267,10 +33970,10 @@ Value = NIL \end{chunk} \subsection{OneDimensionalArrayFunctions2} -\index{OneDimensionalArrayFunctions2!Domain} -\index{Domain!OneDimensionalArrayFunctions2} -\index{ARRAY12} -\begin{chunk}{sane} +\index[pkg]{OneDimensionalArrayFunctions2!Domain} +\index[pkg]{Domain!OneDimensionalArrayFunctions2} +\index[pkg]{ARRAY12} +\begin{chunk}{defclass OneDimensionalArrayFunctions2Type} (defclass |OneDimensionalArrayFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "OneDimensionalArrayFunctions2") @@ -33279,7 +33982,7 @@ Value = NIL (comment :initform (list "This package provides tools for operating on one-dimensional arrays" "with unary and binary functions involving different underlying types")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33293,10 +33996,10 @@ Value = NIL \end{chunk} \subsection{OnePointCompletionFunctions2} -\index{OnePointCompletionFunctions2!Domain} -\index{Domain!OnePointCompletionFunctions2} -\index{ONECOMP2} -\begin{chunk}{sane} +\index[pkg]{OnePointCompletionFunctions2!Domain} +\index[pkg]{Domain!OnePointCompletionFunctions2} +\index[pkg]{ONECOMP2} +\begin{chunk}{defclass OnePointCompletionFunctions2Type} (defclass |OnePointCompletionFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "OnePointCompletionFunctions2") @@ -33304,7 +34007,7 @@ Value = NIL (abbreviation :initform 'ONECOMP2) (comment :initform (list "Lifting of maps to one-point completions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33318,10 +34021,10 @@ Value = NIL \end{chunk} \subsection{OpenMathPackage} -\index{OpenMathPackage!Domain} -\index{Domain!OpenMathPackage} -\index{OMPKG} -\begin{chunk}{sane} +\index[pkg]{OpenMathPackage!Domain} +\index[pkg]{Domain!OpenMathPackage} +\index[pkg]{OMPKG} +\begin{chunk}{defclass OpenMathPackageType} (defclass |OpenMathPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "OpenMathPackage") @@ -33330,7 +34033,7 @@ Value = NIL (comment :initform (list "OpenMathPackage provides some simple utilities" "to make reading OpenMath objects easier.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33344,10 +34047,10 @@ Value = NIL \end{chunk} \subsection{OpenMathServerPackage} -\index{OpenMathServerPackage!Domain} -\index{Domain!OpenMathServerPackage} -\index{OMSERVER} -\begin{chunk}{sane} +\index[pkg]{OpenMathServerPackage!Domain} +\index[pkg]{Domain!OpenMathServerPackage} +\index[pkg]{OMSERVER} +\begin{chunk}{defclass OpenMathServerPackageType} (defclass |OpenMathServerPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "OpenMathServerPackage") @@ -33359,7 +34062,7 @@ Value = NIL "to/from a port. Please note the facilities available here are very basic." "The idea is that a user calls, for example, Omserve(4000,60) and then" "another process sends OpenMath objects to port 4000 and reads the result.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33373,10 +34076,10 @@ Value = NIL \end{chunk} \subsection{OperationsQuery} -\index{OperationsQuery!Domain} -\index{Domain!OperationsQuery} -\index{OPQUERY} -\begin{chunk}{sane} +\index[pkg]{OperationsQuery!Domain} +\index[pkg]{Domain!OperationsQuery} +\index[pkg]{OPQUERY} +\begin{chunk}{defclass OperationsQueryType} (defclass |OperationsQueryType| (|AxiomClass|) ((parents :initform ()) (name :initform "OperationsQuery") @@ -33384,7 +34087,7 @@ Value = NIL (abbreviation :initform 'OPQUERY) (comment :initform (list "This package exports tools to create AXIOM Library information databases.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33398,10 +34101,10 @@ Value = NIL \end{chunk} \subsection{OrderedCompletionFunctions2} -\index{OrderedCompletionFunctions2!Domain} -\index{Domain!OrderedCompletionFunctions2} -\index{ORDCOMP2} -\begin{chunk}{sane} +\index[pkg]{OrderedCompletionFunctions2!Domain} +\index[pkg]{Domain!OrderedCompletionFunctions2} +\index[pkg]{ORDCOMP2} +\begin{chunk}{defclass OrderedCompletionFunctions2Type} (defclass |OrderedCompletionFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "OrderedCompletionFunctions2") @@ -33409,7 +34112,7 @@ Value = NIL (abbreviation :initform 'ORDCOMP2) (comment :initform (list "Lifting of maps to ordered completions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33423,10 +34126,10 @@ Value = NIL \end{chunk} \subsection{OrderingFunctions} -\index{OrderingFunctions!Domain} -\index{Domain!OrderingFunctions} -\index{ORDFUNS} -\begin{chunk}{sane} +\index[pkg]{OrderingFunctions!Domain} +\index[pkg]{Domain!OrderingFunctions} +\index[pkg]{ORDFUNS} +\begin{chunk}{defclass OrderingFunctionsType} (defclass |OrderingFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "OrderingFunctions") @@ -33435,7 +34138,7 @@ Value = NIL (comment :initform (list "This package provides ordering functions on vectors which" "are suitable parameters for OrderedDirectProduct.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33449,10 +34152,10 @@ Value = NIL \end{chunk} \subsection{OrthogonalPolynomialFunctions} -\index{OrthogonalPolynomialFunctions!Domain} -\index{Domain!OrthogonalPolynomialFunctions} -\index{ORTHPOL} -\begin{chunk}{sane} +\index[pkg]{OrthogonalPolynomialFunctions!Domain} +\index[pkg]{Domain!OrthogonalPolynomialFunctions} +\index[pkg]{ORTHPOL} +\begin{chunk}{defclass OrthogonalPolynomialFunctionsType} (defclass |OrthogonalPolynomialFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "OrthogonalPolynomialFunctions") @@ -33460,7 +34163,7 @@ Value = NIL (abbreviation :initform 'ORTHPOL) (comment :initform (list "This package provides orthogonal polynomials as functions on a ring.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33474,10 +34177,10 @@ Value = NIL \end{chunk} \subsection{OutputPackage} -\index{OutputPackage!Domain} -\index{Domain!OutputPackage} -\index{OUT} -\begin{chunk}{sane} +\index[pkg]{OutputPackage!Domain} +\index[pkg]{Domain!OutputPackage} +\index[pkg]{OUT} +\begin{chunk}{defclass OutputPackageType} (defclass |OutputPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "OutputPackage") @@ -33485,7 +34188,7 @@ Value = NIL (abbreviation :initform 'OUT) (comment :initform (list "OutPackage allows pretty-printing from programs.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33501,10 +34204,10 @@ Value = NIL \section{P} \subsection{PackageForAlgebraicFunctionField} -\index{PackageForAlgebraicFunctionField!Domain} -\index{Domain!PackageForAlgebraicFunctionField} -\index{PAFF} -\begin{chunk}{sane} +\index[pkg]{PackageForAlgebraicFunctionField!Domain} +\index[pkg]{Domain!PackageForAlgebraicFunctionField} +\index[pkg]{PAFF} +\begin{chunk}{defclass PackageForAlgebraicFunctionFieldType} (defclass |PackageForAlgebraicFunctionFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "PackageForAlgebraicFunctionField") @@ -33513,7 +34216,7 @@ Value = NIL (comment :initform (list "A package that implements the Brill-Noether algorithm." "Part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33527,10 +34230,10 @@ Value = NIL \end{chunk} \subsection{PackageForAlgebraicFunctionFieldOverFiniteField} -\index{PackageForAlgebraicFunctionFieldOverFiniteField!Domain} -\index{Domain!PackageForAlgebraicFunctionFieldOverFiniteField} -\index{PAFFFF} -\begin{chunk}{sane} +\index[pkg]{PackageForAlgebraicFunctionFieldOverFiniteField!Domain} +\index[pkg]{Domain!PackageForAlgebraicFunctionFieldOverFiniteField} +\index[pkg]{PAFFFF} +\begin{chunk}{defclass PackageForAlgebraicFunctionFieldOverFiniteFieldType} (defclass |PackageForAlgebraicFunctionFieldOverFiniteFieldType| (|AxiomClass|) ((parents :initform ()) (name :initform "PackageForAlgebraicFunctionFieldOverFiniteField") @@ -33539,7 +34242,7 @@ Value = NIL (comment :initform (list "A package that implements the Brill-Noether algorithm." "Part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33553,10 +34256,10 @@ Value = NIL \end{chunk} \subsection{PackageForPoly} -\index{PackageForPoly!Domain} -\index{Domain!PackageForPoly} -\index{PFORP} -\begin{chunk}{sane} +\index[pkg]{PackageForPoly!Domain} +\index[pkg]{Domain!PackageForPoly} +\index[pkg]{PFORP} +\begin{chunk}{defclass PackageForPolyType} (defclass |PackageForPolyType| (|AxiomClass|) ((parents :initform ()) (name :initform "PackageForPoly") @@ -33564,7 +34267,7 @@ Value = NIL (abbreviation :initform 'PFORP) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33578,10 +34281,10 @@ Value = NIL \end{chunk} \subsection{PadeApproximantPackage} -\index{PadeApproximantPackage!Domain} -\index{Domain!PadeApproximantPackage} -\index{PADEPAC} -\begin{chunk}{sane} +\index[pkg]{PadeApproximantPackage!Domain} +\index[pkg]{Domain!PadeApproximantPackage} +\index[pkg]{PADEPAC} +\begin{chunk}{defclass PadeApproximantPackageType} (defclass |PadeApproximantPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PadeApproximantPackage") @@ -33590,7 +34293,7 @@ Value = NIL (comment :initform (list "This package computes reliable Pad&ea. approximants using" "a generalized Viskovatov continued fraction algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33604,10 +34307,10 @@ Value = NIL \end{chunk} \subsection{PadeApproximants} -\index{PadeApproximants!Domain} -\index{Domain!PadeApproximants} -\index{PADE} -\begin{chunk}{sane} +\index[pkg]{PadeApproximants!Domain} +\index[pkg]{Domain!PadeApproximants} +\index[pkg]{PADE} +\begin{chunk}{defclass PadeApproximantsType} (defclass |PadeApproximantsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PadeApproximants") @@ -33616,7 +34319,7 @@ Value = NIL (comment :initform (list "This package computes reliable Pad&ea. approximants using" "a generalized Viskovatov continued fraction algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33630,10 +34333,10 @@ Value = NIL \end{chunk} \subsection{PAdicWildFunctionFieldIntegralBasis} -\index{PAdicWildFunctionFieldIntegralBasis!Domain} -\index{Domain!PAdicWildFunctionFieldIntegralBasis} -\index{PWFFINTB} -\begin{chunk}{sane} +\index[pkg]{PAdicWildFunctionFieldIntegralBasis!Domain} +\index[pkg]{Domain!PAdicWildFunctionFieldIntegralBasis} +\index[pkg]{PWFFINTB} +\begin{chunk}{defclass PAdicWildFunctionFieldIntegralBasisType} (defclass |PAdicWildFunctionFieldIntegralBasisType| (|AxiomClass|) ((parents :initform ()) (name :initform "PAdicWildFunctionFieldIntegralBasis") @@ -33647,7 +34350,7 @@ Value = NIL "f(x,y). The package provides a function to compute the integral" "closure of R in the quotient field of F as well as a function to compute" "a 'local integral basis' at a specific prime.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33661,10 +34364,10 @@ Value = NIL \end{chunk} \subsection{ParadoxicalCombinatorsForStreams} -\index{ParadoxicalCombinatorsForStreams!Domain} -\index{Domain!ParadoxicalCombinatorsForStreams} -\index{YSTREAM} -\begin{chunk}{sane} +\index[pkg]{ParadoxicalCombinatorsForStreams!Domain} +\index[pkg]{Domain!ParadoxicalCombinatorsForStreams} +\index[pkg]{YSTREAM} +\begin{chunk}{defclass ParadoxicalCombinatorsForStreamsType} (defclass |ParadoxicalCombinatorsForStreamsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParadoxicalCombinatorsForStreams") @@ -33672,7 +34375,7 @@ Value = NIL (abbreviation :initform 'YSTREAM) (comment :initform (list "Computation of fixed points of mappings on streams")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33686,10 +34389,10 @@ Value = NIL \end{chunk} \subsection{ParametricLinearEquations} -\index{ParametricLinearEquations!Domain} -\index{Domain!ParametricLinearEquations} -\index{PLEQN} -\begin{chunk}{sane} +\index[pkg]{ParametricLinearEquations!Domain} +\index[pkg]{Domain!ParametricLinearEquations} +\index[pkg]{PLEQN} +\begin{chunk}{defclass ParametricLinearEquationsType} (defclass |ParametricLinearEquationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricLinearEquations") @@ -33705,7 +34408,7 @@ Value = NIL "For each quasi-algebraic set, the solution of the linear system" "is given, as a particular solution and a basis of the homogeneous" "system.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33719,10 +34422,10 @@ Value = NIL \end{chunk} \subsection{ParametricPlaneCurveFunctions2} -\index{ParametricPlaneCurveFunctions2!Domain} -\index{Domain!ParametricPlaneCurveFunctions2} -\index{PARPC2} -\begin{chunk}{sane} +\index[pkg]{ParametricPlaneCurveFunctions2!Domain} +\index[pkg]{Domain!ParametricPlaneCurveFunctions2} +\index[pkg]{PARPC2} +\begin{chunk}{defclass ParametricPlaneCurveFunctions2Type} (defclass |ParametricPlaneCurveFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricPlaneCurveFunctions2") @@ -33730,7 +34433,7 @@ Value = NIL (abbreviation :initform 'PARPC2) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33744,10 +34447,10 @@ Value = NIL \end{chunk} \subsection{ParametricSpaceCurveFunctions2} -\index{ParametricSpaceCurveFunctions2!Domain} -\index{Domain!ParametricSpaceCurveFunctions2} -\index{PARSC2} -\begin{chunk}{sane} +\index[pkg]{ParametricSpaceCurveFunctions2!Domain} +\index[pkg]{Domain!ParametricSpaceCurveFunctions2} +\index[pkg]{PARSC2} +\begin{chunk}{defclass ParametricSpaceCurveFunctions2Type} (defclass |ParametricSpaceCurveFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricSpaceCurveFunctions2") @@ -33755,7 +34458,7 @@ Value = NIL (abbreviation :initform 'PARSC2) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33769,10 +34472,10 @@ Value = NIL \end{chunk} \subsection{ParametricSurfaceFunctions2} -\index{ParametricSurfaceFunctions2!Domain} -\index{Domain!ParametricSurfaceFunctions2} -\index{PARSU2} -\begin{chunk}{sane} +\index[pkg]{ParametricSurfaceFunctions2!Domain} +\index[pkg]{Domain!ParametricSurfaceFunctions2} +\index[pkg]{PARSU2} +\begin{chunk}{defclass ParametricSurfaceFunctions2Type} (defclass |ParametricSurfaceFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametricSurfaceFunctions2") @@ -33780,7 +34483,7 @@ Value = NIL (abbreviation :initform 'PARSU2) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33794,10 +34497,10 @@ Value = NIL \end{chunk} \subsection{ParametrizationPackage} -\index{ParametrizationPackage!Domain} -\index{Domain!ParametrizationPackage} -\index{PARAMP} -\begin{chunk}{sane} +\index[pkg]{ParametrizationPackage!Domain} +\index[pkg]{Domain!ParametrizationPackage} +\index[pkg]{PARAMP} +\begin{chunk}{defclass ParametrizationPackageType} (defclass |ParametrizationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ParametrizationPackage") @@ -33805,7 +34508,7 @@ Value = NIL (abbreviation :initform 'PARAMP) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33819,10 +34522,10 @@ Value = NIL \end{chunk} \subsection{PartialFractionPackage} -\index{PartialFractionPackage!Domain} -\index{Domain!PartialFractionPackage} -\index{PFRPAC} -\begin{chunk}{sane} +\index[pkg]{PartialFractionPackage!Domain} +\index[pkg]{Domain!PartialFractionPackage} +\index[pkg]{PFRPAC} +\begin{chunk}{defclass PartialFractionPackageType} (defclass |PartialFractionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PartialFractionPackage") @@ -33834,7 +34537,7 @@ Value = NIL "The user gives a fraction of polynomials, and a variable and" "the package converts it to the proper datatype for the" "PartialFraction domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33848,10 +34551,10 @@ Value = NIL \end{chunk} \subsection{PartitionsAndPermutations} -\index{PartitionsAndPermutations!Domain} -\index{Domain!PartitionsAndPermutations} -\index{PARTPERM} -\begin{chunk}{sane} +\index[pkg]{PartitionsAndPermutations!Domain} +\index[pkg]{Domain!PartitionsAndPermutations} +\index[pkg]{PARTPERM} +\begin{chunk}{defclass PartitionsAndPermutationsType} (defclass |PartitionsAndPermutationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PartitionsAndPermutations") @@ -33861,7 +34564,7 @@ Value = NIL "PartitionsAndPermutations contains functions for generating streams of" "integer partitions, and streams of sequences of integers" "composed from a multi-set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33875,10 +34578,10 @@ Value = NIL \end{chunk} \subsection{PatternFunctions1} -\index{PatternFunctions1!Domain} -\index{Domain!PatternFunctions1} -\index{PATTERN1} -\begin{chunk}{sane} +\index[pkg]{PatternFunctions1!Domain} +\index[pkg]{Domain!PatternFunctions1} +\index[pkg]{PATTERN1} +\begin{chunk}{defclass PatternFunctions1Type} (defclass |PatternFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternFunctions1") @@ -33886,7 +34589,7 @@ Value = NIL (abbreviation :initform 'PATTERN1) (comment :initform (list "Utilities for handling patterns")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33900,10 +34603,10 @@ Value = NIL \end{chunk} \subsection{PatternFunctions2} -\index{PatternFunctions2!Domain} -\index{Domain!PatternFunctions2} -\index{PATTERN2} -\begin{chunk}{sane} +\index[pkg]{PatternFunctions2!Domain} +\index[pkg]{Domain!PatternFunctions2} +\index[pkg]{PATTERN2} +\begin{chunk}{defclass PatternFunctions2Type} (defclass |PatternFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternFunctions2") @@ -33911,7 +34614,7 @@ Value = NIL (abbreviation :initform 'PATTERN2) (comment :initform (list "Lifts maps to patterns")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33925,10 +34628,10 @@ Value = NIL \end{chunk} \subsection{PatternMatch} -\index{PatternMatch!Domain} -\index{Domain!PatternMatch} -\index{PATMATCH} -\begin{chunk}{sane} +\index[pkg]{PatternMatch!Domain} +\index[pkg]{Domain!PatternMatch} +\index[pkg]{PATMATCH} +\begin{chunk}{defclass PatternMatchType} (defclass |PatternMatchType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatch") @@ -33936,7 +34639,7 @@ Value = NIL (abbreviation :initform 'PATMATCH) (comment :initform (list "This package provides the top-level pattern macthing functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33950,10 +34653,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchAssertions} -\index{PatternMatchAssertions!Domain} -\index{Domain!PatternMatchAssertions} -\index{PMASS} -\begin{chunk}{sane} +\index[pkg]{PatternMatchAssertions!Domain} +\index[pkg]{Domain!PatternMatchAssertions} +\index[pkg]{PMASS} +\begin{chunk}{defclass PatternMatchAssertionsType} (defclass |PatternMatchAssertionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchAssertions") @@ -33961,7 +34664,7 @@ Value = NIL (abbreviation :initform 'PMASS) (comment :initform (list "Attaching assertions to symbols for pattern matching;")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -33975,10 +34678,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchFunctionSpace} -\index{PatternMatchFunctionSpace!Domain} -\index{Domain!PatternMatchFunctionSpace} -\index{PMFS} -\begin{chunk}{sane} +\index[pkg]{PatternMatchFunctionSpace!Domain} +\index[pkg]{Domain!PatternMatchFunctionSpace} +\index[pkg]{PMFS} +\begin{chunk}{defclass PatternMatchFunctionSpaceType} (defclass |PatternMatchFunctionSpaceType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchFunctionSpace") @@ -33986,7 +34689,7 @@ Value = NIL (abbreviation :initform 'PMFS) (comment :initform (list "This package provides pattern matching functions on function spaces.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34000,10 +34703,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchIntegerNumberSystem} -\index{PatternMatchIntegerNumberSystem!Domain} -\index{Domain!PatternMatchIntegerNumberSystem} -\index{PMINS} -\begin{chunk}{sane} +\index[pkg]{PatternMatchIntegerNumberSystem!Domain} +\index[pkg]{Domain!PatternMatchIntegerNumberSystem} +\index[pkg]{PMINS} +\begin{chunk}{defclass PatternMatchIntegerNumberSystemType} (defclass |PatternMatchIntegerNumberSystemType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchIntegerNumberSystem") @@ -34011,7 +34714,7 @@ Value = NIL (abbreviation :initform 'PMINS) (comment :initform (list "This package provides pattern matching functions on integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34025,10 +34728,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchIntegration} -\index{PatternMatchIntegration!Domain} -\index{Domain!PatternMatchIntegration} -\index{INTPM} -\begin{chunk}{sane} +\index[pkg]{PatternMatchIntegration!Domain} +\index[pkg]{Domain!PatternMatchIntegration} +\index[pkg]{INTPM} +\begin{chunk}{defclass PatternMatchIntegrationType} (defclass |PatternMatchIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchIntegration") @@ -34038,7 +34741,7 @@ Value = NIL "PatternMatchIntegration provides functions that use" "the pattern matcher to find some indefinite and definite integrals" "involving special functions and found in the litterature.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34052,10 +34755,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchKernel} -\index{PatternMatchKernel!Domain} -\index{Domain!PatternMatchKernel} -\index{PMKERNEL} -\begin{chunk}{sane} +\index[pkg]{PatternMatchKernel!Domain} +\index[pkg]{Domain!PatternMatchKernel} +\index[pkg]{PMKERNEL} +\begin{chunk}{defclass PatternMatchKernelType} (defclass |PatternMatchKernelType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchKernel") @@ -34063,7 +34766,7 @@ Value = NIL (abbreviation :initform 'PMKERNEL) (comment :initform (list "This package provides pattern matching functions on kernels.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34077,10 +34780,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchListAggregate} -\index{PatternMatchListAggregate!Domain} -\index{Domain!PatternMatchListAggregate} -\index{PMLSAGG} -\begin{chunk}{sane} +\index[pkg]{PatternMatchListAggregate!Domain} +\index[pkg]{Domain!PatternMatchListAggregate} +\index[pkg]{PMLSAGG} +\begin{chunk}{defclass PatternMatchListAggregateType} (defclass |PatternMatchListAggregateType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchListAggregate") @@ -34088,7 +34791,7 @@ Value = NIL (abbreviation :initform 'PMLSAGG) (comment :initform (list "This package provides pattern matching functions on lists.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34102,10 +34805,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchPolynomialCategory} -\index{PatternMatchPolynomialCategory!Domain} -\index{Domain!PatternMatchPolynomialCategory} -\index{PMPLCAT} -\begin{chunk}{sane} +\index[pkg]{PatternMatchPolynomialCategory!Domain} +\index[pkg]{Domain!PatternMatchPolynomialCategory} +\index[pkg]{PMPLCAT} +\begin{chunk}{defclass PatternMatchPolynomialCategoryType} (defclass |PatternMatchPolynomialCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchPolynomialCategory") @@ -34113,7 +34816,7 @@ Value = NIL (abbreviation :initform 'PMPLCAT) (comment :initform (list "This package provides pattern matching functions on polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34127,10 +34830,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchPushDown} -\index{PatternMatchPushDown!Domain} -\index{Domain!PatternMatchPushDown} -\index{PMDOWN} -\begin{chunk}{sane} +\index[pkg]{PatternMatchPushDown!Domain} +\index[pkg]{Domain!PatternMatchPushDown} +\index[pkg]{PMDOWN} +\begin{chunk}{defclass PatternMatchPushDownType} (defclass |PatternMatchPushDownType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchPushDown") @@ -34138,7 +34841,7 @@ Value = NIL (abbreviation :initform 'PMDOWN) (comment :initform (list "This packages provides tools for matching recursively in type towers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34152,10 +34855,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchQuotientFieldCategory} -\index{PatternMatchQuotientFieldCategory!Domain} -\index{Domain!PatternMatchQuotientFieldCategory} -\index{PMQFCAT} -\begin{chunk}{sane} +\index[pkg]{PatternMatchQuotientFieldCategory!Domain} +\index[pkg]{Domain!PatternMatchQuotientFieldCategory} +\index[pkg]{PMQFCAT} +\begin{chunk}{defclass PatternMatchQuotientFieldCategoryType} (defclass |PatternMatchQuotientFieldCategoryType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchQuotientFieldCategory") @@ -34163,7 +34866,7 @@ Value = NIL (abbreviation :initform 'PMQFCAT) (comment :initform (list "This package provides pattern matching functions on quotients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34177,10 +34880,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchResultFunctions2} -\index{PatternMatchResultFunctions2!Domain} -\index{Domain!PatternMatchResultFunctions2} -\index{PATRES2} -\begin{chunk}{sane} +\index[pkg]{PatternMatchResultFunctions2!Domain} +\index[pkg]{Domain!PatternMatchResultFunctions2} +\index[pkg]{PATRES2} +\begin{chunk}{defclass PatternMatchResultFunctions2Type} (defclass |PatternMatchResultFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchResultFunctions2") @@ -34188,7 +34891,7 @@ Value = NIL (abbreviation :initform 'PATRES2) (comment :initform (list "Lifts maps to pattern matching results.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34202,10 +34905,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchSymbol} -\index{PatternMatchSymbol!Domain} -\index{Domain!PatternMatchSymbol} -\index{PMSYM} -\begin{chunk}{sane} +\index[pkg]{PatternMatchSymbol!Domain} +\index[pkg]{Domain!PatternMatchSymbol} +\index[pkg]{PMSYM} +\begin{chunk}{defclass PatternMatchSymbolType} (defclass |PatternMatchSymbolType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchSymbol") @@ -34213,7 +34916,7 @@ Value = NIL (abbreviation :initform 'PMSYM) (comment :initform (list "This package provides pattern matching functions on symbols.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34227,10 +34930,10 @@ Value = NIL \end{chunk} \subsection{PatternMatchTools} -\index{PatternMatchTools!Domain} -\index{Domain!PatternMatchTools} -\index{PMTOOLS} -\begin{chunk}{sane} +\index[pkg]{PatternMatchTools!Domain} +\index[pkg]{Domain!PatternMatchTools} +\index[pkg]{PMTOOLS} +\begin{chunk}{defclass PatternMatchToolsType} (defclass |PatternMatchToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PatternMatchTools") @@ -34238,7 +34941,7 @@ Value = NIL (abbreviation :initform 'PMTOOLS) (comment :initform (list "This package provides tools for the pattern matcher.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34252,10 +34955,10 @@ Value = NIL \end{chunk} \subsection{Permanent} -\index{Permanent!Domain} -\index{Domain!Permanent} -\index{PERMAN} -\begin{chunk}{sane} +\index[pkg]{Permanent!Domain} +\index[pkg]{Domain!Permanent} +\index[pkg]{PERMAN} +\begin{chunk}{defclass PermanentType} (defclass |PermanentType| (|AxiomClass|) ((parents :initform ()) (name :initform "Permanent") @@ -34264,7 +34967,7 @@ Value = NIL (comment :initform (list "Permanent implements the functions permanent, the" "permanent for square matrices.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34278,10 +34981,10 @@ Value = NIL \end{chunk} \subsection{PermutationGroupExamples} -\index{PermutationGroupExamples!Domain} -\index{Domain!PermutationGroupExamples} -\index{PGE} -\begin{chunk}{sane} +\index[pkg]{PermutationGroupExamples!Domain} +\index[pkg]{Domain!PermutationGroupExamples} +\index[pkg]{PGE} +\begin{chunk}{defclass PermutationGroupExamplesType} (defclass |PermutationGroupExamplesType| (|AxiomClass|) ((parents :initform ()) (name :initform "PermutationGroupExamples") @@ -34294,7 +34997,7 @@ Value = NIL "of symmetric groups called Young subgroups." "Furthermore, Rubik's group as permutation group of 48 integers and a list" "of sporadic simple groups derived from the atlas of finite groups.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34308,10 +35011,10 @@ Value = NIL \end{chunk} \subsection{PiCoercions} -\index{PiCoercions!Domain} -\index{Domain!PiCoercions} -\index{PICOERCE} -\begin{chunk}{sane} +\index[pkg]{PiCoercions!Domain} +\index[pkg]{Domain!PiCoercions} +\index[pkg]{PICOERCE} +\begin{chunk}{defclass PiCoercionsType} (defclass |PiCoercionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PiCoercions") @@ -34320,7 +35023,7 @@ Value = NIL (comment :initform (list "Provides a coercion from the symbolic fractions in %pi with" "integer coefficients to any Expression type.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34334,10 +35037,10 @@ Value = NIL \end{chunk} \subsection{PlotFunctions1} -\index{PlotFunctions1!Domain} -\index{Domain!PlotFunctions1} -\index{PLOT1} -\begin{chunk}{sane} +\index[pkg]{PlotFunctions1!Domain} +\index[pkg]{Domain!PlotFunctions1} +\index[pkg]{PLOT1} +\begin{chunk}{defclass PlotFunctions1Type} (defclass |PlotFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PlotFunctions1") @@ -34346,7 +35049,7 @@ Value = NIL (comment :initform (list "PlotFunctions1 provides facilities for plotting curves" "where functions SF -> SF are specified by giving an expression")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34360,10 +35063,10 @@ Value = NIL \end{chunk} \subsection{PlotTools} -\index{PlotTools!Domain} -\index{Domain!PlotTools} -\index{PLOTTOOL} -\begin{chunk}{sane} +\index[pkg]{PlotTools!Domain} +\index[pkg]{Domain!PlotTools} +\index[pkg]{PLOTTOOL} +\begin{chunk}{defclass PlotToolsType} (defclass |PlotToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PlotTools") @@ -34371,7 +35074,7 @@ Value = NIL (abbreviation :initform 'PLOTTOOL) (comment :initform (list "This package exports plotting tools")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34385,10 +35088,10 @@ Value = NIL \end{chunk} \subsection{ProjectiveAlgebraicSetPackage} -\index{ProjectiveAlgebraicSetPackage!Domain} -\index{Domain!ProjectiveAlgebraicSetPackage} -\index{PRJALGPK} -\begin{chunk}{sane} +\index[pkg]{ProjectiveAlgebraicSetPackage!Domain} +\index[pkg]{Domain!ProjectiveAlgebraicSetPackage} +\index[pkg]{PRJALGPK} +\begin{chunk}{defclass ProjectiveAlgebraicSetPackageType} (defclass |ProjectiveAlgebraicSetPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "ProjectiveAlgebraicSetPackage") @@ -34396,7 +35099,7 @@ Value = NIL (abbreviation :initform 'PRJALGPK) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34410,10 +35113,10 @@ Value = NIL \end{chunk} \subsection{PointFunctions2} -\index{PointFunctions2!Domain} -\index{Domain!PointFunctions2} -\index{PTFUNC2} -\begin{chunk}{sane} +\index[pkg]{PointFunctions2!Domain} +\index[pkg]{Domain!PointFunctions2} +\index[pkg]{PTFUNC2} +\begin{chunk}{defclass PointFunctions2Type} (defclass |PointFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PointFunctions2") @@ -34421,7 +35124,7 @@ Value = NIL (abbreviation :initform 'PTFUNC2) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34435,10 +35138,10 @@ Value = NIL \end{chunk} \subsection{PointPackage} -\index{PointPackage!Domain} -\index{Domain!PointPackage} -\index{PTPACK} -\begin{chunk}{sane} +\index[pkg]{PointPackage!Domain} +\index[pkg]{Domain!PointPackage} +\index[pkg]{PTPACK} +\begin{chunk}{defclass PointPackageType} (defclass |PointPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PointPackage") @@ -34446,7 +35149,7 @@ Value = NIL (abbreviation :initform 'PTPACK) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34460,10 +35163,10 @@ Value = NIL \end{chunk} \subsection{PointsOfFiniteOrder} -\index{PointsOfFiniteOrder!Domain} -\index{Domain!PointsOfFiniteOrder} -\index{PFO} -\begin{chunk}{sane} +\index[pkg]{PointsOfFiniteOrder!Domain} +\index[pkg]{Domain!PointsOfFiniteOrder} +\index[pkg]{PFO} +\begin{chunk}{defclass PointsOfFiniteOrderType} (defclass |PointsOfFiniteOrderType| (|AxiomClass|) ((parents :initform ()) (name :initform "PointsOfFiniteOrder") @@ -34472,7 +35175,7 @@ Value = NIL (comment :initform (list "This package provides function for testing whether a divisor on a" "curve is a torsion divisor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34486,10 +35189,10 @@ Value = NIL \end{chunk} \subsection{PointsOfFiniteOrderRational} -\index{PointsOfFiniteOrderRational!Domain} -\index{Domain!PointsOfFiniteOrderRational} -\index{PFOQ} -\begin{chunk}{sane} +\index[pkg]{PointsOfFiniteOrderRational!Domain} +\index[pkg]{Domain!PointsOfFiniteOrderRational} +\index[pkg]{PFOQ} +\begin{chunk}{defclass PointsOfFiniteOrderRationalType} (defclass |PointsOfFiniteOrderRationalType| (|AxiomClass|) ((parents :initform ()) (name :initform "PointsOfFiniteOrderRational") @@ -34498,7 +35201,7 @@ Value = NIL (comment :initform (list "This package provides function for testing whether a divisor on a" "curve is a torsion divisor.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34512,10 +35215,10 @@ Value = NIL \end{chunk} \subsection{PointsOfFiniteOrderTools} -\index{PointsOfFiniteOrderTools!Domain} -\index{Domain!PointsOfFiniteOrderTools} -\index{PFOTOOLS} -\begin{chunk}{sane} +\index[pkg]{PointsOfFiniteOrderTools!Domain} +\index[pkg]{Domain!PointsOfFiniteOrderTools} +\index[pkg]{PFOTOOLS} +\begin{chunk}{defclass PointsOfFiniteOrderToolsType} (defclass |PointsOfFiniteOrderToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PointsOfFiniteOrderTools") @@ -34523,7 +35226,7 @@ Value = NIL (abbreviation :initform 'PFOTOOLS) (comment :initform (list "Utilities for PFOQ and PFO")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34537,10 +35240,10 @@ Value = NIL \end{chunk} \subsection{PolynomialPackageForCurve} -\index{PolynomialPackageForCurve!Domain} -\index{Domain!PolynomialPackageForCurve} -\index{PLPKCRV} -\begin{chunk}{sane} +\index[pkg]{PolynomialPackageForCurve!Domain} +\index[pkg]{Domain!PolynomialPackageForCurve} +\index[pkg]{PLPKCRV} +\begin{chunk}{defclass PolynomialPackageForCurveType} (defclass |PolynomialPackageForCurveType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialPackageForCurve") @@ -34548,7 +35251,7 @@ Value = NIL (abbreviation :initform 'PLPKCRV) (comment :initform (list "The following is part of the PAFF package")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34562,10 +35265,10 @@ Value = NIL \end{chunk} \subsection{PolToPol} -\index{PolToPol!Domain} -\index{Domain!PolToPol} -\index{POLTOPOL} -\begin{chunk}{sane} +\index[pkg]{PolToPol!Domain} +\index[pkg]{Domain!PolToPol} +\index[pkg]{POLTOPOL} +\begin{chunk}{defclass PolToPolType} (defclass |PolToPolType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolToPol") @@ -34573,7 +35276,7 @@ Value = NIL (abbreviation :initform 'POLTOPOL) (comment :initform (list "Package with the conversion functions among different kind of polynomials")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34587,10 +35290,10 @@ Value = NIL \end{chunk} \subsection{PolyGroebner} -\index{PolyGroebner!Domain} -\index{Domain!PolyGroebner} -\index{PGROEB} -\begin{chunk}{sane} +\index[pkg]{PolyGroebner!Domain} +\index[pkg]{Domain!PolyGroebner} +\index[pkg]{PGROEB} +\begin{chunk}{defclass PolyGroebnerType} (defclass |PolyGroebnerType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolyGroebner") @@ -34608,7 +35311,7 @@ Value = NIL "of variables which is passed as a second argument. The coefficient" "domain is allowed to be any gcd domain, but the groebner basis is" "computed as if the polynomials were over a field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34622,10 +35325,10 @@ Value = NIL \end{chunk} \subsection{PolynomialAN2Expression} -\index{PolynomialAN2Expression!Domain} -\index{Domain!PolynomialAN2Expression} -\index{PAN2EXPR} -\begin{chunk}{sane} +\index[pkg]{PolynomialAN2Expression!Domain} +\index[pkg]{Domain!PolynomialAN2Expression} +\index[pkg]{PAN2EXPR} +\begin{chunk}{defclass PolynomialAN2ExpressionType} (defclass |PolynomialAN2ExpressionType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialAN2Expression") @@ -34634,7 +35337,7 @@ Value = NIL (comment :initform (list "This package provides a coerce from polynomials over" "algebraic numbers to Expression AlgebraicNumber.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34648,10 +35351,10 @@ Value = NIL \end{chunk} \subsection{PolynomialCategoryLifting} -\index{PolynomialCategoryLifting!Domain} -\index{Domain!PolynomialCategoryLifting} -\index{POLYLIFT} -\begin{chunk}{sane} +\index[pkg]{PolynomialCategoryLifting!Domain} +\index[pkg]{Domain!PolynomialCategoryLifting} +\index[pkg]{POLYLIFT} +\begin{chunk}{defclass PolynomialCategoryLiftingType} (defclass |PolynomialCategoryLiftingType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialCategoryLifting") @@ -34662,7 +35365,7 @@ Value = NIL "given a set S and polynomials over R with maps from the" "variables into S and the coefficients into S, maps polynomials" "into S. S is assumed to support +, * and **.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34676,10 +35379,10 @@ Value = NIL \end{chunk} \subsection{PolynomialCategoryQuotientFunctions} -\index{PolynomialCategoryQuotientFunctions!Domain} -\index{Domain!PolynomialCategoryQuotientFunctions} -\index{POLYCATQ} -\begin{chunk}{sane} +\index[pkg]{PolynomialCategoryQuotientFunctions!Domain} +\index[pkg]{Domain!PolynomialCategoryQuotientFunctions} +\index[pkg]{POLYCATQ} +\begin{chunk}{defclass PolynomialCategoryQuotientFunctionsType} (defclass |PolynomialCategoryQuotientFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialCategoryQuotientFunctions") @@ -34689,7 +35392,7 @@ Value = NIL "Manipulations on polynomial quotients" "This package transforms multivariate polynomials or fractions into" "univariate polynomials or fractions, and back.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34703,10 +35406,10 @@ Value = NIL \end{chunk} \subsection{PolynomialComposition} -\index{PolynomialComposition!Domain} -\index{Domain!PolynomialComposition} -\index{PCOMP} -\begin{chunk}{sane} +\index[pkg]{PolynomialComposition!Domain} +\index[pkg]{Domain!PolynomialComposition} +\index[pkg]{PCOMP} +\begin{chunk}{defclass PolynomialCompositionType} (defclass |PolynomialCompositionType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialComposition") @@ -34715,7 +35418,7 @@ Value = NIL (comment :initform (list "Polynomial composition and decomposition functions" "If f = g o h then g=leftFactor(f,h) and h=rightFactor(f,g)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34729,10 +35432,10 @@ Value = NIL \end{chunk} \subsection{PolynomialDecomposition} -\index{PolynomialDecomposition!Domain} -\index{Domain!PolynomialDecomposition} -\index{PDECOMP} -\begin{chunk}{sane} +\index[pkg]{PolynomialDecomposition!Domain} +\index[pkg]{Domain!PolynomialDecomposition} +\index[pkg]{PDECOMP} +\begin{chunk}{defclass PolynomialDecompositionType} (defclass |PolynomialDecompositionType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialDecomposition") @@ -34741,7 +35444,7 @@ Value = NIL (comment :initform (list "Polynomial composition and decomposition functions" "If f = g o h then g=leftFactor(f,h) and h=rightFactor(f,g)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34755,10 +35458,10 @@ Value = NIL \end{chunk} \subsection{PolynomialFactorizationByRecursion} -\index{PolynomialFactorizationByRecursion!Domain} -\index{Domain!PolynomialFactorizationByRecursion} -\index{PFBR} -\begin{chunk}{sane} +\index[pkg]{PolynomialFactorizationByRecursion!Domain} +\index[pkg]{Domain!PolynomialFactorizationByRecursion} +\index[pkg]{PFBR} +\begin{chunk}{defclass PolynomialFactorizationByRecursionType} (defclass |PolynomialFactorizationByRecursionType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialFactorizationByRecursion") @@ -34768,7 +35471,7 @@ Value = NIL "PolynomialFactorizationByRecursion(R,E,VarSet,S)" "is used for factorization of sparse univariate polynomials over" "a domain S of multivariate polynomials over R.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34782,10 +35485,10 @@ Value = NIL \end{chunk} \subsection{PolynomialFactorizationByRecursionUnivariate} -\index{PolynomialFactorizationByRecursionUnivariate!Domain} -\index{Domain!PolynomialFactorizationByRecursionUnivariate} -\index{PFBRU} -\begin{chunk}{sane} +\index[pkg]{PolynomialFactorizationByRecursionUnivariate!Domain} +\index[pkg]{Domain!PolynomialFactorizationByRecursionUnivariate} +\index[pkg]{PFBRU} +\begin{chunk}{defclass PolynomialFactorizationByRecursionUnivariateType} (defclass |PolynomialFactorizationByRecursionUnivariateType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialFactorizationByRecursionUnivariate") @@ -34797,7 +35500,7 @@ Value = NIL "S is univariate polynomials over R" "We are interested in handling SparseUnivariatePolynomials over" "S, is a variable we shall call z")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34811,10 +35514,10 @@ Value = NIL \end{chunk} \subsection{PolynomialFunctions2} -\index{PolynomialFunctions2!Domain} -\index{Domain!PolynomialFunctions2} -\index{POLY2} -\begin{chunk}{sane} +\index[pkg]{PolynomialFunctions2!Domain} +\index[pkg]{Domain!PolynomialFunctions2} +\index[pkg]{POLY2} +\begin{chunk}{defclass PolynomialFunctions2Type} (defclass |PolynomialFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialFunctions2") @@ -34823,7 +35526,7 @@ Value = NIL (comment :initform (list "This package takes a mapping between coefficient rings, and lifts" "it to a mapping between polynomials over those rings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34837,10 +35540,10 @@ Value = NIL \end{chunk} \subsection{PolynomialGcdPackage} -\index{PolynomialGcdPackage!Domain} -\index{Domain!PolynomialGcdPackage} -\index{PGCD} -\begin{chunk}{sane} +\index[pkg]{PolynomialGcdPackage!Domain} +\index[pkg]{Domain!PolynomialGcdPackage} +\index[pkg]{PGCD} +\begin{chunk}{defclass PolynomialGcdPackageType} (defclass |PolynomialGcdPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialGcdPackage") @@ -34852,7 +35555,7 @@ Value = NIL "domain is imposed by the lifting strategy. It is assumed that" "the coefficient domain has the property that almost all specializations" "preserve the degree of the gcd.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34866,10 +35569,10 @@ Value = NIL \end{chunk} \subsection{PolynomialInterpolation} -\index{PolynomialInterpolation!Domain} -\index{Domain!PolynomialInterpolation} -\index{PINTERP} -\begin{chunk}{sane} +\index[pkg]{PolynomialInterpolation!Domain} +\index[pkg]{Domain!PolynomialInterpolation} +\index[pkg]{PINTERP} +\begin{chunk}{defclass PolynomialInterpolationType} (defclass |PolynomialInterpolationType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialInterpolation") @@ -34877,7 +35580,7 @@ Value = NIL (abbreviation :initform 'PINTERP) (comment :initform (list "This package exports interpolation algorithms")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34891,10 +35594,10 @@ Value = NIL \end{chunk} \subsection{PolynomialInterpolationAlgorithms} -\index{PolynomialInterpolationAlgorithms!Domain} -\index{Domain!PolynomialInterpolationAlgorithms} -\index{PINTERPA} -\begin{chunk}{sane} +\index[pkg]{PolynomialInterpolationAlgorithms!Domain} +\index[pkg]{Domain!PolynomialInterpolationAlgorithms} +\index[pkg]{PINTERPA} +\begin{chunk}{defclass PolynomialInterpolationAlgorithmsType} (defclass |PolynomialInterpolationAlgorithmsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialInterpolationAlgorithms") @@ -34902,7 +35605,7 @@ Value = NIL (abbreviation :initform 'PINTERPA) (comment :initform (list "This package exports interpolation algorithms")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34916,10 +35619,10 @@ Value = NIL \end{chunk} \subsection{PolynomialNumberTheoryFunctions} -\index{PolynomialNumberTheoryFunctions!Domain} -\index{Domain!PolynomialNumberTheoryFunctions} -\index{PNTHEORY} -\begin{chunk}{sane} +\index[pkg]{PolynomialNumberTheoryFunctions!Domain} +\index[pkg]{Domain!PolynomialNumberTheoryFunctions} +\index[pkg]{PNTHEORY} +\begin{chunk}{defclass PolynomialNumberTheoryFunctionsType} (defclass |PolynomialNumberTheoryFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialNumberTheoryFunctions") @@ -34928,7 +35631,7 @@ Value = NIL (comment :initform (list "This package provides various polynomial number theoretic functions" "over the integers.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34942,10 +35645,10 @@ Value = NIL \end{chunk} \subsection{PolynomialRoots} -\index{PolynomialRoots!Domain} -\index{Domain!PolynomialRoots} -\index{POLYROOT} -\begin{chunk}{sane} +\index[pkg]{PolynomialRoots!Domain} +\index[pkg]{Domain!PolynomialRoots} +\index[pkg]{POLYROOT} +\begin{chunk}{defclass PolynomialRootsType} (defclass |PolynomialRootsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialRoots") @@ -34953,7 +35656,7 @@ Value = NIL (abbreviation :initform 'POLYROOT) (comment :initform (list "Computes n-th roots of quotients of multivariate polynomials")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34967,10 +35670,10 @@ Value = NIL \end{chunk} \subsection{PolynomialSetUtilitiesPackage} -\index{PolynomialSetUtilitiesPackage!Domain} -\index{Domain!PolynomialSetUtilitiesPackage} -\index{PSETPK} -\begin{chunk}{sane} +\index[pkg]{PolynomialSetUtilitiesPackage!Domain} +\index[pkg]{Domain!PolynomialSetUtilitiesPackage} +\index[pkg]{PSETPK} +\begin{chunk}{defclass PolynomialSetUtilitiesPackageType} (defclass |PolynomialSetUtilitiesPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialSetUtilitiesPackage") @@ -34981,7 +35684,7 @@ Value = NIL "The aim of many of the operations of this package is to remove certain" "factors in some polynomials in order to avoid unnecessary computations" "in algorithms involving splitting techniques by partial factorization.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -34995,10 +35698,10 @@ Value = NIL \end{chunk} \subsection{PolynomialSolveByFormulas} -\index{PolynomialSolveByFormulas!Domain} -\index{Domain!PolynomialSolveByFormulas} -\index{SOLVEFOR} -\begin{chunk}{sane} +\index[pkg]{PolynomialSolveByFormulas!Domain} +\index[pkg]{Domain!PolynomialSolveByFormulas} +\index[pkg]{SOLVEFOR} +\begin{chunk}{defclass PolynomialSolveByFormulasType} (defclass |PolynomialSolveByFormulasType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialSolveByFormulas") @@ -35009,7 +35712,7 @@ Value = NIL "allowing their recursive use over different domains." "Care is taken to introduce few radicals so that radical extension" "domains can more easily simplify the results.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35023,10 +35726,10 @@ Value = NIL \end{chunk} \subsection{PolynomialSquareFree} -\index{PolynomialSquareFree!Domain} -\index{Domain!PolynomialSquareFree} -\index{PSQFR} -\begin{chunk}{sane} +\index[pkg]{PolynomialSquareFree!Domain} +\index[pkg]{Domain!PolynomialSquareFree} +\index[pkg]{PSQFR} +\begin{chunk}{defclass PolynomialSquareFreeType} (defclass |PolynomialSquareFreeType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialSquareFree") @@ -35040,7 +35743,7 @@ Value = NIL "removed so that factors will be primitive as well as square-free." "Over an infinite ring of finite characteristic,it may not be possible to" "guarantee that the factors are square-free.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35054,10 +35757,10 @@ Value = NIL \end{chunk} \subsection{PolynomialToUnivariatePolynomial} -\index{PolynomialToUnivariatePolynomial!Domain} -\index{Domain!PolynomialToUnivariatePolynomial} -\index{POLY2UP} -\begin{chunk}{sane} +\index[pkg]{PolynomialToUnivariatePolynomial!Domain} +\index[pkg]{Domain!PolynomialToUnivariatePolynomial} +\index[pkg]{POLY2UP} +\begin{chunk}{defclass PolynomialToUnivariatePolynomialType} (defclass |PolynomialToUnivariatePolynomialType| (|AxiomClass|) ((parents :initform ()) (name :initform "PolynomialToUnivariatePolynomial") @@ -35069,7 +35772,7 @@ Value = NIL "univariate polynomial in one of its variables with" "coefficients which are again a polynomial in all the" "other variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35083,10 +35786,10 @@ Value = NIL \end{chunk} \subsection{PowerSeriesLimitPackage} -\index{PowerSeriesLimitPackage!Domain} -\index{Domain!PowerSeriesLimitPackage} -\index{LIMITPS} -\begin{chunk}{sane} +\index[pkg]{PowerSeriesLimitPackage!Domain} +\index[pkg]{Domain!PowerSeriesLimitPackage} +\index[pkg]{LIMITPS} +\begin{chunk}{defclass PowerSeriesLimitPackageType} (defclass |PowerSeriesLimitPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PowerSeriesLimitPackage") @@ -35097,7 +35800,7 @@ Value = NIL "in one or more variables as one of the variables approaches a" "limiting value. Included are two-sided limits, left- and right-" "hand limits, and limits at plus or minus infinity.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35111,10 +35814,10 @@ Value = NIL \end{chunk} \subsection{PrecomputedAssociatedEquations} -\index{PrecomputedAssociatedEquations!Domain} -\index{Domain!PrecomputedAssociatedEquations} -\index{PREASSOC} -\begin{chunk}{sane} +\index[pkg]{PrecomputedAssociatedEquations!Domain} +\index[pkg]{Domain!PrecomputedAssociatedEquations} +\index[pkg]{PREASSOC} +\begin{chunk}{defclass PrecomputedAssociatedEquationsType} (defclass |PrecomputedAssociatedEquationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "PrecomputedAssociatedEquations") @@ -35124,7 +35827,7 @@ Value = NIL "PrecomputedAssociatedEquations stores some generic" "precomputations which speed up the computations of the" "associated equations needed for factoring operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35138,10 +35841,10 @@ Value = NIL \end{chunk} \subsection{PrimitiveArrayFunctions2} -\index{PrimitiveArrayFunctions2!Domain} -\index{Domain!PrimitiveArrayFunctions2} -\index{PRIMARR2} -\begin{chunk}{sane} +\index[pkg]{PrimitiveArrayFunctions2!Domain} +\index[pkg]{Domain!PrimitiveArrayFunctions2} +\index[pkg]{PRIMARR2} +\begin{chunk}{defclass PrimitiveArrayFunctions2Type} (defclass |PrimitiveArrayFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "PrimitiveArrayFunctions2") @@ -35150,7 +35853,7 @@ Value = NIL (comment :initform (list "This package provides tools for operating on primitive arrays" "with unary and binary functions involving different underlying types")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35164,10 +35867,10 @@ Value = NIL \end{chunk} \subsection{PrimitiveElement} -\index{PrimitiveElement!Domain} -\index{Domain!PrimitiveElement} -\index{PRIMELT} -\begin{chunk}{sane} +\index[pkg]{PrimitiveElement!Domain} +\index[pkg]{Domain!PrimitiveElement} +\index[pkg]{PRIMELT} +\begin{chunk}{defclass PrimitiveElementType} (defclass |PrimitiveElementType| (|AxiomClass|) ((parents :initform ()) (name :initform "PrimitiveElement") @@ -35176,7 +35879,7 @@ Value = NIL (comment :initform (list "PrimitiveElement provides functions to compute primitive elements" "in algebraic extensions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35190,10 +35893,10 @@ Value = NIL \end{chunk} \subsection{PrimitiveRatDE} -\index{PrimitiveRatDE!Domain} -\index{Domain!PrimitiveRatDE} -\index{ODEPRIM} -\begin{chunk}{sane} +\index[pkg]{PrimitiveRatDE!Domain} +\index[pkg]{Domain!PrimitiveRatDE} +\index[pkg]{ODEPRIM} +\begin{chunk}{defclass PrimitiveRatDEType} (defclass |PrimitiveRatDEType| (|AxiomClass|) ((parents :initform ()) (name :initform "PrimitiveRatDE") @@ -35203,7 +35906,7 @@ Value = NIL "PrimitiveRatDE provides functions for in-field solutions of linear" "ordinary differential equations, in the transcendental case." "The derivation to use is given by the parameter L.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35217,10 +35920,10 @@ Value = NIL \end{chunk} \subsection{PrimitiveRatRicDE} -\index{PrimitiveRatRicDE!Domain} -\index{Domain!PrimitiveRatRicDE} -\index{ODEPRRIC} -\begin{chunk}{sane} +\index[pkg]{PrimitiveRatRicDE!Domain} +\index[pkg]{Domain!PrimitiveRatRicDE} +\index[pkg]{ODEPRRIC} +\begin{chunk}{defclass PrimitiveRatRicDEType} (defclass |PrimitiveRatRicDEType| (|AxiomClass|) ((parents :initform ()) (name :initform "PrimitiveRatRicDE") @@ -35228,7 +35931,7 @@ Value = NIL (abbreviation :initform 'ODEPRRIC) (comment :initform (list "In-field solution of Riccati equations, primitive case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35242,10 +35945,10 @@ Value = NIL \end{chunk} \subsection{PrintPackage} -\index{PrintPackage!Domain} -\index{Domain!PrintPackage} -\index{PRINT} -\begin{chunk}{sane} +\index[pkg]{PrintPackage!Domain} +\index[pkg]{Domain!PrintPackage} +\index[pkg]{PRINT} +\begin{chunk}{defclass PrintPackageType} (defclass |PrintPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "PrintPackage") @@ -35253,7 +35956,7 @@ Value = NIL (abbreviation :initform 'PRINT) (comment :initform (list "PrintPackage provides a print function for output forms.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35267,10 +35970,10 @@ Value = NIL \end{chunk} \subsection{PseudoLinearNormalForm} -\index{PseudoLinearNormalForm!Domain} -\index{Domain!PseudoLinearNormalForm} -\index{PSEUDLIN} -\begin{chunk}{sane} +\index[pkg]{PseudoLinearNormalForm!Domain} +\index[pkg]{Domain!PseudoLinearNormalForm} +\index[pkg]{PSEUDLIN} +\begin{chunk}{defclass PseudoLinearNormalFormType} (defclass |PseudoLinearNormalFormType| (|AxiomClass|) ((parents :initform ()) (name :initform "PseudoLinearNormalForm") @@ -35279,7 +35982,7 @@ Value = NIL (comment :initform (list "PseudoLinearNormalForm provides a function for computing a block-companion" "form for pseudo-linear operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35293,10 +35996,10 @@ Value = NIL \end{chunk} \subsection{PseudoRemainderSequence} -\index{PseudoRemainderSequence!Domain} -\index{Domain!PseudoRemainderSequence} -\index{PRS} -\begin{chunk}{sane} +\index[pkg]{PseudoRemainderSequence!Domain} +\index[pkg]{Domain!PseudoRemainderSequence} +\index[pkg]{PRS} +\begin{chunk}{defclass PseudoRemainderSequenceType} (defclass |PseudoRemainderSequenceType| (|AxiomClass|) ((parents :initform ()) (name :initform "PseudoRemainderSequence") @@ -35308,7 +36011,7 @@ Value = NIL "resultantEuclidean, subResultantGcdEuclidean, semiSubResultantGcdEuclidean1," "semiSubResultantGcdEuclidean2" "These procedures come from improvements of the subresultants algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35322,10 +36025,10 @@ Value = NIL \end{chunk} \subsection{PureAlgebraicIntegration} -\index{PureAlgebraicIntegration!Domain} -\index{Domain!PureAlgebraicIntegration} -\index{INTPAF} -\begin{chunk}{sane} +\index[pkg]{PureAlgebraicIntegration!Domain} +\index[pkg]{Domain!PureAlgebraicIntegration} +\index[pkg]{INTPAF} +\begin{chunk}{defclass PureAlgebraicIntegrationType} (defclass |PureAlgebraicIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "PureAlgebraicIntegration") @@ -35336,7 +36039,7 @@ Value = NIL "This package provides functions for integration, limited integration," "extended integration and the risch differential equation for" "pure algebraic integrands.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35350,10 +36053,10 @@ Value = NIL \end{chunk} \subsection{PureAlgebraicLODE} -\index{PureAlgebraicLODE!Domain} -\index{Domain!PureAlgebraicLODE} -\index{ODEPAL} -\begin{chunk}{sane} +\index[pkg]{PureAlgebraicLODE!Domain} +\index[pkg]{Domain!PureAlgebraicLODE} +\index[pkg]{ODEPAL} +\begin{chunk}{defclass PureAlgebraicLODEType} (defclass |PureAlgebraicLODEType| (|AxiomClass|) ((parents :initform ()) (name :initform "PureAlgebraicLODE") @@ -35362,7 +36065,7 @@ Value = NIL (comment :initform (list "In-field solution of an linear ordinary differential equation," "pure algebraic case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35376,10 +36079,10 @@ Value = NIL \end{chunk} \subsection{PushVariables} -\index{PushVariables!Domain} -\index{Domain!PushVariables} -\index{PUSHVAR} -\begin{chunk}{sane} +\index[pkg]{PushVariables!Domain} +\index[pkg]{Domain!PushVariables} +\index[pkg]{PUSHVAR} +\begin{chunk}{defclass PushVariablesType} (defclass |PushVariablesType| (|AxiomClass|) ((parents :initform ()) (name :initform "PushVariables") @@ -35387,7 +36090,7 @@ Value = NIL (abbreviation :initform 'PUSHVAR) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35403,10 +36106,10 @@ Value = NIL \section{Q} \subsection{QuasiAlgebraicSet2} -\index{QuasiAlgebraicSet2!Domain} -\index{Domain!QuasiAlgebraicSet2} -\index{QALGSET2} -\begin{chunk}{sane} +\index[pkg]{QuasiAlgebraicSet2!Domain} +\index[pkg]{Domain!QuasiAlgebraicSet2} +\index[pkg]{QALGSET2} +\begin{chunk}{defclass QuasiAlgebraicSet2Type} (defclass |QuasiAlgebraicSet2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "QuasiAlgebraicSet2") @@ -35437,7 +36140,7 @@ Value = NIL "basis of radical ideals and" "is inefficient and restricted when compared to the" "two in QuasiAlgebraicSet.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35451,10 +36154,10 @@ Value = NIL \end{chunk} \subsection{QuasiComponentPackage} -\index{QuasiComponentPackage!Domain} -\index{Domain!QuasiComponentPackage} -\index{QCMPACK} -\begin{chunk}{sane} +\index[pkg]{QuasiComponentPackage!Domain} +\index[pkg]{Domain!QuasiComponentPackage} +\index[pkg]{QCMPACK} +\begin{chunk}{defclass QuasiComponentPackageType} (defclass |QuasiComponentPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "QuasiComponentPackage") @@ -35464,7 +36167,7 @@ Value = NIL "A package for removing redundant quasi-components and redundant" "branches when decomposing a variety by means of quasi-components" "of regular triangular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35478,10 +36181,10 @@ Value = NIL \end{chunk} \subsection{QuotientFieldCategoryFunctions2} -\index{QuotientFieldCategoryFunctions2!Domain} -\index{Domain!QuotientFieldCategoryFunctions2} -\index{QFCAT2} -\begin{chunk}{sane} +\index[pkg]{QuotientFieldCategoryFunctions2!Domain} +\index[pkg]{Domain!QuotientFieldCategoryFunctions2} +\index[pkg]{QFCAT2} +\begin{chunk}{defclass QuotientFieldCategoryFunctions2Type} (defclass |QuotientFieldCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "QuotientFieldCategoryFunctions2") @@ -35490,7 +36193,7 @@ Value = NIL (comment :initform (list "This package extends a function between integral domains" "to a mapping between their quotient fields.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35504,10 +36207,10 @@ Value = NIL \end{chunk} \subsection{QuaternionCategoryFunctions2} -\index{QuaternionCategoryFunctions2!Domain} -\index{Domain!QuaternionCategoryFunctions2} -\index{QUATCT2} -\begin{chunk}{sane} +\index[pkg]{QuaternionCategoryFunctions2!Domain} +\index[pkg]{Domain!QuaternionCategoryFunctions2} +\index[pkg]{QUATCT2} +\begin{chunk}{defclass QuaternionCategoryFunctions2Type} (defclass |QuaternionCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "QuaternionCategoryFunctions2") @@ -35517,7 +36220,7 @@ Value = NIL "QuaternionCategoryFunctions2 implements functions between" "two quaternion domains. The function map is used by" "the system interpreter to coerce between quaternion types.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35533,10 +36236,10 @@ Value = NIL \section{R} \subsection{RadicalEigenPackage} -\index{RadicalEigenPackage!Domain} -\index{Domain!RadicalEigenPackage} -\index{REP} -\begin{chunk}{sane} +\index[pkg]{RadicalEigenPackage!Domain} +\index[pkg]{Domain!RadicalEigenPackage} +\index[pkg]{REP} +\begin{chunk}{defclass RadicalEigenPackageType} (defclass |RadicalEigenPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RadicalEigenPackage") @@ -35548,7 +36251,7 @@ Value = NIL "rational functions over the integers." "(see Fraction Polynomial Integer)." "The eigenvalues and eigenvectors are expressed in terms of radicals.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35562,10 +36265,10 @@ Value = NIL \end{chunk} \subsection{RadicalSolvePackage} -\index{RadicalSolvePackage!Domain} -\index{Domain!RadicalSolvePackage} -\index{SOLVERAD} -\begin{chunk}{sane} +\index[pkg]{RadicalSolvePackage!Domain} +\index[pkg]{Domain!RadicalSolvePackage} +\index[pkg]{SOLVERAD} +\begin{chunk}{defclass RadicalSolvePackageType} (defclass |RadicalSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RadicalSolvePackage") @@ -35575,7 +36278,7 @@ Value = NIL "This package tries to find solutions" "expressed in terms of radicals for systems of equations" "of rational functions with coefficients in an integral domain R.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35589,10 +36292,10 @@ Value = NIL \end{chunk} \subsection{RadixUtilities} -\index{RadixUtilities!Domain} -\index{Domain!RadixUtilities} -\index{RADUTIL} -\begin{chunk}{sane} +\index[pkg]{RadixUtilities!Domain} +\index[pkg]{Domain!RadixUtilities} +\index[pkg]{RADUTIL} +\begin{chunk}{defclass RadixUtilitiesType} (defclass |RadixUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "RadixUtilities") @@ -35600,7 +36303,7 @@ Value = NIL (abbreviation :initform 'RADUTIL) (comment :initform (list "This package provides tools for creating radix expansions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35614,10 +36317,10 @@ Value = NIL \end{chunk} \subsection{RandomDistributions} -\index{RandomDistributions!Domain} -\index{Domain!RandomDistributions} -\index{RDIST} -\begin{chunk}{sane} +\index[pkg]{RandomDistributions!Domain} +\index[pkg]{Domain!RandomDistributions} +\index[pkg]{RDIST} +\begin{chunk}{defclass RandomDistributionsType} (defclass |RandomDistributionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "RandomDistributions") @@ -35625,7 +36328,7 @@ Value = NIL (abbreviation :initform 'RDIST) (comment :initform (list "This package exports random distributions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35639,10 +36342,10 @@ Value = NIL \end{chunk} \subsection{RandomFloatDistributions} -\index{RandomFloatDistributions!Domain} -\index{Domain!RandomFloatDistributions} -\index{RFDIST} -\begin{chunk}{sane} +\index[pkg]{RandomFloatDistributions!Domain} +\index[pkg]{Domain!RandomFloatDistributions} +\index[pkg]{RFDIST} +\begin{chunk}{defclass RandomFloatDistributionsType} (defclass |RandomFloatDistributionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "RandomFloatDistributions") @@ -35650,7 +36353,7 @@ Value = NIL (abbreviation :initform 'RFDIST) (comment :initform (list "This package exports random floating-point distributions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35664,10 +36367,10 @@ Value = NIL \end{chunk} \subsection{RandomIntegerDistributions} -\index{RandomIntegerDistributions!Domain} -\index{Domain!RandomIntegerDistributions} -\index{RIDIST} -\begin{chunk}{sane} +\index[pkg]{RandomIntegerDistributions!Domain} +\index[pkg]{Domain!RandomIntegerDistributions} +\index[pkg]{RIDIST} +\begin{chunk}{defclass RandomIntegerDistributionsType} (defclass |RandomIntegerDistributionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "RandomIntegerDistributions") @@ -35675,7 +36378,7 @@ Value = NIL (abbreviation :initform 'RIDIST) (comment :initform (list "This package exports integer distributions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35689,10 +36392,10 @@ Value = NIL \end{chunk} \subsection{RandomNumberSource} -\index{RandomNumberSource!Domain} -\index{Domain!RandomNumberSource} -\index{RANDSRC} -\begin{chunk}{sane} +\index[pkg]{RandomNumberSource!Domain} +\index[pkg]{Domain!RandomNumberSource} +\index[pkg]{RANDSRC} +\begin{chunk}{defclass RandomNumberSourceType} (defclass |RandomNumberSourceType| (|AxiomClass|) ((parents :initform ()) (name :initform "RandomNumberSource") @@ -35702,7 +36405,7 @@ Value = NIL "Random number generators." "All random numbers used in the system should originate from" "the same generator. This package is intended to be the source.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35716,10 +36419,10 @@ Value = NIL \end{chunk} \subsection{RationalFactorize} -\index{RationalFactorize!Domain} -\index{Domain!RationalFactorize} -\index{RATFACT} -\begin{chunk}{sane} +\index[pkg]{RationalFactorize!Domain} +\index[pkg]{Domain!RationalFactorize} +\index[pkg]{RATFACT} +\begin{chunk}{defclass RationalFactorizeType} (defclass |RationalFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFactorize") @@ -35734,7 +36437,7 @@ Value = NIL "GaloisGroupFactorizer is then" "used to factor the integer polynomial. The result is normalized" "with respect to the original lcm of the denominators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35748,10 +36451,10 @@ Value = NIL \end{chunk} \subsection{RationalFunction} -\index{RationalFunction!Domain} -\index{Domain!RationalFunction} -\index{RF} -\begin{chunk}{sane} +\index[pkg]{RationalFunction!Domain} +\index[pkg]{Domain!RationalFunction} +\index[pkg]{RF} +\begin{chunk}{defclass RationalFunctionType} (defclass |RationalFunctionType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunction") @@ -35760,7 +36463,7 @@ Value = NIL (comment :initform (list "Utilities that provide the same top-level manipulations on" "fractions than on polynomials.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35774,10 +36477,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionDefiniteIntegration} -\index{RationalFunctionDefiniteIntegration!Domain} -\index{Domain!RationalFunctionDefiniteIntegration} -\index{DEFINTRF} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionDefiniteIntegration!Domain} +\index[pkg]{Domain!RationalFunctionDefiniteIntegration} +\index[pkg]{DEFINTRF} +\begin{chunk}{defclass RationalFunctionDefiniteIntegrationType} (defclass |RationalFunctionDefiniteIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionDefiniteIntegration") @@ -35787,7 +36490,7 @@ Value = NIL "Definite integration of rational functions." "RationalFunctionDefiniteIntegration provides functions to" "compute definite integrals of rational functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35801,10 +36504,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionFactor} -\index{RationalFunctionFactor!Domain} -\index{Domain!RationalFunctionFactor} -\index{RFFACT} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionFactor!Domain} +\index[pkg]{Domain!RationalFunctionFactor} +\index[pkg]{RFFACT} +\begin{chunk}{defclass RationalFunctionFactorType} (defclass |RationalFunctionFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionFactor") @@ -35813,7 +36516,7 @@ Value = NIL (comment :initform (list "Factorization of univariate polynomials with coefficients which" "are rational functions with integer coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35827,10 +36530,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionFactorizer} -\index{RationalFunctionFactorizer!Domain} -\index{Domain!RationalFunctionFactorizer} -\index{RFFACTOR} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionFactorizer!Domain} +\index[pkg]{Domain!RationalFunctionFactorizer} +\index[pkg]{RFFACTOR} +\begin{chunk}{defclass RationalFunctionFactorizerType} (defclass |RationalFunctionFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionFactorizer") @@ -35841,7 +36544,7 @@ Value = NIL "(called factorFraction) which factors fractions of polynomials by factoring" "the numerator and denominator. Since any non zero fraction is a unit" "the usual factor operation will just return the original fraction.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35855,10 +36558,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionIntegration} -\index{RationalFunctionIntegration!Domain} -\index{Domain!RationalFunctionIntegration} -\index{INTRF} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionIntegration!Domain} +\index[pkg]{Domain!RationalFunctionIntegration} +\index[pkg]{INTRF} +\begin{chunk}{defclass RationalFunctionIntegrationType} (defclass |RationalFunctionIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionIntegration") @@ -35866,7 +36569,7 @@ Value = NIL (abbreviation :initform 'INTRF) (comment :initform (list "This package provides functions for the integration of rational functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35880,10 +36583,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionLimitPackage} -\index{RationalFunctionLimitPackage!Domain} -\index{Domain!RationalFunctionLimitPackage} -\index{LIMITRF} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionLimitPackage!Domain} +\index[pkg]{Domain!RationalFunctionLimitPackage} +\index[pkg]{LIMITRF} +\begin{chunk}{defclass RationalFunctionLimitPackageType} (defclass |RationalFunctionLimitPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionLimitPackage") @@ -35891,7 +36594,7 @@ Value = NIL (abbreviation :initform 'LIMITRF) (comment :initform (list "Computation of limits for rational functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35905,10 +36608,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionSign} -\index{RationalFunctionSign!Domain} -\index{Domain!RationalFunctionSign} -\index{SIGNRF} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionSign!Domain} +\index[pkg]{Domain!RationalFunctionSign} +\index[pkg]{SIGNRF} +\begin{chunk}{defclass RationalFunctionSignType} (defclass |RationalFunctionSignType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionSign") @@ -35916,7 +36619,7 @@ Value = NIL (abbreviation :initform 'SIGNRF) (comment :initform (list "Find the sign of a rational function around a point or infinity.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35930,10 +36633,10 @@ Value = NIL \end{chunk} \subsection{RationalFunctionSum} -\index{RationalFunctionSum!Domain} -\index{Domain!RationalFunctionSum} -\index{SUMRF} -\begin{chunk}{sane} +\index[pkg]{RationalFunctionSum!Domain} +\index[pkg]{Domain!RationalFunctionSum} +\index[pkg]{SUMRF} +\begin{chunk}{defclass RationalFunctionSumType} (defclass |RationalFunctionSumType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalFunctionSum") @@ -35941,7 +36644,7 @@ Value = NIL (abbreviation :initform 'SUMRF) (comment :initform (list "Computes sums of rational functions")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35955,10 +36658,10 @@ Value = NIL \end{chunk} \subsection{RationalIntegration} -\index{RationalIntegration!Domain} -\index{Domain!RationalIntegration} -\index{INTRAT} -\begin{chunk}{sane} +\index[pkg]{RationalIntegration!Domain} +\index[pkg]{Domain!RationalIntegration} +\index[pkg]{INTRAT} +\begin{chunk}{defclass RationalIntegrationType} (defclass |RationalIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalIntegration") @@ -35966,7 +36669,7 @@ Value = NIL (abbreviation :initform 'INTRAT) (comment :initform (list "This package provides functions for the base case of the Risch algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -35980,10 +36683,10 @@ Value = NIL \end{chunk} \subsection{RationalInterpolation} -\index{RationalInterpolation!Domain} -\index{Domain!RationalInterpolation} -\index{RINTERP} -\begin{chunk}{sane} +\index[pkg]{RationalInterpolation!Domain} +\index[pkg]{Domain!RationalInterpolation} +\index[pkg]{RINTERP} +\begin{chunk}{defclass RationalInterpolationType} (defclass |RationalInterpolationType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalInterpolation") @@ -35991,7 +36694,7 @@ Value = NIL (abbreviation :initform 'RINTERP) (comment :initform (list "This package exports rational interpolation algorithms")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36005,10 +36708,10 @@ Value = NIL \end{chunk} \subsection{RationalLODE} -\index{RationalLODE!Domain} -\index{Domain!RationalLODE} -\index{ODERAT} -\begin{chunk}{sane} +\index[pkg]{RationalLODE!Domain} +\index[pkg]{Domain!RationalLODE} +\index[pkg]{ODERAT} +\begin{chunk}{defclass RationalLODEType} (defclass |RationalLODEType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalLODE") @@ -36017,7 +36720,7 @@ Value = NIL (comment :initform (list "RationalLODE provides functions for in-field solutions of linear" "ordinary differential equations, in the rational case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36031,10 +36734,10 @@ Value = NIL \end{chunk} \subsection{RationalRetractions} -\index{RationalRetractions!Domain} -\index{Domain!RationalRetractions} -\index{RATRET} -\begin{chunk}{sane} +\index[pkg]{RationalRetractions!Domain} +\index[pkg]{Domain!RationalRetractions} +\index[pkg]{RATRET} +\begin{chunk}{defclass RationalRetractionsType} (defclass |RationalRetractionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalRetractions") @@ -36042,7 +36745,7 @@ Value = NIL (abbreviation :initform 'RATRET) (comment :initform (list "Rational number testing and retraction functions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36056,10 +36759,10 @@ Value = NIL \end{chunk} \subsection{RationalRicDE} -\index{RationalRicDE!Domain} -\index{Domain!RationalRicDE} -\index{ODERTRIC} -\begin{chunk}{sane} +\index[pkg]{RationalRicDE!Domain} +\index[pkg]{Domain!RationalRicDE} +\index[pkg]{ODERTRIC} +\begin{chunk}{defclass RationalRicDEType} (defclass |RationalRicDEType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalRicDE") @@ -36067,7 +36770,7 @@ Value = NIL (abbreviation :initform 'ODERTRIC) (comment :initform (list "In-field solution of Riccati equations, rational case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36081,10 +36784,10 @@ Value = NIL \end{chunk} \subsection{RationalUnivariateRepresentationPackage} -\index{RationalUnivariateRepresentationPackage!Domain} -\index{Domain!RationalUnivariateRepresentationPackage} -\index{RURPK} -\begin{chunk}{sane} +\index[pkg]{RationalUnivariateRepresentationPackage!Domain} +\index[pkg]{Domain!RationalUnivariateRepresentationPackage} +\index[pkg]{RURPK} +\begin{chunk}{defclass RationalUnivariateRepresentationPackageType} (defclass |RationalUnivariateRepresentationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RationalUnivariateRepresentationPackage") @@ -36097,7 +36800,7 @@ Value = NIL "InternalRationalUnivariateRepresentationPackage constructor." "It is used in the ZeroDimensionalSolvePackage" "for solving polynomial systems with finitely many solutions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36111,10 +36814,10 @@ Value = NIL \end{chunk} \subsection{RealPolynomialUtilitiesPackage} -\index{RealPolynomialUtilitiesPackage!Domain} -\index{Domain!RealPolynomialUtilitiesPackage} -\index{POLUTIL} -\begin{chunk}{sane} +\index[pkg]{RealPolynomialUtilitiesPackage!Domain} +\index[pkg]{Domain!RealPolynomialUtilitiesPackage} +\index[pkg]{POLUTIL} +\begin{chunk}{defclass RealPolynomialUtilitiesPackageType} (defclass |RealPolynomialUtilitiesPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RealPolynomialUtilitiesPackage") @@ -36123,7 +36826,7 @@ Value = NIL (comment :initform (list "RealPolynomialUtilitiesPackage provides common functions used" "by interval coding.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36137,10 +36840,10 @@ Value = NIL \end{chunk} \subsection{RealSolvePackage} -\index{RealSolvePackage!Domain} -\index{Domain!RealSolvePackage} -\index{REALSOLV} -\begin{chunk}{sane} +\index[pkg]{RealSolvePackage!Domain} +\index[pkg]{Domain!RealSolvePackage} +\index[pkg]{REALSOLV} +\begin{chunk}{defclass RealSolvePackageType} (defclass |RealSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RealSolvePackage") @@ -36149,7 +36852,7 @@ Value = NIL (comment :initform (list "This package provides numerical solutions of systems of" "polynomial equations for use in ACPLOT")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36163,10 +36866,10 @@ Value = NIL \end{chunk} \subsection{RealZeroPackage} -\index{RealZeroPackage!Domain} -\index{Domain!RealZeroPackage} -\index{REAL0} -\begin{chunk}{sane} +\index[pkg]{RealZeroPackage!Domain} +\index[pkg]{Domain!RealZeroPackage} +\index[pkg]{REAL0} +\begin{chunk}{defclass RealZeroPackageType} (defclass |RealZeroPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RealZeroPackage") @@ -36178,7 +36881,7 @@ Value = NIL "precision. The results are returned as a list of" "isolating intervals which are expressed as records with" "'left' and 'right' rational number components.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36192,10 +36895,10 @@ Value = NIL \end{chunk} \subsection{RealZeroPackageQ} -\index{RealZeroPackageQ!Domain} -\index{Domain!RealZeroPackageQ} -\index{REAL0Q} -\begin{chunk}{sane} +\index[pkg]{RealZeroPackageQ!Domain} +\index[pkg]{Domain!RealZeroPackageQ} +\index[pkg]{REAL0Q} +\begin{chunk}{defclass RealZeroPackageQType} (defclass |RealZeroPackageQType| (|AxiomClass|) ((parents :initform ()) (name :initform "RealZeroPackageQ") @@ -36206,7 +36909,7 @@ Value = NIL "polynomials over the rational numbers to arbitrary user-specified" "precision. The results are returned as a list of isolating intervals," "expressed as records with 'left' and 'right' rational number components.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36220,10 +36923,10 @@ Value = NIL \end{chunk} \subsection{RectangularMatrixCategoryFunctions2} -\index{RectangularMatrixCategoryFunctions2!Domain} -\index{Domain!RectangularMatrixCategoryFunctions2} -\index{RMCAT2} -\begin{chunk}{sane} +\index[pkg]{RectangularMatrixCategoryFunctions2!Domain} +\index[pkg]{Domain!RectangularMatrixCategoryFunctions2} +\index[pkg]{RMCAT2} +\begin{chunk}{defclass RectangularMatrixCategoryFunctions2Type} (defclass |RectangularMatrixCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "RectangularMatrixCategoryFunctions2") @@ -36233,7 +36936,7 @@ Value = NIL "RectangularMatrixCategoryFunctions2 provides functions between" "two matrix domains. The functions provided are map and" "reduce.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36247,10 +36950,10 @@ Value = NIL \end{chunk} \subsection{RecurrenceOperator} -\index{RecurrenceOperator!Domain} -\index{Domain!RecurrenceOperator} -\index{RECOP} -\begin{chunk}{sane} +\index[pkg]{RecurrenceOperator!Domain} +\index[pkg]{Domain!RecurrenceOperator} +\index[pkg]{RECOP} +\begin{chunk}{defclass RecurrenceOperatorType} (defclass |RecurrenceOperatorType| (|AxiomClass|) ((parents :initform ()) (name :initform "RecurrenceOperator") @@ -36260,7 +36963,7 @@ Value = NIL "This package provides an operator for the n-th term of a recurrence and an" "operator for the coefficient of x^n in a function specified by a functional" "equation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36274,10 +36977,10 @@ Value = NIL \end{chunk} \subsection{ReducedDivisor} -\index{ReducedDivisor!Domain} -\index{Domain!ReducedDivisor} -\index{RDIV} -\begin{chunk}{sane} +\index[pkg]{ReducedDivisor!Domain} +\index[pkg]{Domain!ReducedDivisor} +\index[pkg]{RDIV} +\begin{chunk}{defclass ReducedDivisorType} (defclass |ReducedDivisorType| (|AxiomClass|) ((parents :initform ()) (name :initform "ReducedDivisor") @@ -36285,7 +36988,7 @@ Value = NIL (abbreviation :initform 'RDIV) (comment :initform (list "Finds the order of a divisor over a finite field")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36299,10 +37002,10 @@ Value = NIL \end{chunk} \subsection{ReduceLODE} -\index{ReduceLODE!Domain} -\index{Domain!ReduceLODE} -\index{ODERED} -\begin{chunk}{sane} +\index[pkg]{ReduceLODE!Domain} +\index[pkg]{Domain!ReduceLODE} +\index[pkg]{ODERED} +\begin{chunk}{defclass ReduceLODEType} (defclass |ReduceLODEType| (|AxiomClass|) ((parents :initform ()) (name :initform "ReduceLODE") @@ -36311,7 +37014,7 @@ Value = NIL (comment :initform (list "Elimination of an algebraic from the coefficentss" "of a linear ordinary differential equation.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36325,10 +37028,10 @@ Value = NIL \end{chunk} \subsection{ReductionOfOrder} -\index{ReductionOfOrder!Domain} -\index{Domain!ReductionOfOrder} -\index{REDORDER} -\begin{chunk}{sane} +\index[pkg]{ReductionOfOrder!Domain} +\index[pkg]{Domain!ReductionOfOrder} +\index[pkg]{REDORDER} +\begin{chunk}{defclass ReductionOfOrderType} (defclass |ReductionOfOrderType| (|AxiomClass|) ((parents :initform ()) (name :initform "ReductionOfOrder") @@ -36338,7 +37041,7 @@ Value = NIL "ReductionOfOrder provides" "functions for reducing the order of linear ordinary differential equations" "once some solutions are known.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36352,10 +37055,10 @@ Value = NIL \end{chunk} \subsection{RegularSetDecompositionPackage} -\index{RegularSetDecompositionPackage!Domain} -\index{Domain!RegularSetDecompositionPackage} -\index{RSDCMPK} -\begin{chunk}{sane} +\index[pkg]{RegularSetDecompositionPackage!Domain} +\index[pkg]{Domain!RegularSetDecompositionPackage} +\index[pkg]{RSDCMPK} +\begin{chunk}{defclass RegularSetDecompositionPackageType} (defclass |RegularSetDecompositionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RegularSetDecompositionPackage") @@ -36381,7 +37084,7 @@ Value = NIL "WARNING. There is no need for a user to call directly any operation" "of this package since they can be accessed by the domain TS." "Thus, the operations of this package are not documented.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36395,10 +37098,10 @@ Value = NIL \end{chunk} \subsection{RegularTriangularSetGcdPackage} -\index{RegularTriangularSetGcdPackage!Domain} -\index{Domain!RegularTriangularSetGcdPackage} -\index{RSETGCD} -\begin{chunk}{sane} +\index[pkg]{RegularTriangularSetGcdPackage!Domain} +\index[pkg]{Domain!RegularTriangularSetGcdPackage} +\index[pkg]{RSETGCD} +\begin{chunk}{defclass RegularTriangularSetGcdPackageType} (defclass |RegularTriangularSetGcdPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RegularTriangularSetGcdPackage") @@ -36407,7 +37110,7 @@ Value = NIL (comment :initform (list "An internal package for computing gcds and resultants of univariate" "polynomials with coefficients in a tower of simple extensions of a field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36421,10 +37124,10 @@ Value = NIL \end{chunk} \subsection{RepeatedDoubling} -\index{RepeatedDoubling!Domain} -\index{Domain!RepeatedDoubling} -\index{REPDB} -\begin{chunk}{sane} +\index[pkg]{RepeatedDoubling!Domain} +\index[pkg]{Domain!RepeatedDoubling} +\index[pkg]{REPDB} +\begin{chunk}{defclass RepeatedDoublingType} (defclass |RepeatedDoublingType| (|AxiomClass|) ((parents :initform ()) (name :initform "RepeatedDoubling") @@ -36432,7 +37135,7 @@ Value = NIL (abbreviation :initform 'REPDB) (comment :initform (list "Implements multiplication by repeated addition")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36446,10 +37149,10 @@ Value = NIL \end{chunk} \subsection{RepeatedSquaring} -\index{RepeatedSquaring!Domain} -\index{Domain!RepeatedSquaring} -\index{REPSQ} -\begin{chunk}{sane} +\index[pkg]{RepeatedSquaring!Domain} +\index[pkg]{Domain!RepeatedSquaring} +\index[pkg]{REPSQ} +\begin{chunk}{defclass RepeatedSquaringType} (defclass |RepeatedSquaringType| (|AxiomClass|) ((parents :initform ()) (name :initform "RepeatedSquaring") @@ -36457,7 +37160,7 @@ Value = NIL (abbreviation :initform 'REPSQ) (comment :initform (list "Implements exponentiation by repeated squaring")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36471,10 +37174,10 @@ Value = NIL \end{chunk} \subsection{RepresentationPackage1} -\index{RepresentationPackage1!Domain} -\index{Domain!RepresentationPackage1} -\index{REP1} -\begin{chunk}{sane} +\index[pkg]{RepresentationPackage1!Domain} +\index[pkg]{Domain!RepresentationPackage1} +\index[pkg]{REP1} +\begin{chunk}{defclass RepresentationPackage1Type} (defclass |RepresentationPackage1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "RepresentationPackage1") @@ -36489,7 +37192,7 @@ Value = NIL "Note that instead of having parameters from Permutation" "this package allows list notation of permutations as well:" "for example [1,4,3,2] denotes permutes 2 and 4 and fixes 1 and 3.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36503,10 +37206,10 @@ Value = NIL \end{chunk} \subsection{RepresentationPackage2} -\index{RepresentationPackage2!Domain} -\index{Domain!RepresentationPackage2} -\index{REP2} -\begin{chunk}{sane} +\index[pkg]{RepresentationPackage2!Domain} +\index[pkg]{Domain!RepresentationPackage2} +\index[pkg]{REP2} +\begin{chunk}{defclass RepresentationPackage2Type} (defclass |RepresentationPackage2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "RepresentationPackage2") @@ -36522,7 +37225,7 @@ Value = NIL "Note that most functions are randomized functions of Las Vegas type" "every answer is correct, but with small probability" "the algorithm fails to get an answer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36536,10 +37239,10 @@ Value = NIL \end{chunk} \subsection{ResolveLatticeCompletion} -\index{ResolveLatticeCompletion!Domain} -\index{Domain!ResolveLatticeCompletion} -\index{RESLATC} -\begin{chunk}{sane} +\index[pkg]{ResolveLatticeCompletion!Domain} +\index[pkg]{Domain!ResolveLatticeCompletion} +\index[pkg]{RESLATC} +\begin{chunk}{defclass ResolveLatticeCompletionType} (defclass |ResolveLatticeCompletionType| (|AxiomClass|) ((parents :initform ()) (name :initform "ResolveLatticeCompletion") @@ -36548,7 +37251,7 @@ Value = NIL (comment :initform (list "This package provides coercions for the special types Exit" "and Void.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36562,10 +37265,10 @@ Value = NIL \end{chunk} \subsection{RetractSolvePackage} -\index{RetractSolvePackage!Domain} -\index{Domain!RetractSolvePackage} -\index{RETSOL} -\begin{chunk}{sane} +\index[pkg]{RetractSolvePackage!Domain} +\index[pkg]{Domain!RetractSolvePackage} +\index[pkg]{RETSOL} +\begin{chunk}{defclass RetractSolvePackageType} (defclass |RetractSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RetractSolvePackage") @@ -36575,7 +37278,7 @@ Value = NIL "RetractSolvePackage is an interface to SystemSolvePackage" "that attempts to retract the coefficients of the equations before" "solving.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36589,10 +37292,10 @@ Value = NIL \end{chunk} \subsection{RootsFindingPackage} -\index{RootsFindingPackage!Domain} -\index{Domain!RootsFindingPackage} -\index{RFP} -\begin{chunk}{sane} +\index[pkg]{RootsFindingPackage!Domain} +\index[pkg]{Domain!RootsFindingPackage} +\index[pkg]{RFP} +\begin{chunk}{defclass RootsFindingPackageType} (defclass |RootsFindingPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "RootsFindingPackage") @@ -36608,7 +37311,7 @@ Value = NIL "a list of all found zeros is kept and for each other call of a function" "that finds zeroes, a check is made on that list; this is to keep" "a kind of 'canonical' representation of the elements.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36624,10 +37327,10 @@ Value = NIL \section{S} \subsection{SAERationalFunctionAlgFactor} -\index{SAERationalFunctionAlgFactor!Domain} -\index{Domain!SAERationalFunctionAlgFactor} -\index{SAERFFC} -\begin{chunk}{sane} +\index[pkg]{SAERationalFunctionAlgFactor!Domain} +\index[pkg]{Domain!SAERationalFunctionAlgFactor} +\index[pkg]{SAERFFC} +\begin{chunk}{defclass SAERationalFunctionAlgFactorType} (defclass |SAERationalFunctionAlgFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "SAERationalFunctionAlgFactor") @@ -36636,7 +37339,7 @@ Value = NIL (comment :initform (list "Factorization of univariate polynomials with coefficients in an" "algebraic extension of \spadtype{Fraction Polynomial Integer}.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36650,10 +37353,10 @@ Value = NIL \end{chunk} \subsection{ScriptFormulaFormat1} -\index{ScriptFormulaFormat1!Domain} -\index{Domain!ScriptFormulaFormat1} -\index{FORMULA1} -\begin{chunk}{sane} +\index[pkg]{ScriptFormulaFormat1!Domain} +\index[pkg]{Domain!ScriptFormulaFormat1} +\index[pkg]{FORMULA1} +\begin{chunk}{defclass ScriptFormulaFormat1Type} (defclass |ScriptFormulaFormat1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "ScriptFormulaFormat1") @@ -36663,7 +37366,7 @@ Value = NIL "ScriptFormulaFormat1 provides a utility coercion for" "changing to SCRIPT formula format anything that has a coercion to" "the standard output format.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36677,10 +37380,10 @@ Value = NIL \end{chunk} \subsection{SegmentBindingFunctions2} -\index{SegmentBindingFunctions2!Domain} -\index{Domain!SegmentBindingFunctions2} -\index{SEGBIND2} -\begin{chunk}{sane} +\index[pkg]{SegmentBindingFunctions2!Domain} +\index[pkg]{Domain!SegmentBindingFunctions2} +\index[pkg]{SEGBIND2} +\begin{chunk}{defclass SegmentBindingFunctions2Type} (defclass |SegmentBindingFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "SegmentBindingFunctions2") @@ -36689,7 +37392,7 @@ Value = NIL (comment :initform (list "This package provides operations for mapping functions onto" "SegmentBindings.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36703,10 +37406,10 @@ Value = NIL \end{chunk} \subsection{SegmentFunctions2} -\index{SegmentFunctions2!Domain} -\index{Domain!SegmentFunctions2} -\index{SEG2} -\begin{chunk}{sane} +\index[pkg]{SegmentFunctions2!Domain} +\index[pkg]{Domain!SegmentFunctions2} +\index[pkg]{SEG2} +\begin{chunk}{defclass SegmentFunctions2Type} (defclass |SegmentFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "SegmentFunctions2") @@ -36714,7 +37417,7 @@ Value = NIL (abbreviation :initform 'SEG2) (comment :initform (list "This package provides operations for mapping functions onto segments.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36728,10 +37431,10 @@ Value = NIL \end{chunk} \subsection{SimpleAlgebraicExtensionAlgFactor} -\index{SimpleAlgebraicExtensionAlgFactor!Domain} -\index{Domain!SimpleAlgebraicExtensionAlgFactor} -\index{SAEFACT} -\begin{chunk}{sane} +\index[pkg]{SimpleAlgebraicExtensionAlgFactor!Domain} +\index[pkg]{Domain!SimpleAlgebraicExtensionAlgFactor} +\index[pkg]{SAEFACT} +\begin{chunk}{defclass SimpleAlgebraicExtensionAlgFactorType} (defclass |SimpleAlgebraicExtensionAlgFactorType| (|AxiomClass|) ((parents :initform ()) (name :initform "SimpleAlgebraicExtensionAlgFactor") @@ -36740,7 +37443,7 @@ Value = NIL (comment :initform (list "Factorization of univariate polynomials with coefficients in an" "algebraic extension of the rational numbers (Fraction Integer).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36754,10 +37457,10 @@ Value = NIL \end{chunk} \subsection{SimplifyAlgebraicNumberConvertPackage} -\index{SimplifyAlgebraicNumberConvertPackage!Domain} -\index{Domain!SimplifyAlgebraicNumberConvertPackage} -\index{SIMPAN} -\begin{chunk}{sane} +\index[pkg]{SimplifyAlgebraicNumberConvertPackage!Domain} +\index[pkg]{Domain!SimplifyAlgebraicNumberConvertPackage} +\index[pkg]{SIMPAN} +\begin{chunk}{defclass SimplifyAlgebraicNumberConvertPackageType} (defclass |SimplifyAlgebraicNumberConvertPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SimplifyAlgebraicNumberConvertPackage") @@ -36766,7 +37469,7 @@ Value = NIL (comment :initform (list "Package to allow simplify to be called on AlgebraicNumbers" "by converting to EXPR(INT)")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36780,10 +37483,10 @@ Value = NIL \end{chunk} \subsection{SmithNormalForm} -\index{SmithNormalForm!Domain} -\index{Domain!SmithNormalForm} -\index{SMITH} -\begin{chunk}{sane} +\index[pkg]{SmithNormalForm!Domain} +\index[pkg]{Domain!SmithNormalForm} +\index[pkg]{SMITH} +\begin{chunk}{defclass SmithNormalFormType} (defclass |SmithNormalFormType| (|AxiomClass|) ((parents :initform ()) (name :initform "SmithNormalForm") @@ -36792,7 +37495,7 @@ Value = NIL (comment :initform (list "SmithNormalForm is a package" "which provides some standard canonical forms for matrices.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36806,10 +37509,10 @@ Value = NIL \end{chunk} \subsection{SortedCache} -\index{SortedCache!Domain} -\index{Domain!SortedCache} -\index{SCACHE} -\begin{chunk}{sane} +\index[pkg]{SortedCache!Domain} +\index[pkg]{Domain!SortedCache} +\index[pkg]{SCACHE} +\begin{chunk}{defclass SortedCacheType} (defclass |SortedCacheType| (|AxiomClass|) ((parents :initform ()) (name :initform "SortedCache") @@ -36821,7 +37524,7 @@ Value = NIL "element of S once it is in the cache. This way, equality and ordering" "on S are tested directly on the integers associated with the elements" "of S, once they have been entered in the cache.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36835,10 +37538,10 @@ Value = NIL \end{chunk} \subsection{SortPackage} -\index{SortPackage!Domain} -\index{Domain!SortPackage} -\index{SORTPAK} -\begin{chunk}{sane} +\index[pkg]{SortPackage!Domain} +\index[pkg]{Domain!SortPackage} +\index[pkg]{SORTPAK} +\begin{chunk}{defclass SortPackageType} (defclass |SortPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SortPackage") @@ -36846,7 +37549,7 @@ Value = NIL (abbreviation :initform 'SORTPAK) (comment :initform (list "This package exports sorting algorithnms")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36860,10 +37563,10 @@ Value = NIL \end{chunk} \subsection{SparseUnivariatePolynomialFunctions2} -\index{SparseUnivariatePolynomialFunctions2!Domain} -\index{Domain!SparseUnivariatePolynomialFunctions2} -\index{SUP2} -\begin{chunk}{sane} +\index[pkg]{SparseUnivariatePolynomialFunctions2!Domain} +\index[pkg]{Domain!SparseUnivariatePolynomialFunctions2} +\index[pkg]{SUP2} +\begin{chunk}{defclass SparseUnivariatePolynomialFunctions2Type} (defclass |SparseUnivariatePolynomialFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "SparseUnivariatePolynomialFunctions2") @@ -36876,7 +37579,7 @@ Value = NIL "Note that the mapping is assumed" "to send zero to zero, since it will only be applied to the non-zero" "coefficients of the polynomial.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36890,10 +37593,10 @@ Value = NIL \end{chunk} \subsection{SpecialOutputPackage} -\index{SpecialOutputPackage!Domain} -\index{Domain!SpecialOutputPackage} -\index{SPECOUT} -\begin{chunk}{sane} +\index[pkg]{SpecialOutputPackage!Domain} +\index[pkg]{Domain!SpecialOutputPackage} +\index[pkg]{SPECOUT} +\begin{chunk}{defclass SpecialOutputPackageType} (defclass |SpecialOutputPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SpecialOutputPackage") @@ -36902,7 +37605,7 @@ Value = NIL (comment :initform (list "SpecialOutputPackage allows FORTRAN, Tex and" "Script Formula Formatter output from programs.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36916,10 +37619,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeQuasiComponentPackage} -\index{SquareFreeQuasiComponentPackage!Domain} -\index{Domain!SquareFreeQuasiComponentPackage} -\index{SFQCMPK} -\begin{chunk}{sane} +\index[pkg]{SquareFreeQuasiComponentPackage!Domain} +\index[pkg]{Domain!SquareFreeQuasiComponentPackage} +\index[pkg]{SFQCMPK} +\begin{chunk}{defclass SquareFreeQuasiComponentPackageType} (defclass |SquareFreeQuasiComponentPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SquareFreeQuasiComponentPackage") @@ -36929,7 +37632,7 @@ Value = NIL "A internal package for removing redundant quasi-components and redundant" "branches when decomposing a variety by means of quasi-components" "of regular triangular sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36943,10 +37646,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeRegularSetDecompositionPackage} -\index{SquareFreeRegularSetDecompositionPackage!Domain} -\index{Domain!SquareFreeRegularSetDecompositionPackage} -\index{SRDCMPK} -\begin{chunk}{sane} +\index[pkg]{SquareFreeRegularSetDecompositionPackage!Domain} +\index[pkg]{Domain!SquareFreeRegularSetDecompositionPackage} +\index[pkg]{SRDCMPK} +\begin{chunk}{defclass SquareFreeRegularSetDecompositionPackageType} (defclass |SquareFreeRegularSetDecompositionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SquareFreeRegularSetDecompositionPackage") @@ -36971,7 +37674,7 @@ Value = NIL "WARNING. There is no need for a user to call directly any operation" "of this package since they can be accessed by the domain TS." "Thus, the operations of this package are not documented.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -36985,10 +37688,10 @@ Value = NIL \end{chunk} \subsection{SquareFreeRegularTriangularSetGcdPackage} -\index{SquareFreeRegularTriangularSetGcdPackage!Domain} -\index{Domain!SquareFreeRegularTriangularSetGcdPackage} -\index{SFRGCD} -\begin{chunk}{sane} +\index[pkg]{SquareFreeRegularTriangularSetGcdPackage!Domain} +\index[pkg]{Domain!SquareFreeRegularTriangularSetGcdPackage} +\index[pkg]{SFRGCD} +\begin{chunk}{defclass SquareFreeRegularTriangularSetGcdPackageType} (defclass |SquareFreeRegularTriangularSetGcdPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SquareFreeRegularTriangularSetGcdPackage") @@ -36999,7 +37702,7 @@ Value = NIL "polynomials with coefficients in a tower of simple extensions of a field." "There is no need to use directly this package since its main operations are" "available from TS.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37013,10 +37716,10 @@ Value = NIL \end{chunk} \subsection{StorageEfficientMatrixOperations} -\index{StorageEfficientMatrixOperations!Domain} -\index{Domain!StorageEfficientMatrixOperations} -\index{MATSTOR} -\begin{chunk}{sane} +\index[pkg]{StorageEfficientMatrixOperations!Domain} +\index[pkg]{Domain!StorageEfficientMatrixOperations} +\index[pkg]{MATSTOR} +\begin{chunk}{defclass StorageEfficientMatrixOperationsType} (defclass |StorageEfficientMatrixOperationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "StorageEfficientMatrixOperations") @@ -37028,7 +37731,7 @@ Value = NIL "in existing matrices, rather than creating new matrices. This" "package works only for matrices of type Matrix and uses the" "internal representation of this type.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37042,10 +37745,10 @@ Value = NIL \end{chunk} \subsection{StreamFunctions1} -\index{StreamFunctions1!Domain} -\index{Domain!StreamFunctions1} -\index{STREAM1} -\begin{chunk}{sane} +\index[pkg]{StreamFunctions1!Domain} +\index[pkg]{Domain!StreamFunctions1} +\index[pkg]{STREAM1} +\begin{chunk}{defclass StreamFunctions1Type} (defclass |StreamFunctions1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamFunctions1") @@ -37053,7 +37756,7 @@ Value = NIL (abbreviation :initform 'STREAM1) (comment :initform (list "Functions defined on streams with entries in one set.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37067,10 +37770,10 @@ Value = NIL \end{chunk} \subsection{StreamFunctions2} -\index{StreamFunctions2!Domain} -\index{Domain!StreamFunctions2} -\index{STREAM2} -\begin{chunk}{sane} +\index[pkg]{StreamFunctions2!Domain} +\index[pkg]{Domain!StreamFunctions2} +\index[pkg]{STREAM2} +\begin{chunk}{defclass StreamFunctions2Type} (defclass |StreamFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamFunctions2") @@ -37078,7 +37781,7 @@ Value = NIL (abbreviation :initform 'STREAM2) (comment :initform (list "Functions defined on streams with entries in two sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37092,10 +37795,10 @@ Value = NIL \end{chunk} \subsection{StreamFunctions3} -\index{StreamFunctions3!Domain} -\index{Domain!StreamFunctions3} -\index{STREAM3} -\begin{chunk}{sane} +\index[pkg]{StreamFunctions3!Domain} +\index[pkg]{Domain!StreamFunctions3} +\index[pkg]{STREAM3} +\begin{chunk}{defclass StreamFunctions3Type} (defclass |StreamFunctions3Type| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamFunctions3") @@ -37103,7 +37806,7 @@ Value = NIL (abbreviation :initform 'STREAM3) (comment :initform (list "Functions defined on streams with entries in three sets.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37117,10 +37820,10 @@ Value = NIL \end{chunk} \subsection{StreamInfiniteProduct} -\index{StreamInfiniteProduct!Domain} -\index{Domain!StreamInfiniteProduct} -\index{STINPROD} -\begin{chunk}{sane} +\index[pkg]{StreamInfiniteProduct!Domain} +\index[pkg]{Domain!StreamInfiniteProduct} +\index[pkg]{STINPROD} +\begin{chunk}{defclass StreamInfiniteProductType} (defclass |StreamInfiniteProductType| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamInfiniteProduct") @@ -37130,7 +37833,7 @@ Value = NIL "This package computes infinite products of Taylor series over an" "integral domain of characteristic 0. Here Taylor series are" "represented by streams of Taylor coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37144,10 +37847,10 @@ Value = NIL \end{chunk} \subsection{StreamTaylorSeriesOperations} -\index{StreamTaylorSeriesOperations!Domain} -\index{Domain!StreamTaylorSeriesOperations} -\index{STTAYLOR} -\begin{chunk}{sane} +\index[pkg]{StreamTaylorSeriesOperations!Domain} +\index[pkg]{Domain!StreamTaylorSeriesOperations} +\index[pkg]{STTAYLOR} +\begin{chunk}{defclass StreamTaylorSeriesOperationsType} (defclass |StreamTaylorSeriesOperationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamTaylorSeriesOperations") @@ -37156,7 +37859,7 @@ Value = NIL (comment :initform (list "StreamTaylorSeriesOperations implements Taylor series arithmetic," "where a Taylor series is represented by a stream of its coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37170,10 +37873,10 @@ Value = NIL \end{chunk} \subsection{StreamTensor} -\index{StreamTensor!Domain} -\index{Domain!StreamTensor} -\index{STNSR} -\begin{chunk}{sane} +\index[pkg]{StreamTensor!Domain} +\index[pkg]{Domain!StreamTensor} +\index[pkg]{STNSR} +\begin{chunk}{defclass StreamTensorType} (defclass |StreamTensorType| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamTensor") @@ -37181,7 +37884,7 @@ Value = NIL (abbreviation :initform 'STNSR) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37195,10 +37898,10 @@ Value = NIL \end{chunk} \subsection{StreamTranscendentalFunctions} -\index{StreamTranscendentalFunctions!Domain} -\index{Domain!StreamTranscendentalFunctions} -\index{STTF} -\begin{chunk}{sane} +\index[pkg]{StreamTranscendentalFunctions!Domain} +\index[pkg]{Domain!StreamTranscendentalFunctions} +\index[pkg]{STTF} +\begin{chunk}{defclass StreamTranscendentalFunctionsType} (defclass |StreamTranscendentalFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamTranscendentalFunctions") @@ -37208,7 +37911,7 @@ Value = NIL "StreamTranscendentalFunctions implements transcendental functions on" "Taylor series, where a Taylor series is represented by a stream of" "its coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37222,10 +37925,10 @@ Value = NIL \end{chunk} \subsection{StreamTranscendentalFunctionsNonCommutative} -\index{StreamTranscendentalFunctionsNonCommutative!Domain} -\index{Domain!StreamTranscendentalFunctionsNonCommutative} -\index{STTFNC} -\begin{chunk}{sane} +\index[pkg]{StreamTranscendentalFunctionsNonCommutative!Domain} +\index[pkg]{Domain!StreamTranscendentalFunctionsNonCommutative} +\index[pkg]{STTFNC} +\begin{chunk}{defclass StreamTranscendentalFunctionsNonCommutativeType} (defclass |StreamTranscendentalFunctionsNonCommutativeType| (|AxiomClass|) ((parents :initform ()) (name :initform "StreamTranscendentalFunctionsNonCommutative") @@ -37235,7 +37938,7 @@ Value = NIL "StreamTranscendentalFunctionsNonCommutative implements transcendental" "functions on Taylor series over a non-commutative ring, where a Taylor" "series is represented by a stream of its coefficients.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37249,10 +37952,10 @@ Value = NIL \end{chunk} \subsection{StructuralConstantsPackage} -\index{StructuralConstantsPackage!Domain} -\index{Domain!StructuralConstantsPackage} -\index{SCPKG} -\begin{chunk}{sane} +\index[pkg]{StructuralConstantsPackage!Domain} +\index[pkg]{Domain!StructuralConstantsPackage} +\index[pkg]{SCPKG} +\begin{chunk}{defclass StructuralConstantsPackageType} (defclass |StructuralConstantsPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "StructuralConstantsPackage") @@ -37262,7 +37965,7 @@ Value = NIL "StructuralConstantsPackage provides functions creating" "structural constants from a multiplication tables or a basis" "of a matrix algebra and other useful functions in this context.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37276,10 +37979,10 @@ Value = NIL \end{chunk} \subsection{SturmHabichtPackage} -\index{SturmHabichtPackage!Domain} -\index{Domain!SturmHabichtPackage} -\index{SHP} -\begin{chunk}{sane} +\index[pkg]{SturmHabichtPackage!Domain} +\index[pkg]{Domain!SturmHabichtPackage} +\index[pkg]{SHP} +\begin{chunk}{defclass SturmHabichtPackageType} (defclass |SturmHabichtPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SturmHabichtPackage") @@ -37288,7 +37991,7 @@ Value = NIL (comment :initform (list "This package produces functions for counting etc. real roots of univariate" "polynomials in x over R, which must be an OrderedIntegralDomain")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37302,10 +38005,10 @@ Value = NIL \end{chunk} \subsection{SubResultantPackage} -\index{SubResultantPackage!Domain} -\index{Domain!SubResultantPackage} -\index{SUBRESP} -\begin{chunk}{sane} +\index[pkg]{SubResultantPackage!Domain} +\index[pkg]{Domain!SubResultantPackage} +\index[pkg]{SUBRESP} +\begin{chunk}{defclass SubResultantPackageType} (defclass |SubResultantPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SubResultantPackage") @@ -37316,7 +38019,7 @@ Value = NIL "for the `Lazard Rioboo' enhancement to Tragers integrations formula" "For efficiency reasons this has been rewritten to call Lionel Ducos" "package which is currently the best one.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37330,10 +38033,10 @@ Value = NIL \end{chunk} \subsection{SupFractionFactorizer} -\index{SupFractionFactorizer!Domain} -\index{Domain!SupFractionFactorizer} -\index{SUPFRACF} -\begin{chunk}{sane} +\index[pkg]{SupFractionFactorizer!Domain} +\index[pkg]{Domain!SupFractionFactorizer} +\index[pkg]{SUPFRACF} +\begin{chunk}{defclass SupFractionFactorizerType} (defclass |SupFractionFactorizerType| (|AxiomClass|) ((parents :initform ()) (name :initform "SupFractionFactorizer") @@ -37343,7 +38046,7 @@ Value = NIL "SupFractionFactorize contains the factor function for univariate" "polynomials over the quotient field of a ring S such that the package" "MultivariateFactorize works for S")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37357,10 +38060,10 @@ Value = NIL \end{chunk} \subsection{SystemODESolver} -\index{SystemODESolver!Domain} -\index{Domain!SystemODESolver} -\index{ODESYS} -\begin{chunk}{sane} +\index[pkg]{SystemODESolver!Domain} +\index[pkg]{Domain!SystemODESolver} +\index[pkg]{ODESYS} +\begin{chunk}{defclass SystemODESolverType} (defclass |SystemODESolverType| (|AxiomClass|) ((parents :initform ()) (name :initform "SystemODESolver") @@ -37369,7 +38072,7 @@ Value = NIL (comment :initform (list "SystemODESolver provides tools for triangulating" "and solving some systems of linear ordinary differential equations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37383,10 +38086,10 @@ Value = NIL \end{chunk} \subsection{SystemSolvePackage} -\index{SystemSolvePackage!Domain} -\index{Domain!SystemSolvePackage} -\index{SYSSOLP} -\begin{chunk}{sane} +\index[pkg]{SystemSolvePackage!Domain} +\index[pkg]{Domain!SystemSolvePackage} +\index[pkg]{SYSSOLP} +\begin{chunk}{defclass SystemSolvePackageType} (defclass |SystemSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "SystemSolvePackage") @@ -37407,7 +38110,7 @@ Value = NIL "be solved for, treating all other symbols appearing as parameters" "or omit the list of symbols in which case the system tries to" "solve with respect to all symbols appearing in the input.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37421,10 +38124,10 @@ Value = NIL \end{chunk} \subsection{SymmetricGroupCombinatoricFunctions} -\index{SymmetricGroupCombinatoricFunctions!Domain} -\index{Domain!SymmetricGroupCombinatoricFunctions} -\index{SGCF} -\begin{chunk}{sane} +\index[pkg]{SymmetricGroupCombinatoricFunctions!Domain} +\index[pkg]{Domain!SymmetricGroupCombinatoricFunctions} +\index[pkg]{SGCF} +\begin{chunk}{defclass SymmetricGroupCombinatoricFunctionsType} (defclass |SymmetricGroupCombinatoricFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "SymmetricGroupCombinatoricFunctions") @@ -37435,7 +38138,7 @@ Value = NIL "functions concerning symmetric groups and representation" "theory: list young tableaus, improper partitions, subsets" "bijection of Coleman.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37449,10 +38152,10 @@ Value = NIL \end{chunk} \subsection{SymmetricFunctions} -\index{SymmetricFunctions!Domain} -\index{Domain!SymmetricFunctions} -\index{SYMFUNC} -\begin{chunk}{sane} +\index[pkg]{SymmetricFunctions!Domain} +\index[pkg]{Domain!SymmetricFunctions} +\index[pkg]{SYMFUNC} +\begin{chunk}{defclass SymmetricFunctionsType} (defclass |SymmetricFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "SymmetricFunctions") @@ -37460,7 +38163,7 @@ Value = NIL (abbreviation :initform 'SYMFUNC) (comment :initform (list "Computes all the symmetric functions in n variables.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37476,10 +38179,10 @@ Value = NIL \section{T} \subsection{TableauxBumpers} -\index{TableauxBumpers!Domain} -\index{Domain!TableauxBumpers} -\index{TABLBUMP} -\begin{chunk}{sane} +\index[pkg]{TableauxBumpers!Domain} +\index[pkg]{Domain!TableauxBumpers} +\index[pkg]{TABLBUMP} +\begin{chunk}{defclass TableauxBumpersType} (defclass |TableauxBumpersType| (|AxiomClass|) ((parents :initform ()) (name :initform "TableauxBumpers") @@ -37490,7 +38193,7 @@ Value = NIL "correspondence between sequences and pairs of Young tableaux." "The 2 Young tableaux are represented as a single tableau with" "pairs as components.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37504,10 +38207,10 @@ Value = NIL \end{chunk} \subsection{TabulatedComputationPackage} -\index{TabulatedComputationPackage!Domain} -\index{Domain!TabulatedComputationPackage} -\index{TBCMPPK} -\begin{chunk}{sane} +\index[pkg]{TabulatedComputationPackage!Domain} +\index[pkg]{Domain!TabulatedComputationPackage} +\index[pkg]{TBCMPPK} +\begin{chunk}{defclass TabulatedComputationPackageType} (defclass |TabulatedComputationPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "TabulatedComputationPackage") @@ -37520,7 +38223,7 @@ Value = NIL "a hash-table. The user does not need to worry about the management of" "this hash-table. However, onnly one hash-table is built by calling" "TabulatedComputationPackage(Key ,Entry).")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37534,10 +38237,10 @@ Value = NIL \end{chunk} \subsection{TangentExpansions} -\index{TangentExpansions!Domain} -\index{Domain!TangentExpansions} -\index{TANEXP} -\begin{chunk}{sane} +\index[pkg]{TangentExpansions!Domain} +\index[pkg]{Domain!TangentExpansions} +\index[pkg]{TANEXP} +\begin{chunk}{defclass TangentExpansionsType} (defclass |TangentExpansionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TangentExpansions") @@ -37545,7 +38248,7 @@ Value = NIL (abbreviation :initform 'TANEXP) (comment :initform (list "Expands tangents of sums and scalar products.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37559,10 +38262,10 @@ Value = NIL \end{chunk} \subsection{TaylorSolve} -\index{TaylorSolve!Domain} -\index{Domain!TaylorSolve} -\index{UTSSOL} -\begin{chunk}{sane} +\index[pkg]{TaylorSolve!Domain} +\index[pkg]{Domain!TaylorSolve} +\index[pkg]{UTSSOL} +\begin{chunk}{defclass TaylorSolveType} (defclass |TaylorSolveType| (|AxiomClass|) ((parents :initform ()) (name :initform "TaylorSolve") @@ -37570,7 +38273,7 @@ Value = NIL (abbreviation :initform 'UTSSOL) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37584,10 +38287,10 @@ Value = NIL \end{chunk} \subsection{TemplateUtilities} -\index{TemplateUtilities!Domain} -\index{Domain!TemplateUtilities} -\index{TEMUTL} -\begin{chunk}{sane} +\index[pkg]{TemplateUtilities!Domain} +\index[pkg]{Domain!TemplateUtilities} +\index[pkg]{TEMUTL} +\begin{chunk}{defclass TemplateUtilitiesType} (defclass |TemplateUtilitiesType| (|AxiomClass|) ((parents :initform ()) (name :initform "TemplateUtilities") @@ -37595,7 +38298,7 @@ Value = NIL (abbreviation :initform 'TEMUTL) (comment :initform (list "This package provides functions for template manipulation")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37609,10 +38312,10 @@ Value = NIL \end{chunk} \subsection{TexFormat1} -\index{TexFormat1!Domain} -\index{Domain!TexFormat1} -\index{TEX1} -\begin{chunk}{sane} +\index[pkg]{TexFormat1!Domain} +\index[pkg]{Domain!TexFormat1} +\index[pkg]{TEX1} +\begin{chunk}{defclass TexFormat1Type} (defclass |TexFormat1Type| (|AxiomClass|) ((parents :initform ()) (name :initform "TexFormat1") @@ -37621,7 +38324,7 @@ Value = NIL (comment :initform (list "TexFormat1 provides a utility coercion for changing" "to TeX format anything that has a coercion to the standard output format.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37635,10 +38338,10 @@ Value = NIL \end{chunk} \subsection{ToolsForSign} -\index{ToolsForSign!Domain} -\index{Domain!ToolsForSign} -\index{TOOLSIGN} -\begin{chunk}{sane} +\index[pkg]{ToolsForSign!Domain} +\index[pkg]{Domain!ToolsForSign} +\index[pkg]{TOOLSIGN} +\begin{chunk}{defclass ToolsForSignType} (defclass |ToolsForSignType| (|AxiomClass|) ((parents :initform ()) (name :initform "ToolsForSign") @@ -37646,7 +38349,7 @@ Value = NIL (abbreviation :initform 'TOOLSIGN) (comment :initform (list "Tools for the sign finding utilities.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37660,10 +38363,10 @@ Value = NIL \end{chunk} \subsection{TopLevelDrawFunctions} -\index{TopLevelDrawFunctions!Domain} -\index{Domain!TopLevelDrawFunctions} -\index{DRAW} -\begin{chunk}{sane} +\index[pkg]{TopLevelDrawFunctions!Domain} +\index[pkg]{Domain!TopLevelDrawFunctions} +\index[pkg]{DRAW} +\begin{chunk}{defclass TopLevelDrawFunctionsType} (defclass |TopLevelDrawFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TopLevelDrawFunctions") @@ -37672,7 +38375,7 @@ Value = NIL (comment :initform (list "TopLevelDrawFunctions provides top level functions for" "drawing graphics of expressions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37686,10 +38389,10 @@ Value = NIL \end{chunk} \subsection{TopLevelDrawFunctionsForAlgebraicCurves} -\index{TopLevelDrawFunctionsForAlgebraicCurves!Domain} -\index{Domain!TopLevelDrawFunctionsForAlgebraicCurves} -\index{DRAWCURV} -\begin{chunk}{sane} +\index[pkg]{TopLevelDrawFunctionsForAlgebraicCurves!Domain} +\index[pkg]{Domain!TopLevelDrawFunctionsForAlgebraicCurves} +\index[pkg]{DRAWCURV} +\begin{chunk}{defclass TopLevelDrawFunctionsForAlgebraicCurvesType} (defclass |TopLevelDrawFunctionsForAlgebraicCurvesType| (|AxiomClass|) ((parents :initform ()) (name :initform "TopLevelDrawFunctionsForAlgebraicCurves") @@ -37698,7 +38401,7 @@ Value = NIL (comment :initform (list "TopLevelDrawFunctionsForAlgebraicCurves provides top level" "functions for drawing non-singular algebraic curves.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37712,10 +38415,10 @@ Value = NIL \end{chunk} \subsection{TopLevelDrawFunctionsForCompiledFunctions} -\index{TopLevelDrawFunctionsForCompiledFunctions!Domain} -\index{Domain!TopLevelDrawFunctionsForCompiledFunctions} -\index{DRAWCFUN} -\begin{chunk}{sane} +\index[pkg]{TopLevelDrawFunctionsForCompiledFunctions!Domain} +\index[pkg]{Domain!TopLevelDrawFunctionsForCompiledFunctions} +\index[pkg]{DRAWCFUN} +\begin{chunk}{defclass TopLevelDrawFunctionsForCompiledFunctionsType} (defclass |TopLevelDrawFunctionsForCompiledFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TopLevelDrawFunctionsForCompiledFunctions") @@ -37724,7 +38427,7 @@ Value = NIL (comment :initform (list "TopLevelDrawFunctionsForCompiledFunctions provides top level" "functions for drawing graphics of expressions.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37738,10 +38441,10 @@ Value = NIL \end{chunk} \subsection{TopLevelDrawFunctionsForPoints} -\index{TopLevelDrawFunctionsForPoints!Domain} -\index{Domain!TopLevelDrawFunctionsForPoints} -\index{DRAWPT} -\begin{chunk}{sane} +\index[pkg]{TopLevelDrawFunctionsForPoints!Domain} +\index[pkg]{Domain!TopLevelDrawFunctionsForPoints} +\index[pkg]{DRAWPT} +\begin{chunk}{defclass TopLevelDrawFunctionsForPointsType} (defclass |TopLevelDrawFunctionsForPointsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TopLevelDrawFunctionsForPoints") @@ -37750,7 +38453,7 @@ Value = NIL (comment :initform (list "TopLevelDrawFunctionsForPoints provides top level functions" "for drawing curves and surfaces described by sets of points.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37764,10 +38467,10 @@ Value = NIL \end{chunk} \subsection{TopLevelThreeSpace} -\index{TopLevelThreeSpace!Domain} -\index{Domain!TopLevelThreeSpace} -\index{TOPSP} -\begin{chunk}{sane} +\index[pkg]{TopLevelThreeSpace!Domain} +\index[pkg]{Domain!TopLevelThreeSpace} +\index[pkg]{TOPSP} +\begin{chunk}{defclass TopLevelThreeSpaceType} (defclass |TopLevelThreeSpaceType| (|AxiomClass|) ((parents :initform ()) (name :initform "TopLevelThreeSpace") @@ -37775,7 +38478,7 @@ Value = NIL (abbreviation :initform 'TOPSP) (comment :initform (list "This package exports a function for making a ThreeSpace")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37789,10 +38492,10 @@ Value = NIL \end{chunk} \subsection{TranscendentalHermiteIntegration} -\index{TranscendentalHermiteIntegration!Domain} -\index{Domain!TranscendentalHermiteIntegration} -\index{INTHERTR} -\begin{chunk}{sane} +\index[pkg]{TranscendentalHermiteIntegration!Domain} +\index[pkg]{Domain!TranscendentalHermiteIntegration} +\index[pkg]{INTHERTR} +\begin{chunk}{defclass TranscendentalHermiteIntegrationType} (defclass |TranscendentalHermiteIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "TranscendentalHermiteIntegration") @@ -37800,7 +38503,7 @@ Value = NIL (abbreviation :initform 'INTHERTR) (comment :initform (list "Hermite integration, transcendental case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37814,10 +38517,10 @@ Value = NIL \end{chunk} \subsection{TranscendentalIntegration} -\index{TranscendentalIntegration!Domain} -\index{Domain!TranscendentalIntegration} -\index{INTTR} -\begin{chunk}{sane} +\index[pkg]{TranscendentalIntegration!Domain} +\index[pkg]{Domain!TranscendentalIntegration} +\index[pkg]{INTTR} +\begin{chunk}{defclass TranscendentalIntegrationType} (defclass |TranscendentalIntegrationType| (|AxiomClass|) ((parents :initform ()) (name :initform "TranscendentalIntegration") @@ -37826,7 +38529,7 @@ Value = NIL (comment :initform (list "This package provides functions for the transcendental" "case of the Risch algorithm.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37840,10 +38543,10 @@ Value = NIL \end{chunk} \subsection{TranscendentalManipulations} -\index{TranscendentalManipulations!Domain} -\index{Domain!TranscendentalManipulations} -\index{TRMANIP} -\begin{chunk}{sane} +\index[pkg]{TranscendentalManipulations!Domain} +\index[pkg]{Domain!TranscendentalManipulations} +\index[pkg]{TRMANIP} +\begin{chunk}{defclass TranscendentalManipulationsType} (defclass |TranscendentalManipulationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TranscendentalManipulations") @@ -37852,7 +38555,7 @@ Value = NIL (comment :initform (list "TranscendentalManipulations provides functions to simplify and" "expand expressions involving transcendental operators.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37866,10 +38569,10 @@ Value = NIL \end{chunk} \subsection{TranscendentalRischDE} -\index{TranscendentalRischDE!Domain} -\index{Domain!TranscendentalRischDE} -\index{RDETR} -\begin{chunk}{sane} +\index[pkg]{TranscendentalRischDE!Domain} +\index[pkg]{Domain!TranscendentalRischDE} +\index[pkg]{RDETR} +\begin{chunk}{defclass TranscendentalRischDEType} (defclass |TranscendentalRischDEType| (|AxiomClass|) ((parents :initform ()) (name :initform "TranscendentalRischDE") @@ -37877,7 +38580,7 @@ Value = NIL (abbreviation :initform 'RDETR) (comment :initform (list "Risch differential equation, transcendental case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37891,10 +38594,10 @@ Value = NIL \end{chunk} \subsection{TranscendentalRischDESystem} -\index{TranscendentalRischDESystem!Domain} -\index{Domain!TranscendentalRischDESystem} -\index{RDETRS} -\begin{chunk}{sane} +\index[pkg]{TranscendentalRischDESystem!Domain} +\index[pkg]{Domain!TranscendentalRischDESystem} +\index[pkg]{RDETRS} +\begin{chunk}{defclass TranscendentalRischDESystemType} (defclass |TranscendentalRischDESystemType| (|AxiomClass|) ((parents :initform ()) (name :initform "TranscendentalRischDESystem") @@ -37902,7 +38605,7 @@ Value = NIL (abbreviation :initform 'RDETRS) (comment :initform (list "Risch differential equation system, transcendental case.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37916,10 +38619,10 @@ Value = NIL \end{chunk} \subsection{TransSolvePackage} -\index{TransSolvePackage!Domain} -\index{Domain!TransSolvePackage} -\index{SOLVETRA} -\begin{chunk}{sane} +\index[pkg]{TransSolvePackage!Domain} +\index[pkg]{Domain!TransSolvePackage} +\index[pkg]{SOLVETRA} +\begin{chunk}{defclass TransSolvePackageType} (defclass |TransSolvePackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "TransSolvePackage") @@ -37940,7 +38643,7 @@ Value = NIL "in terms of tan(x/2) to express in terms of tan(x)." "Other examples are the expressions sqrt(x+1)+sqrt(x+7)+1 or" "sqrt(sin(x))+1 .")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37954,10 +38657,10 @@ Value = NIL \end{chunk} \subsection{TransSolvePackageService} -\index{TransSolvePackageService!Domain} -\index{Domain!TransSolvePackageService} -\index{SOLVESER} -\begin{chunk}{sane} +\index[pkg]{TransSolvePackageService!Domain} +\index[pkg]{Domain!TransSolvePackageService} +\index[pkg]{SOLVESER} +\begin{chunk}{defclass TransSolvePackageServiceType} (defclass |TransSolvePackageServiceType| (|AxiomClass|) ((parents :initform ()) (name :initform "TransSolvePackageService") @@ -37971,7 +38674,7 @@ Value = NIL "func2:=2*X ::EXPR INT convert them via univariate" "to FRAC SUP EXPR INT and then the solution is func3:=X**3+X**2-X" "of type FRAC SUP EXPR INT")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -37985,10 +38688,10 @@ Value = NIL \end{chunk} \subsection{TriangularMatrixOperations} -\index{TriangularMatrixOperations!Domain} -\index{Domain!TriangularMatrixOperations} -\index{TRIMAT} -\begin{chunk}{sane} +\index[pkg]{TriangularMatrixOperations!Domain} +\index[pkg]{Domain!TriangularMatrixOperations} +\index[pkg]{TRIMAT} +\begin{chunk}{defclass TriangularMatrixOperationsType} (defclass |TriangularMatrixOperationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TriangularMatrixOperations") @@ -38002,7 +38705,7 @@ Value = NIL "d * inv(B) also has entries in R, we return d * inv(B). Thus," "it is not necessary to pass to the quotient field in any of our" "computations.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38016,10 +38719,10 @@ Value = NIL \end{chunk} \subsection{TrigonometricManipulations} -\index{TrigonometricManipulations!Domain} -\index{Domain!TrigonometricManipulations} -\index{TRIGMNIP} -\begin{chunk}{sane} +\index[pkg]{TrigonometricManipulations!Domain} +\index[pkg]{Domain!TrigonometricManipulations} +\index[pkg]{TRIGMNIP} +\begin{chunk}{defclass TrigonometricManipulationsType} (defclass |TrigonometricManipulationsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TrigonometricManipulations") @@ -38028,7 +38731,7 @@ Value = NIL (comment :initform (list "TrigonometricManipulations provides transformations from" "trigonometric functions to complex exponentials and logarithms, and back.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38042,10 +38745,10 @@ Value = NIL \end{chunk} \subsection{TubePlotTools} -\index{TubePlotTools!Domain} -\index{Domain!TubePlotTools} -\index{TUBETOOL} -\begin{chunk}{sane} +\index[pkg]{TubePlotTools!Domain} +\index[pkg]{Domain!TubePlotTools} +\index[pkg]{TUBETOOL} +\begin{chunk}{defclass TubePlotToolsType} (defclass |TubePlotToolsType| (|AxiomClass|) ((parents :initform ()) (name :initform "TubePlotTools") @@ -38053,7 +38756,7 @@ Value = NIL (abbreviation :initform 'TUBETOOL) (comment :initform (list "Tools for constructing tubes around 3-dimensional parametric curves.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38067,10 +38770,10 @@ Value = NIL \end{chunk} \subsection{TwoDimensionalPlotClipping} -\index{TwoDimensionalPlotClipping!Domain} -\index{Domain!TwoDimensionalPlotClipping} -\index{CLIP} -\begin{chunk}{sane} +\index[pkg]{TwoDimensionalPlotClipping!Domain} +\index[pkg]{Domain!TwoDimensionalPlotClipping} +\index[pkg]{CLIP} +\begin{chunk}{defclass TwoDimensionalPlotClippingType} (defclass |TwoDimensionalPlotClippingType| (|AxiomClass|) ((parents :initform ()) (name :initform "TwoDimensionalPlotClipping") @@ -38080,7 +38783,7 @@ Value = NIL "Automatic clipping for 2-dimensional plots" "The purpose of this package is to provide reasonable plots of" "functions with singularities.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38094,10 +38797,10 @@ Value = NIL \end{chunk} \subsection{TwoFactorize} -\index{TwoFactorize!Domain} -\index{Domain!TwoFactorize} -\index{TWOFACT} -\begin{chunk}{sane} +\index[pkg]{TwoFactorize!Domain} +\index[pkg]{Domain!TwoFactorize} +\index[pkg]{TWOFACT} +\begin{chunk}{defclass TwoFactorizeType} (defclass |TwoFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "TwoFactorize") @@ -38107,7 +38810,7 @@ Value = NIL "A basic package for the factorization of bivariate polynomials" "over a finite field." "The functions here represent the base step for the multivariate factorizer.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38123,10 +38826,10 @@ Value = NIL \section{U} \subsection{UnivariateFactorize} -\index{UnivariateFactorize!Domain} -\index{Domain!UnivariateFactorize} -\index{UNIFACT} -\begin{chunk}{sane} +\index[pkg]{UnivariateFactorize!Domain} +\index[pkg]{Domain!UnivariateFactorize} +\index[pkg]{UNIFACT} +\begin{chunk}{defclass UnivariateFactorizeType} (defclass |UnivariateFactorizeType| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariateFactorize") @@ -38136,7 +38839,7 @@ Value = NIL "Package for the factorization of univariate polynomials with integer" "coefficients. The factorization is done by 'lifting' (HENSEL) the" "factorization over a finite field.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38150,10 +38853,10 @@ Value = NIL \end{chunk} \subsection{UnivariateFormalPowerSeriesFunctions} -\index{UnivariateFormalPowerSeriesFunctions!Domain} -\index{Domain!UnivariateFormalPowerSeriesFunctions} -\index{UFPS1} -\begin{chunk}{sane} +\index[pkg]{UnivariateFormalPowerSeriesFunctions!Domain} +\index[pkg]{Domain!UnivariateFormalPowerSeriesFunctions} +\index[pkg]{UFPS1} +\begin{chunk}{defclass UnivariateFormalPowerSeriesFunctionsType} (defclass |UnivariateFormalPowerSeriesFunctionsType| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariateFormalPowerSeriesFunctions") @@ -38161,7 +38864,7 @@ Value = NIL (abbreviation :initform 'UFPS1) (comment :initform (list "This package has no description")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38175,10 +38878,10 @@ Value = NIL \end{chunk} \subsection{UnivariateLaurentSeriesFunctions2} -\index{UnivariateLaurentSeriesFunctions2!Domain} -\index{Domain!UnivariateLaurentSeriesFunctions2} -\index{ULS2} -\begin{chunk}{sane} +\index[pkg]{UnivariateLaurentSeriesFunctions2!Domain} +\index[pkg]{Domain!UnivariateLaurentSeriesFunctions2} +\index[pkg]{ULS2} +\begin{chunk}{defclass UnivariateLaurentSeriesFunctions2Type} (defclass |UnivariateLaurentSeriesFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariateLaurentSeriesFunctions2") @@ -38188,7 +38891,7 @@ Value = NIL "Mapping package for univariate Laurent series" "This package allows one to apply a function to the coefficients of" "a univariate Laurent series.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38202,10 +38905,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomialCategoryFunctions2} -\index{UnivariatePolynomialCategoryFunctions2!Domain} -\index{Domain!UnivariatePolynomialCategoryFunctions2} -\index{UPOLYC2} -\begin{chunk}{sane} +\index[pkg]{UnivariatePolynomialCategoryFunctions2!Domain} +\index[pkg]{Domain!UnivariatePolynomialCategoryFunctions2} +\index[pkg]{UPOLYC2} +\begin{chunk}{defclass UnivariatePolynomialCategoryFunctions2Type} (defclass |UnivariatePolynomialCategoryFunctions2Type| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariatePolynomialCategoryFunctions2") @@ -38214,7 +38917,7 @@ Value = NIL (comment :initform (list "Mapping from polynomials over R to polynomials over S" "given a map from R to S assumed to send zero to zero.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38228,10 +38931,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomialCommonDenominator} -\index{UnivariatePolynomialCommonDenominator!Domain} -\index{Domain!UnivariatePolynomialCommonDenominator} -\index{UPCDEN} -\begin{chunk}{sane} +\index[pkg]{UnivariatePolynomialCommonDenominator!Domain} +\index[pkg]{Domain!UnivariatePolynomialCommonDenominator} +\index[pkg]{UPCDEN} +\begin{chunk}{defclass UnivariatePolynomialCommonDenominatorType} (defclass |UnivariatePolynomialCommonDenominatorType| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariatePolynomialCommonDenominator") @@ -38241,7 +38944,7 @@ Value = NIL "UnivariatePolynomialCommonDenominator provides" "functions to compute the common denominator of the coefficients of" "univariate polynomials over the quotient field of a gcd domain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38255,10 +38958,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomialDecompositionPackage} -\index{UnivariatePolynomialDecompositionPackage!Domain} -\index{Domain!UnivariatePolynomialDecompositionPackage} -\index{UPDECOMP} -\begin{chunk}{sane} +\index[pkg]{UnivariatePolynomialDecompositionPackage!Domain} +\index[pkg]{Domain!UnivariatePolynomialDecompositionPackage} +\index[pkg]{UPDECOMP} +\begin{chunk}{defclass UnivariatePolynomialDecompositionPackageType} (defclass |UnivariatePolynomialDecompositionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariatePolynomialDecompositionPackage") @@ -38268,7 +38971,7 @@ Value = NIL "UnivariatePolynomialDecompositionPackage implements" "functional decomposition of univariate polynomial with coefficients" "in an IntegralDomain of CharacteristicZero.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil) (withlist :initform nil) (haslist :initform nil) @@ -38282,10 +38985,10 @@ Value = NIL \end{chunk} \subsection{UnivariatePolynomialDivisionPackage} -\index{UnivariatePolynomialDivisionPackage!Domain} -\index{Domain!UnivariatePolynomialDivisionPackage} -\index{UPDIVP} -\begin{chunk}{sane} +\index[pkg]{UnivariatePolynomialDivisionPackage!Domain} +\index[pkg]{Domain!UnivariatePolynomialDivisionPackage} +\index[pkg]{UPDIVP} +\begin{chunk}{defclass UnivariatePolynomialDivisionPackageType} (defclass |UnivariatePolynomialDivisionPackageType| (|AxiomClass|) ((parents :initform ()) (name :initform "UnivariatePolynomialDivisionPackage") @@ -38295,7 +38998,7 @@ Value = NIL "UnivariatePolynomialDivisionPackage provides a" "division for non monic univarite polynomials with coefficients in" "an IntegralDomain.")) - (arglist :initform nil) + (argslist :initform nil) (macros :initform nil)