\chapter{Structure of Programs}
A {\REDUCE} program\index{Program structure} consists of a set of
functional commands which are evaluated sequentially by the computer.
These commands are built up from declarations, statements and expressions.
Such entities are composed of sequences of numbers, variables, operators,
strings, reserved words and delimiters (such as commas and parentheses),
which in turn are sequences of basic characters.
\section{The {\REDUCE} Standard Character Set}
\index{Character set}The basic characters which are used to build
{\REDUCE} symbols are the following:
\begin{enumerate}
\item The 26 letters {\tt a} through {\tt z}
\item The 10 decimal digits {\tt 0} through {\tt 9}
\item The special characters \_\_ ! " \$ \% ' ( ) * + , - . / : ; $<$ $>$
= \{ \} $<$blank$>$
\end{enumerate}
With the exception of strings and characters preceded by an
exclamation mark\index{Exclamation mark}, the case
of characters is ignored: depending of the underlying LISP
they will all be converted internally into lower case or
upper case: {\tt ALPHA}, {\tt Alpha} and {\tt alpha}
represent the same symbol. Most implementations allow you to switch
this conversion off. The operating instructions for a particular
implementation should be consulted on this point. For portability, we
shall limit ourselves to the standard character set in this exposition.
\section{Numbers}
\index{Number}There are several different types of numbers available in
\REDUCE. Integers consist of a signed or unsigned sequence of decimal
digits written without a decimal point, for example:
\begin{verbatim}
-2, 5396, +32
\end{verbatim}
In principle, there is no practical limit on the number of digits
permitted as exact arithmetic is used in most implementations. (You should
however check the specific instructions for your particular system
implementation to make sure that this is true.) For example, if you ask
for the value of $2^{2000}$ you get it
displayed as a number of 603 decimal digits, taking up nine lines of
output on an interactive display. It should be borne in mind of course
that computations with such long numbers can be quite slow.
Numbers that aren't integers are usually represented as the quotient of
two integers, in lowest terms: that is, as rational numbers.
In essentially all versions of {\REDUCE} it is also possible (but not always
desirable!) to ask {\REDUCE} to work with floating point approximations to
numbers again, to any precision. Such numbers are called {\em real}.
\index{Real} They can be input in two ways:
\begin{enumerate}
\item as a signed or unsigned sequence of any number of decimal digits
with an embedded or trailing decimal point.
\item as in 1. followed by a decimal exponent which is written as the
letter {\tt E} followed by a signed or unsigned integer.
\end{enumerate}
e.g. {\tt 32. +32.0 0.32E2} and {\tt 320.E-1} are all representations of
32.
The declaration {\tt SCIENTIFIC\_NOTATION}\ttindex{SCIENTIFIC\_NOTATION}
controls the output format of floating point numbers. At
the default settings, any number with five or less digits before the
decimal point is printed in a fixed-point notation, e.g., {\tt 12345.6}.
Numbers with more than five digits are printed in scientific notation,
e.g., {\tt 1.234567E+5}. Similarly, by default, any number with eleven or
more zeros after the decimal point is printed in scientific notation. To
change these defaults, {\tt SCIENTIFIC\_NOTATION} can be used in one of two
ways. {\tt SCIENTIFIC\_NOTATION} {\em m};, where {\em m\/} is a positive
integer, sets the printing format so that a number with more than {\em m\/}
digits before the decimal point, or {\em m\/} or more zeros after the
decimal point, is printed in scientific notation. {\tt SCIENTIFIC\_NOTATION}
\{{\em m,n}\}, with {\em m\/} and {\em n\/} both positive integers, sets the
format so that a number with more than {\em m\/} digits before the decimal
point, or {\em n\/} or more zeros after the decimal point is printed in
scientific notation.
{\it CAUTION:} The unsigned part of any number\index{Number} may {\em not\/}
begin with a decimal point, as this causes confusion with the {\tt CONS} (.)
operator, i.e., NOT ALLOWED: {\tt .5 -.23 +.12};
use {\tt 0.5 -0.23 +0.12} instead.
\section{Identifiers}
Identifiers\index{Identifier} in {\REDUCE} consist of one or more
alphanumeric characters (i.e. alphabetic letters or decimal
digits) the first of which must be alphabetic. The maximum number of
characters allowed is implementation dependent, although twenty-four is
permitted in most implementations. In addition, the underscore character
(\_) is considered a letter if it is {\it within} an identifier. For example,
\begin{verbatim}
a az p1 q23p a_very_long_variable
\end{verbatim}
are all identifiers, whereas
\begin{verbatim}
_a
\end{verbatim}
is not.
A sequence of alphanumeric characters in which the first is a digit is
interpreted as a product. For example, {\tt 2ab3c} is interpreted as
{\tt 2*ab3c}. There is one exception to this: If the first letter after a
digit is {\tt E}, the system will try to interpret that part of the
sequence as a real number\index{Real}, which may fail in some cases. For
example, {\tt 2E12} is the real number $2.0*10^{12}$, {\tt 2e3c} is
2000.0*C, and {\tt 2ebc} gives an error.
Special characters, such as $-$, *, and blank, may be used in identifiers
too, even as the first character, but each must be preceded by an
exclamation mark in input. For example:
\begin{verbatim}
light!-years d!*!*n good! morning
!$sign !5goldrings
\end{verbatim}
{\it CAUTION:} Many system identifiers have such special characters in their
names (especially * and =). If the user accidentally picks the name of one
of them for his own purposes it may have catastrophic consequences for his
{\REDUCE} run. Users are therefore advised to avoid such names.
Identifiers are used as variables, labels and to name arrays, operators
and procedures.
\subsection*{Restrictions}
The reserved words listed in another section may not be used as
identifiers. No spaces may appear within an identifier, and an identifier
may not extend over a line of text. (Hyphenation of an identifier, by
using a reserved character as a hyphen before an end-of-line character is
possible in some versions of {\REDUCE}).
\section{Variables}
Every variable\index{Variable} is named by an identifier, and is given a
specific type. The type is of no concern to the ordinary user. Most
variables are allowed to have the default type, called {\em scalar}.
These can receive, as values, the representation of any ordinary algebraic
expression. In the absence of such a value, they stand for themselves.
\subsection*{Reserved Variables}
Several variables\index{Reserved variable} in {\REDUCE} have particular
properties which should not be changed by the user. These variables
include:
\begin{list}{}{\renewcommand{\makelabel}[1]{{\tt#1}\hspace{\fill}}%
\settowidth{\labelwidth}{\tt INFINITY}%
\setlength{\labelsep}{1em}%
\settowidth{\leftmargin}{\tt INFINITY\hspace*{\labelsep}}}
\item[E] Intended to represent the base of
\ttindex{E}
the natural logarithms. {\tt log(e)}, if it occurs in an expression, is
automatically replaced by 1. If {\tt ROUNDED}\ttindex{ROUNDED} is
on, {\tt E} is replaced by the value of E to the current degree of
floating point precision\index{Numerical precision}.
\item[I] Intended to represent the square
\ttindex{I}
root of $-1$. {\tt i\verb|^|2} is replaced by $-1$, and appropriately for higher
powers of {\tt I}. This applies only to the symbol {\tt I} used on the top
level, not as a formal parameter in a procedure, a local variable, nor in
the context {\tt for i:= ...}
\item[INFINITY] Intended to represent $\infty$
\ttindex{INFINITY}
in limit and power series calculations for example. Note however that the
current system does {\em not\/} do proper arithmetic on $\infty$. For example,
{\tt infinity + infinity} is {\tt 2*infinity}.
\item[NIL] In {\REDUCE} (algebraic mode only)
taken as a synonym for zero. Therefore {\tt NIL} cannot be used as a
variable.
\item[PI] Intended to represent the circular
\ttindex{PI}
constant. With {\tt ROUNDED} on, it is replaced by the value of $\pi$ to
the current degree of floating point precision.
\item[T] Should not be used as a formal
\ttindex{T}
parameter or local variable in procedures, since conflict arises with the
symbolic mode meaning of T as {\em true}.
\end{list}
Other reserved variables, such as {\tt LOW\_POW}, described in other sections,
are listed in Appendix A.
Using these reserved variables\index{Reserved variable} inappropriately
will lead to errors.
There are also internal variables used by {\REDUCE} that have similar
restrictions. These usually have an asterisk in their names, so it is
unlikely a casual user would use one. An example of such a variable is
{\tt K!*} used in the asymptotic command package.
Certain words are reserved in {\REDUCE}. They may only be used in the manner
intended. A list of these is given in the section ``Reserved Identifiers''.
There are, of course, an impossibly large number of such names to keep in
mind. The reader may therefore want to make himself a copy of the list,
deleting the names he doesn't think he is likely to use by mistake.
\section{Strings}
Strings\index{String} are used in {\tt WRITE} statements, in other
output statements (such as error messages), and to name files. A string
consists of any number of characters enclosed in double quotes. For example:
\begin{verbatim}
"A String".
\end{verbatim}
Lower case characters within a string are not converted to upper case.
The string {\tt ""} represents the empty string. A double quote may be
included in a string by preceding it by another double quote. Thus
{\tt "a""b"} is the string {\tt a"b}, and {\tt """"} is the string {\tt "}.
\section{Comments}
Text can be included in program\index{Program} listings for the
convenience of human readers, in such a way that {\REDUCE} pays no
attention to it. There are two ways to do this:
\begin{enumerate}
\item Everything from the word {\tt COMMENT}\ttindex{COMMENT} to the next
statement terminator, normally ; or \$, is ignored. Such comments
can be placed anywhere a blank could properly appear. (Note that {\tt END}
and $>>$ are {\em not\/} treated as {\tt COMMENT} delimiters!)
\item Everything from the symbol {\tt \%}\index{Percent sign} to the end
of the line on which it appears is ignored. Such comments can be placed
as the last part of any line. Statement terminators have no special
meaning in such comments. Remember to put a semicolon before the {\tt \%}
if the earlier part of the line is intended to be so terminated. Remember
also to begin each line of a multi-line {\tt \%} comment with a {\tt \%}
sign.
\end{enumerate}
\section{Operators}
\label{sec-operators}
Operators\index{Operator} in {\REDUCE} are specified by name and type.
There are two types, infix\index{Infix operator} and prefix.
\index{Prefix operator} Operators can be purely abstract, just symbols
with no properties; they can have values assigned (using {\tt :=} or
simple {\tt LET} declarations) for specific arguments; they can have
properties declared for some collection of arguments (using more general
{\tt LET} declarations); or they can be fully defined (usually by a
procedure declaration).
Infix operators\index{Infix operator} have a definite precedence with
respect to one another, and normally occur between their arguments.
For example:
\begin{quote}
\begin{tabbing}
{\tt a + b - c} \hspace{1.5in} \= (spaces optional) \\
{\tt x<y and y=z} \> (spaces required where shown)
\end{tabbing}
\end{quote}
Spaces can be freely inserted between operators and variables or operators
and operators. They are required only where operator names are spelled out
with letters (such as the {\tt AND} in the example) and must be unambiguously
separated from another such or from a variable (like {\tt Y}). Wherever one
space can be used, so can any larger number.
Prefix operators occur to the left of their arguments, which are written as
a list enclosed in parentheses and separated by commas, as with normal
mathematical functions, e.g.,
\begin{verbatim}
cos(u)
df(x^2,x)
q(v+w)
\end{verbatim}
Unmatched parentheses, incorrect groupings of infix operators
\index{Infix operator} and the like, naturally lead to syntax errors. The
parentheses can be omitted (replaced by a space following the
operator\index{Operator} name) if the operator is unary and the argument
is a single symbol or begins with a prefix operator name:
\begin{quote}
\begin{tabbing}
{\tt cos y} \hspace{1.75in} \= means cos(y) \\
{\tt cos (-y)} \> -- parentheses necessary \\
{\tt log cos y} \> means log(cos(y)) \\
{\tt log cos (a+b)} \> means log(cos(a+b))
\end{tabbing}
\end{quote}
but
\begin{quote}
\begin{tabbing}
{\tt cos a*b} \hspace{1.6in} \= means (cos a)*b \\
{\tt cos -y} \> is erroneous (treated as a variable \\
\> ``cos'' minus the variable y)
\end{tabbing}
\end{quote}
A unary prefix operator\index{Prefix operator} has a precedence
\index{Operator precedence} higher than any infix operator, including
unary infix operators. \index{Infix operator}
In other words, {\REDUCE} will always interpret {\tt cos~y + 3} as
{\tt (cos~y) + 3} rather than as {\tt cos(y + 3)}.
Infix operators may also be used in a prefix format on input, e.g.,
{\tt +(a,b,c)}. On output, however, such expressions will always be
printed in infix form (i.e., {\tt a + b + c} for this example).
A number of prefix operators are built into the system with predefined
properties. Users may also add new operators and define their rules for
simplification. The built in operators are described in another section.
\subsection*{Built-In Infix Operators}
The following infix operators\index{Infix operator} are built into the
system. They are all defined internally as procedures.
\begin{verbatim}
<infix operator>::= where|:=|or|and|member|memq|=|neq|eq|
>=|>|<=|<|+|-|*|/|^|**|.
\end{verbatim}
These operators may be further divided into the following subclasses:
\begin{verbatim}
<assignment operator> ::= :=
<logical operator> ::= or|and|member|memq
<relational operator> ::= =|neq|eq|>=|>|<=|<
<substitution operator> ::= where
<arithmetic operator> ::= +|-|*|/|^|**
<construction operator> ::= .
\end{verbatim}
{\tt MEMQ} and {\tt EQ} are not used in the algebraic mode of
{\REDUCE}. They are explained in the section on symbolic mode.
{\tt WHERE} is described in the section on substitutions.
In previous versions of {\REDUCE}, {\em not} was also defined as an infix
operator. In the present version it is a regular prefix operator, and
interchangeable with {\em null}.
For compatibility with the intermediate language used by {\REDUCE}, each
special character infix operator\index{Infix operator} has an alternative
alphanumeric identifier associated with it. These identifiers may be used
interchangeably with the corresponding special character names on input.
This correspondence is as follows:
\begin{quote}
\begin{tabbing}
{\tt := setq} \hspace{0.5in} \= (the assignment operator) \\
{\tt = equal} \\
{\tt >= geq} \\
{\tt > greaterp} \\
{\tt <= leq} \\
{\tt < lessp} \\
{\tt + plus} \\
{\tt - difference} \> (if unary, {\tt minus}) \\
{\tt * times} \\
{\tt / quotient} \> (if unary, {\tt recip}) \\
{\tt \verb|^| or ** expt} \> (raising to a power) \\
{\tt . cons}
\end{tabbing}
\end{quote}
Note: {\tt NEQ} is used to mean {\em not equal}. There is no special
symbol provided for it.
The above operators\index{Operator} are binary, except {\tt NOT} which is
unary and {\tt +} and {\tt *} which are nary (i.e., taking an arbitrary
number of arguments). In addition, {\tt -} and {\tt /} may be used as
unary operators, e.g., /2 means the same as 1/2. Any other operator is
parsed as a binary operator using a left association rule. Thus {\tt
a/b/c} is interpreted as {\tt (a/b)/c}. There are two exceptions to this
rule: {\tt :=} and {\tt .} are right associative. Example: {\tt a:=b:=c}
is interpreted as {\tt a:=(b:=c)}. Unlike ALGOL and PASCAL, {\tt \verb|^|} is
left associative. In other words, {\tt a\verb|^|b\verb|^|c} is interpreted as
{\tt (a\verb|^|b)\verb|^|c}.
The operators\index{Operator} {\tt $<$}, {\tt $<$=}, {\tt $>$}, {\tt $>$=}
can only be used for making comparisons between numbers. No meaning is
currently assigned to this kind of comparison between general expressions.
Parentheses may be used to specify the order of combination. If
parentheses are omitted then this order is by the ordering of the
precedence list\index{Operator precedence} defined by the right-hand side
of the {\tt <infix operator>}\index{Infix operator} table
at the beginning of this section,
from lowest to highest. In other words, {\tt WHERE} has the lowest
precedence, and {\tt .} (the dot operator) the highest.