Artifact 0ea0701917e974acaae0b83168b85927c5b99dd1ed6028307f2cb9eee342695f:
- Executable file
r37/doc/manual/intro.tex
— part of check-in
[f2fda60abd]
at
2011-09-02 18:13:33
on branch master
— Some historical releases purely for archival purposes
git-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/trunk/historical@1375 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: arthurcnorman@users.sourceforge.net, size: 8356) [annotate] [blame] [check-ins using] [more...]
\chapter{Introductory Information} \index{Introduction}{\REDUCE} is a system for carrying out algebraic operations accurately, no matter how complicated the expressions become. It can manipulate polynomials in a variety of forms, both expanding and factoring them, and extract various parts of them as required. {\REDUCE} can also do differentiation and integration, but we shall only show trivial examples of this in this introduction. Other topics not considered include the use of arrays, the definition of procedures and operators, the specific routines for high energy physics calculations, the use of files to eliminate repetitious typing and for saving results, and the editing of the input text. Also not considered in any detail in this introduction are the many options that are available for varying computational procedures, output forms, number systems used, and so on. {\REDUCE} is designed to be an interactive system, so that the user can input an algebraic expression and see its value before moving on to the next calculation. For those systems that do not support interactive use, or for those calculations, especially long ones, for which a standard script can be defined, {\REDUCE} can also be used in batch mode. In this case, a sequence of commands can be given to {\REDUCE} and results obtained without any user interaction during the computation. In this introduction, we shall limit ourselves to the interactive use of {\REDUCE}, since this illustrates most completely the capabilities of the system. When {\REDUCE} is called, it begins by printing a banner message like: \begin{verbatim} REDUCE 3.7, 15-Jan-99 ... \end{verbatim} where the version number and the system release date will change from time to time. It then prompts the user for input by: \begin{verbatim} 1: \end{verbatim} You can now type a {\REDUCE} statement, terminated by a semicolon to indicate the end of the expression, for example: \begin{verbatim} (x+y+z)^2; \end{verbatim} This expression would normally be followed by another character (a \key{Return} on an ASCII keyboard) to ``wake up'' the system, which would then input the expression, evaluate it, and return the result: \begin{verbatim} 2 2 2 X + 2*X*Y + 2*X*Z + Y + 2*Y*Z + Z \end{verbatim} Let us review this simple example to learn a little more about the way that {\REDUCE} works. First, we note that {\REDUCE} deals with variables, and constants like other computer languages, but that in evaluating the former, a variable can stand for itself. Expression evaluation normally follows the rules of high school algebra, so the only surprise in the above example might be that the expression was expanded. {\REDUCE} normally expands expressions where possible, collecting like terms and ordering the variables in a specific manner. However, expansion, ordering of variables, format of output and so on is under control of the user, and various declarations are available to manipulate these. Another characteristic of the above example is the use of lower case on input and upper case on output. In fact, input may be in either mode, but output is usually in lower case. To make the difference between input and output more distinct in this manual, all expressions intended for input will be shown in lower case and output in upper case. However, for stylistic reasons, we represent all single identifiers in the text in upper case. Finally, the numerical prompt can be used to reference the result in a later computation. As a further illustration of the system features, the user should try: \begin{verbatim} for i:= 1:40 product i; \end{verbatim} The result in this case is the value of 40!, \begin{verbatim} 815915283247897734345611269596115894272000000000 \end{verbatim} You can also get the same result by saying \begin{verbatim} factorial 40; \end{verbatim} Since we want exact results in algebraic calculations, it is essential that integer arithmetic be performed to arbitrary precision, as in the above example. Furthermore, the {\tt FOR} statement in the above is illustrative of a whole range of combining forms that {\REDUCE} supports for the convenience of the user. Among the many options in {\REDUCE} is the use of other number systems, such as multiple precision floating point with any specified number of digits --- of use if roundoff in, say, the $100^{th}$ digit is all that can be tolerated. In many cases, it is necessary to use the results of one calculation in succeeding calculations. One way to do this is via an assignment for a variable, such as \begin{verbatim} u := (x+y+z)^2; \end{verbatim} If we now use {\tt U} in later calculations, the value of the right-hand side of the above will be used. The results of a given calculation are also saved in the variable {\tt WS}\ttindex{WS} (for WorkSpace), so this can be used in the next calculation for further processing. For example, the expression \begin{verbatim} df(ws,x); \end{verbatim} following the previous evaluation will calculate the derivative of {\tt (x+y+z)\verb|^|2} with respect to {\tt X}. Alternatively, \begin{verbatim} int(ws,y); \end{verbatim} would calculate the integral of the same expression with respect to y. {\REDUCE} is also capable of handling symbolic matrices. For example, \begin{verbatim} matrix m(2,2); \end{verbatim} declares m to be a two by two matrix, and \begin{verbatim} m := mat((a,b),(c,d)); \end{verbatim} gives its elements values. Expressions that include {\tt M} and make algebraic sense may now be evaluated, such as {\tt 1/m} to give the inverse, {\tt 2*m - u*m\verb|^|2} to give us another matrix and {\tt det(m)} to give us the determinant of {\tt M}. {\REDUCE} has a wide range of substitution capabilities. The system knows about elementary functions, but does not automatically invoke many of their well-known properties. For example, products of trigonometrical functions are not converted automatically into multiple angle expressions, but if the user wants this, he can say, for example: \begin{verbatim} (sin(a+b)+cos(a+b))*(sin(a-b)-cos(a-b)) where cos(~x)*cos(~y) = (cos(x+y)+cos(x-y))/2, cos(~x)*sin(~y) = (sin(x+y)-sin(x-y))/2, sin(~x)*sin(~y) = (cos(x-y)-cos(x+y))/2; \end{verbatim} where the tilde in front of the variables {\tt X} and {\tt Y} indicates that the rules apply for all values of those variables. The result of this calculation is \begin{verbatim} -(COS(2*A) + SIN(2*B)) \end{verbatim} \extendedmanual{See also the user-contributed packages ASSIST (chapter~\ref{ASSIST}), CAMAL (chapter~\ref{CAMAL}) and TRIGSIMP (chapter~\ref{TRIGSIMP}).} Another very commonly used capability of the system, and an illustration of one of the many output modes of {\REDUCE}, is the ability to output results in a FORTRAN compatible form. Such results can then be used in a FORTRAN based numerical calculation. This is particularly useful as a way of generating algebraic formulas to be used as the basis of extensive numerical calculations. For example, the statements \begin{verbatim} on fort; df(log(x)*(sin(x)+cos(x))/sqrt(x),x,2); \end{verbatim} will result in the output \begin{verbatim} ANS=(-4.*LOG(X)*COS(X)*X**2-4.*LOG(X)*COS(X)*X+3.* . LOG(X)*COS(X)-4.*LOG(X)*SIN(X)*X**2+4.*LOG(X)* . SIN(X)*X+3.*LOG(X)*SIN(X)+8.*COS(X)*X-8.*COS(X)-8. . *SIN(X)*X-8.*SIN(X))/(4.*SQRT(X)*X**2) \end{verbatim} These algebraic manipulations illustrate the algebraic mode of {\REDUCE}. {\REDUCE} is based on Standard Lisp. A symbolic mode is also available for executing Lisp statements. These statements follow the syntax of Lisp, e.g. \begin{verbatim} symbolic car '(a); \end{verbatim} Communication between the two modes is possible. With this simple introduction, you are now in a position to study the material in the full {\REDUCE} manual in order to learn just how extensive the range of facilities really is. If further tutorial material is desired, the seven {\REDUCE} Interactive Lessons by David R. Stoutemyer are recommended. These are normally distributed with the system.