diff git a/books/bookvol0.pamphlet b/books/bookvol0.pamphlet
index 08a195a..3487c16 100644
 a/books/bookvol0.pamphlet
+++ b/books/bookvol0.pamphlet
@@ 13,6 +13,38 @@
\setcounter{topnumber}{50}
\setcounter{bottomnumber}{50}
+
+%%
+%% sechead consolidates standard page indexing
+%% it replaces the \section tag for domains so we
+%% create proper cross references and index entries
+%%
+\newcommand{\domainhead}[1]{% e.g. \domainhead{domain}
+\section{#1}
+\label{#1}%
+\index{{#1}}}%
+
+%%
+%% domainref consolidates standard page indexing
+%% it replaces the \ref tag for domain
+%%
+\newcommand{\domainref}[1]{% e.g. \domainref{domain}
+{\tt #1}{ \ref{#1} on page~\pageref{#1}}}
+
+%%
+%% sectionref consolidates standard page indexing
+%% it replaces the \ref tag for labels
+%%
+\newcommand{\sectionref}[1]{% e.g. \sectionref{domain}
+{section~\ref{#1} on page~\pageref{#1}}}
+
+%%
+%% figureref consolidates standard page indexing
+%% it replaces the \ref tag for labels
+%%
+\newcommand{\figureref}[1]{% e.g. \sectionref{domain}
+{figure~\ref{#1} on page~\pageref{#1}}}
+
% spadcommands are the actual text that you type at the axiom prompt
\newcommand{\spadcommand}[1]%
{\begin{flushleft}{\tt #1}\end{flushleft}\vskip .1cm }
@@ 568,8 +600,8 @@ As another example of a HyperDoc facility, suppose that you want to
compute the roots of $x^{49}  49x^4 + 9$ to 49 digits (as in our
previous example) and you don't know how to tell Axiom to do this.
The ``basic command'' facility of HyperDoc leads the way. Through the
series of HyperDoc windows shown in Figure \ref{figintrobr} on
page~\pageref{figintrobr} and the specified mouse clicks, you and
+series of HyperDoc windows shown in \figureref{figintrobr}
+and the specified mouse clicks, you and
HyperDoc generate the correct command to issue to compute the answer.
\subsection{Interactive Programming }
@@ 3737,7 +3769,7 @@ examples online, execute Axiom expressions, and generate
graphics. If you are in a graphical windowing environment, it is
usually started automatically when Axiom begins. If it is not
running, issue {\tt )hd} to start it. We discuss the basics of
HyperDoc in Chapter \ref{ugHyper} on page~\pageref{ugHyper}.
+HyperDoc in \sectionref{ugHyper}.
To interrupt an Axiom computation, hold down the \index{interrupt}
{\bf Ctrl} (control) key and press {\bf c}. This brings you back to
@@ 3913,7 +3945,7 @@ $$
\label{ugIntroTypes}
Everything in Axiom has a type. The type determines what operations
you can perform on an object and how the object can be used.
Chapter~\ref{ugTypes} on page~\pageref{ugTypes} is dedicated to the
+The \sectionref{ugTypes} is dedicated to the
interactive use of types. Several of the final chapters discuss how
types are built and how they are organized in the Axiom library.
@@ 3971,8 +4003,8 @@ refers to a value. To {\sl assign} a value to a variable,
\index{variable!naming} the operator ``{\tt :=}'' \index{assignment}
is used.\footnote{Axiom actually has two forms of assignment:
{\it immediate} assignment, as discussed here, and {\it delayed
assignment}. See Section \ref{ugLangAssign} on page~\pageref{ugLangAssign}
for details.} A variable initially has no restrictions on the kinds
+assignment}. See \sectionref{ugLangAssign} for details.}
+A variable initially has no restrictions on the kinds
of \index{declaration} values to which it can refer.
This assignment gives the value $4$ (an integer) to
@@ 4092,7 +4124,7 @@ such trouble spots.
Objects of one type can usually be ``converted'' to objects of several
other types. To {\sl convert} an object to a new type, use the ``{\tt ::}''
infix operator.\footnote{Conversion is discussed in detail in
\ref{ugTypesConvert} on page~\pageref{ugTypesConvert}.} For example,
+\sectionref{ugTypesConvert}.} For example,
to display an object, it is necessary to convert the object to type
{\tt OutputForm}.
@@ 4180,7 +4212,7 @@ operations are provided for efficiency reasons.
\subsection{Some Predefined Macros}
\label{ugIntroMacros}
Axiom provides several macros for your convenience.\footnote{See
\ref{ugUserMacros} on page~\pageref{ugUserMacros} for a discussion on
+\sectionref{ugUserMacros} for a discussion on
how to write your own macros.} Macros are names
\index{macro!predefined} (or forms) that expand to larger expressions
for commonly used values.
@@ 4229,9 +4261,9 @@ is the same as if you had entered
\end{verbatim}
Axiom statements in an input file
(see Section \ref{ugInOutIn} on page~\pageref{ugInOutIn}),
+(see \sectionref{ugInOutIn})
can use indentation to indicate the program structure .
(see Section \ref{ugLangBlocks} on page~\pageref{ugLangBlocks}).
+(see \sectionref{ugLangBlocks}).
\subsection{Comments}
\label{ugIntroComments}
@@ 4524,8 +4556,8 @@ $$
\returnType{Type: IntegerMod 6}
Inversion is not available if the modulus is not a prime number.
Modular arithmetic and prime fields are discussed in Section
\ref{ugxProblemFinitePrime} on page~\pageref{ugxProblemFinitePrime}.
+Modular arithmetic and prime fields are discussed in
+\sectionref{ugxProblemFinitePrime}.
\spadcommand{1/y}
\begin{verbatim}
@@ 4647,8 +4679,8 @@ data structures are particularly useful for interactive computation
and others are useful for building applications. The data structures
of Axiom are organized into {\sl category hierarchies}.
A {\it list} \footnote{Lists are discussed in Section \ref{ListXmpPage} on
page~\pageref{ListXmpPage}} is the most commonly used data structure in
+A {\it list} \footnote{\domainref{List}}
+is the most commonly used data structure in
Axiom for holding objects all of the same type. The name {\it list} is
short for ``linkedlist of nodes.'' Each node consists of a value
(\spadfunFrom{first}{List}) and a link (\spadfunFrom{rest}{List}) that
@@ 4720,8 +4752,7 @@ $$
A {\it stream} is a structure that (potentially) has an infinite
number of distinct elements. Think of a stream as an
``infinite list'' where elements are computed successively.
\footnote{Streams are discussed in Section{StreamXmpPage} on
page~\pageref{StreamXmpPage}}
+\footnote{\domainref{Stream}}
Create an infinite stream of factored integers. Only a certain number
of initial elements are computed and displayed.
@@ 4753,13 +4784,11 @@ For example, {\bf first} and {\bf rest} are used to access
elements and successive nodes of a stream.
A {\it onedimensional array} is another data structure used to hold
objects of the same type \footnote{OnedimensionalArray is discussed in
Section \ref{OneDimensionalArrayXmpPage} on
page~\pageref{OneDimensionalArrayXmpPage}}. Unlike lists,
onedimensional arrays are inflexiblethey are
\index{array!onedimensional} implemented using a fixed block of
storage. Their advantage is that they give quick and equal access
time to any element.
+objects of the same type \footnote{\domainref{OneDimensionalArray}}.
+Unlike lists, onedimensional
+arrays are inflexiblethey are \index{array!onedimensional}
+implemented using a fixed block of storage. Their advantage is that
+they give quick and equal access time to any element.
A simple way to create a onedimensional array is to apply the
operation {\bf oneDimensionalArray} to a list of elements.
@@ 4816,9 +4845,8 @@ $$
$$
\returnType{Type: Bits}
A {\it flexible array} \footnote{FlexibleArray is discussed in Section
\ref{FlexibleArrayXmpPage} on page~\pageref{FlexibleArrayXmpPage}} is
a cross between a list \index{array!flexible} and a onedimensional
+A {\it flexible array} \footnote{\domainref{FlexibleArray}}
+is a cross between a list \index{array!flexible} and a onedimensional
array. Like a onedimensional array, a flexible array occupies a fixed
block of storage. Its block of storage, however, has room to expand.
When it gets full, it grows (a new, larger block of storage is
@@ 4845,8 +4873,8 @@ $$
Flexible arrays are used to implement ``heaps.'' A {\it heap} is an
example of a data structure called a {\it priority queue}, where
elements are ordered with respect to one another. A heap
\footnote{Heap is discussed in Section \ref{HeapXmpPage} on
page~\pageref{HeapXmpPage}} is organized so as to optimize insertion
+\footnote{\domainref{Heap}}
+is organized so as to optimize insertion
and extraction of maximum elements. The {\bf extract!} operation
returns the maximum element of the heap, after destructively removing
that element and reorganizing the heap so that the next maximum
@@ 4876,10 +4904,10 @@ $$
A {\it binary tree} is a ``tree'' with at most two branches
\index{tree} per node: it is either empty, or else is a node
consisting of a value, and a left and right subtree (again, binary
trees). \footnote{BinarySearchTrees are discussed in Section
\ref{BinarySearchTreeXmpPage} on page~\pageref{BinarySearchTreeXmpPage}}
+trees). \footnote{\domainref{BinarySearchTree}}
Examples of binary tree types are {\tt BinarySearchTree},
{\tt PendantTree}, {\tt TournamentTree}, and {\tt BalancedBinaryTree}.
+\footnote{\domainref{BalancedBinaryTree}}
A {\it binary search tree} is a binary tree such that,
\index{tree!binary search} for each node, the value of the node is
@@ 4910,8 +4938,8 @@ $$
\returnType{Type: List Integer}
A {\it set} is a collection of elements where duplication and order is
irrelevant. \footnote{Sets are discussed in Section \ref{SetXmpPage}
on page~\pageref{SetXmpPage}} Sets are always finite and have no
+irrelevant. \footnote{\domainref{Set}}
+Sets are always finite and have no
corresponding structure like streams for infinite collections.
Create sets using braces ``\{`` and ``\}'' rather than brackets.
@@ 4925,8 +4953,7 @@ $$
\returnType{Type: Set Fraction Integer}
A {\it multiset} is a set that keeps track of the number of duplicate
values. \footnote{Multisets are discussed in Section
\ref{MultisetXmpPage} on page~\pageref{MultisetXmpPage}}
+values. \footnote{\domainref{Multiset}}
For all the primes $p$ between 2 and 1000, find the
distribution of $p \bmod 5$.
@@ 4984,8 +5011,8 @@ $$
\returnType{Type: Table(Integer,Integer)}
A {\it record} is an example of an inhomogeneous collection of
objects.\footnote{See \ref{ugTypesRecords} on
page~\pageref{ugTypesRecords} for details.} A record consists of a
+objects.\footnote{See \sectionref{ugTypesRecords} for details.}
+A record consists of a
set of named {\it selectors} that can be used to access its
components. \index{Record@{\sf Record}}
@@ 5014,8 +5041,8 @@ $$
\returnType{Type: Record(age: Integer,salary: Float)}
A {\it union} is a data structure used when objects have multiple
types.\footnote{See \ref{ugTypesUnions} on
page~\pageref{ugTypesUnions} for details.} \index{Union@{\sf Union}}
+types.\footnote{See \sectionref{ugTypesUnions} for details.}
+\index{Union@{\sf Union}}
Let $dog$ be either an integer or a string value.
\spadcommand{dog: Union(licenseNumber: Integer, name: String)}
@@ 5029,8 +5056,8 @@ $$
\returnType{Type: Union(name: String,...)}
All told, there are over forty different data structures in Axiom.
Using the domain constructors described in Chapter \ref{ugDomains} on
page~\pageref{ugDomains}, you can add your own data structure or
+Using the domain constructors described in \sectionref{ugDomains},
+you can add your own data structure or
extend an existing one. Choosing the right data structure for your
application may be the key to obtaining good performance.
@@ 5052,12 +5079,12 @@ algebraic operations are available for matrices but not for arrays.
Because of this, we limit our discussion here to {\tt Matrix}, that
can be regarded as an extension of {\tt TwoDimensionalArray}. See {\tt
TwoDimensionalArray} for more information about arrays. For more
information about Axiom's linear algebra facilities, see {\tt Matrix},
{\tt Permanent}, {\tt SquareMatrix}, {\tt Vector}, see Section
\ref{ugProblemEigen} on page~\pageref{ugProblemEigen} (computation of
eigenvalues and eigenvectors), and Section \ref{ugProblemLinPolEqn} on
page~\pageref{ugProblemLinPolEqn} (solution of linear and polynomial
equations).
+information about Axiom's linear algebra facilities, see
+\domainref{Matrix}, \domainref{Permanent}, \domainref{SquareMatrix},
+\domainref{Vector}, \domainref{TwoDimensionalArray},
+\sectionref{ugProblemEigen} (computation of eigenvalues and eigenvectors),
+and \sectionref{ugProblemLinPolEqn}
+(solution of linear and polynomial equations).
You can create a matrix from a list of lists, \index{matrix!creating}
where each of the inner lists represents a row of the matrix.
@@ 5072,8 +5099,8 @@ $$
$$
\returnType{Type: Matrix Integer}
The ``collections'' construct (see \ref{ugLangIts} on
page~\pageref{ugLangIts}) is useful for creating matrices whose
+The ``collections'' construct (see \sectionref{ugLangIts})
+is useful for creating matrices whose
entries are given by formulas. \index{matrix!Hilbert}
\spadcommand{matrix([ [1/(i + j  x) for i in 1..4] for j in 1..4])}
$$
@@ 5163,7 +5190,7 @@ write some Axiom programs to tackle your application.
Axiom allows you to write functions interactively,
\index{function} thereby effectively extending the system library.
Here we give a few simple examples, leaving the details to
Chapter \ref{ugUser} on page~\pageref{ugUser}.
+\sectionref{ugUser}.
We begin by looking at several ways that you can define the
``factorial'' function in Axiom. The first way is to give a
@@ 5251,7 +5278,7 @@ $$
You are not limited to oneline functions in Axiom. If you place your
function definitions in {\bf .input} files \index{file!input} (see
\ref{ugInOutIn} on page~\pageref{ugInOutIn}), you can have multiline
+\sectionref{ugInOutIn}), you can have multiline
functions that use indentation for grouping.
Given $n$ elements, {\bf diagonalMatrix} creates an
@@ 5513,7 +5540,7 @@ expression $f$ as a real variable $x$ tends to a limit
value $a$, enter {\tt limit(f, x=a)}. Use
{\bf complexLimit} if the variable is complex. Additional
information and examples of limits are in
Section \ref{ugProblemLimits} on page~\pageref{ugProblemLimits}.
+\sectionref{ugProblemLimits}.
You can take limits of functions with parameters.
\index{limit!of function with parameters}
@@ 5584,8 +5611,7 @@ Axiom tries to compute and display the first ten elements of a series.
Use {\tt )set streams calculate} to change the default value to
something else. For the purposes of this document, we have used this
system command to display fewer than ten terms. For more information
about working with series, see \ref{ugProblemSeries} on
page~\pageref{ugProblemSeries}.
+about working with series, see \sectionref{ugProblemSeries}.
You can convert a functional expression to a power series by using the
operation {\bf series}. In this example, {\tt sin(a*x)} is
@@ 6183,7 +6209,7 @@ $$
\returnType{Type: Union(Expression Integer,...)}
More examples of Axiom's integration capabilities are discussed in
Section \ref{ugProblemIntegration} on page~\pageref{ugProblemIntegration}.
+\sectionref{ugProblemIntegration}.
\section{Differential Equations}
\label{ugIntroDiffEqns}
@@ 6742,7 +6768,7 @@ display options set from the 3D Control Panel.
The PostScript output was produced by clicking on the
{\bf save} 3D Control Panel button and then
clicking on the {\bf PS} button.
See Section \ref{ugProblemNumeric} on page~\pageref{ugProblemNumeric}
+See \sectionref{ugProblemNumeric}
for more details and examples of Axiom's numeric and graphics capabilities.
\spadgraph{draw((x,y) +> real atan complex(x,y), \%pi..\%pi, \%pi..\%pi, colorFunction == (x,y) +> argument atan complex(x,y))}
@@ 6756,11 +6782,11 @@ for more details and examples of Axiom's numeric and graphics capabilities.
An exhibit of Axiom images is given later. For a description of the
commands and programs that produced these figures, see
\ref{ugAppGraphics} on page~\pageref{ugAppGraphics}. PostScript
+\sectionref{ugAppGraphics}. PostScript
\index{PostScript} output is available so that Axiom images can be
printed.\footnote{PostScript is a trademark of Adobe Systems
Incorporated, registered in the United States.} See \ref{ugGraph} on
page~\pageref{ugGraph} for more examples and details about using
+Incorporated, registered in the United States.} See \sectionref{ugGraph}
+for more examples and details about using
Axiom's graphics facilities.
This concludes your tour of Axiom.
@@ 7128,9 +7154,8 @@ prevents the system from building meaningless domains such as
{\tt Polynomial(Boolean)} and then wrongfully applying algorithms that
presume that the ring axioms hold.
Enough on categories. To learn more about them, see Chapter
\ref{ugCategories} on page~\pageref{ugCategories}.
We now return to our discussion of domains.
+Enough on categories. To learn more about them, see
+\sectionref{ugCategories}. We now return to our discussion of domains.
Domains {\it export} a set of operations to make them available for
systemwide use. {\tt Integer}, for example, exports the operations
@@ 7171,7 +7196,7 @@ over a domain $R$ to polynomials over $S$. To convert an object from
{\tt Polynomial(Integer)} to {\tt Polynomial(Float)}, Axiom builds the
package {\tt PolynomialFunctions2(Integer,Float)} in order to create
the required conversion function. (This happens ``behind the scenes''
for you: see \ref{ugTypesConvert} on page~\pageref{ugTypesConvert}
+for you: see \sectionref{ugTypesConvert}
for details on how to convert objects.)
Axiom categories, domains and packages and all their contained
@@ 7183,8 +7208,8 @@ domains and their functions and how to write your own functions.
\section{Writing Types and Modes}
\label{ugTypesWriting}
We have already seen in the last section \ref{ugTypesBasic} on
page~\pageref{ugTypesBasic} several examples of types. Most of these
+We have already seen in the last section \sectionref{ugTypesBasic}
+several examples of types. Most of these
examples had either no arguments (for example, {\tt Integer}) or one
argument (for example, {\tt Polynomial (Integer)}). In this section
we give details about writing arbitrary types. We then define modes
@@ 7197,12 +7222,12 @@ you declare variables.
\returnType{Type: Void}
You need to do so when you declare functions
(See Section \ref{ugTypesDeclare} on page~\pageref{ugTypesDeclare}),
+(See \sectionref{ugTypesDeclare})
\spadcommand{f : Integer > String}
\returnType{Type: Void}
You need to do so when you convert an object from one type to another
(See Section \ref{ugTypesConvert} on page~\pageref{ugTypesConvert}).
+(See \sectionref{ugTypesConvert}).
\spadcommand{factor(2 :: Complex(Integer))}
$$
{i \ {{\left( 1+i
@@ 7218,7 +7243,7 @@ $$
\returnType{Type: Boolean}
You need to do so when you give computation target type information
(See Section \ref{ugTypesPkgCall} on page~\pageref{ugTypesPkgCall}).
+(See \sectionref{ugTypesPkgCall})
\spadcommand{(2 = 3)@Boolean}
$$
{\tt false}
@@ 7279,7 +7304,7 @@ $$
\returnType{Type: Complex Fraction Integer}
If you supply computation target type information
(See Section \ref{ugTypesPkgCall} on page~\pageref{ugTypesPkgCall})
+(See \sectionref{ugTypesPkgCall})
then you should enclose the argument in parentheses.
\spadcommand{(2/3)@Fraction(Polynomial(Integer))}
$$
@@ 7336,9 +7361,8 @@ and {\tt SquareMatrix(?, ?)} are all
invalid. The question mark must take the place of a domain, not data.
This rules out, for example, the two {\tt SquareMatrix} expressions.
Modes can be used for declarations (See Section \ref{ugTypesDeclare}
on page~\pageref{ugTypesDeclare}) and conversions (Section
\ref{ugTypesConvert} on page~\pageref{ugTypesConvert}). However, you
+Modes can be used for declarations (See \sectionref{ugTypesDeclare})
+and conversions (\sectionref{ugTypesConvert}). However, you
cannot use a mode for package calling or giving target type information.
\subsection{Abbreviations}
@@ 7395,7 +7419,7 @@ abbreviations. For a specific constructor, use {\tt )abbreviation
query}. \index{abbreviation} You can also use the {\tt )what} system
command to see the names and abbreviations of constructors.
\index{what} For more information about {\tt )what}, see
\ref{ugSysCmdwhat} on page~\pageref{ugSysCmdwhat}.
+\sectionref{ugSysCmdwhat}.
{\tt )abbreviation query} can be abbreviated (no pun intended) to
{\tt )abb q}.
@@ 7463,10 +7487,8 @@ For multiple variables, the syntax is
You can always combine a declaration with an assignment. When you do,
it is equivalent to first giving a declaration statement, then giving
an assignment. For more information on assignment, see
Section \ref{ugIntroAssign} on page~\pageref{ugIntroAssign} and
Section \ref{ugLangAssign} on page~\pageref{ugLangAssign}.
To see how to declare your own functions,
see \ref{ugUserDeclare} on page~\pageref{ugUserDeclare}.
+\sectionref{ugIntroAssign} and \sectionref{ugLangAssign}.
+To see how to declare your own functions, see \sectionref{ugUserDeclare}.
This declares one variable to have a type.
\spadcommand{a : Integer}
@@ 7567,8 +7589,8 @@ $$
\returnType{Type: Complex Polynomial Integer}
This is a polynomial with complex integer coefficients. The objects
are convertible from one to the other. See \ref{ugTypesConvert} on
page~\pageref{ugTypesConvert} for more information.
+are convertible from one to the other. See \sectionref{ugTypesConvert}
+for more information.
\spadcommand{g : POLY COMPLEX ? := (x + y*\%i)**2}
$$
@@ 7923,7 +7945,7 @@ $$
\subsection{Unions With Selectors}
\label{ugTypesUnionsWSel}
Like records (\ref{ugTypesRecords} on page~\pageref{ugTypesRecords}),
+Like records (\sectionref{ugTypesRecords}),
you can write {\tt Union} types \index{selector!union} with selectors.
\index{union!selector}
@@ 7953,7 +7975,7 @@ integer {\it and} a float {\it and} a string. An object of type
{\it or} a float {\it or} a string.
Here is a version of the {\bf sayBranch} function (cf.
\ref{ugTypesUnionsWOSel} on page~\pageref{ugTypesUnionsWOSel}) that
+\sectionref{ugTypesUnionsWOSel}) that
works with a union with selectors. It displays a message stating in
which branch of the {\tt Union} the object lies.
@@ 8177,7 +8199,7 @@ multiplication, whereas {\tt SquareMatrix} does not. That is because
{\tt Fraction} requires that its argument belong to the category
{\tt IntegralDomain} and \index{category} {\tt Complex} requires that its
argument belong to {\tt CommutativeRing}.
See \ref{ugTypesBasic} on page~\pageref{ugTypesBasic} for a
+See \sectionref{ugTypesBasic} for a
brief discussion of categories. The {\tt Integer} level did not move
anywhere because it does not allow any arguments. We also did not
move the {\tt SquareMatrix} part anywhere, but we could have.
@@ 8464,7 +8486,7 @@ your having to qualify it with type information. Nevertheless, there
are times when you need to help it along by providing hints (or even
orders!) to get Axiom to do what you want.
We saw in \ref{ugTypesDeclare} on page~\pageref{ugTypesDeclare} that
+We saw in \sectionref{ugTypesDeclare} that
declarations using types and modes control the type of the results
produced. For example, we can either produce a complex object with
polynomial real and imaginary parts or a polynomial with complex
@@ 8526,8 +8548,7 @@ $$ fun\ (\ arg_1, arg_2, \ldots, arg_N\ )\$type$$
For example, to call the ``minimum'' function from {\rm DoubleFloat} on two
integers, you could write {\bf min}(4,89){\tt DoubleFloat}. Another use of
package calling is to tell AXIOM to use a library function rather than a
function you defined. We discuss this in
Section \ref{ugUserUse} on page~\pageref{ugUserUse}.
+function you defined. We discuss this in \sectionref{ugUserUse}.
Sometimes rather than specifying where an operation comes from, you
just want to say what type the result should be. We say that you provide a
@@ 8764,8 +8785,8 @@ Every \index{constructor!exposed} domain and package in the Axiom
library \index{constructor!hidden} is \index{exposed!constructor}
either exposed (meaning that you can use its operations without doing
anything special) or it is {\it hidden} (meaning you have to either
package call (see \ref{ugTypesPkgCall} on
page~\pageref{ugTypesPkgCall}) the operations it contains or
+package call (see \sectionref{ugTypesPkgCall})
+the operations it contains or
explicitly expose it to use the operations). The initial exposure
status for a constructor is set in the file {\bf exposed.lsp} (see the
{\it Installer's Note} \index{exposed.lsp @{\bf exposed.lsp}} for
@@ 8834,8 +8855,8 @@ you should issue {\tt )set expose add group basic} to restore your default
environment. \index{set expose add group}
It is more likely that you would want to expose or hide individual
constructors. In \ref{ugUserTriangle} on
page~\pageref{ugUserTriangle} we use several operations from
+constructors. In \sectionref{ugUserTriangle}
+we use several operations from
{\tt OutputForm}, a domain usually hidden. To avoid package calling every
operation from {\tt OutputForm}, we expose the domain and let Axiom
conclude that those operations should be used. Use {\tt )set expose
@@ 8883,7 +8904,7 @@ Hide {\tt OutputForm} so we don't run into problems with any later examples!
\end{verbatim}
Finally, exposure is done on a framebyframe basis. A {\it frame}
(see \ref{ugSysCmdframe} on page~\pageref{ugSysCmdframe})
+(see \sectionref{ugSysCmdframe})
\index{frame!exposure and} is one of possibly several logical Axiom
workspaces within a physical one, each having its own environment (for
example, variables and function definitions). If you have several
@@ 8901,8 +8922,7 @@ To conclude this chapter, we introduce you to some system commands
that you can use for getting more information about domains, packages,
categories, and operations. The most powerful Axiom facility for
getting information about constructors and operations is the Browse
component of HyperDoc. This is discussed in Chapter
\ref{ugBrowse} on page~\pageref{ugBrowse}.
+component of HyperDoc. This is discussed in \sectionref{ugBrowse}.
Use the {\tt )what} system command to see lists of system objects
whose name contain a particular substring (uppercase or lowercase is
@@ 9017,9 +9037,8 @@ So if {\tt D1} is a commutative ring (such as the integers or floats) and
called {\bf complex} that takes two elements of {\tt D1} and creates an
element of {\tt D}. The primary example of a constructor implementing
domains belonging to {\tt ComplexCategory} is {\tt Complex}. See
\ref{Complex} on page~\pageref{Complex} for more information on that and see
\ref{ugUserDeclare} on page~\pageref{ugUserDeclare}
for more information on function types.
+\domainref{Complex} for more information on that and see
+\sectionref{ugUserDeclare} for more information on function types.
\setcounter{chapter}{2}
@@ 9083,9 +9102,8 @@ toplevel menu.
\label{ugHyperKeys}
The following keyboard definitions are in effect throughout HyperDoc.
See \ref{ugHyperScroll} on page~\pageref{ugHyperScroll} and
\ref{ugHyperInput} on page~\pageref{ugHyperInput} for some contextual key
definitions.
+See \sectionref{ugHyperScroll} and \sectionref{ugHyperInput}
+for some contextual key definitions.
\begin{description}
\item[F1] Display the main help page.
@@ 9131,7 +9149,7 @@ To move up or down one screen at a time, use the \fbox{\bf PageUp} and
region up and down one page each time you press them.
If the HyperDoc page does not contain an input area (see
\ref{ugHyperInput} on page~\pageref{ugHyperInput}), you can also use
+\sectionref{ugHyperInput}, you can also use
the \fbox{\bf Home} and \fbox{$\uparrow$} and \fbox{$\downarrow$}
arrow keys to navigate. When you press the \fbox{\bf Home} key, the
screen is positioned at the very top of the page. Use the
@@ 9417,8 +9435,7 @@ file is in your home directory or in the directory you specified with
\index{cd} {\tt {)cd}}.\\
}
In \ref{ugLangBlocks} on page~\pageref{ugLangBlocks}
we discuss using indentation in input files to
+In \sectionref{ugLangBlocks} we discuss using indentation in input files to
group statements into {\it blocks.}
\section{The .axiom.input File}
@@ 10112,7 +10129,7 @@ $$
\returnType{Type: PositiveInteger}
There is no syntactic form for multiple delayed assignments. See the
discussion in section \ref{ugUserDelay} on page~\pageref{ugUserDelay}
+discussion in \sectionref{ugUserDelay}
about how Axiom differentiates between delayed assignments and user
functions of no arguments.
@@ 10239,7 +10256,7 @@ $$
\returnType{Type: Polynomial Float}
Blocks can be used in the clauses of {\tt ifthenelse} expressions
(see \ref{ugLangIf} on page~\pageref{ugLangIf}).
+(see \sectionref{ugLangIf}).
\spadcommand{if h > 3.1 then 1.0 else (z := cos(h); max(z,0.5))}
$$
@@ 10325,8 +10342,8 @@ An {\tt ifthenelse} expression always returns a value. If the
{\tt else} clause is missing then the entire expression returns the unique
value of {\tt Void}. If both clauses are present, the type of the
value returned by {\tt if} is obtained by resolving the types of the
values of the two clauses. See \ref{ugTypesResolve} on
page~\pageref{ugTypesResolve} for more information.
+values of the two clauses. See \sectionref{ugTypesResolve}
+for more information.
The predicate must evaluate to, or be convertible to, an object of
type {\tt Boolean}: {\tt true} or {\tt false}. By default, the equal
@@ 10347,8 +10364,7 @@ predicate and equality testing is performed. \index{Boolean} Thus you
need not qualify the ``{\tt =}'' in any way. In other contexts you
may need to tell Axiom that you want to test for equality rather than
create an equation. In those cases, use ``{\tt @}'' and a target type
of {\tt Boolean}. See section \ref{ugTypesPkgCall} on
page~\pageref{ugTypesPkgCall} for more information.
+of {\tt Boolean}. See \sectionref{ugTypesPkgCall} for more information.
The compound symbol meaning ``not equal'' in Axiom is
\index{inequality testing} ``{$\sim =$}''. \index{\_notequal@$\sim =$}
@@ 10450,8 +10466,8 @@ following message:
\end{center}
It is still possible that Axiom can evaluate the loop but in {\it
interpretcode mode}. See section \ref{ugUserCompInt} on
page~\pageref{ugUserCompInt} where this is discussed in terms
+interpretcode mode}. See \sectionref{ugUserCompInt}
+where this is discussed in terms
\index{panic!avoiding} of compiling versus interpreting functions.
\subsection{return in Loops}
@@ 10510,7 +10526,7 @@ f() ==
\returnType{Type: Void}
When we try {\bf f} again we get what we wanted. See
\ref{ugUserBlocks} on page~\pageref{ugUserBlocks} for more information.
+\sectionref{ugUserBlocks} for more information.
\spadcommand{f()}
\begin{verbatim}
@@ 10531,7 +10547,7 @@ always return the unique value of {\tt Void}., you cannot return a
value with {\tt break}. That is, {\tt break} takes no argument.
This example is a modification of the last example in the previous
section \ref{ugLangLoopsReturn} on page~\pageref{ugLangLoopsReturn}.
+\sectionref{ugLangLoopsReturn}.
Instead of using {\tt return}, we'll use {\tt break}.
\begin{verbatim}
@@ 10721,8 +10737,7 @@ $$
Scan the rows looking for the first negative element. We remark that
you can reformulate this example in a better, more concise form by
using a {\tt for} clause with {\tt repeat}. See
\ref{ugLangLoopsForIn} on page~\pageref{ugLangLoopsForIn} for more
information.
+\sectionref{ugLangLoopsForIn} for more information.
\begin{verbatim}
repeat
@@ 11008,8 +11023,7 @@ for i in 1..5 repeat
\end{verbatim}
\returnType{Type: Void}
See section \ref{SegmentXmpPage} on page~\pageref{SegmentXmpPage} for
more information about segments.
+See \domainref{Segment}.
\subsection{for i in n..m by s repeat}
\label{ugLangLoopsForInNMS}
@@ 11175,8 +11189,7 @@ for i in 1..50 repeat
\subsection{Parallel Iteration}
\label{ugLangLoopsPar}
The last example of the previous section
\ref{ugLangLoopsForInPred} on page~\pageref{ugLangLoopsForInPred}
+The last example of the previous \sectionref{ugLangLoopsForInPred}
gives an example of {\it nested iteration}: a loop is contained
\index{iteration!nested} in another loop. \index{iteration!parallel}
Sometimes you want to iterate across two lists in parallel, or perhaps
@@ 11320,7 +11333,7 @@ or any {\tt for} clause to the left.
\label{ugLangIts}
All of what we did for loops in
\ref{ugLangLoops} on page~\pageref{ugLangLoops} \index{iteration}
+\sectionref{ugLangLoops} \index{iteration}
can be transformed into expressions that create lists
\index{list!created by iterator} and streams. \index{stream!created
by iterator} The {\tt repeat}, {\tt break} or {\tt iterate} words are not used but
@@ 11563,9 +11576,7 @@ $$
$$
\returnType{Type: List List List PositiveInteger}
See List
(section \ref{ListXmpPage} on page~\pageref{ListXmpPage}) and Stream
(section \ref{StreamXmpPage} on page~\pageref{StreamXmpPage})
+See \domainref{List} and \domainref{Stream}
for more information on creating and
manipulating lists and streams, respectively.
@@ 11793,7 +11804,7 @@ $$
This is an unnamed function that does the same thing, using the
``mapsto'' syntax {\tt +>} that we discuss in
section \ref{ugUserAnon} on page~\pageref{ugUserAnon}.
+\sectionref{ugUserAnon}.
\spadcommand{(x +> if x < 0 then x else x)(8)}
$$
8
@@ 11803,8 +11814,8 @@ $$
Functions can be used alone or serve as the building blocks for larger
programs. Usually they return a value that you might want to use in
the next stage of a computation, but not always (for example, see
\ref{ExitXmpPage} on page~\pageref{ExitXmpPage} and \ref{VoidXmpPage}
on page~\pageref{VoidXmpPage}). They may also read data from your
+\domainref{Exit} and \domainref{Void}.
+They may also read data from your
keyboard, move information from one place to another, or format and
display results on your screen.
@@ 11975,8 +11986,7 @@ number of arguments that you choose.
If you define a function in the workspace that has the same name and
number of arguments as one in the library, then your definition takes
precedence. In fact, to get the library function you must
{\sl packagecall} it
(see section \ref{ugTypesPkgCall} on page~\pageref{ugTypesPkgCall}).
+{\sl packagecall} it (see \sectionref{ugTypesPkgCall}).
To use a function in Axiom, you apply it to its arguments. Most
functions are applied by entering the name of the function followed by
@@ 12020,7 +12030,7 @@ be written as $2*x\ {\tt \&D} x$ returning $2$.
Every function in Axiom is identified by a {\it name} and
{\it type}. (An exception is an ``anonymous function'' discussed in
\ref{ugUserAnon} on page~\pageref{ugUserAnon}.)
+\sectionref{ugUserAnon}.)
The type of a function is always a mapping of the
form \spadsig{Source}{Target} where {\tt Source} and {\tt Target} are types.
To enter a type from the keyboard, enter the arrow by using a hyphen
@@ 12039,7 +12049,7 @@ are all done with the same function name but with different functions.
\section{Declaring the Type of Functions}
\label{ugUserDeclare}
In \ref{ugTypesDeclare} on page~\pageref{ugTypesDeclare} we discussed
+In \sectionref{ugTypesDeclare} we discussed
how to declare a variable to restrict the kind of values that can be
assigned to it. In this section we show how to declare a variable
that refers to function objects.
@@ 12102,7 +12112,7 @@ h(): POLY INT == ...
A current restriction on function declarations is that they must
involve fully specified types (that is, cannot include modes involving
explicit or implicit ``{\tt ?}''). For more information on declaring
things in general, see \ref{ugTypesDeclare} on page~\pageref{ugTypesDeclare}.
+things in general, see \sectionref{ugTypesDeclare}.
\section{OneLine Functions}
\label{ugUserOne}
@@ 12280,17 +12290,16 @@ Here $x+1$ for $x = "axiom"$ makes no sense.
or "$" to specify which version of the function you need.
\end{verbatim}
As you will see in Chapter \ref{ugCategories} on
page~\pageref{ugCategories}, Axiom has a formal idea of categories for
what ``makes sense.''
+As you will see in \sectionref{ugCategories},
+Axiom has a formal idea of categories for what ``makes sense.''
\section{Functions vs. Operations}
\label{ugUserDecOpers}
A function is an object that you can create, manipulate, pass to, and
return from functions (for some interesting examples of library
functions that manipulate functions, see \ref{MappingPackage1XmpPage}
on page~\pageref{MappingPackage1XmpPage}). Yet, we often seem to use
+functions that manipulate functions, see \domainref{MappingPackage1}.
+Yet, we often seem to use
the term {\it operation} and {\it function} interchangeably in Axiom. What
is the distinction?
@@ 12313,21 +12322,19 @@ excluding the value; thus an operation has a name and a type. An
operation is what domains and packages export. Thus {\tt Ring}
exports one operation ``{\tt +}''. Every ring also exports this
operation. Also, the author of every ring in the system is obliged
under contract (see \ref{ugPackagesAbstract} on
page~\pageref{ugPackagesAbstract}) to provide an implementation for
this operation.
+under contract (see \sectionref{ugPackagesAbstract}
+to provide an implementation for this operation.
This chapter is all about functionshow you create them
interactively and how you apply them to meet your needs. In Chapter
\ref{ugPackages} on page~\pageref{ugPackages} you will learn how to
create them for the Axiom library. Then in Chapter \ref{ugCategories}
on page~\pageref{ugCategories}, you will learn about categories and
exported operations.
+interactively and how you apply them to meet your needs. In
+\sectionref{ugPackages} you will learn how to
+create them for the Axiom library. Then in \sectionref{ugCategories},
+you will learn about categories and exported operations.
\section{Delayed Assignments vs. Functions with No Arguments}
\label{ugUserDelay}
In \ref{ugLangAssign} on page~\pageref{ugLangAssign} we discussed the
+In \sectionref{ugLangAssign} we discussed the
difference between immediate and \index{function!with no arguments}
delayed assignments. In this section we show the difference between
delayed assignments and functions of no arguments.
@@ 12405,8 +12412,7 @@ $$
\returnType{Type: Float}
If you want the library operation, we have to packagecall it
(see \ref{ugTypesPkgCall} on page~\pageref{ugTypesPkgCall}
for more information).
+(see \sectionref{ugTypesPkgCall} for more information).
\spadcommand{sin(4.3)\$Float}
$$
{0.9161659367 4945498404}
@@ 12484,7 +12490,7 @@ creating an object of type {\tt Fraction(Integer)}.
{\tt Fraction(Integer)} are found in either domain.
\item Axiom resolves
\index{resolve}
(see \ref{ugTypesResolve} on page~\pageref{ugTypesResolve})
+(see \sectionref{ugTypesResolve})
the types and gets {\tt Polynomial (Fraction (Integer))}.
\item The $x$ and the $2/3$ are converted to objects of this
type and {\tt +} is applied, yielding the answer, an object of type
@@ 12565,7 +12571,7 @@ Cannot compile conversion for types involving local variables.
Sometimes you can help a function to compile by using an extra
conversion or by using $pretend$. \index{pretend} See
\ref{ugTypesSubdomains} on page~\pageref{ugTypesSubdomains} for details.
+\sectionref{ugTypesSubdomains} for details.
When a function is compilable, you have the choice of whether it is
compiled to Common Lisp and then interpreted by the Common Lisp
@@ 12863,10 +12869,10 @@ $$
We have already seen some examples of \index{function!predicate}
predicates \index{predicate!in function definition}
(\ref{ugUserPieceBasic} on page~\pageref{ugUserPieceBasic}).
+(\sectionref{ugUserPieceBasic}.
Predicates are {\tt Boolean}valued expressions and Axiom uses them
for filtering collections (see \ref{ugLangIts} on
page~\pageref{ugLangIts}) and for placing constraints on function
+for filtering collections (see \sectionref{ugLangIts}
+and for placing constraints on function
arguments. In this section we discuss their latter usage.
The simplest use of a predicate is one you don't see at all.
@@ 13019,8 +13025,7 @@ highly unlikely that a function with no arguments should be cached.\\
}
You should also be careful about caching functions that depend on free
variables. See \ref{ugUserFreeLocal} on
page~\pageref{ugUserFreeLocal} for an example.
+variables. See \sectionref{ugUserFreeLocal} for an example.
\section{Recurrence Relations}
\label{ugUserRecur}
@@ 13107,11 +13112,10 @@ The transformations that Axiom uses for {\bf fib} caches the last two
values. For a more general $k$th order recurrence relation, Axiom
caches the last $k$ values. If, after computing a value for {\bf
fib}, you ask for some larger value, Axiom picks up the cached values
and continues computing from there. See \ref{ugUserFreeLocal} on
page~\pageref{ugUserFreeLocal} for an example of a function definition
that has this same behavior. Also see \ref{ugUserCache} on
page~\pageref{ugUserCache} for a more general discussion of how you
can cache function values.
+and continues computing from there. See \sectionref{ugUserFreeLocal}
+for an example of a function definition
+that has this same behavior. Also see \sectionref{ugUserCache}
+for a more general discussion of how you can cache function values.
Recurrence relations can be used for defining recurrence relations
involving polynomials, rational functions, or anything you like.
@@ 13154,8 +13158,7 @@ workspace. There are several versions, depending on how many
arguments the function has. The first argument to {\bf function} is
always the expression to be converted into the function body, and the
second is always the name to be used for the function. For more
information, see section \ref{MakeFunctionXmpPage} on
page~\pageref{MakeFunctionXmpPage}.
+information, see \domainref{MakeFunction}.
Start with a simple example of a polynomial in three variables.
\spadcommand{p := x + y**2  z**3}
@@ 13329,7 +13332,7 @@ for {\tt Integer}, {\tt Float}, {\tt String}, {\tt Complex},
You need not restrict yourself to functions that only fit on one line
or are written in a piecewise manner. The body of the function can
be a block, as discussed in \ref{ugLangBlocks} on page~\pageref{ugLangBlocks}.
+be a block, as discussed in \sectionref{ugLangBlocks}.
Here is a short function that swaps two elements of a list, array or vector.
\begin{verbatim}
@@ 13654,7 +13657,7 @@ in your functions. No declaration is needed for this situation, but
be sure to initialize their values.
Be careful if you use free variables and you cache the value of your
function (see \ref{ugUserCache} on page~\pageref{ugUserCache}).
+function (see \sectionref{ugUserCache}).
Caching {\it only} checks if the values of the function arguments are
the same as in a function call previously seen. It does not check if
any of the free variables on which the function depends have changed
@@ 13756,7 +13759,7 @@ To conclude this section, we give an iterative definition of
\index{Fibonacci numbers} a function that computes Fibonacci numbers.
This definition approximates the definition into which Axiom
transforms the recurrence relation definition of {\bf fib} in
\ref{ugUserRecur} on page~\pageref{ugUserRecur}.
+\sectionref{ugUserRecur}.
Global variables {\tt past} and {\tt present} are used to hold the last
computed Fibonacci numbers.
@@ 14175,7 +14178,7 @@ seen before.
To make these output operations available, we have to {\it expose} the
domain {\tt OutputForm}. \index{OutputForm} See
\ref{ugTypesExpose} on page~\pageref{ugTypesExpose}
+\sectionref{ugTypesExpose}
for more information about exposing domains and packages.
\spadcommand{)set expose add constructor OutputForm}
\begin{verbatim}
@@ 14902,7 +14905,7 @@ The general format for drawing a function defined by a formula $f(x)$ is:
where $a..b$ defines the range of $x$, and where {\it options}
prescribes zero or more options as described in
\ref{ugGraphTwoDOptions} on page~\pageref{ugGraphTwoDOptions}. An
+\sectionref{ugGraphTwoDOptions}. An
example of an option is $curveColor == bright red().$ An alternative
format involving functions $f$ and $g$ is also available.\\
}
@@ 14979,7 +14982,7 @@ parametric formulas $x = f(t)$ and $y = g(t)$ is:
where $a..b$ defines the range of the independent variable $t$, and
where {\it options} prescribes zero or more options as described in
\ref{ugGraphThreeDOptions} on page~\pageref{ugGraphThreeDOptions}. An
+\sectionref{ugGraphThreeDOptions}. An
example of an option is $curveColor == bright red().$\\ }
Here's an example:
@@ 15063,7 +15066,7 @@ independent variables of $p$. A {\tt range} option is always given to
designate a bounding rectangular region of the plane
$a \leq x \leq b, c \leq y \leq d$.
Zero or more additional options as described in
\ref{ugGraphTwoDOptions} on page~\pageref{ugGraphTwoDOptions} may be given.\\
+\sectionref{ugGraphTwoDOptions} may be given.\\
}
We require that the polynomial has rational or integral coefficients.
@@ 15144,8 +15147,8 @@ specified, clipping applies to the yaxis.
Option {\tt curveColor} sets the color of the graph curves or lines to
be the \index{graphics!2D options!curve color} indicated palette color
\index{curve!color} (see \ref{ugGraphColor} on page~\pageref{ugGraphColor} and
\ref{ugGraphColorPalette} on page~\pageref{ugGraphColorPalette}).
+\index{curve!color} (see \sectionref{ugGraphColor} and
+\sectionref{ugGraphColorPalette}).
\index{color!curve}
\spadgraph{draw(sin(x),x=\%pi..\%pi, curveColor == bright red())}
@@ 15155,8 +15158,7 @@ be the \index{graphics!2D options!curve color} indicated palette color
Option {\tt pointColor} sets the color of the graph points to the
indicated \index{graphics!2D options!point color} palette color (see
\ref{ugGraphColor} on page~\pageref{ugGraphColor} and
\ref{ugGraphColorPalette} on page~\pageref{ugGraphColorPalette}).
+\sectionref{ugGraphColor} and \sectionref{ugGraphColorPalette}).
\index{color!point}
\spadgraph{draw(sin(x),x=\%pi..\%pi, pointColor == pastel yellow())}
@@ 15189,7 +15191,7 @@ Option $coordinates$ indicates the coordinate system in which the
graph \index{graphics!2D options!coordinates} is plotted. The default
is to use the Cartesian coordinate system.
\index{Cartesian!coordinate system} For more details, see
\ref{ugGraphCoord} on page~\pageref{ugGraphCoord}
+\sectionref{ugGraphCoord}
{or {\tt CoordinateSystems}.}
\index{coordinate system!Cartesian}
@@ 16126,10 +16128,10 @@ plotData2D("file.data", "2D Data Plot")
\subsection{Addendum: Appending a Graph to a Viewport Window Containing a Graph}
\label{ugGraphTwoDappend}
This section demonstrates how to append a twodi\men\sion\al graph to a viewport
already containing other graphs.
The default {\bf draw} command places a graph into the first
{\tt GraphImage} slot position of the {\tt TwoDimensionalViewport}.
+This section demonstrates how to append a twodi\men\sion\al graph
+to a viewport already containing other graphs. The default {\bf draw}
+command places a graph into the first {\tt GraphImage} slot position
+of the {\tt TwoDimensionalViewport}.
This graph is in the first slot in its viewport.
@@ 16194,8 +16196,7 @@ of two variables $x$ and $y$ is:
\end{center}
where $a..b$ and $c..d$ define the range of $x$
and $y$, and where {\it options} prescribes zero or more
options as described in \ref{ugGraphThreeDOptions}
on page~\pageref{ugGraphThreeDOptions}.
+options as described in \sectionref{ugGraphThreeDOptions}.
An example of an option is $title == "Title of Graph".$
An alternative format involving a function $f$ is also
available.\\
@@ 16250,8 +16251,7 @@ $z = h(t)$ is:
\end{center}
where $a..b$ defines the range of the independent variable
$t$, and where {\it options} prescribes zero or more options
as described in \ref{ugGraphThreeDOptions}
on page~\pageref{ugGraphThreeDOptions}.
+as described in \sectionref{ugGraphThreeDOptions}.
An example of an option is $title == "Title of Graph".$
An alternative format involving functions $f$, $g$ and
$h$ is also available.\\
@@ 16324,7 +16324,7 @@ and $z = h(u,v)$ is:
where $a..b$ and $c..d$ define the range of the
independent variables $u$ and $v$, and where
{\it options} prescribes zero or more options as described in
\ref{ugGraphThreeDOptions} on page~\pageref{ugGraphThreeDOptions}.
+\sectionref{ugGraphThreeDOptions}.
An example of an option is $title == "Title of Graph".$
An alternative format involving functions $f$, $g$ and
$h$ is also available.\\
@@ 16337,7 +16337,7 @@ The values of the functions supplied to {\bf surface} are
\index{parabolic cylindrical coordinate system}
interpreted in coordinates as given by a {\tt coordinates} option,
here as parabolic cylindrical coordinates (see
\ref{ugGraphCoord} on page~\pageref{ugGraphCoord}).
+\sectionref{ugGraphCoord}.
\spadgraph{draw(surface(u*cos(v), u*sin(v), v*cos(u)), u=4..4, v=0..\%pi, coordinates== parabolicCylindrical)}
@@ 16481,7 +16481,7 @@ Normally the Cartesian coordinate system is used.
\index{Cartesian!coordinate system}
To change this, use the {\tt coordinates} option.
\index{coordinate system!Cartesian}
For details, see \ref{ugGraphCoord} on page~\pageref{ugGraphCoord}.
+For details, see \sectionref{ugGraphCoord}.
\spadcommand{m(u:DFLOAT,v:DFLOAT):DFLOAT == 1 }
\begin{verbatim}
@@ 17913,16 +17913,15 @@ operations defined on these types and the related complex types.
\index{numeric operations}
%
As we mentioned in Chapter
\ref{ugIntro} on page~\pageref{ugIntro}, the {\tt Float} type is a software
+\sectionref{ugIntro}, the {\tt Float} type is a software
implementation of floatingpoint numbers in which the exponent and the
\index{floatingpoint number}
significand may have any number of digits.
\index{number!floatingpoint}
See
\ref{FloatXmpPage} on page~\pageref{FloatXmpPage}
+See \domainref{Float}
for detailed information about this domain.
The {\tt DoubleFloat} (see \ref{DoubleFloatXmpPage} on
page~\pageref{DoubleFloatXmpPage}) is usually a hardware implementation
+The \domainref{DoubleFloat}
+is usually a hardware implementation
of floating point numbers, corresponding to machine double
precision.
The types {\tt Complex Float} and {\tt Complex DoubleFloat} are
@@ 18590,8 +18589,7 @@ $$
Convert this to have coefficients in the finite
field with $19^3$ elements.
See \ref{ugProblemFinite} on page~\pageref{ugProblemFinite}
for more information about finite fields.
+See \sectionref{ugProblemFinite} for more information about finite fields.
\spadcommand{factor(u :: POLY FFX(PF 19,3)) }
$$
@@ 18783,10 +18781,9 @@ In this section we show you how to work with one root or all roots
of a polynomial.
These roots are represented symbolically (as opposed to being
numeric approximations).
See \ref{ugxProblemOnePol} on page~\pageref{ugxProblemOnePol} and
\ref{ugxProblemPolSys} on page~\pageref{ugxProblemPolSys} for
information about solving for the roots of one or more
polynomials.
+See \sectionref{ugxProblemOnePol} and
+\sectionref{ugxProblemPolSys} for
+information about solving for the roots of one or more polynomials.
\subsection{Using a Single Root of a Polynomial}
\label{ugxProblemSymRootOne}
@@ 18945,7 +18942,7 @@ $$
Corresponding to the pair of operations
{\bf rootOf}/{\bf zeroOf} in
\ref{ugxProblemOnePol} on page~\pageref{ugxProblemOnePol}, there is
+\sectionref{ugxProblemOnePol}, there is
an operation {\bf zerosOf} that, like {\bf rootsOf},
computes all the roots
of a given polynomial, but which expresses some of them in terms of
@@ 19278,7 +19275,7 @@ systems of linear equations, finding the roots of polynomials and
\index{linear equation}
solving systems of polynomial equations.
For a discussion of the solution of differential equations, see
\ref{ugProblemDEQ} on page~\pageref{ugProblemDEQ}.
+\sectionref{ugProblemDEQ}.
\subsection{Solution of Systems of Linear Equations}
\label{ugxProblemLinSys}
@@ 19591,8 +19588,7 @@ to {\bf solve} for single equations.
Instead of a polynomial equation, one has to give a list of
equations and instead of a single variable to solve for, a list of
variables.
For solutions of single equations see
\ref{ugxProblemOnePol} on page~\pageref{ugxProblemOnePol}.
+For solutions of single equations see \sectionref{ugxProblemOnePol}.
Use the operation {\bf solve} if you want implicitly presented
solutions.
@@ 20143,8 +20139,7 @@ $$
Sometimes {\bf integrate} can involve symbolic algebraic numbers
such as those returned by \spadfunFrom{rootOf}{Expression}.
To see how to work with these strange generated symbols (such as
$\%\%a0$), see
\ref{ugxProblemSymRootAll} on page~\pageref{ugxProblemSymRootAll}.
+$\%\%a0$), see \sectionref{ugxProblemSymRootAll}.
Definite integration is the process of computing the area between
\index{integration!definite}
@@ 20257,8 +20252,7 @@ can also use {\bf taylor}, {\bf laurent} and {\bf puiseux} in
situations where you know what kind of exponents are involved.
For information about solving differential equations in terms of
power series, see
\ref{ugxProblemDEQSeries} on page~\pageref{ugxProblemDEQSeries}.
+power series, see \sectionref{ugxProblemDEQSeries}.
\subsection{Creation of Power Series}
\label{ugxProblemSeriesCreate}
@@ 20353,8 +20347,7 @@ $$
You can also convert an expression into a series expansion. This
expression creates the series expansion of $1/log(y)$ about $y = 1$.
For details and more examples, see \ref{ugxProblemSeriesConversions}
on page~\pageref{ugxProblemSeriesConversions}.
+For details and more examples, see \sectionref{ugxProblemSeriesConversions}.
\spadcommand{series(1/log(y),y = 1)}
$$
@@ 20382,10 +20375,9 @@ $$
You can create power series with more general coefficients. You
normally accomplish this via a type declaration (see
\ref{ugTypesDeclare} on page~\pageref{ugTypesDeclare}).
See \ref{ugxProblemSeriesFunctions} on
page~\pageref{ugxProblemSeriesFunctions} for some warnings about working with
declared series.
+\sectionref{ugTypesDeclare}).
+See \sectionref{ugxProblemSeriesFunctions}
+for some warnings about working with declared series.
We declare that $y$ is a onevariable Taylor series
\index{series!Taylor} ({\tt UTS} is the abbreviation for
@@ 20426,7 +20418,7 @@ $$
You can also create a power series by giving an explicit formula for
its $n$th coefficient. For details and more examples, see
\ref{ugxProblemSeriesFormula} on page~\pageref{ugxProblemSeriesFormula}.
+\sectionref{ugxProblemSeriesFormula}.
To create a series about $w = 0$ whose $n$th Taylor coefficient is
$1/n!$, you can evaluate this expression. This is the Taylor
@@ 21133,8 +21125,7 @@ functions by giving formulas for their coefficients. You can also
compute such series expansions directly simply by specifying the
function and the point about which the series is to be expanded.
\index{GenerateUnivariatePowerSeries} See
\ref{ugxProblemSeriesConversions} on
page~\pageref{ugxProblemSeriesConversions} for more information.
+\sectionref{ugxProblemSeriesConversions} for more information.
Consider the Taylor expansion of $e^x$ \index{series!Taylor}
about $x = 0$:
@@ 21177,8 +21168,7 @@ specifies that the series is to be expanded in powers of $(x  0)$,
that is, in powers of $x$. Since we did not specify an initial
degree, the first term in the series was the term of degree 0 (the
constant term). Note that the formula was given as an anonymous
function. These are discussed in \ref{ugUserAnon} on
page~\pageref{ugUserAnon}.
+function. These are discussed in \sectionref{ugUserAnon}.
Consider the Taylor expansion of $log x$ about $x = 1$:
@@ 21344,8 +21334,8 @@ finite object.
In general this is the zeroequivalence problem and is undecidable.\\
}
As we discussed in \ref{ugxProblemSeriesConversions} on
page~\pageref{ugxProblemSeriesConversions}, you can also use
+As we discussed in \sectionref{ugxProblemSeriesConversions},
+you can also use
the operations {\bf taylor}, {\bf laurent} and {\bf puiseux} instead
of {\bf series} if you know ahead of time what kind of exponents a
series has. You can't go wrong using {\bf series}, though.
@@ 21633,7 +21623,7 @@ when integrating factors can be found just by integration.
\end{itemize}
For a discussion of the solution of systems of linear and polynomial
equations, see \ref{ugProblemLinPolEqn} on page~\pageref{ugProblemLinPolEqn}.
+equations, see \sectionref{ugProblemLinPolEqn}.
\subsection{ClosedForm Solutions of Linear Differential Equations}
\label{ugxProblemLDEQClosed}
@@ 22189,8 +22179,7 @@ different representations of extensions and different extensions of a
single field. Finally, note that you usually need to packagecall
operations from finite fields if the operations do not take as an
argument an object of the field. See
\ref{ugTypesPkgCall} on page~\pageref{ugTypesPkgCall} for more
information on packagecalling.
+\sectionref{ugTypesPkgCall} for more information on packagecalling.
\subsection{Modular Arithmetic and Prime Fields}
\label{ugxProblemFinitePrime}
@@ 22526,9 +22515,8 @@ representation that performs arithmetic with univariate (onevariable)
polynomials modulo an irreducible polynomial. This polynomial may be
given explicitly by you or automatically generated. The ground field
may be the prime field or one you specify. See
\ref{ugxProblemFiniteExtensionFinite} on
page~\pageref{ugxProblemFiniteExtensionFinite} for general information about
finite field extensions.
+\sectionref{ugxProblemFiniteExtensionFinite}
+for general information about finite field extensions.
For {\tt FiniteField} (abbreviation {\tt FF}) you provide a prime
number $p$ and an extension degree $n$. This degree can be 1.
@@ 22700,7 +22688,7 @@ cyclic multiplicative group). Multiplication (and hence
exponentiation) using this representation is easy. To do addition, we
consider our primitive element as the root of a primitive polynomial
(an irreducible polynomial whose roots are all primitive). See
\ref{ugxProblemFiniteUtility} on page~\pageref{ugxProblemFiniteUtility}
+\sectionref{ugxProblemFiniteUtility}
for examples of how to compute such a polynomial.
To use {\tt FiniteFieldCyclicGroup} you provide a prime number and an
@@ 22778,8 +22766,7 @@ polynomial.
\returnType{Type: Domain}
We use a utility operation to generate an irreducible primitive
polynomial (see
\ref{ugxProblemFiniteUtility} on page~\pageref{ugxProblemFiniteUtility}).
+polynomial (see \sectionref{ugxProblemFiniteUtility}).
The polynomial has one variable that is ``anonymous'':
it displays as a question mark.
@@ 22900,8 +22887,7 @@ The degree of the extension is the degree of the polynomial.
\returnType{Type: Domain}
We use a utility operation to generate an irreducible normal
polynomial (see
\ref{ugxProblemFiniteUtility} on page~\pageref{ugxProblemFiniteUtility}).
+polynomial (see \sectionref{ugxProblemFiniteUtility}). p
The polynomial has
one variable that is ``anonymous'': it displays as a question mark.
@@ 23039,8 +23025,7 @@ $$
There are also conversions available for the situation, when $K_m$ and
$K_n$ are represented in different ways (see
\ref{ugxProblemFiniteExtensionFinite} on
page~\pageref{ugxProblemFiniteExtensionFinite}). For example let's choose
+\sectionref{ugxProblemFiniteExtensionFinite}). For example let's choose
$K_m$ where the representation is 0 plus the cyclic multiplicative
group and $K_n$ with a normal basis representation.
@@ 24715,8 +24700,8 @@ In this chapter we show examples of many of the most commonly used
AXIOM domains and packages. The sections are organized by constructor
names.
\section{AssociationList}
\label{AssociationListXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{AssociationList}
The {\tt AssociationList} constructor provides a general structure for
associative storage. This type provides association lists in which
@@ 24863,13 +24848,11 @@ $$
\returnType{Type:
AssociationList(String,Record(monthsOld: Integer,gender: String))}
For more information about tables,
see \ref{TableXmpPage} on page~\pageref{TableXmpPage}.
For more information about lists,
see \ref{ListXmpPage} on page~\pageref{ListXmpPage}.
+For more information about tables, see \domainref{Table}.
+For more information about lists, see \domainref{List}.
\section{BalancedBinaryTree}
\label{BalancedBinaryTreeXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{BalancedBinaryTree}
{\tt BalancedBinaryTrees(S)} is the domain of balanced binary trees
with elements of type {\tt S} at the nodes. A binary tree is either
@@ 25004,14 +24987,13 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{BasicOperator}
\label{BasicOperatorXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{BasicOperator}
A basic operator is an object that can be symbolically applied to a
list of arguments from a set, the result being a kernel over that set
or an expression. In addition to this section, please see
\ref{ExpressionXmpPage} on page~\pageref{ExpressionXmpPage} and
\ref{KernelXmpPage} on page~\pageref{KernelXmpPage} for additional
+\domainref{Expression} and \domainref{Kernel} for additional
information and examples.
You create an object of type {\tt BasicOperator} by using the
@@ 25058,8 +25040,7 @@ $$
\returnType{Type: Union(Record(particular: Expression Integer,
basis: List Expression Integer),...)}
See \ref{ugProblemDEQPage} on page~\pageref{ugProblemDEQPage}
in Section \ref{ugProblemDEQNumber} on page~\pageref{ugProblemDEQNumber}
+See \sectionref{ugProblemDEQPage}
for this kind of use of {\tt BasicOperator}.
Use the single argument form of \spadfunFrom{operator}{BasicOperator}
@@ 25194,17 +25175,15 @@ table()
$$
\returnType{Type: AssociationList(String,None)}
\section{BinaryExpansion}
\label{BinaryExpansionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{BinaryExpansion}
All rational numbers have repeating binary expansions. Operations to
access the individual bits of a binary expansion can be obtained by
converting the value to {\tt RadixExpansion(2)}. More examples of
expansions are available in
\ref{DecimalExpansionXmpPage} on page~\pageref{DecimalExpansionXmpPage},
\ref{HexadecimalExpansionXmpPage} on
page~\pageref{HexadecimalExpansionXmpPage}, and
\ref{RadixExpansionXmpPage} on page~\pageref{RadixExpansionXmpPage}.
+\domainref{DecimalExpansion}, \domainref{HexadecimalExpansion}, and
+\domainref{RadixExpansion}.
The expansion (of type {\tt BinaryExpansion}) of a rational number
is returned by the \spadfunFrom{binary}{BinaryExpansion} operation.
@@ 25303,8 +25282,8 @@ x+{1.{\overline {01}}}
$$
\returnType{Type: Polynomial BinaryExpansion}
\section{BinarySearchTree}
\label{BinarySearchTreeXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{BinarySearchTree}
{\tt BinarySearchTree(R)} is the domain of binary trees with elements
of type {\tt R}, ordered across the nodes of the tree. A nonempty
@@ 25439,8 +25418,8 @@ $$
$$
\returnType{Type: Boolean}
\section{CardinalNumber}
\label{CardinalNumberXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{CardinalNumber}
The {\tt CardinalNumber} domain can be used for values indicating the
cardinality of sets, both finite and infinite. For example, the
@@ 25653,8 +25632,8 @@ Aleph \left({2} \right)
$$
\returnType{Type: CardinalNumber}
\section{CartesianTensor}
\label{CartesianTensorXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{CartesianTensor}
{\tt CartesianTensor(i0,dim,R)} provides Cartesian tensors with
components belonging to a commutative ring {\tt R}. Tensors can be
@@ 26535,13 +26514,13 @@ polynomial or expression type for the components. In this case, it is
up to the user to satisfy any constraints which arise on the basis of
this interpretation.
\section{Character}
\label{CharacterXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Character}
+
The members of the domain {\tt Character} are values
representing letters, numerals and other text elements.
For more information on related topics, see
\ref{CharacterClassXmpPage} on page~\pageref{CharacterClassXmpPage} and
\ref{StringXmpPage} on page~\pageref{StringXmpPage}.
+\domainref{CharacterClass} and \domainref{String}.
Characters can be obtained using {\tt String} notation.
@@ 26667,8 +26646,9 @@ $$
$$
\returnType{Type: List Boolean}
\section{CharacterClass}
\label{CharacterClassXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{CharacterClass}
+
The {\tt CharacterClass} domain allows classes of characters to be
defined and manipulated efficiently.
@@ 26781,11 +26761,11 @@ $$
\returnType{Type: CharacterClass}
For more information on related topics, see
\ref{CharacterXmpPage} on page~\pageref{CharacterXmpPage} and
\ref{StringXmpPage} on page~\pageref{StringXmpPage}.
+\domainref{Character} and \domainref{String}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{CliffordAlgebra}
\section{CliffordAlgebra}
\label{CliffordAlgebraXmpPage}
\noindent
{\tt CliffordAlgebra(n,K,Q)} defines a vector space of dimension $2^n$
@@ 26860,7 +26840,7 @@ c+{d \ {e \sb {1}}}
$$
\returnType{Type: CliffordAlgebra(1,Fraction Polynomial Integer,MATRIX)}
See \ref{ComplexXmpPage} on page~\pageref{ComplexXmpPage}
+See \domainref{Complex}
for examples of Axiom's constructor implementing complex numbers.
\spadcommand{x * y }
@@ 26965,7 +26945,7 @@ $$
$$
\returnType{Type: CliffordAlgebra(2,Fraction Polynomial Integer,MATRIX)}
See \ref{QuaternionXmpPage} on page~\pageref{QuaternionXmpPage}
+See \domainref{Quaternion}
for examples of Axiom's constructor implementing quaternions.
\spadcommand{y * x }
@@ 27151,15 +27131,15 @@ $$
$$
\returnType{Type: CliffordAlgebra(4,Fraction Integer,MATRIX)}
\section{Complex}
\label{ComplexXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Complex}
The {\tt Complex} constructor implements complex objects over a
commutative ring {\tt R}. Typically, the ring {\tt R} is {\tt Integer},
{\tt Fraction Integer}, {\tt Float} or {\tt DoubleFloat}.
{\tt R} can also be a symbolic type, like {\tt Polynomial Integer}.
For more information about the numerical and graphical aspects of
complex numbers, see \ref{ugProblemNumeric} on page~\pageref{ugProblemNumeric}.
+complex numbers, see \sectionref{ugProblemNumeric}.
Complex objects are created by the \spadfunFrom{complex}{Complex} operation.
@@ 27203,9 +27183,7 @@ $$
$$
\returnType{Type: Complex Fraction Integer}
Use a conversion (\ref{ugTypesConvertPage} on
page~\pageref{ugTypesConvertPage} in Section
\ref{ugTypesConvertNumber} on page~\pageref{ugTypesConvertNumber})
+Use a conversion (see \sectionref{ugTypesConvertPage})
to view the last object as a fraction of complex integers.
\spadcommand{\% :: Fraction Complex Integer }
@@ 27291,8 +27269,8 @@ $$
$$
\returnType{Type: Factored Complex Integer}
\section{ContinuedFraction}
\label{ContinuedFractionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{ContinuedFraction}
Continued fractions have been a fascinating and useful tool in
mathematics for well over three hundred years. Axiom implements
@@ 27300,7 +27278,7 @@ continued fractions for fractions of any Euclidean domain. In
practice, this usually means rational numbers. In this section we
demonstrate some of the operations available for manipulating both
finite and infinite continued fractions. It may be helpful if you
review \ref{StreamXmpPage} on page~\pageref{StreamXmpPage} to remind
+review \domainref{Stream} to remind
yourself of some of the operations with streams.
The {\tt ContinuedFraction} domain is a field and therefore you can
@@ 27662,8 +27640,8 @@ $$
$$
\returnType{Type: Stream Float}
\section{CycleIndicators}
\label{CycleIndicatorsXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{CycleIndicators}
This section is based upon the paper J. H. Redfield, ``The Theory of
GroupReduced Distributions'', American J. Math.,49 (1927) 433455,
@@ 28294,8 +28272,8 @@ The smallest is
3
\end{verbatim}
\section{DeRhamComplex}
\label{DeRhamComplexXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{DeRhamComplex}
The domain constructor {\tt DeRhamComplex} creates the class of
differential forms of arbitrary degree over a coefficient ring. The
@@ 28520,8 +28498,7 @@ $$
$$
\returnType{Type: DeRhamComplex(Integer,[x,y,z])}
Now we define some ``basic operators'' (see
\ref{OperatorXmpPage} on page~\pageref{OperatorXmpPage}).
+Now we define some ``basic operators'' (see \domainref{Operator}).
\spadcommand{a : BOP := operator('a) }
$$
@@ 28748,17 +28725,15 @@ a
$$
\returnType{Type: Expression Integer}
\section{DecimalExpansion}
\label{DecimalExpansionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{DecimalExpansion}
All rationals have repeating decimal expansions. Operations to access
the individual digits of a decimal expansion can be obtained by
converting the value to {\tt RadixExpansion(10)}. More examples of
expansions are available in
\ref{BinaryExpansionXmpPage} on page~\pageref{BinaryExpansionXmpPage},
\ref{HexadecimalExpansionXmpPage} on
page~\pageref{HexadecimalExpansionXmpPage}, and
\ref{RadixExpansionXmpPage} on page~\pageref{RadixExpansionXmpPage}.
+\domainref{BinaryExpansion}, \domainref{HexadecimalExpansion}, and
+\domainref{RadixExpansion}.
The operation \spadfunFrom{decimal}{DecimalExpansion} is used to create
this expansion of type {\tt DecimalExpansion}.
@@ 28849,8 +28824,8 @@ x+{1.{\overline 3}}
$$
\returnType{Type: Polynomial DecimalExpansion}
\section{DistributedMultivariatePolynomial}
\label{DistributedMultivariatePolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{DistributedMultivariatePolynomial}
\hyphenation{HomogeneousDistributedMultivariatePolynomial}
@@ 29013,18 +28988,13 @@ Gr\"{o}bner basis calculations which can be very
sensitive to term ordering.
For more information on related topics, see
\ref{ugIntroVariablesPage} on page~\pageref{ugIntroVariablesPage} in Section
\ref{ugIntroVariablesNumber} on page~\pageref{ugIntroVariablesNumber},
\ref{ugTypesConvertPage} on page~\pageref{ugTypesConvertPage} in Section
\ref{ugTypesConvertNumber} on page~\pageref{ugTypesConvertNumber},
\ref{PolynomialXmpPage} on page~\pageref{PolynomialXmpPage},
\ref{UnivariatePolynomialXmpPage} on
page~\pageref{UnivariatePolynomialXmpPage}, and
\ref{MultivariatePolynomialXmpPage} on
page~\pageref{MultivariatePolynomialXmpPage}.

\section{DoubleFloat}
\label{DoubleFloatXmpPage}
+\sectionref{ugIntroVariablesPage},
+\sectionref{ugTypesConvertPage},
+\domainref{Polynomial}, \domainref{UnivariatePolynomial}, and
+\domainref{MultivariatePolynomial}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{DoubleFloat}
Axiom provides two kinds of floating point numbers. The domain
{\tt Float} (abbreviation {\tt FLOAT}) implements a model of arbitrary
@@ 29126,20 +29096,17 @@ $$
By far, the most common usage of {\tt DoubleFloat} is for functions to
be graphed. For more information about Axiom's numerical and
graphical facilities, see Section
\ref{ugGraph} on page~\pageref{ugGraph},
\ref{ugProblemNumeric} on page~\pageref{ugProblemNumeric}, and
\ref{FloatXmpPage} on page~\pageref{FloatXmpPage}.
+\sectionref{ugGraph}, \sectionref{ugProblemNumeric}, and \domainref{Float}.
\section{EqTable}
\label{EqTableXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{EqTable}
The {\tt EqTable} domain provides tables where the keys are compared
using \spadfunFrom{eq?}{EqTable}. Keys are considered equal only if
they are the same instance of a structure. This is useful if the keys
are themselves updatable structures. Otherwise, all operations are
the same as for type {\tt Table}. See
\ref{TableXmpPage} on page~\pageref{TableXmpPage} for general
information about tables.
+\domainref{Table} for general information about tables.
The operation \spadfunFrom{table}{EqTable} is here used to create a table
where the keys are lists of integers.
@@ 29190,8 +29157,8 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{Equation}
\label{EquationXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Equation}
The {\tt Equation} domain provides equations as mathematical objects.
These are used, for example, as the input to various
@@ 29291,8 +29258,8 @@ $$
$$
\returnType{Type: Boolean}
\section{Exit}
\label{ExitXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Exit}
A function that does not return directly to its caller has {\tt Exit}
as its return type. The operation {\tt error} is an example of one
@@ 29353,14 +29320,11 @@ $$
$$
\returnType{Type: NonNegativeInteger}
For functions which return no value at all, use {\tt Void}. See
\ref{ugUserPage} on page~\pageref{ugUserPage} in Section
\ref{ugUserNumber} on page~\pageref{ugUserNumber} and
\ref{VoidXmpPage} on page~\pageref{VoidXmpPage} for
more information.
+For functions which return no value at all, use {\tt Void}.
+\domainref{Void} for more information.
\section{Expression}
\label{ExpressionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Expression}
{\tt Expression} is a constructor that creates domains whose objects
can have very general symbolic forms. Here are some examples:
@@ 29450,8 +29414,7 @@ that have category {\tt Field}. Thus you can invert any nonzero
expression and you shouldn't expect an operation like {\tt factor} to
give you much information. You can imagine expressions as being
represented as quotients of ``multivariate'' polynomials where the
``variables'' are kernels (see
\ref{KernelXmpPage} on page~\pageref{KernelXmpPage}). A kernel can
+``variables'' are kernels (see \domainref{Kernel}. A kernel can
either be a symbol such as {\tt x} or a symbolic function application
like {\tt sin(x + 4)}. The second example is actually a nested kernel
since the argument to {\tt sin} contains the kernel {\tt x}.
@@ 29464,8 +29427,7 @@ $$
Actually, the argument to {\tt sin} is an expression, and so the
structure of {\tt Expression} is recursive.
\ref{KernelXmpPage} on page~\pageref{KernelXmpPage}
demonstrates how to extract the kernels in an expression.
+\domainref{Kernel} demonstrates how to extract the kernels in an expression.
Use the HyperDoc Browse facility to see what operations are applicable
to expression. At the time of this writing, there were 262 operations
@@ 29510,9 +29472,7 @@ $$
$$
\returnType{Type: Expression Integer}
See
\ref{ugIntroCalcDerivPage} on page~\pageref{ugIntroCalcDerivPage} in Section
\ref{ugIntroCalcDerivNumber} on page~\pageref{ugIntroCalcDerivNumber}
+See \sectionref{ugIntroCalcDerivPage}
for more examples of expressions and derivatives.
\spadcommand{D(e, [x, y], [1, 2]) }
@@ 29551,18 +29511,12 @@ $$
\returnType{Type: Expression Integer}
See
\ref{ugIntroCalcLimitsPage} on page~\pageref{ugIntroCalcLimitsPage} in Section
\ref{ugIntroCalcLimitsNumber} on page~\pageref{ugIntroCalcLimitsNumber} and
\ref{ugIntroSeriesPage} on page~\pageref{ugIntroSeriesPage} in Section
\ref{ugIntroSeriesNumber} on page~\pageref{ugIntroSeriesNumber}
for more examples of expressions and
+\sectionref{ugIntroCalcLimitsPage} and
+\sectionref{ugIntroSeriesPage} for more examples of expressions and
calculus. Differential equations involving expressions are discussed
in \ref{ugProblemDEQPage} on page~\pageref{ugProblemDEQPage} in Section
\ref{ugProblemDEQNumber} on page~\pageref{ugProblemDEQNumber}.
+in \sectionref{ugProblemDEQPage} on page~\pageref{ugProblemDEQPage}.
Chapter 8 has many advanced examples: see
\ref{ugProblemIntegrationPage} on page~\pageref{ugProblemIntegrationPage}
in Section
\ref{ugProblemIntegrationNumber} on page~\pageref{ugProblemIntegrationNumber}
+\sectionref{ugProblemIntegrationPage}
for a discussion of Axiom's integration facilities.
When an expression involves no ``symbol kernels'' (for example,
@@ 29654,12 +29608,11 @@ $$
$$
\returnType{Type: Expression Integer}
See \ref{ugUserRulesPage} on page~\pageref{ugUserRulesPage} in Section
\ref{ugUserRulesNumber} on page~\pageref{ugUserRulesNumber} for
+See \sectionref{ugUserRulesPage} for
examples of how to write your own rewrite rules for expressions.
\section{Factored}
\label{FactoredXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Factored}
{\tt Factored} creates a domain whose objects are kept in factored
form as long as possible. Thus certain operations like
@@ 29906,9 +29859,7 @@ $$
\returnType{Type: Boolean}
Another way to get the zero and one factored objects is to use
package calling (see
\ref{ugTypesPkgCallPage} on page~\pageref{ugTypesPkgCallPage} in Section
\ref{ugTypesPkgCallNumber} on page~\pageref{ugTypesPkgCallNumber}).
+package calling (see \sectionref{ugTypesPkgCallPage}).
\spadcommand{0\$Factored(Integer)}
$$
@@ 29925,10 +29876,8 @@ $$
\subsection{Creating New Factored Objects}
The \spadfunFrom{map}{Factored} operation is used to iterate across
the unit and bases of a factored object. See
\ref{FactoredFunctionsTwoXmpPage} on
page~\pageref{FactoredFunctionsTwoXmpPage} for a discussion of
\spadfunFrom{map}{Factored}.
+the unit and bases of a factored object. See \domainref{FactoredFunctions2}
+for a discussion of \spadfunFrom{map}{Factored}.
The following four operations take a base and an exponent and create a
factored object. They differ in handling the flag component.
@@ 30040,8 +29989,8 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{FactoredFunctions2}
\label{FactoredFunctions2XmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{FactoredFunctions2}
The {\tt FactoredFunctions2} package implements one operation,
\spadfunFrom{map}{FactoredFunctions2}, for applying an operation to every
@@ 30100,12 +30049,10 @@ $$
\returnType{Type: Union("nil",...)}
For more information about factored objects and their use, see
\ref{FactoredXmpPage} on page~\pageref{FactoredXmpPage} and
\ref{ugProblemGaloisPage} on page~\pageref{ugProblemGaloisPage} in Section
\ref{ugProblemGaloisNumber} on page~\pageref{ugProblemGaloisNumber}.
+\domainref{Factored} and \sectionref{ugProblemGaloisPage}.
\section{File}
\label{FileXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{File}
The {\tt File(S)} domain provides a basic interface to read and
write values of type {\tt S} in files.
@@ 30225,13 +30172,11 @@ be represented in a file. In particular, delayed values containing
compiled functions cannot be saved.
For more information on related topics, see
\ref{TextFileXmpPage} on page~\pageref{TextFileXmpPage},
\ref{KeyedAccessFileXmpPage} on page~\pageref{KeyedAccessFileXmpPage},
\ref{LibraryXmpPage} on page~\pageref{LibraryXmpPage}, and
\ref{FileNameXmpPage} on page~\pageref{FileNameXmpPage}.
+\domainref{TextFile}, \domainref{KeyedAccessFile},
+\domainref{Library}, and \domainref{FileName}.
\section{FileName}
\label{FileNameXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{FileName}
The {\tt FileName} domain provides an interface to the computer's file
system. Functions are provided to manipulate file names and to test
@@ 30390,8 +30335,8 @@ $$
$$
\returnType{Type: FileName}
\section{FlexibleArray}
\label{FlexibleArrayXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{FlexibleArray}
The {\tt FlexibleArray} domain constructor creates onedimensional
arrays of elements of the same type. Flexible arrays are an attempt
@@ 30404,8 +30349,7 @@ the new block.
Flexible arrays have available most of the operations provided by
{\tt OneDimensionalArray} (see
\ref{OneDimensionalArrayXmpPage} on page~\pageref{OneDimensionalArrayXmpPage}
and \ref{VectorXmpPage} on page~\pageref{VectorXmpPage}).
+\domainref{OneDimensionalArray} and \domainref{Vector}.
Since flexible arrays are also of category
{\tt ExtensibleLinearAggregate}, they have operations {\tt concat!},
{\tt delete!}, {\tt insert!}, {\tt merge!}, {\tt remove!},
@@ 30575,8 +30519,8 @@ $$
$$
\returnType{Type: Boolean}
\section{Float}
\label{FloatXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Float}
Axiom provides two kinds of floating point numbers. The domain
{\tt Float} (abbreviation {\tt FLOAT}) implements a model of arbitrary
@@ 30593,10 +30537,8 @@ Arbitraryprecision floatingpoint arithmetic typically takes twenty
to two hundred times more time than hardware floating point.
For more information about Axiom's numeric and graphic facilities, see
\ref{ugGraphPage} on page~\pageref{ugGraphPage} in Section
\ref{ugGraphNumber} on page~\pageref{ugGraphNumber},
\ref{ugProblemNumeric} on page~\pageref{ugProblemNumeric}, and
\ref{DoubleFloatXmpPage} on page~\pageref{DoubleFloatXmpPage}.
+\sectionref{ugGraphPage}, \sectionref{ugProblemNumeric}, and
+\domainref{DoubleFloat}.
\subsection{Introduction to Float}
@@ 30633,9 +30575,7 @@ $$
\subsection{Conversion Functions}
You can use conversion (\ref{ugTypesConvertPage} on
page~\pageref{ugTypesConvertPage} in Section
\ref{ugTypesConvertNumber} on page~\pageref{ugTypesConvertNumber}) to
+You can use conversion (\sectionref{ugTypesConvertPage} to
go back and forth between {\tt Integer}, {\tt Fraction Integer} and
{\tt Float}, as appropriate.
@@ 30975,8 +30915,8 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{Fraction}
\label{FractionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Fraction}
The {\tt Fraction} domain implements quotients. The elements must
belong to a domain of category {\tt IntegralDomain}: multiplication
@@ 31028,7 +30968,7 @@ Operations like \spadfunFrom{max}{Fraction},
\spadfunFrom{positive?}{Fraction} and \spadfunFrom{zero?}{Fraction}
are all available if they are provided for the numerators and
denominators.
See \ref{IntegerXmpPage} on page~\pageref{IntegerXmpPage} for examples.
+See \domainref{Integer} for examples.
Don't expect a useful answer from \spadfunFrom{factor}{Fraction},
\spadfunFrom{gcd}{Fraction} or \spadfunFrom{lcm}{Fraction} if you apply
@@ 31068,10 +31008,8 @@ $$
\returnType{Type: ContinuedFraction Integer}
Use {\tt partialFraction} to create a partial fraction.
See
\ref{ContinuedFractionXmpPage} on page~\pageref{ContinuedFractionXmpPage}
and \ref{PartialFractionXmpPage} on page~\pageref{PartialFractionXmpPage} for
additional information and examples.
+See \domainref{ContinuedFraction} and and \domainref{PartialFraction}
+for additional information and examples.
\spadcommand{partialFraction(7,12)}
$$
@@ 31088,9 +31026,7 @@ $$
$$
\returnType{Type: Complex Fraction Integer}
Conversion is discussed in detail in
Section~\ref{ugTypesConvertPage}
on page~\pageref{ugTypesConvertPage}.
+Conversion is discussed in detail in \sectionref{ugTypesConvertPage}.
\spadcommand{g :: FRAC COMPLEX INT }
$$
@@ 31098,8 +31034,8 @@ $$
$$
\returnType{Type: Fraction Complex Integer}
\section{FullPartialFractionExpansion}
\label{FullPartialFractionExpansionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{FullPartialFractionExpansion}
The domain {\tt FullPartialFractionExpansion} implements
factorfree conversion of quotients to full partial fractions.
@@ 31414,17 +31350,15 @@ $$
For more information, see the paper: Bronstein, M and Salvy, B.
``Full Partial Fraction Decomposition of Rational Functions,''
{\it Proceedings of ISSAC'93, Kiev}, ACM Press. Also see
\ref{PartialFractionXmpPage} on page~\pageref{PartialFractionXmpPage}
for standard partial fraction decompositions.
+\domainref{PartialFraction} for standard partial fraction decompositions.
\section{GeneralSparseTable}
\label{GeneralSparseTableXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{GeneralSparseTable}
Sometimes when working with tables there is a natural value to use as
the entry in all but a few cases. The {\tt GeneralSparseTable}
constructor can be used to provide any table type with a default value
for entries. See \ref{TableXmpPage} on page~\pageref{TableXmpPage}
for general information about tables.
+for entries. See \domainref{Table} for general information about tables.
Suppose we launched a fundraising campaign to raise fifty thousand dollars.
To record the contributions, we want a table with strings as keys
@@ 31480,8 +31414,8 @@ So the project is cancelled and we can delete the data base:
\spadcommand{)system rm r kaf*.sdata }
\section{GroebnerFactorizationPackage}
\label{GroebnerFactorizationPackageXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{GroebnerFactorizationPackage}
Solving systems of polynomial equations with the Gr\"{o}bner basis
algorithm can often be very time consuming because, in general, the
@@ 31678,14 +31612,13 @@ calculation does not terminate in a reasonable time. See the source
code for {\tt GroebnerFactorizationPackage} in {\bf groebf.input}
for more details about the algorithms used.
\section{Heap}
\label{HeapXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Heap}
The domain {\tt Heap(S)} implements a priority queue of objects of
type {\tt S} such that the operation {\tt extract!} removes and
returns the maximum element. The implementation represents heaps as
flexible arrays (see
\ref{FlexibleArrayXmpPage} on page~\pageref{FlexibleArrayXmpPage}).
+flexible arrays (see \domainref{FlexibleArray}.)
The representation and algorithms give complexity of $O(\log(n))$
for insertion and extractions, and $O(n)$ for construction.
@@ 31764,8 +31697,8 @@ $$
$$
\returnType{Type: List Integer}
\section{HexadecimalExpansion}
\label{HexadecimalExpansionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{HexadecimalExpansion}
All rationals have repeating hexadecimal expansions. The operation
\spadfunFrom{hex}{HexadecimalExpansion} returns these expansions of
@@ 31773,9 +31706,8 @@ type {\tt HexadecimalExpansion}. Operations to access the individual
numerals of a hexadecimal expansion can be obtained by converting the
value to {\tt RadixExpansion(16)}. More examples of expansions are
available in the
\ref{DecimalExpansionXmpPage} on page~\pageref{DecimalExpansionXmpPage},
\ref{BinaryExpansionXmpPage} on page~\pageref{BinaryExpansionXmpPage}, and
\ref{RadixExpansionXmpPage} on page~\pageref{RadixExpansionXmpPage}.
+\domainref{DecimalExpansion}, \domainref{BinaryExpansion}, and
+\domainref{RadixExpansion}.
This is a hexadecimal expansion of a rational number.
@@ 31853,22 +31785,17 @@ x+{1.{\overline 5}}
$$
\returnType{Type: Polynomial HexadecimalExpansion}
\section{Integer}
\label{IntegerXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Integer}
Axiom provides many operations for manipulating arbitrary precision
integers. In this section we will show some of those that come from
{\tt Integer} itself plus some that are implemented in other packages.
More examples of using integers are in the following sections:
\ref{ugIntroNumbersPage} on page~\pageref{ugIntroNumbersPage} in section
\ref{ugIntroNumbersNumber} on page~\pageref{ugIntroNumbersNumber}
\ref{IntegerNumberTheoryFunctionsXmpPage} on
page~\pageref{IntegerNumberTheoryFunctionsXmpPage},
\ref{DecimalExpansionXmpPage} on page~\pageref{DecimalExpansionXmpPage},
\ref{BinaryExpansionXmpPage} on page~\pageref{BinaryExpansionXmpPage},
\ref{HexadecimalExpansionXmpPage} on
page~\pageref{HexadecimalExpansionXmpPage}, and
\ref{RadixExpansionXmpPage} on page~\pageref{RadixExpansionXmpPage}.
+\sectionref{ugIntroNumbersPage},
+\domainref{IntegerNumberTheoryFunctions},
+\domainref{DecimalExpansion}, \domainref{BinaryExpansion},
+\domainref{HexadecimalExpansion}, and \domainref{RadixExpansion}.
\subsection{Basic Functions}
@@ 32077,7 +32004,7 @@ $$
The infix operator ``/'' is {\it not} used to compute the quotient of
integers. Rather, it is used to create rational numbers as described
in \ref{FractionXmpPage} on page~\pageref{FractionXmpPage}.
+in \domainref{Fraction}.
\spadcommand{13 / 4}
$$
@@ 32105,9 +32032,7 @@ $$
One integer is evenly divisible by another if the remainder is zero.
The operation \spadfunFrom{exquo}{Integer} can also be used. See
\ref{ugTypesUnionsPage} on page~\pageref{ugTypesUnionsPage} in Section
\ref{ugTypesUnionsNumber} on page~\pageref{ugTypesUnionsNumber} for an
example.
+\sectionref{ugTypesUnionsPage} for an example.
\spadcommand{zero?(167604736446952 rem 2003644)}
$$
@@ 32132,8 +32057,7 @@ $$
$$
\returnType{Type: PositiveInteger}
Records are discussed in detail in Section
\ref{ugTypesRecords} on page~\pageref{ugTypesRecords}.
+Records are discussed in detail in \sectionref{ugTypesRecords}.
\spadcommand{d.remainder }
$$
@@ 32145,7 +32069,7 @@ $$
Use the operation \spadfunFrom{factor}{Integer} to factor integers.
It returns an object of type {\tt Factored Integer}.
See \ref{FactoredXmpPage} on page~\pageref{FactoredXmpPage}
+See \domainref{Factored}
for a discussion of the manipulation of factored objects.
\spadcommand{factor 102400}
@@ 32201,7 +32125,7 @@ $$
You might sometimes want to see the factorization of an integer
when it is considered a {\it Gaussian integer}.
See \ref{ComplexXmpPage} on page~\pageref{ComplexXmpPage} for more details.
+See \domainref{Complex} for more details.
\spadcommand{factor(2 :: Complex Integer)}
$$
@@ 32214,8 +32138,8 @@ $$
\subsection{Some Number Theoretic Functions}
Axiom provides several number theoretic operations for integers.
More examples are in \ref{IntegerNumberTheoryFunctionsXmpPage} on
page~\pageref{IntegerNumberTheoryFunctionsXmpPage}.
+More examples are in \domainref{IntegerNumberTheoryFunctions}.
+
The operation \spadfunFrom{fibonacci}{IntegerNumberTheoryFunctions}
computes the Fibonacci numbers. The algorithm has running time
@@ 32312,8 +32236,8 @@ $$
$$
\returnType{Type: RomanNumeral}
\section{IntegerLinearDependence}
\label{IntegerLinearDependenceXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{IntegerLinearDependence}
The elements $v_1, \dots,v_n$ of a module {\tt M} over a ring {\tt R}
are said to be {\it linearly dependent over {\tt R}} if there exist
@@ 32417,8 +32341,8 @@ $$
$$
\returnType{Type: Union(Vector Fraction Integer,...)}
\section{IntegerNumberTheoryFunctions}
\label{IntegerNumberTheoryFunctionsXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{IntegerNumberTheoryFunctions}
The {\tt IntegerNumberTheoryFunctions} package contains a variety of
operations of interest to number theorists. Many of these operations
@@ 32641,16 +32565,16 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{Kernel}
\label{KernelXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Kernel}
A {\it kernel} is a symbolic function application (such as {\tt sin(x+ y)})
or a symbol (such as {\tt x}). More precisely, a nonsymbol
kernel over a set {\it S} is an operator applied to a given list of
arguments from {\it S}. The operator has type {\tt BasicOperator}
(see \ref{BasicOperatorXmpPage} on page~\pageref{BasicOperatorXmpPage})
+(see \domainref{BasicOperator}
and the kernel object is usually part of an expression object (see
\ref{ExpressionXmpPage} on page~\pageref{ExpressionXmpPage}).
+\domainref{Expression}.
Kernels are created implicitly for you when you create expressions.
@@ 32862,12 +32786,11 @@ $$
Conceptually, an object of type {\tt Expression} can be thought of a
quotient of multivariate polynomials, where the ``variables'' are
kernels. The arguments of the kernels are again expressions and so
the structure recurses. See \ref{ExpressionXmpPage} on
page~\pageref{ExpressionXmpPage} for examples of
+the structure recurses. See \domainref{Expression} for examples of
using kernels to take apart expression objects.
\section{KeyedAccessFile}
\label{KeyedAccessFileXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{KeyedAccessFile}
The domain {\tt KeyedAccessFile(S)} provides files which can be used
as associative tables. Data values are stored in these files and can
@@ 33050,12 +32973,10 @@ $$
\spadcommand{)system rm r /tmp/editor.year}
For more information on related topics, see
\ref{FileXmpPage} on page~\pageref{FileXmpPage},
\ref{TextFileXmpPage} on page~\pageref{TextFileXmpPage}, and
\ref{LibraryXmpPage} on page~\pageref{LibraryXmpPage}.
+\domainref{File}, \domainref{TextFile}, and \domainref{Library}.
\section{LexTriangularPackage}
\label{LexTriangularPackageXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LexTriangularPackage}
The {\tt LexTriangularPackage} package constructor provides an
implementation of the {\em lexTriangular} algorithm (D. Lazard
@@ 36874,8 +36795,8 @@ to the indeterminate {\bf f}, the second to {\bf e} and so on. See
{\tt ZeroDimensionalSolvePackage} to learn more about the
\spadfunFrom{realSolve}{ZeroDimensionalSolvePackage} operation.
\section{LazardSetSolvingPackage}
\label{LazardSetSolvingPackageXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LazardSetSolvingPackage}
The {\tt LazardSetSolvingPackage} package constructor solves
polynomial systems by means of Lazard triangular sets. However one
@@ 38156,8 +38077,8 @@ zerodimensional regular chains. Moreover, each of them is normalized
components may be investigated further with the
{\tt ZeroDimensionalSolvePackage} package constructor.
\section{Library}
\label{LibraryXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Library}
The {\tt Library} domain provides a simple way to store Axiom values
in a file. This domain is similar to {\tt KeyedAccessFile} but fewer
@@ 38225,12 +38146,10 @@ file system.
\spadcommand{)system rm rf /tmp/Neat.stuff }
For more information on related topics, see
\ref{FileXmpPage} on page~\pageref{FileXmpPage},
\ref{TextFileXmpPage} on page~\pageref{TextFileXmpPage}, and
\ref{KeyedAccessFileXmpPage} on page~\pageref{KeyedAccessFileXmpPage}.
+\domainref{File}, \domainref{TextFile}, and \domainref{KeyedAccessFile}.
\section{LieExponentials}
\label{LieExponentialsXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LieExponentials}
\spadcommand{ a: Symbol := 'a }
$$
@@ 38360,8 +38279,9 @@ $$
$$
\returnType{Type: LieExponentials(Symbol,Fraction Integer,3)}
\section{LiePolynomial}
\label{LiePolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LiePolynomial}
+
Declaration of domains
\spadcommand{RN := Fraction Integer }
@@ 38604,8 +38524,8 @@ $$
$$
\returnType{Type: LiePolynomial(Symbol,Fraction Integer)}
\section{LinearOrdinaryDifferentialOperator}
\label{LinearOrdinaryDifferentialOperatorXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LinearOrdinaryDifferentialOperator}
{\tt LinearOrdinaryDifferentialOperator(A, diff)} is the domain of
linear ordinary differential operators with coefficients in a ring
@@ 38959,8 +38879,8 @@ $$
$$
\returnType{Type: List List Equation Fraction Polynomial Integer}
\section{LinearOrdinaryDifferentialOperator1}
\label{LinearOrdinaryDifferentialOperator1XmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LinearOrdinaryDifferentialOperator1}
{\tt LinearOrdinaryDifferentialOperator1(A)} is the domain of linear
ordinary differential operators with coefficients in the differential ring
@@ 39232,8 +39152,8 @@ $$
\returnType{Type:
LinearOrdinaryDifferentialOperator1 Fraction UnivariatePolynomial(x,Integer)}
\section{LinearOrdinaryDifferentialOperator2}
\label{LinearOrdinaryDifferentialOperator2XmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LinearOrdinaryDifferentialOperator2}
{\tt LinearOrdinaryDifferentialOperator2(A, M)} is the domain of
linear ordinary differential operators with coefficients in the
@@ 39650,8 +39570,8 @@ SquareMatrix(3,
UnivariatePolynomial(x,Integer)),
UnivariatePolynomial(x,Integer))}
\section{List}
\label{ListXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{List}
A \index{list} is a finite collection of elements in a specified
order that can contain duplicates. A list is a convenient structure
@@ 40023,12 +39943,10 @@ $$
\returnType{Type: Stream Integer}
What is created in this case is a {\tt Stream} which is a
generalization of a list. See
\ref{StreamXmpPage} on page~\pageref{StreamXmpPage} for more
information.
+generalization of a list. See \domainref{Stream} for more information.
\section{LyndonWord}
\label{LyndonWordXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{LyndonWord}
Initialisations
@@ 40273,8 +40191,8 @@ $$
$$
\returnType{Type: LyndonWord Symbol}
\section{Magma}
\label{MagmaXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Magma}
Initialisations
@@ 40447,8 +40365,8 @@ $$
$$
\returnType{Type: Boolean}
\section{MakeFunction}
\label{MakeFunctionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{MakeFunction}
It is sometimes useful to be able to define a function given by
the result of a calculation.
@@ 40675,12 +40593,10 @@ $$
$$
\returnType{Type: SquareMatrix(2,Integer)}
For more information, see
\ref{ugUserMakePage} on page~\pageref{ugUserMakePage} in Section
\ref{ugUserMakeNumber} on page~\pageref{ugUserMakeNumber}.
+For more information, see \sectionref{ugUserMakePage}.
\section{MappingPackage1}
\label{MappingPackage1XmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{MappingPackage1}
Function are objects of type {\tt Mapping}. In this section we
demonstrate some library operations from the packages
@@ 40950,8 +40866,8 @@ $$
$$
\returnType{Type: List Integer}
\section{Matrix}
\label{MatrixXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Matrix}
The {\tt Matrix} domain provides arithmetic operations on matrices
and standard functions from linear algebra.
@@ 41482,20 +41398,14 @@ $$
\returnType{Type: Matrix Integer}
For more information on related topics, see
\ref{ugIntroTwoDimPage} on page~\pageref{ugIntroTwoDimPage} in Section
\ref{ugIntroTwoDimNumber} on page~\pageref{ugIntroTwoDimNumber},
\ref{ugProblemEigenPage} on page~\pageref{ugProblemEigenPage} in Section
\ref{ugProblemEigenNumber} on page~\pageref{ugProblemEigenNumber},
\ref{ugxFloatHilbertPage} on page~\pageref{ugxFloatHilbertPage} in Section
\ref{ugxFloatHilbertNumber} on page~\pageref{ugxFloatHilbertNumber},
\ref{PermanentXmpPage} on page~\pageref{PermanentXmpPage},
\ref{VectorXmpPage} on page~\pageref{VectorXmpPage},
\ref{OneDimensionalArrayXmpPage} on page~\pageref{OneDimensionalArrayXmpPage},
and
\ref{TwoDimensionalArrayXmpPage} on page~\pageref{TwoDimensionalArrayXmpPage}.
+\sectionref{ugIntroTwoDimPage},
+\sectionref{ugProblemEigenPage},
+\sectionref{ugxFloatHilbertPage},
+\domainref{Permanent}, \domainref{Vector}, \domainref{OneDimensionalArray},
+and \domainref{TwoDimensionalArray}.
\section{Multiset}
\label{MultisetXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Multiset}
The domain {\tt Multiset(R)} is similar to {\tt Set(R)} except that
multiplicities (counts of duplications) are maintained and displayed.
@@ 41631,8 +41541,8 @@ $$
$$
\returnType{Type: List Boolean}
\section{MultivariatePolynomial}
\label{MultivariatePolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{MultivariatePolynomial}
The domain constructor {\tt MultivariatePolynomial} is similar to {\tt
Polynomial} except that it specifies the variables to be used. {\tt
@@ 41789,14 +41699,11 @@ in the manipulation and display of expressions via its conversion
facility.
For more information on related topics, see
\ref{PolynomialXmpPage} on page~\pageref{PolynomialXmpPage},
\ref{UnivariatePolynomialXmpPage} on
page~\pageref{UnivariatePolynomialXmpPage}, and
\ref{DistributedMultivariatePolynomialXmpPage} on
page~\pageref{DistributedMultivariatePolynomialXmpPage}.
+\domainref{Polynomial}, \domainref{UnivariatePolynomial}, and
+\domainref{DistributedMultivariatePolynomial}.
\section{None}
\label{NoneXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{None}
The {\tt None} domain is not very useful for interactive work but it
is provided nevertheless for completeness of the Axiom type system.
@@ 41830,14 +41737,13 @@ $$
$$
\returnType{Type: List NonNegativeInteger}
\section{Octonion}
\label{OctonionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Octonion}
The Octonions, also called the CayleyDixon algebra, defined over a
commutative ring are an eightdimensional nonassociative algebra.
Their construction from quaternions is similar to the construction
of quaternions from complex numbers (see
\ref{QuaternionXmpPage} on page~\pageref{QuaternionXmpPage}).
+of quaternions from complex numbers (see \domainref{Quaternion}).
As {\tt Octonion} creates an eightdimensional algebra, you have to
give eight components to construct an octonion.
@@ 41963,8 +41869,8 @@ $$
$$
\returnType{Type: Polynomial Integer}
\section{OneDimensionalArray}
\label{OneDimensionalArrayXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{OneDimensionalArray}
The {\tt OneDimensionalArray} domain is used for storing data in a
onedimensional indexed data structure. Such an array is a
@@ 41973,8 +41879,7 @@ belong to the same Axiom domain. Each array has a fixed length
specified by the user and arrays are not extensible. The indexing of
onedimensional arrays is onebased. This means that the ``first''
element of an array is given the index {\tt 1}. See also
\ref{VectorXmpPage} on page~\pageref{VectorXmpPage} and
\ref{FlexibleArrayXmpPage} on page~\pageref{FlexibleArrayXmpPage}.
+\domainref{Vector} and \domainref{FlexibleArray}.
To create a onedimensional array, apply the operation
{\tt oneDimensionalArray} to a list.
@@ 42072,8 +41977,8 @@ $$
$$
\returnType{Type: OneDimensionalArray Integer}
\section{Operator}
\label{OperatorXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Operator}
Given any ring {\tt R}, the ring of the {\tt Integer}linear operators
over {\tt R} is called {\tt Operator(R)}. To create an operator over
@@ 42354,8 +42259,8 @@ $$
$$
\returnType{Type: Polynomial Fraction Integer}
\section{OrderedVariableList}
\label{OrderedVariableListXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{OrderedVariableList}
The domain {\tt OrderedVariableList} provides symbols which are
restricted to a particular list and have a definite ordering. Those
@@ 42406,8 +42311,8 @@ $$
$$
\returnType{Type: Boolean}
\section{OrderlyDifferentialPolynomial}
\label{OrderlyDifferentialPolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{OrderlyDifferentialPolynomial}
Many systems of differential equations may be transformed to
equivalent systems of ordinary differential equations where the
@@ 42820,8 +42725,8 @@ $$
$$
\returnType{Type: OrderlyDifferentialPolynomial Fraction Integer}
\section{PartialFraction}
\label{PartialFractionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{PartialFraction}
A {\it partial fraction} is a decomposition of a quotient into a sum
of quotients where the denominators of the summands are powers of
@@ 42909,8 +42814,7 @@ $$
$$
\returnType{Type: PartialFraction Integer}
Given two gaussian integers (see
\ref{ComplexXmpPage} on page~\pageref{ComplexXmpPage}), you can
+Given two gaussian integers (see \domainref{Complex}), you can
decompose their quotient into a partial fraction.
\spadcommand{partialFraction(1, 13 + 14 * \%i) }
@@ 42939,8 +42843,7 @@ The polynomials in this object have type
{\tt UnivariatePolynomial(x, Fraction Integer)}.
We use the \spadfunFrom{primeFactor}{Factored} operation (see
\ref{FactoredXmpPage} on page~\pageref{FactoredXmpPage})
to create the denominator in factored form directly.
+\domainref{Factored}) to create the denominator in factored form directly.
\spadcommand{u : FR UP(x, FRAC INT) := reduce(*,[primeFactor(x+i,i) for i in 1..4]) }
$$
@@ 42995,12 +42898,11 @@ $$
$$
\returnType{Type: PartialFraction UnivariatePolynomial(x,Fraction Integer)}
All see \ref{FullPartialFractionExpansionXmpPage} on
page~\pageref{FullPartialFractionExpansionXmpPage} for examples of
+All see \domainref{FullPartialFractionExpansion} for examples of
factorfree conversion of quotients to full partial fractions.
\section{Permanent}
\label{PermanentXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Permanent}
The package {\tt Permanent} provides the function
\spadfunFrom{permanent}{Permanent} for square matrices. The
@@ 43061,8 +42963,8 @@ $$
$$
\returnType{Type: List NonNegativeInteger}
\section{Polynomial}
\label{PolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Polynomial}
The domain constructor {\tt Polynomial} (abbreviation: {\tt POLY})
provides polynomials with an arbitrary number of unspecified
@@ 43117,8 +43019,7 @@ the representation unless you are working on an advanced application
where it is critical. The polynomial types created from {\tt
DistributedMultivariatePolynomial} and
{\tt NewDistributedMultivariatePolynomial} (discussed in
\ref{DistributedMultivariatePolynomialXmpPage} on
page~\pageref{DistributedMultivariatePolynomialXmpPage}) are stored and
+\domainref{DistributedMultivariatePolynomial}) are stored and
displayed in a nonrecursive manner.
You see a ``flat'' display of the above polynomial by converting to
@@ 43144,8 +43045,8 @@ $$
$$
\returnType{Type: Polynomial Integer}
See \ref{FactoredXmpPage} on page~\pageref{FactoredXmpPage}
to see how to create objects in factored form directly.
+See \domainref{Factored} to see how to create objects in
+factored form directly.
\spadcommand{q := (y1) * x * (z+5) }
$$
@@ 43173,9 +43074,7 @@ to think of solving problems in general ways. Axiom facilities for
factoring polynomials created with {\tt Polynomial} are currently
restricted to the integer and rational number coefficient cases.
There are more complete facilities for factoring univariate
polynomials: see \ref{ugProblemFactorPage} on
page~\pageref{ugProblemFactorPage} in Section \ref{ugProblemFactorNumber}
on page~\pageref{ugProblemFactorNumber}.
+polynomials: see \sectionref{ugProblemFactorPage}.
The standard arithmetic operations are available for polynomials.
@@ 43585,23 +43484,17 @@ $$
\returnType{Type: Polynomial Float}
For more information on related topics, see
\ref{UnivariatePolynomialXmpPage} on
page~\pageref{UnivariatePolynomialXmpPage},
\ref{MultivariatePolynomialXmpPage} on
page~\pageref{MultivariatePolynomialXmpPage}, and
\ref{DistributedMultivariatePolynomialXmpPage} on
page~\pageref{DistributedMultivariatePolynomialXmpPage}. You can also issue
+\domainref{UnivariatePolynomial}, \domainref{MultivariatePolynomial}, and
+\domainref{DistributedMultivariatePolynomial}. You can also issue
the system command {\tt )show Polynomial} to display the full list
of operations defined by {\tt Polynomial}.
\section{Quaternion}
\label{QuaternionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Quaternion}
The domain constructor {\tt Quaternion} implements quaternions over
commutative rings. For information on related topics, see
%\menuxmpref{CliffordAlgebra}
\ref{ComplexXmpPage} on page~\pageref{ComplexXmpPage} and
\ref{OctonionXmpPage} on page~\pageref{OctonionXmpPage}.
+\domainref{Complex} and \domainref{Octonion}.
You can also issue the system command
{\tt )show Quaternion} to display the full list of operations
defined by {\tt Quaternion}.
@@ 43701,8 +43594,8 @@ $$
$$
\returnType{Type: Quaternion Fraction Integer}
\section{RadixExpansion}
\label{RadixExpansionXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{RadixExpansion}
It possible to expand numbers in general bases.
@@ 43849,13 +43742,11 @@ $$
\returnType{Type: Fraction Integer}
More examples of expansions are available in
\ref{DecimalExpansionXmpPage} on page~\pageref{DecimalExpansionXmpPage},
\ref{BinaryExpansionXmpPage} on page~\pageref{BinaryExpansionXmpPage}, and
\ref{HexadecimalExpansionXmpPage} on
page~\pageref{HexadecimalExpansionXmpPage}.
+\domainref{DecimalExpansion}, \domainref{BinaryExpansion}, and
+\domainref{HexadecimalExpansion}.
\section{RealClosure}
\label{RealClosureXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{RealClosure}
The Real Closure 1.0 package provided by Renaud Rioboo
(Renaud.Rioboo@lip6.fr) consists of different packages, categories and
@@ 44627,8 +44518,8 @@ $$
$$
\returnType{Type: Boolean}
\section{RegularTriangularSet}
\label{RegularTriangularSetXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{RegularTriangularSet}
The {\tt RegularTriangularSet} domain constructor implements regular
triangular sets. These particular triangular sets were introduced by
@@ 45928,8 +45819,8 @@ solve your favorite system with {\tt zeroSetSplit}. There exist more
options at the development level that are not currently available in
this public version.
\section{RomanNumeral}
\label{RomanNumeralXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{RomanNumeral}
The Roman numeral package was added to Axiom in MCMLXXXVI for use in
denoting higher order derivatives.
@@ 46058,8 +45949,8 @@ $$
Issue the system command {\tt )show RomanNumeral} to display the full
list of operations defined by {\tt RomanNumeral}.
\section{Segment}
\label{SegmentXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Segment}
The {\tt Segment} domain provides a generalized interval type.
@@ 46095,7 +45986,7 @@ An increment can be specified using the ``{\tt by}'' construct.
\spadcommand{t := 10..3 by 2 }
$$
{{10}..3} \mbox{\rm by\ } 2
+{{10}..3} \mbox{\rm\ by\ } 2
$$
\returnType{Type: Segment PositiveInteger}
@@ 46162,11 +46053,10 @@ $$
\returnType{Type: List Integer}
For more information on related topics, see
\ref{SegmentBindingXmpPage} on page~\pageref{SegmentBindingXmpPage} and
\ref{UniversalSegmentXmpPage} on page~\pageref{UniversalSegmentXmpPage}.
+\domainref{SegmentBinding} and \domainref{UniversalSegment}.
\section{SegmentBinding}
\label{SegmentBindingXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{SegmentBinding}
The {\tt SegmentBinding} type is used to indicate a range for a named
symbol.
@@ 46216,11 +46106,10 @@ $$
\returnType{Type: Segment Fraction Integer}
For more information on related topics, see
\ref{SegmentXmpPage} on page~\pageref{SegmentXmpPage} and
\ref{UniversalSegmentXmpPage} on page~\pageref{UniversalSegmentXmpPage}.
+\domainref{Segment} and \domainref{UniversalSegment}.
\section{Set}
\label{SetXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Set}
The {\tt Set} domain allows one to represent explicit finite sets of values.
These are similar to lists, but duplicate elements are not allowed.
@@ 46416,11 +46305,10 @@ $$
$$
\returnType{Type: Set PositiveInteger}
For more information about lists, see \ref{ListXmpPage} on
page~\pageref{ListXmpPage}.
+For more information about lists, see \domainref{List}.
\section{SingleInteger}
\label{SingleIntegerXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{SingleInteger}
The {\tt SingleInteger} domain is intended to provide support in Axiom
for machine integer arithmetic. It is generally much faster than
@@ 46451,8 +46339,7 @@ $$
To avoid confusion with {\tt Integer}, which is the default type for
integers, you usually need to work with declared variables
(\ref{ugTypesDeclarePage} on page~\pageref{ugTypesDeclarePage} in Section
\ref{ugTypesDeclareNumber} on page~\pageref{ugTypesDeclareNumber})
+(\sectionref{ugTypesDeclarePage}).
\ldots
\spadcommand{a := 1234 :: SingleInteger }
@@ 46461,9 +46348,7 @@ $$
$$
\returnType{Type: SingleInteger}
or use package calling
(\ref{ugTypesPkgCallPage} on page~\pageref{ugTypesPkgCallPage} in Section
\ref{ugTypesPkgCallNumber} on page~\pageref{ugTypesPkgCallNumber}).
+or use package calling (\sectionref{ugTypesPkgCallPage}).
\spadcommand{b := 124\$SingleInteger }
$$
@@ 46540,12 +46425,10 @@ $$
Many other operations are available for small integers, including many
of those provided for {\tt Integer}. To see the other operations, use
the Browse HyperDoc facility (\ref{ugBrowsePage} on
page~\pageref{ugBrowsePage} in Section
\ref{ugBrowseNumber} on page~\pageref{ugBrowseNumber}).
+the Browse HyperDoc facility (\sectionref{ugBrowsePage})
\section{SparseTable}
\label{SparseTableXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{SparseTable}
The {\tt SparseTable} domain provides a general purpose table type
with default entries.
@@ 46613,15 +46496,13 @@ If a specific table representation is required, the
{\tt GeneralSparseTable} constructor should be used. The domain
{\tt SparseTable(K, E, dflt)} is equivalent to
{\tt GeneralSparseTable(K,E,Table(K,E), dflt)}.
For more information, see
\ref{TableXmpPage} on page~\pageref{TableXmpPage} and
\ref{GeneralSparseTableXmpPage} on page~\pageref{GeneralSparseTableXmpPage}.
+For more information, see \domainref{Table} and \domainref{GeneralSparseTable}.
\section{SquareMatrix}
\label{SquareMatrixXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{SquareMatrix}
The top level matrix type in Axiom is {\tt Matrix} (see
\ref{MatrixXmpPage} on page~\pageref{MatrixXmpPage}), which provides
+\domainref{Matrix}, which provides
basic arithmetic and linear algebra functions. However, since the
matrices can be of any size it is not true that any pair can be added
or multiplied. Thus {\tt Matrix} has little algebraic structure.
@@ 46736,16 +46617,11 @@ $$
\returnType{Type: SquareMatrix(2,Polynomial Complex Integer)}
For more information on related topics, see
\ref{ugTypesWritingModesPage} on
page~\pageref{ugTypesWritingModesPage} in Section
\ref{ugTypesWritingModesNumber} on
page~\pageref{ugTypesWritingModesNumber}, \ref{ugTypesExposePage} on
page~\pageref{ugTypesExposePage} in Section \ref{ugTypesExposeNumber}
on page~\pageref{ugTypesExposeNumber}, and \ref{MatrixXmpPage} on
page~\pageref{MatrixXmpPage}.
+\sectionref{ugTypesWritingModesPage}, \sectionref{ugTypesExposePage},
+and \domainref{Matrix}.
\section{SquareFreeRegularTriangularSet}
\label{SquareFreeRegularTriangularSetXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{SquareFreeRegularTriangularSet}
The {\tt SquareFreeRegularTriangularSet} domain constructor implements
squarefree regular triangular sets. See the
@@ 47137,8 +47013,8 @@ OrderedVariableList [x,y,z,t],
NewSparseMultivariatePolynomial(Integer,
OrderedVariableList [x,y,z,t])))}
\section{Stream}
\label{StreamXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Stream}
A {\tt Stream} object is represented as a list whose last element
contains the wherewithal to create the next element, should it ever be
@@ 47259,24 +47135,18 @@ $$
The packages {\tt StreamFunctions1}, {\tt StreamFunctions2} and
{\tt StreamFunctions3} export some useful stream manipulation operations.
For more information, see \ref{ugLangItsPage} on
page~\pageref{ugLangItsPage} in Section \ref{ugLangItsNumber} on
page~\pageref{ugLangItsNumber}, \ref{ugProblemSeriesPage} on
page~\pageref{ugProblemSeriesPage} in Section
\ref{ugProblemSeriesNumber} on page~\pageref{ugProblemSeriesNumber},
\ref{ContinuedFractionXmpPage} on
page~\pageref{ContinuedFractionXmpPage}, and \ref{ListXmpPage} on
page~\pageref{ListXmpPage}.

\section{String}
\label{StringXmpPage}
+For more information, see \sectionref{ugLangItsPage},
+\sectionref{ugProblemSeriesPage},
+\domainref{ContinuedFraction}, and \domainref{List}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{String}
The type {\tt String} provides character strings. Character strings
provide all the operations for a onedimensional array of characters,
plus additional operations for manipulating text. For more
information on related topics, see
\ref{CharacterXmpPage} on page~\pageref{CharacterXmpPage} and
\ref{CharacterClassXmpPage} on page~\pageref{CharacterClassXmpPage}.
+\domainref{Character} and \domainref{CharacterClass}.
You can also issue the system command
{\tt )show String} to display the full list of operations defined
by {\tt String}.
@@ 47565,13 +47435,13 @@ $$
$$
\returnType{Type: PositiveInteger}
\section{StringTable}
\label{StringTableXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{StringTable}
This domain provides a table type in which the keys are known to be
strings so special techniques can be used. Other than performance,
the type {\tt StringTable(S)} should behave exactly the same way as
{\tt Table(String,S)}. See \ref{TableXmpPage} on page~\pageref{TableXmpPage}
+{\tt Table(String,S)}. See \domainref{Table}
for general information about tables.
This creates a new table whose keys are strings.
@@ 47602,8 +47472,8 @@ for s in split("My name is Ian Watt.",char " ")
\end{verbatim}
\returnType{Void}
\section{Symbol}
\label{SymbolXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Symbol}
Symbols are one of the basic types manipulated by Axiom. The
{\tt Symbol} domain provides ways to create symbols of many varieties.
@@ 47871,8 +47741,8 @@ presup: List OutputForm,
presub: List OutputForm,
args: List OutputForm)}
\section{Table}
\label{TableXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Table}
The {\tt Table} constructor provides a general structure for
associative storage. This type provides hash tables in which data
@@ 48047,30 +47917,26 @@ This allows new entries to be appended onto the front of the list
to cover up old entries.
This is useful when table entries need to be stacked or when
frequent list traversals are required.
See \ref{AssociationListXmpPage} on page~\pageref{AssociationListXmpPage}
for more information.
+See \domainref{AssociationList} for more information.
\item {\tt EqTable} gives tables in which keys are considered
equal only when they are in fact the same instance of a structure.
See \ref{EqTableXmpPage} on page~\pageref{EqTableXmpPage} for more information.
+See \domainref{EqTable} for more information.
\item {\tt StringTable} should be used when the keys are known to
be strings.
See \ref{StringTableXmpPage} on page~\pageref{StringTableXmpPage}
for more information.
+See \domainref{StringTable} for more information.
\item {\tt SparseTable} provides tables with default
entries, so
lookup never fails. The {\tt GeneralSparseTable} constructor
can be used to make any table type behave this way.
See \ref{SparseTableXmpPage} on page~\pageref{SparseTableXmpPage}
for more information.
+See \domainref{SparseTable} for more information.
\item {\tt KeyedAccessFile} allows values to be saved in a file,
accessed as a table.
See \ref{KeyedAccessFileXmpPage} on page~\pageref{KeyedAccessFileXmpPage}
for more information.
+See \domainref{KeyedAccessFile} for more information.
\end{list}
\noindent
\section{TextFile}
\label{TextFileXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{TextFile}
The domain {\tt TextFile} allows Axiom to read and write
character data and exchange text with other programs.
@@ 48161,19 +48027,16 @@ Finally, clean up.
\spadcommand{)system rm /tmp/MOTD}
For more information on related topics, see
\ref{FileXmpPage} on page~\pageref{FileXmpPage},
\ref{KeyedAccessFileXmpPage} on page~\pageref{KeyedAccessFileXmpPage}, and
\ref{LibraryXmpPage} on page~\pageref{LibraryXmpPage}.
+\domainref{File}, \domainref{KeyedAccessFile}, and \domainref{Library}.
\section{TwoDimensionalArray}
\label{TwoDimensionalArrayXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{TwoDimensionalArray}
The {\tt TwoDimensionalArray} domain is used for storing data in a
two dimensional data structure indexed by row and by column. Such an array
is a homogeneous data structure in that all the entries of the array
must belong to the same Axiom domain (although see
\ref{ugTypesAnyNonePage} on page~\pageref{ugTypesAnyNonePage} in Section
\ref{ugTypesAnyNoneNumber} on page~\pageref{ugTypesAnyNoneNumber}). Each
+\sectionref{ugTypesAnyNonePage}. Each
array has a fixed number of rows and columns specified by the user and
arrays are not extensible. In Axiom, the indexing of twodimensional
arrays is onebased. This means that both the ``first'' row of an
@@ 48434,11 +48297,10 @@ $$
For more information about the operations available for {\tt
TwoDimensionalArray}, issue {\tt )show TwoDimensionalArray}. For
information on related topics, see
\ref{MatrixXmpPage} on page~\pageref{MatrixXmpPage} and
\ref{OneDimensionalArrayXmpPage} on page~\pageref{OneDimensionalArrayXmpPage}.
+\domainref{Matrix} and \domainref{OneDimensionalArray}.
\section{UnivariatePolynomial}
\label{UnivariatePolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{UnivariatePolynomial}
The domain constructor {\tt UnivariatePolynomial} (abbreviated {\tt
UP}) creates domains of univariate polynomials in a specified
@@ 48824,23 +48686,18 @@ $$
$$
\returnType{Type: UnivariatePolynomial(b1,Fraction Polynomial Integer)}
See \ref{ugProblemFactorPage} on page~\pageref{ugProblemFactorPage} in Section
\ref{ugProblemFactorNumber} on page~\pageref{ugProblemFactorNumber}
+See \sectionref{ugProblemFactorPage}
for a discussion of the factorization facilities
in Axiom for univariate polynomials.
For more information on related topics, see
\ref{ugIntroVariablesPage} on page~\pageref{ugIntroVariablesPage} in Section
\ref{ugIntroVariablesNumber} on page~\pageref{ugIntroVariablesNumber},
\ref{ugTypesConvertPage} on page~\pageref{ugTypesConvertPage} in Section
\ref{ugTypesConvertNumber} on page~\pageref{ugTypesConvertNumber},
\ref{PolynomialXmpPage} on page~\pageref{PolynomialXmpPage},
\ref{MultivariatePolynomialXmpPage} on
page~\pageref{MultivariatePolynomialXmpPage}, and
\ref{DistributedMultivariatePolynomialXmpPage} on
page~\pageref{DistributedMultivariatePolynomialXmpPage}.

\section{UnivariateSkewPolynomial}
\label{UnivariateSkewPolynomial}
+\sectionref{ugIntroVariablesPage},
+\sectionref{ugTypesConvertPage},
+\domainref{Polynomial}, \domainref{MultivariatePolynomial}, and
+\domainref{DistributedMultivariatePolynomial}.
+
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{UnivariateSkewPolynomial}
+
Skew or Ore polynomial rings provide a unified framework to
compute with differential and difference equations.
@@ 49313,9 +49170,8 @@ $$
\right]}
$$

\section{UniversalSegment}
\label{UniversalSegmentXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{UniversalSegment}
The {\tt UniversalSegment} domain generalizes {\tt Segment}
by allowing segments without a ``hi'' end point.
@@ 49328,7 +49184,7 @@ $$
\spadcommand{nevens := (0..) by 2 }
$$
{0..} \mbox{\rm by\ } 2
+{0..} \mbox{\rm\ by\ } 2
$$
\returnType{Type: UniversalSegment NonNegativeInteger}
@@ 49393,13 +49249,11 @@ $$
\returnType{Type: Stream Integer}
For more information on related topics, see
\ref{SegmentXmpPage} on page~\pageref{SegmentXmpPage},
\ref{SegmentBindingXmpPage} on page~\pageref{SegmentBindingXmpPage},
\ref{ListXmpPage} on page~\pageref{ListXmpPage}, and
\ref{StreamXmpPage} on page~\pageref{StreamXmpPage}.
+\domainref{Segment}, \domainref{SegmentBinding}, \domainref{List}, and
+\domainref{Stream}.
\section{Vector}
\label{VectorXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Vector}
The {\tt Vector} domain is used for storing data in a onedimensional
indexed data structure. A vector is a homogeneous data structure in
@@ 49409,8 +49263,7 @@ are not extensible. This domain is similar to the
{\tt OneDimensionalArray} domain, except that when the components of a
{\tt Vector} belong to a {\tt Ring}, arithmetic operations are provided.
For more examples of operations that are defined for both {\tt Vector}
and {\tt OneDimensionalArray}, see
\ref{OneDimensionalArrayXmpPage} on page~\pageref{OneDimensionalArrayXmpPage}.
+and {\tt OneDimensionalArray}, see \domainref{OneDimensionalArray}.
As with the {\tt OneDimensionalArray} domain, a {\tt Vector} can
be created by calling the operation \spadfunFrom{new}{Vector}, its components
@@ 49533,17 +49386,13 @@ $$
\returnType{Type: Vector Integer}
For more information about other aggregate domains, see the following:
\ref{ListXmpPage} on page~\pageref{ListXmpPage},
\ref{MatrixXmpPage} on page~\pageref{MatrixXmpPage},
\ref{OneDimensionalArrayXmpPage} on page~\pageref{OneDimensionalArrayXmpPage},
\ref{SetXmpPage} on page~\pageref{SetXmpPage},
\ref{TableXmpPage} on page~\pageref{TableXmpPage}, and
\ref{TwoDimensionalArrayXmpPage} on page~\pageref{TwoDimensionalArrayXmpPage}.
+\domainref{List}, \domainref{Matrix}, \domainref{OneDimensionalArray},
+\domainref{Set}, \domainref{Table}, and \domainref{TwoDimensionalArray}.
Issue the system command {\tt )show Vector} to display the full list of
operations defined by {\tt Vector}.
\section{Void}
\label{VoidXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{Void}
When an expression is not in a value context, it is given type
{\tt Void}. For example, in the expression
@@ 49588,8 +49437,8 @@ Once a value has been converted to {\tt Void}, it cannot be recovered.
Cannot convert from type Void to PositiveInteger for value "()"
\end{verbatim}
\section{WuWenTsunTriangularSet}
\label{WuWenTsunTriangularSetXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{WuWenTsunTriangularSet}
The {\tt WuWenTsunTriangularSet} domain constructor implements the
characteristic set method of Wu Wen Tsun. This algorithm computes a
@@ 49838,8 +49687,8 @@ Note that the way of understanding triangular decompositions
is detailed in the example of the {\tt RegularTriangularSet}
constructor.
\section{XPBWPolynomial}
\label{XPBWPolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{XPBWPolynomial}
Initialisations
@@ 50698,8 +50547,8 @@ $$
$$
\returnType{Type: XRecursivePolynomial(Symbol,Fraction Integer)}
\section{XPolynomial}
\label{XPolynomialXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{XPolynomial}
The {\tt XPolynomial} domain constructor implements multivariate
polynomials whose set of variables is {\tt Symbol}. These variables
@@ 50884,8 +50733,8 @@ $$
$$
\returnType{Type: XPolynomial Integer}
\section{XPolynomialRing}
\label{XPolynomialRingXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{XPolynomialRing}
The {\tt XPolynomialRing} domain constructor implements generalized
polynomials with coefficients from an arbitrary {\tt Ring} (not
@@ 51199,8 +51048,8 @@ $$
$$
\returnType{Type: XPolynomialRing(SquareMatrix(2,Fraction Integer),OrderedFreeMonoid Symbol)}
\section{ZeroDimensionalSolvePackage}
\label{ZeroDimensionalSolvePackageXmpPage}
+%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
+\domainhead{ZeroDimensionalSolvePackage}
The {\tt ZeroDimensionalSolvePackage} package constructor provides
operations for computing symbolically the complex or real roots of
@@ 54613,8 +54462,7 @@ There are many other things you can do.
In fact, most everything you can do interactively using the
threedi\men\sion\al control panel (such as translating, zooming, resizing,
coloring, perspective and lighting selections) can also be done
directly by operations (see Chapter
\ref{ugGraph} on page~\pageref{ugGraph} for more details).
+directly by operations (see \sectionref{ugGraph} for more details).
When you are done experimenting, say $reset(vp)$ to restore the
picture to its original position and settings.
@@ 54720,15 +54568,14 @@ drawRibbons(flist, xrange) ==
\end{figure}
Here are some remarks on the syntax used in the {\bf drawRibbons} function
(consult Chapter \ref{ugUser} on page~\pageref{ugUser} for more details).
+(consult \sectionref{ugUser} for more details).
Unlike most other programming languages which use semicolons,
parentheses, or {\it begin}{\it end} brackets to delineate the
structure of programs, the structure of an Axiom program is
determined by indentation.
The first line of the function definition always begins in column 1.
All other lines of the function are indented with respect to the first
line and form a {\it pile} (see \ref{ugLangBlocks} on
page~\pageref{ugLangBlocks}).
+line and form a {\it pile} (see \sectionref{ugLangBlocks}).
The definition of {\bf drawRibbons}
consists of a pile of expressions to be executed one after
@@ 55178,7 +55025,7 @@ We draw the complex valued function, again considering the
$(x,y)$plane as the complex plane, using $r$ as the
height (or $z$coordinate) and $\theta$ as the color.
This is a standard plotwe learned how to do this in
Chapter \ref{ugGraph} on page~\pageref{ugGraph}
+\sectionref{ugGraph} 
but here we write a new program to illustrate
the creation of polygon meshes, or grids.
@@ 55256,7 +55103,7 @@ Draw it with an odd number of steps to avoid the pole.
\section{Functions Producing Functions}
\label{ugIntProgFunctions}
In \ref{ugUserMake} on page~\pageref{ugUserMake},
+In \sectionref{ugUserMake},
you learned how to use the operation
{\bf function} to create a function from symbolic formulas.
Here we introduce a similar operation which not only
@@ 55456,11 +55303,10 @@ setImagSteps
setClipValue
}
% Here and throughout the book we should use the terminology
% "type of a function", rather than talking about source and target.
% This is how the brave new world of SMWATT regards them. A function
% is just an object that has a mapping type.
%
+Here and throughout the book we should use the terminology
+"type of a function", rather than talking about source and target.
+A function is just an object that has a mapping type.
+
\chapter{Packages}
\label{ugPackages}
@@ 55472,14 +55318,14 @@ special functions to symbolic facilities for
differential equations, symbolic integration, and limits.
\index{package!constructor}
In Chapter \ref{ugIntProg} on page~\pageref{ugIntProg},
+In \sectionref{ugIntProg},
we developed several useful functions for drawing
vector fields and complex functions.
We now show you how you can add these functions to the
Axiom library to make them available for general use.
The way we created the functions in Chapter \ref{ugIntProg}
on page~\pageref{ugIntProg} is typical of how
+The way we created the functions in \sectionref{ugIntProg}
+is typical of how
you, as an advanced Axiom user, may interact with Axiom.
You have an application.
You go to your editor and create an input file defining some
@@ 55551,17 +55397,15 @@ DrawComplex(): Exports == Implementation where Type definition begins here
\label{ugPackagesNames}
%
Each package has a name and an abbreviation.
For a package of the complex draw functions from Chapter
\ref{ugIntProg} on page~\pageref{ugIntProg},
we choose the name {\tt DrawComplex}
+For a package of the complex draw functions from
+\sectionref{ugIntProg}, we choose the name {\tt DrawComplex}
and
\index{abbreviation!constructor}
abbreviation {\tt DRAWCX}.\footnote{An abbreviation can be any string
of
\index{constructor!abbreviation}
between two and seven capital letters and digits, beginning with a letter.
See \ref{ugTypesWritingAbbr} on page~\pageref{ugTypesWritingAbbr}
for more information.}
+See \sectionref{ugTypesWritingAbbr} for more information.}
To be sure that you have not chosen a name or abbreviation already used by
the system, issue the system command {\tt )show} for both the name and
the abbreviation.
@@ 55585,8 +55429,7 @@ The macros are only usable from their point of definition until the
end of the file.
Consider the definition of
{\tt DrawComplex} in
Figure \ref{figpakcdraw} on page~\pageref{figpakcdraw}.
+{\tt DrawComplex} in \figureref{figpakcdraw}.
After the macro
\index{macro}
definition
@@ 55661,8 +55504,7 @@ As an author of a package, you must ensure that
the {\tt Implementation} part provides a function for each
operation in the {\tt Exports} part.\footnote{The {\tt DrawComplex}
package enhances the facility
described in Chapter
\ref{ugIntProgCompFuns} on page~\pageref{ugIntProgCompFuns} by allowing a
+described in \sectionref{ugIntProgCompFuns} by allowing a
complex function to have
arrows emanating from the surface to indicate the direction of the
complex argument.}
@@ 55847,19 +55689,16 @@ The power of packages becomes evident when packages have parameters.
Usually these parameters are domains and the exported operations have types
involving these parameters.
In Chapter \ref{ugTypes} on page~\pageref{ugTypes},
you learned that categories denote classes of domains.
Although we cover this notion in detail in the next
chapter, we now give you a sneak preview of its usefulness.
+In \sectionref{ugTypes}, you learned that categories denote classes of
+domains. Although we cover this notion in detail in the next chapter,
+we now give you a sneak preview of its usefulness.
In \ref{ugUserBlocks} on page~\pageref{ugUserBlocks},
we defined functions $bubbleSort(m)$ and
$insertionSort(m)$ to sort a list of integers.
If you look at the code for these functions, you see that they may be
used to sort {\it any} structure $m$ with the right properties.
Also, the functions can be used to sort lists of {\it any} elementsnot
just integers.
Let us now recall the code for $bubbleSort$.
+In \sectionref{ugUserBlocks}, we defined functions $bubbleSort(m)$ and
+$insertionSort(m)$ to sort a list of integers. If you look at the
+code for these functions, you see that they may be used to sort {\it
+any} structure $m$ with the right properties. Also, the functions can
+be used to sort lists of {\it any} elementsnot just integers. Let
+us now recall the code for $bubbleSort$.
\begin{verbatim}
bubbleSort(m) ==
@@ 55881,8 +55720,7 @@ by your telling Axiom that $m$ has
the ``attribute'' {\bf finiteAggregate}.
An {\it attribute} is a property
that a domain either has or does not have.
As we show later in
\ref{ugCategoriesAttributes} on page~\pageref{ugCategoriesAttributes},
+As we show later in \sectionref{ugCategoriesAttributes},
programs can query domains as to the presence or absence of an attribute.
The operation {\bf swap} swaps elements of $m$.
@@ 56007,8 +55845,7 @@ corresponding twoargument functions with the operation
insertionSort!(m) == insertionSort!(m,<$S)
\end{verbatim}
In \ref{ugUserBlocks} on page~\pageref{ugUserBlocks},
we give an alternative definition of
+In \sectionref{ugUserBlocks}, we give an alternative definition of
{\bf bubbleSort} using \spadfunFrom{first}{List} and
\spadfunFrom{rest}{List} that is more efficient for a list (for
which access to any element requires traversing the list from its
@@ 56189,7 +56026,7 @@ The third expression of the {\tt and} requires {\tt D1 has
IndexedAggregate(Integer, D2) with} two attributes.
So the interpreter searches for an {\tt IndexedAggregate}
among the ancestors of {\tt List (Integer)} (see
\ref{ugCategoriesHier} on page~\pageref{ugCategoriesHier}).
+\sectionref{ugCategoriesHier}).
It finds one: {\tt IndexedAggregate(Integer, Integer)}.
The interpreter tries defining $D2$ as {\tt Integer}.
After substituting for $D1$ and $D2$, the predicate
@@ 56227,8 +56064,7 @@ how they are defined in Axiom, and how you can extend the
system to include new categories of your own.
We assume that you have read the introductory material on domains
and categories in \ref{ugTypesBasicDomainCons} on
page~\pageref{ugTypesBasicDomainCons}.
+and categories in \sectionref{ugTypesBasicDomainCons}.
There you learned that the notion of packages covered in the
previous chapter are special cases of domains.
While this is in fact the case, it is useful here to regard domains
@@ 56306,8 +56142,7 @@ All parts of a category definition are then indented with respect to this
\index{indentation}
first line.
In Chapter \ref{ugTypes} on page~\pageref{ugTypes},
we talked about {\tt Ring} as denoting the
+In \sectionref{ugTypes}, we talked about {\tt Ring} as denoting the
class of all domains that are rings, in short, the class of all
rings.
While this is the usual naming convention in Axiom, it is also
@@ 56559,8 +56394,7 @@ operations $*$ and $**$.
We actually omitted the last \index{category!defaults} part of the
definition of \index{default definitions} {\tt SemiGroup} in
\ref{ugCategoriesHier} on page~\pageref{ugCategoriesHier}. Here now
is its complete Axiom definition.
+\sectionref{ugCategoriesHier}. Here now is its complete Axiom definition.
\begin{verbatim}
SemiGroup(): Category == SetCategory with
@@ 56764,9 +56598,8 @@ have commutative multiplication?
\spadcommand{Matrix Integer has commutative("*")}
Attributes are used to conditionally export and define operations for
a domain (see \ref{ugDomainsAssertions} on
page~\pageref{ugDomainsAssertions}). Attributes can also be asserted
in a category definition.
+a domain (see \sectionref{ugDomainsAssertions}.
+Attributes can also be asserted in a category definition.
After mentioning category {\tt Ring} many times in this book,
it is high time that we show you its definition:
@@ 56914,18 +56747,18 @@ if R has IntegerNumberSystem then
\end{verbatim}
Here the predicate used is identical to the predicate in the {\tt
Exports} part. This need not be the case. See \ref{ugPackagesConds}
on page~\pageref{ugPackagesConds} for a more complicated example.
+Exports} part. This need not be the case. See \sectionref{ugPackagesConds}
+for a more complicated example.
\section{Anonymous Categories}
\label{ugCategoriesAndPackages}
The part of a category to the right of a {\tt with} is also regarded
as a categoryan ``anonymous category.'' Thus you have already seen
a category definition \index{category!anonymous} in Chapter
\ref{ugPackages} on page~\pageref{ugPackages}. The {\tt Exports} part
of the package {\tt DrawComplex} (\ref{ugPackagesAbstract} on
page~\pageref{ugPackagesAbstract}) is an anonymous category. This is
+a category definition \index{category!anonymous} in
+\sectionref{ugPackages}. The {\tt Exports} part
+of the package {\tt DrawComplex} (\sectionref{ugPackagesAbstract})
+is an anonymous category. This is
not necessary. We could, instead, give this category a name:
%
@@ 56994,7 +56827,7 @@ element of the domain.
If no exported operations mention {\tt \$}, then evidently there is
nothing of interest to do with the objects of the domain. You might
then say that a package is a ``boring'' domain! But, as you saw in
Chapter \ref{ugPackages} on page~\pageref{ugPackages}, packages are a
+\sectionref{ugPackages}, packages are a
very useful notion indeed. The exported operations of a package
depend solely on the parameters to the package constructor and other
explicit domains.
@@ 57035,7 +56868,7 @@ A recommended format for the definition of a domain is:\newline
Note: The brackets {\tt [ ]} here denote optionality.
A complete domain constructor definition for {\tt QuadraticForm} is
shown in Figure \ref{figquadform} on page~\pageref{figquadform}.
+shown in \figureref{figquadform}.
Interestingly, this little domain illustrates all the new concepts you
need to learn.
@@ 57111,8 +56944,7 @@ means that membership in a category does not depend on the values of
the parameters to the domain constructor. This part thus defines the
link between the domains and the category hierarchies given on the
inside covers of this book. As described in
\ref{ugCategoriesCorrectness} on
page~\pageref{ugCategoriesCorrectness}, it is this link that makes it
+\sectionref{ugCategoriesCorrectness}, it is this link that makes it
possible for you to pass objects of the domains as arguments to other
operations in Axiom.
@@ 57129,8 +56961,7 @@ groups, it is possible to pass quadratic forms to algorithms that
only assume arguments to have these abelian group
properties.
In \ref{ugCategoriesConditionals} on
page~\pageref{ugCategoriesConditionals}, you saw that {\tt
+In \sectionref{ugCategoriesConditionals}, you saw that {\tt
Fraction(R)}, a member of {\tt QuotientFieldCategory(R)}, is a member
of {\tt OrderedSet} if $R$ is a member of {\tt OrderedSet}. Likewise,
from the {\tt Exports} part of the definition of {\tt ModMonic(R, S)},
@@ 57255,8 +57086,7 @@ The $Rep$ for quadratic forms is {\tt SquareMatrix(n, K)}.
This means that all objects of the domain are required to be
$n$ by $n$ matrices with elements from {\bf K}.
The code for {\tt quadraticForm} in Figure \ref{figquadform}
on page \pageref{figquadform}
+The code for {\tt quadraticForm} in \figureref{figquadform}
checks that the matrix is symmetric and then converts it to
{\tt \$}, which means, as usual, ``this domain.'' Such explicit
conversions \index{conversion} are generally required by the
@@ 57266,13 +57096,11 @@ this function essentially does nothing.
The {\frenchspacing\tt m :: \$} on line 28 coerces $m$ to a
quadratic form.
In fact, the quadratic form you created in step (3) of
\ref{ugDomainsDemo} on page~\pageref{ugDomainsDemo}
is just the matrix you passed it in
+\sectionref{ugDomainsDemo} is just the matrix you passed it in
disguise!
Without seeing this definition, you would not know that.
Nor can you take advantage of this fact now that you do know!
When we try in the next step of \ref{ugDomainsDemo} on
page~\pageref{ugDomainsDemo} to regard
+When we try in the next step of \sectionref{ugDomainsDemo} to regard
$q$ as a matrix by asking for {\bf nrows}, the number of
its rows, Axiom gives you an error message saying, in
effect, ``Good try, but this won't work!''
@@ 57348,8 +57176,7 @@ of polynomial implementation is used.
Within a given domain, however, you define (at most) one
representation.\footnote{You can make that representation a
{\tt Union} type, however.
See \ref{ugTypesUnions} on page~\pageref{ugTypesUnions}
for examples of unions.}
+See \sectionref{ugTypesUnions} for examples of unions.}
If you want to have multiple representations (that is, several
domains, each with its own representation), use a category to
describe the {\tt Exports}, then define separate domains for each
@@ 57362,8 +57189,7 @@ representation.
The capsule part of {\tt Implementation} defines functions that
implement the operations exported by the domainusually only
some of the operations.
In our demo in \ref{ugDomainsDemo} on page~\pageref{ugDomainsDemo},
we asked for the value of
+In our demo in \sectionref{ugDomainsDemo}, we asked for the value of
$3*qq+q$.
Where do the operations {\tt *}, {\tt +}, and
{\tt } come from?
@@ 57386,8 +57212,7 @@ So do $*$, $+$ and $$ (from QuadraticForm) come from
\section{Defaults}
\label{ugDomainsDefaults}
%
In Chapter \ref{ugPackages} on page~\pageref{ugPackages},
we saw that categories can provide
+In \sectionref{ugPackages}, we saw that categories can provide
default implementations for their operations.
How and when are they used?
When Axiom finds that {\tt QuadraticForm(2, Fraction
@@ 57424,8 +57249,7 @@ Let's apply this search strategy for our example $3*qq+q$.
The scalar multiplication comes first.
Axiom finds a default implementation in
{\tt AbelianGroup\&}.
Remember from \ref{ugCategoriesDefaults} on
page~\pageref{ugCategoriesDefaults} that
+Remember from \sectionref{ugCategoriesDefaults} that
{\tt SemiGroup} provides a default definition for
$x^n$ by repeated squaring?
{\tt AbelianGroup} similarly provides a definition for
@@ 57570,8 +57394,7 @@ e_i \ e_j & = & e_j \ e_i & \hbox{for } i \neq j
\end{array}
$$
Now look at the snapshot of its definition given in Figure
\ref{figclifalg} on page~\pageref{figclifalg}.
+Now look at the snapshot of its definition given in \figureref{figclifalg}.
Lines 910 show part of the definitions of the
{\tt Exports}. A Clifford algebra over a field $K$ is asserted to be
a ring, an algebra over $K$, and a vector space over $K$. Its
@@ 58160,7 +57983,7 @@ First enter the search string {\tt Matrix} into the input area and
click on {\bf Constructors}.
What you get is the {\it constructor page} for {\tt Matrix}.
We show and describe this page in detail in
\ref{ugBrowseDomain} on page~\pageref{ugBrowseDomain}.
+\sectionref{ugBrowseDomain}.
By convention, Axiom does a caseinsensitive search for a
match.
Thus {\tt matrix} is just as good as {\tt Matrix}, has the same
@@ 58168,8 +57991,7 @@ effect as {\tt MaTrix}, and so on.
We recommend that you generally use small letters for names
however.
A search string with only capital letters has a special meaning
(see \ref{ugBrowseCapitalizationConvention} on
page~\pageref{ugBrowseCapitalizationConvention}).
+(see \sectionref{ugBrowseCapitalizationConvention}).
Click on \UpBitmap{} to return to the Browse front page.
@@ 58192,12 +58014,6 @@ the string ``{\tt matrix}.''
\caption{Table of exposed constructors matching {\tt *matrix*} .}
\end{figure}
%% Following para replaced 1995oct30 MGR
%These are all the exposed constructors in
%Axiom.
%To see how to get all exposed and unexposed constructors in
%Axiom, skip to the section entitled {\bf Exposure} in
%\ref{ugBrowseOptions} on page~\pageref{ugBrowseOptions}.
All constructors containing the string are listed, whether
exposed or unexposed.
You can hide the names of the unexposed constructors by clicking
@@ 58220,8 +58036,7 @@ Below the table is a {\it Views} panel.
This panel contains buttons that let you view constructors in different
ways.
To learn about views of constructors, skip to
\ref{ugBrowseViewsOfConstructors} on
page~\pageref{ugBrowseViewsOfConstructors}.
+\sectionref{ugBrowseViewsOfConstructors}.
Click on \UpBitmap{} to return to the Browse front page.
@@ 58244,7 +58059,7 @@ the operations in Axiom of that name.
At the bottom of an operation page is another kind of {\it Views} panel,
one for operation pages.
To learn more about these views, skip to
\ref{ugBrowseViewsOfOperations} on page~\pageref{ugBrowseViewsOfOperations}.
+\sectionref{ugBrowseViewsOfOperations}.
Click on \UpBitmap{} to return to the Browse front page.
@@ 58285,10 +58100,7 @@ matrix} as a part of their name.
\end{figure}
The summary gives you all the names under a heading when the number of
entries is less than 10. % "less than 10." replaces the following:
 % sufficiently small%\footnote{See
%\ref{ugBrowseOptions} to see how you can change this.}.
%% MGR 1995oct31
+entries is less than 10.
Click on \UpBitmap{} to return to the Browse front page.
@@ 58409,7 +58221,7 @@ below.
If you click on an operation name, you bring up a description
page for the operations.
For a detailed description of these pages, skip to
\ref{ugBrowseViewsOfOperations} on page~\pageref{ugBrowseViewsOfOperations}.
+\sectionref{ugBrowseViewsOfOperations}.
\subsubsection{Attributes}
@@ 59039,8 +58851,6 @@ with a {\it Views} panel at the bottom and the message to {\bf
Select a view below}.
To get the descriptions of all these operations as mentioned
above, select the {\bf description} button.}
%See the discussion of {\bf threshold} in
%\ref{ugBrowseOptions}.} %% Removed MGR 1995oct31
\begin{figure}[htbp]
\begin{picture}(324,180)%(54,0)
@@ 59106,73 +58916,6 @@ For example, for the category default package
{\tt MATCAT} since the corresponding category
{\tt MatrixCategory} has abbreviation {\tt MATCAT}.
%% *********************************************************************
%\subsection{Browse Options}
%\label{ugBrowseOptions}
%% *********************************************************************
%
%You can set two options for using Browse: exposure and threshold.
%
%% *********************************************************************
%\subsubsection{Exposure}
%% *********************************************************************
%
%By default, the only constructors, operations, and attributes
%shown by Browse are those from exposed constructors.
%To change this, you can issue
%\index{set hyperdoc browse exposure}
%\begin{verbatim}
%)set hyperdoc browse exposure on
%\end{verbatim}
%After you make this setting, you will see
%both exposed and unexposed constructs.
%By definition, an operation or attribute is exposed only if it is
%exported from an exposed constructor.
%Unexposed items are generally marked by Browse with an asterisk.
%For more information on exposure, see \ref{ugTypesExpose}.
%
%With this setting, try the following experiment.
%Starting with the main Browse page, enter {\tt *matrix*} into the
%input area and click on {\bf Constructors}.
%The result is the following table. %% This line should be texonly. MGR
%
%\begin{figure}[htbp]
%\begin{picture}(324,180)%(54,0)
%\hspace*{\baseLeftSkip}\special{psfile=ps/hconsearch2.ps}
%\end{picture}
%\caption{Table of all constructors matching {\tt *matrix*} .}
%\end{figure}
%
%
%% *********************************************************************
%\subsubsection{Threshold}
%% *********************************************************************
%
%For General, Documentation or Complete searches, a summary is presented
%of all matches.
%When the number of items of a given kind is less than a number called
%{\bf threshold}, Axiom presents a table of names with the heading
%for that kind.
%
%Also, when an operation name is chosen and there are less than {\bf
%threshold} distinct operations, the operations are initially shown in
%{\bf description} mode.
%
%The default value of {\bf threshold} is 10.
%To change its value to say 5, issue
%\index{set hyperdoc browse threshold}
%\begin{verbatim}
%)set hyperdoc browse threshold 5
%\end{verbatim}
%Notice that the headings in
%the summary are active.
%If you click on a heading, you bring up a separate page for those
%entries.
%%
%% Above section removed by MGR, 1995oct30, as these two options do
%% not exist.


\setcounter{chapter}{14} % Chapter 15
\chapter{What's New in Axiom Version 2.0}
@@ 59284,7 +59027,7 @@ general, the correspondence to Axiom types is as follows.
\end{itemize}
(Exceptionally, for NAG EXTERNAL parameters  ASPs in link parlance
 REAL and COMPLEX correspond to {\tt MachineFloat} and {\tt MachineComplex},
respectively; see \ref{aspSection} on page~\pageref{aspSection}.)
+respectively; see \sectionref{aspSection}.)
The correspondence for aggregates is as follows.
\begin{itemize}
@@ 59298,8 +59041,7 @@ The correspondence for aggregates is as follows.
Higherdimensional arrays are not currently needed for the Nag Library.
Arguments which are Fortran FUNCTIONs or SUBROUTINEs correspond
to special ASP domains in Axiom. See \ref{aspSection} on
page~\pageref{aspSection}.
+to special ASP domains in Axiom. See \sectionref{aspSection}.
% 
\subsubsection{Classification of NAG parameters}
@@ 59472,7 +59214,7 @@ retractions from appropriate instantiations of {\tt Expression},
\index{FortranCode}
{\tt FortranCode} allows us to build arbitrarily complex ASPs via a
kind of pseudocode. It is described fully in
\ref{generalFortran} on page~\pageref{generalFortran}.
+\sectionref{generalFortran}.
Every ASP exports two {\bf coerce} functions: one from
{\tt FortranCode} and one from {\tt List FortranCode}. There
@@ 59947,7 +59689,7 @@ by the {\tt nagd} daemon process which may run on a different host.
The {\tt nagman} local agent is started by default whenever you
start Axiom. The {\tt nagd} server must be started separately.
Instructions for installing and running the server are supplied
in \ref{nugNagd} on page~\pageref{nugNagd}.
+in \sectionref{nugNagd}.
Use the {\tt )set naglink host} system command
to point your local agent to a server in your network.
@@ 59998,8 +59740,7 @@ the resulting program on the numeric part of the RPC stream.
The {\tt leave} keyword has been replaced by the
{\tt break} keyword for compatibility with the new Axiom
extension language.
See section \ref{ugLangLoopsBreak} on page~\pageref{ugLangLoopsBreak}
for more information.
+See \sectionref{ugLangLoopsBreak} for more information.
Curly braces are no longer used to create sets. Instead, use
{\bf set} followed by a bracketed expression. For example,
@@ 60007,7 +59748,7 @@ Curly braces are no longer used to create sets. Instead, use
\spadcommand{set [1,2,3,4]}
Curly braces are now used to enclose a block (see section
\ref{ugLangBlocks} on page~\pageref{ugLangBlocks}
+\sectionref{ugLangBlocks}
for more information). For compatibility, a block can still be
enclosed by parentheses as well.
@@ 60161,31 +59902,24 @@ HyperDoc.
A section has been added to the graphics chapter, describing
how to build twodi\men\sion\al graphs from lists of points. An example is
given showing how to read the points from a file.
See section \ref{ugGraphTwoDbuild} on page~\pageref{ugGraphTwoDbuild}
for details.
+See \sectionref{ugGraphTwoDbuild} for details.
A further section has been added to that same chapter, describing
how to add a twodi\men\sion\al graph to a viewport which already
contains other graphs.
See section
\ref{ugGraphTwoDappend} on page~\pageref{ugGraphTwoDappend}
for details.
+See \sectionref{ugGraphTwoDappend} for details.
Chapter 3
and the online HyperDoc help have been unified.
An explanation of operation names ending in ``?'' and ``!'' has
been added to the first chapter.
See the
end of the section
\ref{ugIntroCallFun} on page~\pageref{ugIntroCallFun}
for details.
+See the end of the \sectionref{ugIntroCallFun} for details.
An expanded explanation of using predicates has
been added to the sixth chapter. See the
example involving {\bf evenRule} in the middle of the section
\ref{ugUserRules} on page~\pageref{ugUserRules}
for details.
+example involving {\bf evenRule} in the middle of the
+\sectionref{ugUserRules} for details.
Documentation for the {\tt )compile}, {\tt )library} and
{\tt )load} commands has been greatly changed. This reflects
@@ 60237,7 +59971,7 @@ are available at {\tt interpreter} level.
The default userlevel is {\tt interpreter}.
\index{userlevel}
In addition to the {\tt )set} command (discussed in
\ref{ugSysCmdset} on page~\pageref{ugSysCmdset})
+\sectionref{ugSysCmdset}
you can use the HyperDoc settings facility to change the {\it userlevel.}
@@ 60899,9 +60633,7 @@ The sequence of commands
will call the compiler, edit, and then call the compiler again
on the file {\bf matrix.spad.}
If you do not specify a {\it directory,} the working current
directory (see
\ref{ugSysCmdcd} on page~\pageref{ugSysCmdcd})
is searched for the file.
+directory (see \sectionref{ugSysCmdcd} is searched for the file.
If the file is not found, the standard system directories are searched.
If you do not give any options, all constructors within a file are
@@ 60930,8 +60662,7 @@ completely different.
The {\tt )vartrace} option causes the compiler to generate
extra code for the constructor to support conditional tracing of
variable assignments. (see
\ref{ugSysCmdtrace} on page~\pageref{ugSysCmdtrace}). Without
+variable assignments. (see \sectionref{ugSysCmdtrace}). Without
this option, this code is suppressed and one cannot use
the {\tt )vars} option for the trace command.
@@ 61355,21 +61086,16 @@ Thus {\tt \%\%(1)} is also the previous step,
{\tt \%\%(2)}, is the step before that, and so on.
If an invalid step number is given, Axiom will signal an error.
The {\it environment} information can either be saved in a file or entirely in
memory (the default).
Each frame
(\ref{ugSysCmdframe} on page~\pageref{ugSysCmdframe})
has its own history database.
When it is kept in a file, some of it may also be kept in memory for
efficiency.
When the information is saved in a file, the name of the file is
of the form {\bf FRAME.axh} where ``{\bf FRAME}'' is the name of the
current frame.
The history file is placed in the current working directory
(see \ref{ugSysCmdcd} on page~\pageref{ugSysCmdcd}).
Note that these history database files are not text files (in fact,
they are directories themselves), and so are not in humanreadable
format.
+The {\it environment} information can either be saved in a file or
+entirely in memory (the default). Each frame
+(\sectionref{ugSysCmdframe}) has its own history database. When it is
+kept in a file, some of it may also be kept in memory for efficiency.
+When the information is saved in a file, the name of the file is of
+the form {\bf FRAME.axh} where ``{\bf FRAME}'' is the name of the
+current frame. The history file is placed in the current working
+directory (see \sectionref{ugSysCmdcd}). Note that these history
+database files are not text files (in fact, they are directories
+themselves), and so are not in humanreadable format.
The options to the {\tt )history} command are as follows:
@@ 61426,16 +61152,14 @@ would clear the current workspace and load the contents of the named
saved session. If no saved session name is specified, the system looks
for a file called {\bf last.axh}.
\item[{\tt )save} {\it savedHistoryName}]
is used to save a snapshot of the environment in a file.
This file is placed in the current working directory
(see \ref{ugSysCmdcd} on page~\pageref{ugSysCmdcd}).
Use {\tt )history )restore} to restore the environment to the state
preserved in the file.
This option also creates an input file containing all the lines of input
since you created the workspace frame (for example, by starting your
Axiom session) or last did a {\tt )clear all} or
{\tt )clear completely}.
+\item[{\tt )save} {\it savedHistoryName}] is used to save a snapshot
+of the environment in a file. This file is placed in the current
+working directory (see \sectionref{ugSysCmdcd}). Use {\tt )history
+)restore} to restore the environment to the state preserved in the
+file. This option also creates an input file containing all the lines
+of input since you created the workspace frame (for example, by
+starting your Axiom session) or last did a {\tt )clear all} or {\tt
+)clear completely}.
\item[{\tt )show} \lanb{}{\it n}\ranb{} \lanb{}{\tt both}\ranb{}]
can show previous input lines and output results.
@@ 61614,74 +61338,6 @@ command may be used to drop out of Axiom into Common Lisp.
This command is obsolete. Use {\tt )library} instead.
%% BEGIN OBSOLETE

% The {\tt )load} command is used to bring in the compiled library code
% for constructors and update internal system tables with information
% about the constructors.
% This command is usually only used by Axiom library developers.
%
% The abbreviation of a constructor serves as part of the name of the
% directory in which the compiled code is stored (see
% \ref{ugSysCmdabbreviation} for a discussion of defining and querying
% abbreviations).
% The abbreviation is used in the {\tt )load} command.
% For example, to load the constructors {\tt Integer},
% {\tt NonNegativeInteger} and {\tt List} which have
% abbreviations {\tt INT}, {\tt NNI} and {\tt LIST},
% respectively, issue the command
% \begin{verbatim}
% )load INT NNI LIST
% \end{verbatim}
% To load constructors only if they have not already been
% loaded (that is., load {\it conditionally}), use the {\tt )cond}
% option:
% \begin{verbatim}
% )load INT NNI LIST )cond
% \end{verbatim}
% To query whether particular constructors have been loaded, use the
% {\tt )query} option:
% \begin{verbatim}
% )load I NNI L )query
% \end{verbatim}
% When constructors are loaded from Axiom system directories, some
% checks and updates are not performed because it is assumed that the system
% knows about these constructors.
% To force these checks and updates to occur, add the {\tt )update}
% option to the command:
% \begin{verbatim}
% )load INT NNI LIST )update
% )load INT NNI LIST )cond )update
% \end{verbatim}
% The only time it is really necessary to use the {\tt )load} command is
% when a new constructor has been compiled or an existing constructor has
% been modified and then compiled.
% If an {\tt )abbreviate} command has been issued for a constructor, it
% will be automatically loaded when needed.
% In particular, any constructor that comes with the Axiom system
% will be automatically loaded.
%
% If you write several interdependent constructors it is important that
% they all get loaded when needed.
% To accomplish this, either load them manually or issue
% {\tt )abbreviate} commands for each of the constructors so that they
% will be automatically loaded when needed.
%
% Constructors are automatically exposed in the frame in which you load
% them unless you use the {\tt )noexpose} option.
% \begin{verbatim}
% )load MATCAT )noexpose
% \end{verbatim}
% See \ref{ugTypesExpose}
% for more information about constructor exposure.
%
% \par\noindent{\bf Also See:}
% {\tt )abbreviation} \index{ugSysCmdabbreviation} and
% {\tt )compile} \index{ugSysCmdcompile}.

%% END OBSOLETE


\section{)trace}
\index{ugSysCmdltrace}
@@ 61845,8 +61501,7 @@ The command
will read the contents of the file {\bf matrix.input} into
Axiom.
The ``.input'' file extension is optional.
See \ref{ugInOutIn} on page~\pageref{ugInOutIn}
for more information about {\bf .input} files.
+See \sectionref{ugInOutIn} for more information about {\bf .input} files.
This command remembers the previous file you edited, read or compiled.
If you do not specify a file name, the previous file will be read.
@@ 62369,23 +62024,16 @@ causes a Common Lisp break loop to be entered after
the assignment to any of the listed variables in the traced
function.
\item[{\tt )vars}]
causes the display of the value of any variable after it is
assigned in the traced function.
Note that library code must
have been compiled (see \ref{ugSysCmdcompile} on
page~\pageref{ugSysCmdcompile})
using the {\tt )vartrace} option in order
to support this option.

\item[{\tt )vars} {\it var1 \lanb{}... varN\ranb{}}]
causes the display of the value of any of the specified variables
after they are assigned in the traced function.
Note that library code must
have been compiled (see \ref{ugSysCmdcompile} on
page~\pageref{ugSysCmdcompile})
using the {\tt )vartrace} option in order
to support this option.
+\item[{\tt )vars}] causes the display of the value of any variable
+after it is assigned in the traced function. Note that library code
+must have been compiled (see \sectionref{ugSysCmdcompile} using the
+{\tt )vartrace} option in order to support this option.
+
+\item[{\tt )vars} {\it var1 \lanb{}... varN\ranb{}}] causes the
+display of the value of any of the specified variables after they are
+assigned in the traced function. Note that library code must have
+been compiled (see \sectionref{ugSysCmdcompile} using the {\tt
+)vartrace} option in order to support this option.
\item[{\tt )within} {\it executingFunction}]
causes the display of trace information only if the traced
@@ 62607,8 +62255,7 @@ The command synonym {\tt )apropos} is equivalent to
This is a listing of all categories in the Axiom library at the
time this book was produced.
Use the Browse facility (described in Chapter
\ref{ugBrowse} on page~\pageref{ugBrowse})
+Use the Browse facility (described in \sectionref{ugBrowse})
to get more information about these constructors.
This sample entry will help you read the following table:
@@ 63081,8 +62728,7 @@ $\hbox{{\rm op}}_{j}$ & is an operation exported by the category.
This is a listing of all domains in the Axiom library at the
time this book was produced.
Use the Browse facility (described in Chapter
\ref{ugBrowse} on page~\pageref{ugBrowse})
+Use the Browse facility (described in \sectionref{ugBrowse})
to get more information about these constructors.
This sample entry will help you read the following table:
@@ 64323,8 +63969,7 @@ $\hbox{{\rm op}}_{j}$ & is an operation exported by the domain.
This is a listing of all packages in the Axiom library at the
time this book was produced.
Use the Browse facility (described in Chapter
\ref{ugBrowse} on page~\pageref{ugBrowse})
+Use the Browse facility (described in \sectionref{ugBrowse})
to get more information about these constructors.
This sample entry will help you read the following table:
@@ 65642,7 +65287,7 @@ Additionally, the plane curve function takes
a second parameter: the current parameter of {\it spaceCurve}.
This allows the plane curve to change shape
as it goes around the space curve.
See \ref{ugFimagesFive} for an example of this.
+See \sectionref{ugFimagesFive} for an example of this.
%
\begin{verbatim}
ntubeDraw: (ThreeCurve,TwoCurve,S,S) > VIEW3D
diff git a/changelog b/changelog
index 559c761..be24ef0 100644
 a/changelog
+++ b/changelog
@@ 1,3 +1,5 @@
+20090404 tpd src/axiomwebsite/patches.html 20090404.01.tpd.patch
+20090404 tpd books/bookvol0 fix cross references
20090403 tpd src/axiomwebsite/patches.html 20090403.02.tpd.patch
20090403 tpd src/input/Makefile add unittest3
20090403 tpd src/input/unittest3.input unit test top level loop variables
diff git a/src/axiomwebsite/patches.html b/src/axiomwebsite/patches.html
index b90f94a..782bc59 100644
 a/src/axiomwebsite/patches.html
+++ b/src/axiomwebsite/patches.html
@@ 1042,5 +1042,7 @@ download.html add more binaries
remove gcl2.6.7, gcl2.6.8pre
20090403.02.tpd.patch
bookvol5 collect top level loop code
+20090404.01.tpd.patch
+bookvol0 fix cross references