Artifact ebe634b3728fed0fb98f2e69dac886b5610852e751dc7970fee89e160db5d959:
- File
r36/help/syntax.tex
— part of check-in
[152fb3bdbb]
at
2011-10-17 17:58:33
on branch master
— svn:eol-style, svn:executable and line endings for files
in historical/r36 treegit-svn-id: https://svn.code.sf.net/p/reduce-algebra/code/trunk/historical@1480 2bfe0521-f11c-4a00-b80e-6202646ff360 (user: schoepf@users.sourceforge.net, size: 61415) [annotate] [blame] [check-ins using] [more...]
\section{Syntax} \begin{Command}[semicolon]{;} The semicolon is a statement delimiter, indicating results are to be printed when used in interactive mode. \begin{Examples} (x+1)**2; & X^{2} + 2*X + 1 \\ df(x**2 + 1,x); & 2*X \end{Examples} \begin{Comments} Entering a \key{Return} without a semicolon or dollar sign results in a prompt on the following line. A semicolon or dollar sign can be added at this point to execute the statement. In interactive mode, a statement that is ended with a semicolon and \key{Return} has its results printed on the screen. Inside a group statement \name{<<}\ldots\name{>>} or a \name{begin}\ldots\name{end} block, a semicolon or dollar sign separates individual REDUCE statements. Since results are not printed from a block without a specific \name{return} statement, there is no difference between using the semicolon or dollar sign. In a group statement, the last value produced is the value returned by the group statement. Thus, if a semicolon or dollar sign is placed between the last statement and the ending brackets, the group statement returns the value 0 or {\em nil}, rather than the value of the last statement. \end{Comments} \end{Command} \begin{Command}[dollar]{$} The dollar sign is a statement delimiter, indicating results are not to be printed when used in interactive mode. \begin{Examples} (x+1)**2$ & \explanationo{The workspace is set to $x^{2} + 2x + 1$ but nothing shows on the screen} \\ ws; & X^{2} + 2*X + 1 \end{Examples} \begin{Comments} Entering a \key{Return} without a semicolon or dollar sign results in a prompt on the following line. A semicolon or dollar sign can be added at this point to execute the statement. In interactive mode, a statement that ends with a dollar sign \name{\$} and a \key{Return} is executed, but the results not printed. Inside a \nameref{group} statement \name{<<}\ldots\name{>>} or a \name{begin}\ldots\name{end} \nameref{block}, a semicolon or dollar sign separates individual REDUCE statements. Since results are not printed from a \nameref{block} without a specific \nameref{return} statement, there is no difference between using the semicolon or dollar sign. In a group statement, the last value produced is the value returned by the group statement. Thus, if a semicolon or dollar sign is placed between the last statement and the ending brackets, the group statement returns the value 0 or {\em nil}, rather than the value of the last statement. \end{Comments} \end{Command} \begin{Command}[percent]{%} The percent sign is used to precede comments; everything from a percent to the end of the line is ignored. \begin{Examples} df(x**3 + y,x);\% This is a comment \key{Return} & 3*X^{2} \\ int(3*x**2,x) \%This is a comment; \key{Return} \\ \explanation{A prompt is given, waiting for the semicolon that was not detected in the comment} \end{Examples} \begin{Comments} Statement delimiters \name{;} and \name{\$} are not detected between a percent sign and the end of the line. \end{Comments} \end{Command} % \begin{Operator}[ampersand]{&} % % ***** To be added ***** % % \end{Operator} % % \begin{Operator}[dot]{.} \index{list} The . (dot) infix binary operator adds a new item to the beginning of an existing \nameref{list}. In high energy physics expressions, it can also be used to represent the scalar product of two Lorentz four-vectors. \begin{Syntax} \meta{item} \name{.} \meta{list} \end{Syntax} \meta{item} can be any REDUCE scalar expression, including a list; \meta{list} must be a \nameref{list} to avoid producing an error message. The dot operator is right associative. \begin{Examples} liss := a . \{\}; & LISS := \{A\} \\ liss := b . liss; & LISS := \{B,A\} \\ newliss := liss . liss; & NEWLISS := \{\{B,A\},B,A\} \\ firstlis := a . b . \{c\}; & FIRSTLIS := \{A,B,C\} \\ secondlis := x . y . \{z\}; & SECONDLIS := \{X,Y,Z\} \\ for i := 1:3 sum part(firstlis,i)*part(secondlis,i); & A*X + B*Y + C*Z \end{Examples} \end{Operator} \begin{Operator}[assign]{:=} \index{assign} The \name{:=} is the assignment operator, assigning the value on the right-hand side to the identifier or other valid expression on the left-hand side. \begin{Syntax} \meta{restricted\_expression} \name{:=} \meta{expression} \end{Syntax} \meta{restricted\_expression} is ordinarily a single identifier, though simple expressions may be used (see Comments below). \meta{expression} is any valid REDUCE expression. If \meta{expression} is a \nameref{matrix} identifier, then \meta{restricted\_expression} can be a matrix identifier (redimensioned if necessary) which has each element set to the corresponding elements of the identifier on the right-hand side. \begin{Examples} a := x**2 + 1; & A := X^{2} + 1 \\ a; & X^{2} + 1 \\ first := second := third; & FIRST := SECOND := THIRD \\ first; & THIRD \\ second; & THIRD \\ b := for i := 1:5 product i; & B := 120 \\ b; & 120 \\ w + (c := x + 3) + z; & W + X + Z + 3 \\ c; & X + 3 \\ y + b := c; & Y + B := C \\ y; & - (B - C) \end{Examples} \begin{Comments} The assignment operator is right associative, as shown in the second and third examples. A string of such assignments has all but the last item set to the value of the last item. Embedding an assignment statement in another expression has the side effect of making the assignment, as well as causing the given replacement in the expression. Assignments of values to expressions rather than simple identifiers (such as in the last example above) can also be done, subject to the following remarks: \begin{itemize} \item[(i)] If the left-hand side is an identifier, an operator, or a power, the substitution rule is added to the rule table. \item[(ii)] If the operators \name{- + /} appear on the left-hand side, all but the first term of the expression is moved to the right-hand side. \item[(iii)] If the operator \name{*} appears on the left-hand side, any constant terms are moved to the right-hand side, but the symbolic factors remain. \end{itemize} Assignment is valid for \nameref{array} elements, but not for entire arrays. The assignment operator can also be used to attach functionality to operators. A recursive construction such as \name{a := a + b} is allowed, but when \name{a} is referenced again, the process of resubstitution continues until the expression stack overflows (you get an error message). Recursive assignments can be done safely inside controlled loop expressions, such as \nameref{for}\ldots or \nameref{repeat}\ldots\name{until}. \end{Comments} \end{Operator} \begin{Operator}[equalsign]{=} The \name{=} operator is a prefix or infix equality comparison operator. \begin{Syntax} \name{=}\(\meta{expression}\name{,}\meta{expression}\) or \meta{expression} \name{=} \meta{expression} \end{Syntax} \meta{expression} can be any REDUCE scalar expression. \begin{Examples} a := 4; & A := 4 \\ if =(a,10) then write "yes" else write "no"; & no \\ b := c; & B := C \\ if b = c then write "yes" else write "no"; & yes \\ on rounded; \\ if 4.0 = 4 then write "yes" else write "no"; & yes \end{Examples} \begin{Comments} This logical equality operator can only be used inside a conditional statement, such as \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until}. In other places the equal sign establishes an algebraic object of type \nameref{equation}. \end{Comments} \end{Operator} \begin{Operator}[replace]{=>} The \name{=>} operator is a binary operator used in \ref{rule} lists to denote replacements. \begin{Examples} operator f; \\ let f(x) => x^2; \\ f(x); & x^{2} \end{Examples} \end{Operator} \begin{Operator}[plussign]{+} The \name{+} operator is a prefix or infix n-ary addition operator. \begin{Syntax} \meta{expression} \{ \name{+}\meta{expression}\}\repeated {\em or} \name{+}\(\meta{expression} \{,\meta{expression}\}\repeated\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} x**4 + 4*x**2 + 17*x + 1; & X^{4} + 4*X^{2} + 17*X + 1 \\ 14 + 15 + x; & X + 29 \\ +(1,2,3,4,5); & 15 \end{Examples} \begin{Comments} \name{+} is also valid as an addition operator for \nameref{matrix} variables that are of the same dimensions and for \nameref{equation}s. \end{Comments} \end{Operator} \begin{Operator}[minussign]{-} The \name{-} operator is a prefix or infix binary subtraction operator, as well as the unary minus operator. \begin{Syntax} \meta{expression} \name{-} \meta{expression} or \name{-}\(\meta{expression},\meta{expression}\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} 15 - 4; & 11 \\ x*(-5); & - 5*X \\ a - b - 15; & A - B - 15 \\ -(a,4); & A - 4 \end{Examples} \begin{Comments} The subtraction operator is left associative, so that a - b - c is equivalent to (a - b) - c, as shown in the third example. The subtraction operator is also valid with \nameref{matrix} expressions of the correct dimensions and with \nameref{equation}s. \end{Comments} \end{Operator} \begin{Operator}[asterisk]{*} The \name{*} operator is a prefix or infix n-ary multiplication operator. \begin{Syntax} \meta{expression} \{ \name{*} \meta{expression}\}\repeated or \name{*}\(\meta{expression} \{,\meta{expression}\}\repeated\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} 15*3; & 45 \\ 24*x*yvalue*2; & 48*X*YVALUE \\ *(6,x); & 6*X \\ on rounded; \\ 3*1.5*x*x*x; & 4.5*X^{3} \\ off rounded; \\ 2x**2; & 2*X^{2} \end{Examples} \begin{Comments} REDUCE assumes you are using an implicit multiplication operator when an identifier is preceded by a number, as shown in the last line above. Since no valid identifiers can begin with numbers, there is no ambiguity in making this assumption. The multiplication operator is also valid with \nameref{matrix} expressions of the proper dimensions: matrices \IFTEX{$A$}{A} and \IFTEX{$B$}{B} can be multiplied if \IFTEX{$A$}{A} is \IFTEX{$n \times m$}{n x m} and \IFTEX{$B$}{B} is \IFTEX{$m \times p$}{m x p}. Matrices and \nameref{equation}s can also be multiplied by scalars: the result is as if each element was multiplied by the scalar. \end{Comments} \end{Operator} \begin{Operator}[slash]{/} The \name{/} operator is a prefix or infix binary division operator or prefix unary \nameref{recip}rocal operator. \begin{Syntax} \meta{expression}\name{/}\meta{expression} {\em or} \name{/}\meta{expression} or \name{/}\(\meta{expression},\meta{expression}\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} 20/5; & 4 \\ 100/6; & \rfrac{50}{3} \\ 16/2/x; & \rfrac{8}{X} \\ /b; & \rfrac{1}{B} \\ /(y,5); & \rfrac{Y}{5} \\ on rounded; \\ 35/4; & 8.75 \\ /20; & 0.05 \end{Examples} \begin{Comments} The division operator is left associative, so that \name{a/b/c} is equivalent to \name{(a/b)/c}. The division operator is also valid with square \nameref{matrix} expressions of the same dimensions: With \IFTEX{$A$}{A} and \IFTEX{$B$}{B} both \IFTEX{$n \times n$}{n x n} matrices and \IFTEX{$B$}{B} invertible, \IFTEX{$A/B$}{A/B} is given by \IFTEX{$A \times B^{-1}$}{A*B^{-1}}. Division of a matrix by a scalar is defined, with the results being the division of each element of the matrix by the scalar. Division of a scalar by a matrix is defined if the matrix is invertible, and has the effect of multiplying the scalar by the inverse of the matrix. When \name{/} is used as a reciprocal operator for a matrix, the inverse of the matrix is returned if it exists. \end{Comments} \end{Operator} \begin{Operator}[power]{**} The \name{**} operator is a prefix or infix binary exponentiation operator. \begin{Syntax} \meta{expression} \name{**}\meta{expression} or \name{**}\(\meta{expression},\meta{expression}\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} x**15; & X^{15} \\ x**y**z; & X^{Y*Z} \\ x**(y**z); & X^{Y^{Z}} \\ **(y,4); & Y^{4} \\ on rounded; \\ 2**pi; & 8.82497782708 \end{Examples} \begin{Comments} The exponentiation operator is left associative, so that \name{a**b**c} is equivalent to \name{(a**b)**c}, as shown in the second example. Note that this is {\em not} \name{a**(b**c)}, which would be right associative. When \nameref{nat} is on (the default), REDUCE output produces raised exponents, as shown. The symbol \name{^}, which is the upper-case 6 on most keyboards, may be used in the place of \name{**}. A square \nameref{matrix} may also be raised to positive and negative powers with the exponentiation operator (negative powers require the matrix to be invertible). Scalar expressions and \nameref{equation}s may be raised to fractional and floating-point powers. \end{Comments} \end{Operator} \begin{Operator}[caret]{^} The \name{^} operator is a prefix or infix binary exponentiation operator. It is equivalent to \nameref{power} or **. \begin{Syntax} \meta{expression} \name{^}\meta{expression} or \name{^}\(\meta{expression},\meta{expression}\) \end{Syntax} \meta{expression} may be any valid REDUCE expression. \begin{Examples} x^15; & X^{15} \\ x^y^z; & X^{Y*Z} \\ x^(y^z); & X^{Y^{Z}} \\ ^(y,4); & Y^{4} \\ on rounded; \\ 2^pi; & 8.82497782708 \end{Examples} \begin{Comments} The exponentiation operator is left associative, so that \name{a^b^c} is equivalent to \name{(a^b)^c}, as shown in the second example. Note that this is \meta{not} \name{a^(b^c)}, which would be right associative. When \nameref{nat} is on (the default), REDUCE output produces raised exponents, as shown. A square \nameref{matrix} may also be raised to positive and negative powers with the exponentiation operator (negative powers require the matrix to be invertible). Scalar expressions and \nameref{equation}s may be raised to fractional and floating-point powers. \end{Comments} \end{Operator} \begin{Operator}[geqsign]{>=} \name{>=} is an infix binary comparison operator, which returns {\em true} if its first argument is greater than or equal to its second argument. \begin{Syntax} \meta{expression} \name{>=} \meta{expression} \end{Syntax} \meta{expression} must evaluate to an integer or floating-point number. \begin{Examples} if (3 >= 2) then yes; & yes \\ a := 15; & A := 15 \\ if a >= 20 then big else small; & small \\ \end{Examples} \begin{Comments} The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until} or \nameref{while}\ldots\name{do}. \end{Comments} \end{Operator} \begin{Operator}[greater]{>} The \name{>} is an infix binary comparison operator that returns {\em true} if its first argument is strictly greater than its second. \begin{Syntax} \meta{expression} \name{>} \meta{expression} \end{Syntax} \meta{expression} must evaluate to a number, e.g., integer, rational or floating point number. \begin{Examples} on rounded; \\ if 3.0 > 3 then write "different" else write "same"; & same \\ off rounded; \\ a := 20; & A := 20 \\ if a > 20 then write "bigger" else write "not bigger"; & not bigger \\ \end{Examples} \begin{Comments} The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until} or \nameref{while}\ldots\name{do}. \end{Comments} \end{Operator} \begin{Operator}[leqsign]{<=} \name{<=} is an infix binary comparison operator that returns {\em true} if its first argument is less than or equal to its second argument. \begin{Syntax} \meta{expression} \name{<=} \meta{expression} \end{Syntax} \meta{expression} must evaluate to a number, e.g., integer, rational or floating point number. \begin{Examples} a := 10; & A := 10 \\ if a <= 10 then true; & true \end{Examples} \begin{Comments} The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until} or \nameref{while}\ldots\name{do}. \end{Comments} \end{Operator} \begin{Operator}[less]{<} \name{<} is an infix binary logical comparison operator that returns {\em true} if its first argument is strictly less than its second argument. \begin{Syntax} \meta{expression} \name{<} \meta{expression} \end{Syntax} \meta{expression} must evaluate to a number, e.g., integer, rational or floating point number. \begin{Examples} f := -3; & F := -3 \\ if f < -3 then write "yes" else write "no"; & no \end{Examples} \begin{Comments} The binary comparison operators can only be used for comparisons between numbers or variables that evaluate to numbers. The truth values returned by such a comparison can only be used inside programming constructs, such as \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until} or \nameref{while}\ldots\name{do}. \end{Comments} \end{Operator} \begin{Operator}[tilde]{~} The \name{~} is used as a unary prefix operator in the left-hand sides of \nameref{rule}s to mark \nameref{free variable}s. A double tilde marks an optional \nameref{free variable}. \end{Operator} \begin{Command}[group]{<<} The \name{<<}\ldots\name{>>} command is a group statement, used to group statements together where REDUCE expects a single statement. %%%INCONSISTENT??? \name{or} \begin{Syntax} \name{<<}\meta{statement}\{; \meta{statement} \name{or} \$\meta{statement}\}\optional \name{>>} \end{Syntax} \meta{statement} may be any valid REDUCE statement or expression. \begin{Examples} a := 2; & A := 2 \\ if a < 5 then <<b := a + 10; write b>>; & 12 \\ <<d := c/15; f := d + 3; f**2>>; & \rfrac{C^{2} + 90*C + 202}{225} \end{Examples} \begin{Comments} The value returned from a group statement is the value of the last individual statement executed inside it. Note that when a semicolon is placed between the last statement and the closing brackets, 0 or {\em nil} is returned. Group statements are often used in the consequence portions of \nameref{if}\ldots\name{then}, \nameref{repeat}\ldots\name{until}, and \nameref{while}\ldots\name{do} clauses. They may also be used in interactive operation to execute several statements at one time. Statements inside the group statement are separated by semicolons or dollar signs. \end{Comments} \end{Command} \begin{Operator}{AND} The \name{and} binary logical operator returns {\em true} if both of its arguments are {\em true}. \begin{Syntax} \meta{logical\_expression} \name{and} \meta{logical\_expression} \end{Syntax} \meta{logical\_expression} must evaluate to {\em true} or {\em nil}. \begin{Examples} a := 12; & A := 12 \\ if numberp a and a < 15 then write a**2 else write "no"; & 144 \\ clear a; \\ if numberp a and a < 15 then write a**2 else write "no"; & no \end{Examples} \begin{Comments} Logical operators can only be used inside conditional statements, such as \nameref{while}\ldots\name{do} or \nameref{if}\ldots\name{then}\ldots\name{else}. \name{and} examines each of its arguments in order, and quits, returning {\em nil}, on finding an argument that is not {\em true}. An error results if it is used in other contexts. \name{and} is left associative: \name{x and y and z} is equivalent to \name{(x and y) and z}. \end{Comments} \end{Operator} \begin{Command}{BEGIN} \name{begin} is used to start a \nameref{block} statement, which is closed with \name{end}. \begin{Syntax} \name{begin} \meta{statement}\{\name{;} \meta{statement}\}\optional \ \name{end} \end{Syntax} \meta{statement} is any valid REDUCE statement. \begin{Examples} begin for i := 1:3 do write i end; & \begin{multilineoutput}{1cm} 1 2 3 \end{multilineoutput} \\ begin scalar n;n:=1;b:=for i:=1:4 product(x-i);return n end; & 1 \\ b; & X^{4} - 10*X^{3} + 35*X^{2} - 50*X + 24 \end{Examples} \begin{Comments} A \name{begin}\ldots\name{end} block can do actions (such as \name{write}), but does not return a value unless instructed to by a \nameref{return} statement, which must be the last statement executed in the block. It is unnecessary to insert a semicolon before the \name{end}. Local variables, if any, are declared in the first statement immediately after \name{begin}, and may be defined as \name{scalar, integer,} or \name{real}. \nameref{array} variables declared within a \name{begin}\ldots\name{end} block are global in every case, and \nameref{let} statements have global effects. A \nameref{let} statement involving a formal parameter affects the calling parameter that corresponds to it. \nameref{let} statements involving local variables make global assignments, overwriting outside variables by the same name or creating them if they do not exist. You can use this feature to affect global variables from procedures, but be careful that you do not do it inadvertently. \end{Comments} \end{Command} \begin{Command}{block} A \name{block} is a sequence of statements enclosed by commands \nameref{begin} and \nameref{end}. \begin{Syntax} \name{begin} \meta{statement}\{\name{;} \meta{statement}\}\optional \ \name{end} \end{Syntax} For more details see \nameref{begin}. \end{Command} \begin{Command}{COMMENT} Beginning with the word \name{comment}, all text until the next statement terminator (\name{;} or \name{\$}) is ignored. \begin{Examples} x := a**2 comment--a is the velocity of the particle;; & X := A^{2} \end{Examples} \begin{Comments} Note that the first semicolon ends the comment and the second one terminates the original REDUCE statement. Multiple-line comments are often needed in interactive files. The \name{comment} command allows a normal-looking text to accompany the REDUCE statements in the file. \end{Comments} \end{Command} \begin{Operator}{CONS} The \name{cons} operator adds a new element to the beginning of a \nameref{list}. Its operation is identical to the symbol \nameref{dot} (dot). It can be used infix or prefix. \begin{Syntax} \name{cons}\(\meta{item},\meta{list}\) or \meta{item} \name{cons} \meta{list} \end{Syntax} \meta{item} can be any REDUCE scalar expression, including a list; \meta{list} must be a list. \begin{Examples} liss := cons(a,{b}); & \{A,B\} \\ liss := c cons liss; & \{C,A,B\} \\ newliss := for each y in liss collect cons(y,list x); & NEWLISS := \{\{C,X\},\{A,X\},\{B,X\}\} \\ for each y in newliss sum (first y)*(second y); & X*(A + B + C) \end{Examples} \begin{Comments} If you want to use \name{cons} to put together two elements into a new list, you must make the second one into a list with curly brackets or the \name{list} command. You can also start with an empty list created by \name{\{\}}. The \name{cons} operator is right associative: \name{a cons b cons c} is valid if \name{c} is a list; \name{b} need not be a list. The list produced is \name{\{a,b,c\}}. \end{Comments} \end{Operator} \begin{Command}{END} The command \name{end} has two main uses: \begin{itemize} \item[(i)] as the ending of a \nameref{begin}\ldots\name{end} \nameref{block}; and \item[(ii)] to end input from a file. \end{itemize} \begin{Comments} In a \name{begin}\ldots\name{end} \nameref{block}, there need not be a delimiter (\name{;} or \name{\$}) before the \name{end}, though there must be one after it, or a right bracket matching an earlier left bracket. Files to be read into REDUCE should end with \name{end;}, which must be preceded by a semicolon (usually the last character of the previous line). The additional semicolon avoids problems with mistakes in the files. If you have suspended file operation by answering \name{n} to a \name{pause} command, you are still, technically speaking, ``in" the file. Use \name{end} to exit the file. An \name{end} at the top level of a program is ignored. \end{Comments} \end{Command} \begin{Type}{EQUATION} \index{equation}\index{equal}\index{arithmetic} An \name{equation} is an expression where two algebraic expressions are connected by the (infix) operator \nameref{equal} or by \nameindex{=}. For access to the components of an \name{equation} the operators \nameref{lhs}, \nameref{rhs} or \nameref{part} can be used. The evaluation of the left-hand side of an \name{equation} is controlled by the switch \nameref{evallhseqp}, while the right-hand side is evaluated unconditionally. When an \name{equation} is part of a logical expression, e.g. in a \nameref{if} or \nameref{while} statement, the equation is evaluated by subtracting both sides can comparing the result with zero. Equations occur in many contexts, e.g. as arguments of the \nameref{sub} operator and in the arguments and the results of the operator \nameref{solve}. An equation can be member of a \nameref{list} and you may assign an equation to a variable. Elementary arithmetic is supported for equations: if \nameref{evallhseqp} is on, you may add and subtract equations, and you can combine an equation with a scalar expression by addition, subtraction, multiplication, division and raise an equation to a power. \begin{Examples} on evallhseqp;\\ u:=x+y=1$\\ v:=2x-y=0$\\ 2*u-v; & - 3*y=-2\\ ws/3; & y=\rfrac{2}{3}\\ \end{Examples} Important: the equation must occur in the leftmost term of such an expression. For other operations, e.g. taking function values of both sides, use the \nameref{map} operator. \end{Type} \begin{Operator}{FIRST} \index{list}\index{decomposition} The \name{first} operator returns the first element of a \nameref{list}. \begin{Syntax} \name{first}\(\meta{list}\) or \name{first} \meta{list} \end{Syntax} \meta{list} must be a non-empty list to avoid an error message. \begin{Examples} alist := \{a,b,c,d\}; & ALIST := \{A,B,C,D\} \\ first alist; & A \\ blist := \{x,y,\{ww,aa,qq\},z\}; & BLIST := \{X,Y,\{WW,AA,QQ\},Z\} \\ first third blist; & WW \end{Examples} \end{Operator} \begin{Command}{FOR} \index{loop} The \name{for} command is used for iterative loops. There are many possible forms it can take. \begin{INFO} { \begin{verbatim} / \ / |STEP <number> UNTIL| \ |<var>:=<number>| |<number>| FOR| | : | |<action> <exprn> | \ / | |EACH <var> IN <list> | \ / where <action> ::= DO|PRODUCT|SUM|COLLECT|JOIN. \end{verbatim} } \end{INFO} \begin{TEX} \begin{Syntax} \name{for} \begin{alternative} \meta{var} \name{:=} \meta{start} \name{:} \meta{stop}\\ \meta{var} \name{:=} \meta{start} \name{step} \meta{inc} \name{until} \meta{stop}\\ \name{each} \meta{var} \name{in} \meta{list} \end{alternative} \begin{alternative} \name{collect}\\ \name{do}\\ \name{join}\\ \name{product}\\ \name{sum} \end{alternative} \meta{expression} \end{Syntax} \end{TEX} \meta{var} can be any valid REDUCE identifier except \name{t} or \name{nil}, \meta{inc}, \meta{start} and \meta{stop} can be any expression that evaluates to a positive or negative integer. \meta{list} must be a valid \nameref{list} structure. The action taken must be one of the actions shown above, each of which is followed by a single REDUCE expression, statement or a \nameref{group} (\name{<<}\ldots\name{>>}) or \nameref{block} (\nameref{begin}\ldots\nameref{end}) statement. \begin{Examples} for i := 1:10 sum i; & 55 \\ for a := -2 step 3 until 6 product a; & -8 \\ a := 3; & A := 3 \\ for iter := 4:a do write iter; \\ m := 0; & M := 0 \\ for s := 10 step -1 until 3 do <<d := 10*s;m := m + d>>; \\ m; & 520 \\ for each x in {q,r,s} sum x**2; & Q^{2} + R^{2} + S^{2} \\ for i := 1:4 collect 1/i; & \{1,\rfrac{1}{2},\rfrac{1}{3},\rfrac{1}{4}\} \\ for i := 1:3 join list solve(x**2 + i*x + 1,x); & \begin{multilineoutput}{5cm} \{\{X= -\rfrac{SQRT(3)*I + 1}{2}, X= -\rfrac{SQRT(3)*I - 1}{2}\} \{X=-1\}, \{X= - \rfrac{SQRT(5) + 3}{2},X=\rfrac{SQRT(5) - 3}{2}\}\} \end{multilineoutput} \end{Examples} \begin{Comments} The behavior of each of the five action words follows: \begin{TEX} \begin{center} \begin{tabular}{|l|p{5cm}|p{5cm}|} \hline \multicolumn{3}{|c|}{Action Word Behavior}\\ \hline \multicolumn{1}{|c|}{Keyword} & \multicolumn{1}{c|}{Argument Type} & \multicolumn{1}{c|}{Action} \\ \hline do & statement, command, group or block & Evaluates its argument once for each iteration of the loop, not saving results \\ collect & expression, statement, command, group, block, list & Evaluates its argument once for each iteration of the loop, storing the results in a list which is returned by the \verb|for| statement when done \\ join & list or an operator which produces a list & Evaluates its argument once for each iteration of the loop, appending the elements in each individual result list onto the overall result list \\ product & expression, statement, command, \nameref{group} or \nameref{block} & Evaluates its argument once for each iteration of the loop, multiplying the results together and returning the overall product \\ sum & expression, statement, command, group or block & Evaluates its argument once for each iteration of the loop, adding the results together and returning the overall sum\\ \hline \end{tabular} \end{center} \end{TEX} \begin{INFO} {\begin{verbatim} Action Word Behavior Keyword Argument Type Action do statement, command, group Evaluates its argument once or block for each iteration of the loop, not saving results collect expression, statement, Evaluates its argument once for command, group, block, list each iteration of the loop, storing the results in a list which is returned by the for statement when done join list or an operator which Evaluates its argument once for produces a list each iteration of the loop, appending the elements in each individual result list onto the overall result list product expression, statement, Evaluates its argument once for command, group or block each iteration of the loop, multiplying the results together and returning the overall product sum expression, statement, Evaluates its argument once for command, group or block each iteration of the loop, adding the results together and returning the overall sum \end{verbatim} } \end{INFO} For number-driven \name{for} statements, if the ending limit is smaller than the beginning limit (larger in the case of negative steps) the action statement is not executed at all. The iterative variable is local to the \name{for} statement, and does not affect the value of an identifier with the same name. For list-driven \name{for} statements, if the list is empty, the action statement is not executed, but no error occurs. You can use nested \name{for} statements, with the inner \name{for} statement after the action keyword. You must make sure that your inner statement returns an expression that the outer statement can handle. \end{Comments} \end{Command} \begin{Command}{FOREACH} \index{loop} \name{foreach} is a synonym for the \name{for each} variant of the \nameref{for} construct. It is designed to iterate down a list, and an error will occur if a list is not used. The use of \name{for each} is preferred to \name{foreach}. \begin{Syntax} \name{foreach} \meta{variable} in \meta{list} \meta{action} \meta{expression} \\ where \meta{action} ::= \name{do | product | sum | collect | join} \end{Syntax} \begin{Examples} foreach x in {q,r,s} sum x**2; & Q^{2} + R^{2} + S^{2} \end{Examples} \end{Command} \begin{Operator}{GEQ} The \name{geq} operator is a binary infix or prefix logical operator. It returns true if its first argument is greater than or equal to its second argument. As an infix operator it is identical with \name{>=}. \begin{Syntax} \name{geq}\(\meta{expression},\meta{expression}\) or \meta{expression} \name{geq} \meta{expression} \end{Syntax} \meta{expression} can be any valid REDUCE expression that evaluates to a number. \begin{Examples} a := 20; & A := 20 \\ if geq(a,25) then write "big" else write "small"; & small \\ if a geq 20 then write "big" else write "small"; & big \\ if (a geq 18) then write "big" else write "small"; & big \end{Examples} \begin{Comments} Logical operators can only be used in conditional statements such as \\ \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\name{until}. \end{Comments} \end{Operator} \begin{Command}{GOTO} Inside a \name{begin}\ldots\name{end} \nameref{block}, \name{goto}, or preferably, \name{go to}, transfers flow of control to a labeled statement. \begin{Syntax} \name{go to} \meta{labeled_statement} or \name{goto} \meta{labeled_statement} \end{Syntax} \meta{labeled_statement} is of the form \meta{label} \name{:}\meta{statement} \begin{Examples} \begin{multilineinput} procedure dumb(a); begin scalar q; go to lab; q := df(a**2 - sin(a),a); write q; lab: return a end; \end{multilineinput} & DUMB \\ dumb(17); & 17 \end{Examples} \begin{Comments} \name{go to} can only be used inside a \name{begin}\ldots\name{end} \nameref{block}, and inside the block only statements at the top level can be labeled, not ones inside \name{<<}\ldots\name{>>}, \nameref{while}\ldots\name{do}, etc. \end{Comments} \end{Command} \begin{Operator}{GREATERP} The \name{greaterp} logical operator returns true if its first argument is strictly greater than its second argument. As an infix operator it is identical with \name{>}. \begin{Syntax} \name{greaterp}\(\meta{expression},\meta{expression}\) or \meta{expression} \name{greaterp} \meta{expression} \end{Syntax} \meta{expression} can be any valid REDUCE expression that evaluates to a number. \begin{Examples} a := 20; & A := 20 \\ if greaterp(a,25) then write "big" else write "small"; & small \\ if a greaterp 20 then write "big" else write "small"; & small \\ if (a greaterp 18) then write "big" else write "small"; & big \end{Examples} \begin{Comments} Logical operators can only be used in conditional statements such as \\ \nameref{if}\ldots\name{then}\ldots\name{else} or \nameref{repeat}\ldots\nameref{while}. \end{Comments} \end{Operator} \begin{Command}{IF} The \name{if} command is a conditional statement that executes a statement if a condition is true, and optionally another statement if it is not. \begin{Syntax} \name{if} \meta{condition} \name{then} \meta{statement} \ \&option\(\name{else}\ \meta{statement}\) \end{Syntax} \meta{condition} must be a logical or comparison operator that evaluates to a \nameref{boolean value}. \meta{statement} must be a single REDUCE statement or a \nameref{group} (\name{<<}\ldots\name{>>}) or \nameref{block} (\name{begin}\ldots\name{end}) statement. \begin{Examples} if x = 5 then a := b+c else a := d+f; & D + F \\ x := 9; & X := 9 \\ if numberp x and x<20 then y := sqrt(x) else write "illegal"; & 3 \\ clear x; \\ if numberp x and x<20 then y := sqrt(x) else write "illegal"; & illegal \\ x := 12; & X := 12 \\ a := if x < 5 then 100 else 150; & A := 150 \\ b := u**(if x < 10 then 2); & B := 1 \\ bb := u**(if x > 10 then 2); & BB := U^{2} \end{Examples} \begin{Comments} An \name{if} statement may be used inside an assignment statement and sets its value depending on the conditions, or used anywhere else an expression would be valid, as shown in the last example. If there is no \nameindex{else} clause, the value is 0 if a number is expected, and nothing otherwise. The \name{else} clause may be left out if no action is to be taken if the condition is false. The condition may be a compound conditional statement using \nameref{and} or \nameref{or}. If a non-conditional statement, such as a constant, is used by accident, it is assumed to have value {\em true}. Be sure to use \nameref{group} or \nameref{block} statements after \nameindex{then} or \name{else}. The \name{if} operator is right associative. The following constructions are examples: \begin{itemize} \item[(1)] \begin{Syntax} \name{if} \meta{condition} \name{then} \name{if} \meta{condition} \name{then} \meta{action} \name{else} \meta{action} \end{Syntax} %\end{itemize} which is equivalent to \begin{Syntax} \name{if} \meta{condition} \name{then} \(\name{if}\ \meta{condition} \ \name{then}\ \meta{action}\ \name{else}\ \meta{action}\); \end{Syntax} %\begin{itemize} \item[(2)] \begin{Syntax} \name{if} \meta{condition} \name{then} \meta{action} \name{else if} \meta{condition} \name{then} \meta{action} \name{else} \meta{action} \end{Syntax} which is equivalent to \begin{Syntax} \name{if}\ \meta{condition} \name{then} \meta{action} \name{else} \\ \(\name{if}\ \meta{condition}\ \name{then}\ \meta{action} \ \name{else}\ \meta{action}\). \end{Syntax} \end{itemize} \end{Comments} \end{Command} \begin{Operator}{LIST} \index{list} The \name{list} operator constructs a list from its arguments. \begin{Syntax} \name{list}\(\meta{item} \{,\meta{item}\}\optional\) or \name{list}\(\) to construct an empty list. \end{Syntax} \meta{item} can be any REDUCE scalar expression, including another list. Left and right curly brackets can also be used instead of the operator \name{list} to construct a list. \begin{Examples} liss := list(c,b,c,\{xx,yy\},3x**2+7x+3,df(sin(2*x),x)); & LISS := \{C,B,C,\{XX,YY\},3*X^{2} + 7*X + 3,2*COS(2*X)\} \\ length liss; & 6 \\ liss := \{c,b,c,\{xx,yy\},3x**2+7x+3,df(sin(2*x),x)\}; & LISS := \{C,B,C,\{XX,YY\},3*X^{2} + 7*X + 3,2*COS(2*X)\} \\ emptylis := list(); & EMPTYLIS := \{\} \\ a . emptylis; & \{A\} \end{Examples} \begin{Comments} Lists are ordered, hierarchical structures. The elements stay where you put them, and only change position in the list if you specifically change them. Lists can have nested sublists to any (reasonable) level. The \nameref{part} operator can be used to access elements anywhere within a list hierarchy. The \nameref{length} operator counts the number of top-level elements of its list argument; elements that are themselves lists still only count as one element. \end{Comments} \end{Operator} \begin{Operator}{OR} The \name{or} binary logical operator returns {\it true} if either one or both of its arguments is {\it true}. \begin{Syntax} \meta{logical expression} \name{or} \meta{logical expression} \end{Syntax} \meta{logical expression} must evaluate to {\it true} or {\it nil}. \begin{Examples} a := 10; & A := 10 \\ \begin{multilineinput} if a<0 or a>140 then write "not a valid human age" else write "age = ",a; \end{multilineinput} \\ & age = 10 \\ a := 200; & A := 200 \\ if a < 0 or a > 140 then write "not a valid human age"; & not a valid human age \end{Examples} \begin{Comments} The \name{or} operator is left associative: \name{x or y or z} is equivalent to \name{(x or y)} \name{or z}. Logical operators can only be used in conditional expressions, such as \\ \nameref{if}\ldots\name{then}\ldots\name{else} and \nameref{while}\ldots\name{do}. \name{or} evaluates its arguments in order and quits, returning {\it true}, on finding the first {\it true} statement. \end{Comments} \end{Operator} \begin{Command}{PROCEDURE} The \name{procedure} command allows you to define a mathematical operation as a function with arguments. \begin{Syntax} \&\meta{option} \name{procedure} \meta{identifier} \(\meta{arg}\{,\meta{arg}\}\repeated\)\name{;}\meta{body} \end{Syntax} The \meta{option} may be \nameref{algebraic} or \nameref{symbolic}, indicating the mode under which the procedure is executed, or \nameref{real} or \nameref{integer}, indicating the type of answer expected. The default is algebraic. Real or integer procedures are subtypes of algebraic procedures; type-checking is done on the results of integer procedures, but not on real procedures (in the current REDUCE release). \meta{identifier} may be any valid REDUCE identifier that is not already a procedure name, operator, \nameref{array} or \nameref{matrix}. \meta{arg} is a formal parameter that may be any valid REDUCE identifier. \meta{body} is a single statement (a \nameref{group} or \nameref{block} statement may be used) with the desired activities in it. \begin{Examples} \begin{multilineinput} procedure fac(n); if not (fixp(n) and n>=0) then rederr "Choose nonneg. integer only" else for i := 0:n-1 product i+1; \end{multilineinput} & FAC \\ fac(0); & 1 \\ fac(5); & 120 \\ fac(-5); & ***** choose nonneg. integer only \end{Examples} \begin{Comments} Procedures are automatically declared as operators upon definition. When REDUCE has parsed the procedure definition and successfully converted it to a form for its own use, it prints the name of the procedure. Procedure definitions cannot be nested. Procedures can call other procedures, or can recursively call themselves. Procedure identifiers can be cleared as you would clear an operator. Unlike \nameref{let} statements, new definitions under the same procedure name replace the previous definitions completely. Be careful not to use the name of a system operator for your own procedure. REDUCE may or may not give you a warning message. If you redefine a system operator in your own procedure, the original function of the system operator is lost for the remainder of the REDUCE session. Procedures may have none, one, or more than one parameter. A REDUCE parameter is a formal parameter only; the use of {\it x} as a parameter in a \name{procedure} definition has no connection with a value of {\it x} in the REDUCE session, and the results of calling a procedure have no effect on the value of {\it x}. If a procedure is {\it called} with {\it x} as a parameter, the current value of {\it x} is used as specified in the computation, but is not changed outside the procedure. Making an assignment statement by \name{:=} with a formal parameter on the left-hand side only changes the value of the calling parameter within the procedure. Using a \nameref{let} statement inside a procedure always changes the value globally: a \name{let} with a formal parameter makes the change to the calling parameter. \name{let} statements cannot be made on local variables inside \nameref{begin}\ldots\name{end} \nameref{block}\name{s}. When \nameref{clear} statements are used on formal parameters, the calling variables associated with them are cleared globally too. The use of \name{let} or \name{clear} statements inside procedures should be done with extreme caution. Arrays and operators may be used as parameters to procedures. The body of the procedure can contain statements that appropriately manipulate these arguments. Changes are made to values of the calling arrays or operators. Simple expressions can also be used as arguments, in the place of scalar variables. Matrices may {\it not} be used as arguments to procedures. A procedure that has no parameters is called by the procedure name, immediately followed by empty parentheses. The empty parentheses may be left out when writing a procedure with no parameters, but must appear in a call of the procedure. If this is a nuisance to you, use a \nameref{let} statement on the name of the procedure (i.e., \name{let noargs = noargs()}) after which you can call the procedure by just its name. Procedures that have a single argument can leave out the parentheses around it both in the definition and procedure call. (You can use the parentheses if you wish.) Procedures with more than one argument must use parentheses, with the arguments separated by commas. Procedures often have a \name{begin}\ldots\name{end} block in them. Inside the block, local variables are declared using \name{scalar}, \name{real} or \name{integer} declarations. The declarations must be made immediately after the word \name{begin}, and if more than one type of declaration is made, they are separated by semicolons. REDUCE currently does no type checking on local variables; \name{real} and \name{integer} are treated just like \name{scalar}. Actions take place as specified in the statements inside the block statement. Any identifiers that are not formal parameters or local variables are treated as global variables, and activities involving these identifiers are global in effect. If a return value is desired from a procedure call, a specific \nameref{return} command must be the last statement executed before exiting from the procedure. If no \name{return} is used, a procedure returns a zero or no value. Procedures are often written in a file using an editor, then the file is input using the command \nameref{in}. This method allows easy changes in development, and also allows you to load the named procedures whenever you like, by loading the files that contain them. \end{Comments} \end{Command} \begin{Command}{REPEAT} \index{loop} The \nameref{repeat} command causes repeated execution of a statement \nameindex{until} the given condition is found to be true. The statement is always executed at least once. \begin{Syntax} \name{repeat} \meta{statement} \name{until} \meta{condition} \end{Syntax} \meta{statement} can be a single statement, \nameref{group} statement, or a \name{begin}\ldots\name{end} \nameref{block}. \meta{condition} must be a logical operator that evaluates to {\it true} or {\it nil}. \begin{Examples} <<m := 4; repeat <<write 100*x*m;m := m-1>> until m = 0>>; & \begin{multilineoutput}{6cm} 400*X 300*X 200*X 100*X \end{multilineoutput}\\ <<m := -1; repeat <<write m; m := m-1>> until m <= 0>>; & -1 \end{Examples} \begin{Comments} \name{repeat} must always be followed by an \name{until} with a condition. Be careful not to generate an infinite loop with a condition that is never true. In the second example, if the condition had been \name{m = 0}, it would never have been true since \name{m} already had value -2 when the condition was first evaluated. \end{Comments} \end{Command} \begin{Operator}{REST} \index{list}\index{decomposition} The \name{rest} operator returns a \nameref{list} containing all but the first element of the list it is given. \begin{Syntax} \name{rest}\(\meta{list}\) or \name{rest} \meta{list} \end{Syntax} \meta{list} must be a non-empty list, but need not have more than one element. \begin{Examples} alist := {a,b,c,d}; & ALIST := \{A,B,C,D\}; \\ rest alist; & \{B,C,D\} \\ blist := {x,y,{aa,bb,cc},z}; & BLIST := \{X,Y,\{AA,BB,CC\},Z\} \\ second rest blist; & \{AA,BB,CC\} \\ clist := {c}; & CLIST := C \\ rest clist; & \{\} \end{Examples} \end{Operator} \begin{Command}{RETURN} The \name{return} command causes a value to be returned from inside a \name{begin}\ldots\name{end} \nameref{block}. \begin{TEX} \begin{Syntax} \name{begin} \meta{statements} \name{return} \meta{\&option(expression)} \name{end} \end{Syntax} \end{TEX} \begin{INFO} {\begin{Syntax} \name{begin} \meta{statements} \name{return} \meta{(expression)} \name{end} \end{Syntax} }\end{INFO} \meta{statements} can be any valid REDUCE statements. The value of \meta{expression} is returned. \begin{Examples} begin write "yes"; return a end; & \begin{multilineoutput}{5cm} yes A \end{multilineoutput}\\ \begin{multilineinput} procedure dumb(a); begin if numberp(a) then return a else return 10 end; \end{multilineinput} & DUMB \\ dumb(x); & 10 \\ dumb(-5); & -5 \\ \begin{multilineinput} procedure dumb2(a); begin c := a**2 + 2*a + 1; d := 17; c*d; return end; \end{multilineinput} & DUMB2 \\ dumb2(4); \\ c; & 25 \\ d; & 17 \end{Examples} \begin{Comments} Note in \name{dumb2} above that the assignments were made as requested, but the product \name{c*d} cannot be accessed. Changing the procedure to read \name{return c*d} would remedy this problem. The \name{return} statement is always the last statement executed before leaving the block. If \name{return} has no argument, the block is exited but no value is returned. A block statement does not need a \name{return} ; the statements inside terminate in their normal fashion without one. In that case no value is returned, although the specified actions inside the block take place. The \name{return} command can be used inside \name{<<}\ldots\name{>>} \nameref{group} statements and \nameref{if}\ldots\name{then}\ldots\name{else} commands that are inside \name{begin}\ldots\name{end} \nameref{block}s. It is not valid in these constructions that are not inside a \name{begin}\ldots\name{end} block. It is not valid inside \nameref{for}, \nameref{repeat}\ldots\name{until} or \nameref{while}\ldots\name{do} loops in any construction. To force early termination from loops, the \name{go to}(\nameref{goto}) command must be used. When you use nested block statements, a \name{return} from an inner block exits returning a value to the next-outermost block, rather than all the way to the outside. \end{Comments} \end{Command} \begin{Operator}{REVERSE} \index{list} The \name{reverse} operator returns a \nameref{list} that is the reverse of the list it is given. \begin{Syntax} \name{reverse}\(\meta{list}\) or \name{reverse} \meta{list} \end{Syntax} \meta{list} must be a \nameref{list}. \begin{Examples} aa := \{c,b,a,\{x**2,z**3\},y\}; & AA := \{C,B,A,\{X^{2},Z^{3}\},Y\} \\ reverse aa; & \{Y,\{X^{2},Z^{3}\},A,B,C\} \\ reverse(q . reverse aa); & \{C,B,A,\{X^{2},Z^{3}\},Y,Q\} \end{Examples} \begin{Comments} \name{reverse} and \nameref{cons} can be used together to add a new element to the end of a list (\name{.} adds its new element to the beginning). The \name{reverse} operator uses a noticeable amount of system resources, especially if the list is long. If you are doing much heavy-duty list manipulation, you should probably design your algorithms to avoid much reversing of lists. A moderate amount of list reversing is no problem. \end{Comments} \end{Operator} \begin{Type}{RULE} \index{rule}\index{rule list} A \name{rule} is an instruction to replace an algebraic expression or a part of an expression by another one. \begin{Syntax} \meta{lhs} => \meta{rhs} or \meta{lhs} => \meta{rhs} \name{when} \meta{cond} \end{Syntax} \meta{lhs} is an algebraic expression used as search pattern and \meta{rhs} is an algebraic expression which replaces matches of \meta{rhs}. \name{=>} is the operator \nameref{replace}. \meta{lhs} can contain \nameref{free variable}s which are symbols preceded by a tilde \nameindex{~} in their leftmost position in \meta{lhs}. A double tilde marks an \nameref{optional free variable}. If a rule has a \name{when} \meta{cond} part it will fire only if the evaluation of \meta{cond} has a result \nameref{true}. \meta{cond} may contain references to free variables of \meta{lhs}. Rules can be collected in a \nameref{list} which then forms a \nameindex{rule list}. \name{Rule lists} can be used to collect algebraic knowledge for a specific evaluation context. \name{Rules} and \name{rule lists} are globally activated and deactivated by \nameref{let}, \nameref{forall}, \nameref{clearrules}. For a single evaluation they can be locally activate by \nameref{where}. The active rules for an operator can be visualized by \nameref{showrules}. \begin{Examples} operator f,g,h; \\ let f(x) => x^2; \\ f(x); & x^{2}\\ g_rules:={g(~n,~x)=>h(n/2,x) when evenp n,\\ g(~n,~x)=>h((1-n)/2,x) when not evenp n}$\\ let g_rules;\\ g(3,x); & h(-1,x) \end{Examples} \end{Type} \begin{Type}{Free Variable} \index{variable} A variable preceded by a tilde is considered as \name{free variable} and stands for an arbitrary part in an algebraic form during pattern matching. Free variables occur in the left-hand sides of \nameref{rule}s, in the side relations for \nameref{compact} and in the first arguments of \nameref{map} and \nameref{select} calls. See \nameref{rule} for examples. In rules also \nameref{optional free variable}s may occur. \end{Type} \begin{Type}{Optional Free Variable} \index{variable} A variable preceded by a double tilde is considered as \name{optional free variable} and stands for an arbitrary part part in an algebraic form during pattern matching. In contrast to ordinary \nameref{free variable}s an operator pattern with an \name{optional free variable} matches also if the operand for the variable is missing. In such a case the variable is bound to a neutral value. Optional free variables can be used as term in a sum: set to 0 if missing, factor in a product: set to 1 if missing, exponent: set to 1 if missing \begin{Examples} sin(~~u + ~~n * pi) => sin(u) when evenp u; \end{Examples} Optional free variables are allowed only in the left-hand sides of \nameref{rule}s. \end{Type} \begin{Operator}{SECOND} \index{list}\index{decomposition} The \name{second} operator returns the second element of a list. \begin{Syntax} \name{second}\(\meta{list}\) or \name{second} \meta{list} \end{Syntax} \meta{list} must be a list with at least two elements, to avoid an error message. \begin{Examples} alist := \{a,b,c,d\}; & ALIST := \{A,B,C,D\} \\ second alist; & B \\ blist := \{x,\{aa,bb,cc\},z\}; & BLIST := \{X,\{AA,BB,CC\},Z\} \\ second second blist; & BB \end{Examples} \end{Operator} \begin{Operator}{SET} \index{assign} The \name{set} operator is used for assignments when you want both sides of the assignment statement to be evaluated. %%% INCONSISTENT??? hyphen after restricted \begin{Syntax} \name{set}\(\meta{restricted\_expression},\meta{expression}\) \end{Syntax} \meta{expression} can be any REDUCE expression; \meta{restricted\_expression} must be an identifier or an expression that evaluates to an identifier. \begin{Examples} a := y; & A := Y \\ set(a,sin(x^2)); & SIN(X^{2}) \\ a; & SIN(X^{2}) \\ y; & SIN(X^{2}) \\ a := b + c; & A := B + C \\ set(a-c,z); & Z \\ b; & Z \end{Examples} \begin{Comments} Using an \nameref{array} or \nameref{matrix} reference as the first argument to \name{set} has the result of setting the {\it contents} of the designated element to \name{set}'s second argument. You should be careful to avoid unwanted side effects when you use this facility. \end{Comments} \end{Operator} \begin{Operator}{SETQ} \index{assign} The \name{setq} operator is an infix or prefix binary assignment operator. It is identical to \name{:=}. \begin{Syntax} \name{setq}\(\meta{restricted\_expression},\meta{expression}\) or \\ \meta{restricted\_expression} \name{setq} \meta{expression} \end{Syntax} \meta{restricted expression} is ordinarily a single identifier, though simple expressions may be used (see Comments below). \meta{expression} can be any valid REDUCE expression. If \meta{expression} is a \nameref{matrix} identifier, then \meta{restricted\_expression} can be a matrix identifier (redimensioned if necessary), which has each element set to the corresponding elements of the identifier on the right-hand side. \begin{Examples} setq(b,6); & B := 6 \\ c setq sin(x); & C := SIN(X) \\ w + setq(c,x+3) + z; & W + X + Z + 3 \\ c; & X + 3 \\ setq(a1 + a2,25); & A1 + A2 := 25 \\ a1; & - (A2 - 25) \end{Examples} \begin{Comments} Embedding a \name{setq} statement in an expression has the side effect of making the assignment, as shown in the third example above. Assignments are generally done for identifiers, but may be done for simple expressions as well, subject to the following remarks: \begin{itemize} \item[(i)] If the left-hand side is an identifier, an operator, or a power, the rule is added to the rule table. \item[(ii)] If the operators \name{- + /} appear on the left-hand side, all but the first term of the expression is moved to the right-hand side. \item[(iii)] If the operator \name{*} appears on the left-hand side, any constant terms are moved to the right-hand side, but the symbolic factors remain. \end{itemize} Be careful not to make a recursive \name{setq} assignment that is not controlled inside a loop statement. The process of resubstitution continues until you get a stack overflow message. \name{setq} can be used to attach functionality to operators, as the \name{:=} does. \end{Comments} \end{Operator} \begin{Operator}{THIRD} \index{list}\index{decomposition} The \name{third} operator returns the third item of a \nameref{list}. \begin{Syntax} \name{third}\(\meta{list}\) or \name{third} \meta{list} \end{Syntax} \meta{list} must be a list containing at least three items to avoid an error message. \begin{Examples} alist := \{a,b,c,d\}; & ALIST := \{A,B,C,D\} \\ third alist; & C \\ blist := \{x,\{aa,bb,cc\},y,z\}; & BLIST := \{X,\{AA,BB,CC\},Y,Z\}; \\ third second blist; & CC \\ third blist; & Y \end{Examples} \end{Operator} \begin{Operator}{WHEN} \index{rule} The \name{when} operator is used inside a \name{rule} to make the execution of the rule depend on a boolean condition which is evaluated at execution time. For the use see \nameref{rule}. \end{Operator}