<A NAME=main_index>
<TITLE>Top</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Top</B><MENU>
<LI><A HREF=r38_0004.html>Concepts</A><P>
<LI><A HREF=r38_0019.html>Variables</A><P>
<LI><A HREF=r38_0068.html>Syntax</A><P>
<LI><A HREF=r38_0108.html>Arithmetic Operations</A><P>
<LI><A HREF=r38_0123.html>Boolean Operators</A><P>
<LI><A HREF=r38_0136.html>General Commands</A><P>
<LI><A HREF=r38_0185.html>Algebraic Operators</A><P>
<LI><A HREF=r38_0230.html>Declarations</A><P>
<LI><A HREF=r38_0235.html>Input and Output</A><P>
<LI><A HREF=r38_0263.html>Elementary Functions</A><P>
<LI><A HREF=r38_0340.html>General Switches</A><P>
<LI><A HREF=r38_0350.html>Matrix Operations</A><P>
<LI><A HREF=r38_0408.html>Groebner package</A><P>
<LI><A HREF=r38_0421.html>High Energy Physics</A><P>
<LI><A HREF=r38_0433.html>Numeric Package</A><P>
<LI><A HREF=r38_0443.html>Roots Package</A><P>
<LI><A HREF=r38_0534.html>Special Functions</A><P>
<LI><A HREF=r38_0548.html>Taylor series</A><P>
<LI><A HREF=r38_0570.html>Gnuplot package</A><P>
<LI><A HREF=r38_0624.html>Linear Algebra package</A><P>
<LI><A HREF=r38_0631.html>Matrix Normal Forms</A><P>
<LI><A HREF=r38_0680.html>Miscellaneous Packages</A><P>
<LI><A HREF=r38_0683.html>Outmoded Operations</A><P>
</MENU>
<A NAME=IDENTIFIER>
<TITLE>IDENTIFIER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IDENTIFIER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
Identifiers in REDUCE consist of one or more alphanumeric characters, of
which the first must be alphabetical. The maximum number of characters
allowed is system dependent, but is usually over 100. However, printing
is simplified if they are kept under 25 characters.
<P>
<P>
You can also use special characters in your identifiers, but each must be
preceded by an exclamation point <em>!</em> as an escape character. Useful
special characters are <em> # $ % ^ & * - + = ? < > ~ | / !</em> and
the space. Note that the use of the exclamation point as a special
character requires a second exclamation point as an escape character.
The underscore <em>_</em> is special in this regard. It must be preceded
by an escape character in the first position in an identifier, but is
treated like a normal letter within an identifier.
<P>
<P>
Other characters, such as <em>( ) # ; ` ' "</em> can also be used if
preceded by a <em>!</em>, but as they have special meanings to the Lisp
reader it is best to avoid them to avoid confusion.
<P>
<P>
Many system identifiers have * before or after their names, or - between
words. If you accidentally pick one of these names for your own identifier,
it could have disastrous effects. For this reason it is wise not to include
* or - anywhere in your identifiers.
<P>
<P>
You will notice that REDUCE does not use the escape characters when it prints
identifiers containing special characters; however, you still must use them
when you refer to these identifiers. Be careful when editing statements
containing escaped special characters to treat the character and its escape
as an inseparable pair.
<P>
<P>
Identifiers are used for variable names, labels for <em>go to</em> statements,
and names of arrays, matrices, operators, and procedures. Once an identifier is
used as a matrix, array, scalar or operator identifier, it may not be used
again as a matrix, array or operator. An operator or array identifier may
later be used as a scalar without problems, but a matrix identifier cannot be
used as a scalar. All procedures are entered into the system as operators, so
the name of a procedure may not be used as a matrix, array, or operator
identifier either.
<P>
<P>
<A NAME=KERNEL>
<TITLE>KERNEL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>KERNEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
A <em>kernel</em> is a form that cannot be modified further by the REDUCE
canonical simplifier. Scalar variables are always kernels. The
other important class of kernels are operators with their arguments.
Some examples should help clarify this concept:
<P>
<P>
<P><PRE><TT>
Expression Kernel?
x Yes
varname Yes
cos(a) Yes
log(sin(x**2)) Yes
a*b No
(x+y)**4 No
matrix-identifier No
</TT></PRE><P>Many REDUCE operators expect kernels among their arguments. Error
messages
result from attempts to use non-kernel expressions for these arguments.
<P>
<P>
<A NAME=STRING>
<TITLE>STRING</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STRING</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
A <em>string</em> is any collection of characters enclosed in double quotation
marks (<em>"</em>). It may be used as an argument for a variety of commands
and operators, such as <em>in</em>, <em>rederr</em> and <em>write</em>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
write "this is a string";
this is a string
write a, " ", b, " ",c,"!";
A B C!
</TT></PRE><P><P>
<P>
<A NAME=g2>
<TITLE>Concepts</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Concepts</B><MENU>
<LI><A HREF=r38_0001.html>IDENTIFIER type</A><P>
<LI><A HREF=r38_0002.html>KERNEL type</A><P>
<LI><A HREF=r38_0003.html>STRING type</A><P>
</MENU>
<A NAME=assumptions>
<TITLE>assumptions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASSUMPTIONS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
After solving a linear or polynomial equation system
with parameters, the variable <em>assumptions</em> contains a list
of side relations for the parameters. The solution is valid only
as long as none of these expression is zero.
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve({a*x-b*y+x,y-c},{x,y});
b*c
{{x=-----,y=c}}
a + 1
assumptions;
{a + 1}
</TT></PRE><P><P>
<P>
<A NAME=CARD_NO>
<TITLE>CARD_NO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CARD\_NO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<em>card_no</em>sets the total number of cards allowed in a Fortran
output statement when <em>fort</em> is on. Default is 20.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on fort;
card_no := 4;
CARD_NO=4.
z := (x + y)**15;
ANS1=5005.*X**6*Y**9+3003.*X**5*Y**10+1365.*X**4*Y**
. 11+455.*X**3*Y**12+105.*X**2*Y**13+15.*X*Y**14+Y**15
Z=X**15+15.*X**14*Y+105.*X**13*Y**2+455.*X**12*Y**3+
. 1365.*X**11*Y**4+3003.*X**10*Y**5+5005.*X**9*Y**6+
. 6435.*X**8*Y**7+6435.*X**7*Y**8+ANS1
</TT></PRE><P>Twenty total cards means 19 continuation cards. You may set it for
more
if your Fortran system allows more. Expressions are broken apart in a
Fortran-compatible way if they extend for more than <em>card_no</em>
continuation cards.
<P>
<P>
<P>
<A NAME=E>
<TITLE>E</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>E</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
The constant <em>e</em> is reserved for use as the base of the natural
logarithm. Its value is approximately 2.71828284590, which REDUCE gives
to the current decimal precision when the switch
<A HREF=r38_0330.html>rounded</A> is on.
<P>
<P>
<em>e</em>may be used as an iterative variable in a
<A HREF=r38_0047.html>for</A> statement,
or as a local variable or a
<A HREF=r38_0055.html>procedure</A>. If <em>e</em> is defined
as a local
variable inside the procedure, the normal definition as the base of the
natural logarithm would be suspended inside the procedure.
<P>
<P>
<P>
<A NAME=EVAL_MODE>
<TITLE>EVAL_MODE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EVAL\_MODE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The system variable <em>eval_mode</em> contains the current mode, either
<A HREF=r38_0186.html>algebraic</A> or
<A HREF=r38_0221.html>symbolic</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EVAL_MODE;
ALGEBRAIC
</TT></PRE><P>Some commands do not behave the same way in algebraic and symbolic
modes.
<P>
<P>
<P>
<A NAME=FORT_WIDTH>
<TITLE>FORT_WIDTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FORT\_WIDTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The <em>fort_width</em> variable sets the number of characters in a line of
Fortran-compatible output produced when the
<A HREF=r38_0289.html>fort</A> switch is on.
Default is 70.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
fort_width := 30;
FORT_WIDTH := 30
on fort;
df(sin(x**3*y),x);
ANS=3.*COS(X
. **3*Y)*X**2*
. Y
</TT></PRE><P><em>fort_width</em>includes the usually blank characters at the be
ginning
of the card. As you may notice above, it is conservative and makes the
lines even shorter than it was told.
<P>
<P>
<P>
<A NAME=HIGH_POW>
<TITLE>HIGH_POW</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HIGH\_POW</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The variable <em>high_pow</em> is set by
<A HREF=r38_0141.html>coeff</A> to the highest power
of the variable of interest in the given expression. You can access this
variable for use in further computation or display.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
coeff((x+1)^5*(x*(y+3)^2)^2,x);
{0,
0,
4 3 2
Y + 12*Y + 54*Y + 108*Y + 81,
4 3 2
5*(Y + 12*Y + 54*Y + 108*Y + 81),
4 3 2
10*(Y + 12*Y + 54*Y + 108*Y + 81),
4 3 2
10*(Y + 12*Y + 54*Y + 108*Y + 81),
4 3 2
5*(Y + 12*Y + 54*Y + 108*Y + 81),
4 3 2
Y + 12*Y + 54*Y + 108*Y + 81}
high_pow;
7
</TT></PRE><P>
<A NAME=I>
<TITLE>I</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>I</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
<P>
<P>
REDUCE knows <em>i</em> is the square root of -1,
and that i^2 = -1.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(a + b*i)*(c + d*i);
A*C + A*D*I + B*C*I - B*D
i**2;
-1
</TT></PRE><P><em>i</em>cannot be used as an identifier. It is all right to use
<em>i</em>
as an index variable in a <em>for</em> loop, or as a local (<em>scalar</em>)
variable inside a <em>begin...end</em> block, but it loses its definition as
the square root of -1 inside the block in that case.
<P>
<P>
Only the simplest properties of i are known by REDUCE unless
the switch
<A HREF=r38_0274.html>complex</A> is turned on, which implements full complex
arithmetic in factoring, simplification, and functional values.
<em>complex</em> is ordinarily off.
<P>
<P>
<P>
<A NAME=INFINITY>
<TITLE>INFINITY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INFINITY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
The name <em>infinity</em> is used to represent the infinite positive number.
However, at the present time, arithmetic in terms of this operator reflects
finite arithmetic, rather than true operations on infinity.
<P>
<P>
<A NAME=LOW_POW>
<TITLE>LOW_POW</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LOW\_POW</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The variable <em>low_pow</em> is set by
<A HREF=r38_0141.html>coeff</A> to the lowest power
of the variable of interest in the given expression. You can access this
variable for use in further computation or display.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
coeff((x+2*y)**6,y);
6
{X ,
5
12*X ,
4
60*X ,
3
160*X ,
2
240*X ,
192*X,
64}
low_pow;
0
coeff(x**2*(x*sin(y) + 1),x);
{0,0,1,SIN(Y)}
low_pow;
2
</TT></PRE><P>
<A NAME=NIL>
<TITLE>NIL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NIL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
<P>
<P>
<em>nil</em>represents the truth value false in symbolic mode, and is
a synonym for 0 in algebraic mode. It cannot be used for any other
purpose, even inside procedures or
<A HREF=r38_0047.html>for</A> loops.
<P>
<P>
<A NAME=PI>
<TITLE>PI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
The identifier <em>pi</em> is reserved for use as the circular constant.
Its value is given by 3.14159265358..., which REDUCE gives to the current
decimal precision when REDUCE is in a floating-point mode.
<P>
<P>
<em>pi</em>may be used as a looping variable in a
<A HREF=r38_0047.html>for</A> statement,
or as a local variable in a
<A HREF=r38_0055.html>procedure</A>. Its value in such cases
will be taken from the local environment.
<P>
<P>
<P>
<A NAME=requirements>
<TITLE>requirements</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REQUIREMENTS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
After an attempt to solve an inconsistent equation system
with parameters, the variable <em>requirements</em> contains a list
of expressions. These expressions define a set of conditions implicitly
equated with zero. Any solution to this system defines a setting for
the parameters sufficient to make the original system consistent.
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve({x-a,x-y,y-1},{x,y});
{}
requirements;
{a - 1}
</TT></PRE><P><P>
<P>
<A NAME=ROOT_MULTIPLICITIES>
<TITLE>ROOT_MULTIPLICITIES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOT\_MULTIPLICITIES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The <em>root_multiplicities</em> variable is set to the list of the
multiplicities of the roots of an equation by the
<A HREF=r38_0179.html>solve</A> operator.
<P>
<P>
<A HREF=r38_0179.html>solve</A>returns its solutions in a list. The multipliciti
es of
each solution are put in the corresponding locations of the list
<em>root_multiplicities</em>.
<P>
<P>
<P>
<A NAME=T>
<TITLE>T</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>T</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>constant</B><P>
<P>
The constant <em>t</em> stands for the truth value true. It cannot be used
as a scalar variable in a
<A HREF=r38_0041.html>block</A>, as a looping variable in a
<A HREF=r38_0047.html>for</A> statement or as an
<A HREF=r38_0211.html>operator</A> name.
<P>
<P>
<A NAME=g3>
<TITLE>Variables</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Variables</B><MENU>
<LI><A HREF=r38_0005.html>assumptions variable</A><P>
<LI><A HREF=r38_0006.html>CARD\_NO variable</A><P>
<LI><A HREF=r38_0007.html>E constant</A><P>
<LI><A HREF=r38_0008.html>EVAL\_MODE variable</A><P>
<LI><A HREF=r38_0009.html>FORT\_WIDTH variable</A><P>
<LI><A HREF=r38_0010.html>HIGH\_POW variable</A><P>
<LI><A HREF=r38_0011.html>I constant</A><P>
<LI><A HREF=r38_0012.html>INFINITY constant</A><P>
<LI><A HREF=r38_0013.html>LOW\_POW variable</A><P>
<LI><A HREF=r38_0014.html>NIL constant</A><P>
<LI><A HREF=r38_0015.html>PI constant</A><P>
<LI><A HREF=r38_0016.html>requirements variable</A><P>
<LI><A HREF=r38_0017.html>ROOT\_MULTIPLICITIES variable</A><P>
<LI><A HREF=r38_0018.html>T constant</A><P>
</MENU>
<A NAME=semicolon>
<TITLE>semicolon</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>;</B> _ _ _ <B>SEMICOLON</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The semicolon is a statement delimiter, indicating results are to be printed
when used in interactive mode.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x+1)**2;
2
X + 2*X + 1
df(x**2 + 1,x);
2*X
</TT></PRE><P>Entering a <em>Return</em> without a semicolon or dollar sign resu
lts 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 <em>Return</em> has its results
printed on the screen.
<P>
<P>
Inside a group statement <em><<</em>...<em>>></em>
or a <em>begin</em>...<em>end</em> block, a
semicolon or dollar sign separates individual REDUCE statements. Since
results are not printed from a block without a specific <em>return</em>
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 nil, rather than the value of the
last statement.
<P>
<P>
<P>
<A NAME=dollar>
<TITLE>dollar</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>$</B> _ _ _ <B>DOLLAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The dollar sign is a statement delimiter, indicating results are not to be
printed when used in interactive mode.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x+1)**2$ </TT></PRE><P>The workspace is set to x^2 + 2x + 1
but nothing shows on the screen<P><PRE><TT>
ws;
2
X + 2*X + 1
</TT></PRE><P>
<P>
<P>
Entering a <em>Return</em> 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 <em>$</em> and a <em>Return</em> is
executed, but the results not printed.
<P>
<P>
Inside a
<A HREF=r38_0038.html>group</A> statement <em><<</em>...<em>>></em>
or a <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>, a
semicolon or dollar sign separates individual REDUCE statements. Since
results are not printed from a
<A HREF=r38_0041.html>block</A> without a specific
<A HREF=r38_0058.html>return</A><P>
<P>
statement, there is no difference between using the semicolon or dollar
sign.
<P>
<P>
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 nil, rather than the value of the last statement.
<P>
<P>
<P>
<P>
<A NAME=percent>
<TITLE>percent</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>%</B> _ _ _ <B>PERCENT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The percent sign is used to precede comments; everything from a percent
to the end of the line is ignored.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(x**3 + y,x);% This is a comment key{Return}
2
3*X
int(3*x**2,x) %This is a comment; key{Return}
</TT></PRE><P>A prompt is given, waiting for the semicolon that was not
detected in the comment<P><PRE><TT></TT></PRE><P>
<P>
<P>
Statement delimiters <em>;</em> and <em>$</em> are not detected between a
percent sign and the end of the line.
<P>
<P>
<P>
<A NAME=dot>
<TITLE>dot</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>.</B> _ _ _ <B>DOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The . (dot) infix binary operator adds a new item to the beginning of an
existing
<A HREF=r38_0302.html>list</A>. In high energy physics expressions,
it can also be used
to represent the scalar product of two Lorentz four-vectors.
<P>
<P>
<P> <H3>
syntax: </H3>
<item> <em>.</em> <list>
<P>
<P>
<P>
<item> can be any REDUCE scalar expression, including a list;
<list> must be a
<A HREF=r38_0302.html>list</A> to avoid producing an error message.
The dot operator is right associative.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>
<A NAME=assign>
<TITLE>assign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>:=</B> _ _ _ <B>ASSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>:=</em> is the assignment operator, assigning the value on the right-han
d
side to the identifier or other valid expression on the left-hand side.
<P>
<P>
<P> <H3>
syntax: </H3>
<restricted\_expression> <em>:=</em> <expression>
<P>
<P>
<P>
<restricted\_expression> is ordinarily a single identifier, though simple
expressions may be used (see Comments below). <expression> is any
valid REDUCE expression. If <expression> is a
<A HREF=r38_0345.html>matrix</A>
identifier, then
<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.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := x**2 + 1;
2
A := X + 1
a;
2
X + 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)
</TT></PRE><P>The assignment operator is right associative, as shown in the seco
nd 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.
<P>
<P>
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:
<P>
<P>
_ _ _ (i)
If the left-hand side is an identifier, an operator, or a power, the
substitution rule is added to the rule table.
<P>
<P>
_ _ _ (ii)
If the operators <em>- + /</em> appear on the left-hand side, all but the first
term of the expression is moved to the right-hand side.
<P>
<P>
_ _ _ (iii)
If the operator <em>*</em> appears on the left-hand side, any constant terms are
moved to the right-hand side, but the symbolic factors remain.
<P>
<P>
Assignment is valid for
<A HREF=r38_0188.html>array</A> elements, but not for entire arrays.
The assignment operator can also be used to attach functionality to operators.
<P>
<P>
A recursive construction such as <em>a := a + b</em> is allowed, but when
<em>a</em> 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
<A HREF=r38_0047.html>for</A>... or
<A HREF=r38_0056.html>repeat</A>...<em>until</em>.
<P>
<P>
<P>
<P>
<A NAME=equalsign>
<TITLE>equalsign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>=</B> _ _ _ <B>EQUALSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>=</em> operator is a prefix or infix equality comparison operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>=</em>(<expression><em>,</em><expression>)
or
<expression> <em>=</em> <expression>
<P>
<P>
<P>
<expression> can be any REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>This logical equality operator can only be used inside a condition
al
statement, such as
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>
or
<A HREF=r38_0056.html>repeat</A>...<em>until</em>. In other places the equal
sign establishes an algebraic object of type
<A HREF=r38_0045.html>equation</A>.
<P>
<P>
<P>
<P>
<A NAME=replace>
<TITLE>replace</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>=></B> _ _ _ <B>REPLACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>=></em> operator is a binary operator used in
<A HREF=r38_0060.html>rule</A> lists to
denote replacements.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f;
let f(x) => x^2;
f(x);
2
x
</TT></PRE><P>
<A NAME=plussign>
<TITLE>plussign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>+</B> _ _ _ <B>PLUSSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>+</em> operator is a prefix or infix n-ary addition operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> { <em>+</em><expression>}+
<P>
<P>
or <em>+</em>(<expression> {,<expression>}+)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x**4 + 4*x**2 + 17*x + 1;
4 2
X + 4*X + 17*X + 1
14 + 15 + x;
X + 29
+(1,2,3,4,5);
15
</TT></PRE><P><em>+</em>is also valid as an addition operator for
<A HREF=r38_0345.html>matrix</A> variables
that are of the same dimensions and for
<A HREF=r38_0045.html>equation</A>s.
<P>
<P>
<P>
<A NAME=minussign>
<TITLE>minussign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>-</B> _ _ _ <B>MINUSSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>-</em> operator is a prefix or infix binary subtraction operator, as wel
l
as the unary minus operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>-</em> <expression>
or <em>-</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
15 - 4;
11
x*(-5);
- 5*X
a - b - 15;
A - B - 15
-(a,4);
A - 4
</TT></PRE><P>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
<A HREF=r38_0345.html>matrix</A> expressions of the correct dimensions
and with
<A HREF=r38_0045.html>equation</A>s.
<P>
<P>
<P>
<A NAME=asterisk>
<TITLE>asterisk</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>*</B> _ _ _ <B>ASTERISK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>*</em> operator is a prefix or infix n-ary multiplication operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> { <em>*</em> <expression>}+
<P>
<P>
or <em>*</em>(<expression> {,<expression>}+)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
15*3;
45
24*x*yvalue*2;
48*X*YVALUE
*(6,x);
6*X
on rounded;
3*1.5*x*x*x;
3
4.5*X
off rounded;
2x**2;
2
2*X
</TT></PRE><P>REDUCE assumes you are using an implicit multiplication operator w
hen 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.
<P>
<P>
The multiplication operator is also valid with
<A HREF=r38_0345.html>matrix</A> expressions
of the
proper dimensions: matrices A and B
can be multiplied if
A is n x m and B is
m x p. Matrices and
<A HREF=r38_0045.html>equation</A>s can also be
multiplied by scalars: the
result is as if each element was multiplied by the scalar.
<P>
<P>
<P>
<A NAME=slash>
<TITLE>slash</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>/</B> _ _ _ <B>SLASH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>/</em> operator is a prefix or infix binary division operator or
prefix unary
<A HREF=r38_0101.html>recip</A>rocal operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression><em>/</em><expression> or
<em>/</em><expression>
<P>
<P>
or <em>/</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
20/5;
4
100/6;
50
--
3
16/2/x;
8
-
X
/b;
1
-
B
/(y,5);
Y
-
5
on rounded;
35/4;
8.75
/20;
0.05
</TT></PRE><P>The division operator is left associative, so that <em>a/b/c</em>
is equivalent
to <em>(a/b)/c</em>. The division operator is also valid with square
<A HREF=r38_0345.html>matrix</A> expressions of the same dimensions: With A and
B both n x n matrices and B
invertible, A/B is
given by 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
<em>/</em> is used as a reciprocal operator for a matrix, the inverse of
the matrix is returned if it exists.
<P>
<P>
<P>
<A NAME=power>
<TITLE>power</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>**</B> _ _ _ <B>POWER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>**</em> operator is a prefix or infix binary exponentiation operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>**</em><expression>
or <em>**</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x**15;
15
X
x**y**z;
Y*Z
X
x**(y**z);
Z
Y
X
**(y,4);
4
Y
on rounded;
2**pi;
8.82497782708
</TT></PRE><P>The exponentiation operator is left associative, so that <em>a**b*
*c</em> is
equivalent to <em>(a**b)**c</em>, as shown in the second example. Note
that this is not <em>a**(b**c)</em>, which would be right associative.
<P>
<P>
When
<A HREF=r38_0308.html>nat</A> is on (the default), REDUCE output produces raised
exponents, as shown. The symbol <em>^</em>, which is the upper-case 6 on
most keyboards, may be used in the place of <em>**</em>.
<P>
<P>
A square
<A HREF=r38_0345.html>matrix</A> may also be raised to positive and negative pow
ers
with the exponentiation operator (negative powers require the matrix to be
invertible). Scalar expressions and
<A HREF=r38_0045.html>equation</A>s may be raised to
fractional and floating-point powers.
<P>
<P>
<P>
<A NAME=caret>
<TITLE>caret</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>^</B> _ _ _ <B>CARET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>^</em> operator is a prefix or infix binary exponentiation operator.
It is equivalent to
<A HREF=r38_0031.html>power</A> or **.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>^</em><expression>
or <em>^</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> may be any valid REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x^15;
15
X
x^y^z;
Y*Z
X
x^(y^z);
Z
Y
X
^(y,4);
4
Y
on rounded;
2^pi;
8.82497782708
</TT></PRE><P>The exponentiation operator is left associative, so that <em>a^b^c
</em> is
equivalent to <em>(a^b)^c</em>, as shown in the second example. Note
that this is <not> <em>a^(b^c)</em>, which would be right associative.
<P>
<P>
When
<A HREF=r38_0308.html>nat</A> is on (the default), REDUCE output produces raised
exponents, as shown.
<P>
<P>
A square
<A HREF=r38_0345.html>matrix</A> may also be raised to positive
and negative powers with
the exponentiation operator (negative powers require the matrix to be
invertible). Scalar expressions and
<A HREF=r38_0045.html>equation</A>s
may be raised to fractional and floating-point powers.
<P>
<P>
<P>
<A NAME=geqsign>
<TITLE>geqsign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>>=</B> _ _ _ <B>GEQSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>>=</em> is an infix binary comparison operator, which returns true if
its first argument is greater than or equal to its second argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>>=</em> <expression>
<P>
<P>
<P>
<expression> must evaluate to an integer or floating-point number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if (3 >= 2) then yes;
yes
a := 15;
A := 15
if a >= 20 then big else small;
small
</TT></PRE><P>The binary comparison operators can only be used for comparisons b
etween
numbers or variables that evaluate to numbers. The truth values returned
by such a comparison can only be used inside programming constructs, such
as
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>
or
<A HREF=r38_0056.html>repeat</A>...<em>until</em> or
<A HREF=r38_0228.html>while</A>...<em>do</em>.
<P>
<P>
<P>
<A NAME=greater>
<TITLE>greater</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>></B> _ _ _ <B>GREATER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>></em> is an infix binary comparison operator that returns
true if its first argument is strictly greater than its second.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>></em> <expression>
<P>
<P>
<P>
<expression> must evaluate to a number, e.g., integer, rational or
floating point number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>The binary comparison operators can only be used for comparisons b
etween
numbers or variables that evaluate to numbers. The truth values returned
by such a comparison can only be used inside programming constructs, such
as
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em> or
<A HREF=r38_0056.html>repeat</A>...<em>until</em> or
<A HREF=r38_0228.html>while</A>...<em>do</em>.
<P>
<P>
<P>
<A NAME=leqsign>
<TITLE>leqsign</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B><=</B> _ _ _ <B>LEQSIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em><=</em> is an infix binary comparison operator that returns
true if its first argument is less than or equal to its second argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em><=</em> <expression>
<P>
<P>
<P>
<expression> must evaluate to a number, e.g., integer, rational or
floating point number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 10;
A := 10
if a <= 10 then true;
true
</TT></PRE><P>The binary comparison operators can only be used for comparisons b
etween
numbers or variables that evaluate to numbers. The truth values returned
by such a comparison can only be used inside programming constructs, such
as
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em> or
<A HREF=r38_0056.html>repeat</A>...<em>until</em> or
<A HREF=r38_0228.html>while</A>...<em>do</em>.
<P>
<P>
<P>
<A NAME=less>
<TITLE>less</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B><</B> _ _ _ <B>LESS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em><</em> is an infix binary logical comparison operator that
returns true if its first argument is strictly less than its second
argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em><</em> <expression>
<P>
<P>
<P>
<expression> must evaluate to a number, e.g., integer, rational or
floating point number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
f := -3;
F := -3
if f < -3 then write "yes" else write "no";
no
</TT></PRE><P>The binary comparison operators can only be used for comparisons b
etween
numbers or variables that evaluate to numbers. The truth values returned
by such a comparison can only be used inside programming constructs, such
as
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>
or
<A HREF=r38_0056.html>repeat</A>...<em>until</em> or
<A HREF=r38_0228.html>while</A>...<em>do</em>.
<P>
<P>
<P>
<A NAME=tilde>
<TITLE>tilde</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>~</B> _ _ _ <B>TILDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>~</em> is used as a unary prefix operator in the left-hand
sides of
<A HREF=r38_0060.html>rule</A>s to mark
<A HREF=r38_0061.html>free variable</A>s. A double tilde
marks an optional
<A HREF=r38_0061.html>free variable</A>.
<P>
<P>
<A NAME=group>
<TITLE>group</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B><<</B> _ _ _ <B>GROUP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em><<</em>...<em>>></em> command is a group statement,
used to group statements
together where REDUCE expects a single statement.
<P>
<P>
<P> <H3>
syntax: </H3>
<em><<</em><statement>{; <statement> <em>or</em>
<statement>}* <em>>></em>
<P>
<P>
<P>
<statement> may be any valid REDUCE statement or expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 2;
A := 2
if a < 5 then <<b := a + 10; write b>>;
12
<<d := c/15; f := d + 3; f**2>>;
2
C + 90*C + 202
----------------
225
</TT></PRE><P>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
nil is returned. Group statements are often used in the
consequence portions of
<A HREF=r38_0052.html>if</A>...<em>then</em>,
<A HREF=r38_0056.html>repeat</A>...<em>until</em>, and
<A HREF=r38_0228.html>while</A>...<em>do</em>
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.
<P>
<P>
<P>
<P>
<A NAME=AND>
<TITLE>AND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>and</em> binary logical operator returns true if both of its
arguments are true.
<P>
<P>
<P> <H3>
syntax: </H3>
<logical\_expression> <em>and</em> <logical\_expression>
<P>
<P>
<P>
<logical\_expression> must evaluate to true or nil.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>Logical operators can only be used inside conditional statements,
such as
<A HREF=r38_0228.html>while</A>...<em>do</em> or
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>. <em>and</em> exami
nes each of
its arguments in order, and quits, returning nil, on finding an
argument that is not true. An error results if it is used in other
contexts.
<P>
<P>
<em>and</em>is left associative: <em>x and y and z</em> is equivalent to
<em>(x and y) and z</em>.
<P>
<P>
<P>
<A NAME=BEGIN>
<TITLE>BEGIN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BEGIN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<em>begin</em> is used to start a
<A HREF=r38_0041.html>block</A> statement, which is closed with
<em>end</em>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>begin</em><statement>{<em>;</em> <statement>}* <em>end</em>
<P>
<P>
<P>
<statement> is any valid REDUCE statement.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
begin for i := 1:3 do write i end;
1
2
3
begin scalar n;n:=1;b:=for i:=1:4 product(x-i);return n end;
1
b;
4 3 2
X - 10*X + 35*X - 50*X + 24
</TT></PRE><P>A <em>begin</em>...<em>end</em> block can do actions (such as <em>
write</em>), but
does not
return a value unless instructed to by a
<A HREF=r38_0058.html>return</A> statement, which must
be the last statement executed in the block. It is unnecessary to insert
a semicolon before the <em>end</em>.
<P>
<P>
Local variables, if any, are declared in the first statement immediately
after <em>begin</em>, and may be defined as <em>scalar, integer,</em> or
<em>real</em>.
<A HREF=r38_0188.html>array</A> variables declared
within a <em>begin</em>...<em>end</em> block
are global in every case, and
<A HREF=r38_0199.html>let</A> statements have global
effects. A
<A HREF=r38_0199.html>let</A> statement involving a formal parameter affects
the calling parameter that corresponds to it.
<A HREF=r38_0199.html>let</A> 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.
<P>
<P>
<P>
<P>
<A NAME=block>
<TITLE>block</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BLOCK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
A <em>block</em> is a sequence of statements enclosed by
commands
<A HREF=r38_0040.html>begin</A> and
<A HREF=r38_0044.html>end</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>begin</em><statement>{<em>;</em> <statement>}* <em>end</em>
<P>
<P>
<P>
For more details see
<A HREF=r38_0040.html>begin</A>.
<P>
<P>
<A NAME=COMMENT>
<TITLE>COMMENT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMMENT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
Beginning with the word <em>comment</em>, all text until the next statement
terminator (<em>;</em> or <em>$</em>) is ignored.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x := a**2 comment--a is the velocity of the particle;;
2
X := A
</TT></PRE><P>Note that the first semicolon ends the comment and the second one
terminates the original REDUCE statement.
<P>
<P>
Multiple-line comments are often needed in interactive files. The
<em>comment</em> command allows a normal-looking text to accompany the
REDUCE statements in the file.
<P>
<P>
<P>
<A NAME=CONS>
<TITLE>CONS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>cons</em> operator adds a new element to the beginning of a
<A HREF=r38_0302.html>list</A>. Its
operation is identical to the symbol
<A HREF=r38_0023.html>dot</A> (dot). It can be used
infix or prefix.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cons</em>(<item>,<list>) or <item> <em>cons</em> <list
>
<P>
<P>
<P>
<item> can be any REDUCE scalar expression, including a list; <list>
must be a list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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)
</TT></PRE><P>If you want to use <em>cons</em> to put together two elements into
a new list,
you must make the second one into a list with curly brackets or the <em>list
</em>
command. You can also start with an empty list created by <em>{}</em>.
<P>
<P>
The <em>cons</em> operator is right associative: <em>a cons b cons c</em> is val
id
if <em>c</em> is a list; <em>b</em> need not be a list. The list produced is
<em>{a,b,c}</em>.
<P>
<P>
<P>
<P>
<A NAME=END>
<TITLE>END</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>END</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The command <em>end</em> has two main uses:
<P>
<P>
_ _ _ (i)
as the ending of a
<A HREF=r38_0040.html>begin</A>...<em>end</em>
<A HREF=r38_0041.html>block</A>; and
<P>
_ _ _ (ii)
to end input from a file.
<P>
<P>
In a <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>, there need not be a delimiter
(<em>;</em> or <em>$</em>) before the <em>end</em>, though there must be one
after it, or a right bracket matching an earlier left bracket.
<P>
<P>
Files to be read into REDUCE should end with <em>end;</em>, 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 <em>n</em> to a <em>pause</em>
command, you are still, technically speaking, ``in" the file. Use
<em>end</em> to exit the file.
<P>
<P>
An <em>end</em> at the top level of a program is ignored.
<P>
<P>
<P>
<A NAME=EQUATION>
<TITLE>EQUATION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EQUATION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
<P>
<P>
An <em>equation</em> is an expression where two algebraic expressions
are connected by the (infix) operator
<A HREF=r38_0110.html>equal</A> or by <em>=</em>.
For access to the components of an <em>equation</em> the operators
<A HREF=r38_0158.html>lhs</A>,
<A HREF=r38_0175.html>rhs</A> or
<A HREF=r38_0169.html>part</A> can be used. The
evaluation of the left-hand side of an <em>equation</em> is controlled
by the switch
<A HREF=r38_0283.html>evallhseqp</A>, while the right-hand side is
evaluated unconditionally. When an <em>equation</em> is part of a
logical expression, e.g. in a
<A HREF=r38_0052.html>if</A> or
<A HREF=r38_0228.html>while</A> statement,
the equation is evaluated by subtracting both sides can comparing
the result with zero.
<P>
<P>
Equations occur in many contexts, e.g. as arguments of the
<A HREF=r38_0182.html>sub</A>
operator and in the arguments and the results
of the operator
<A HREF=r38_0179.html>solve</A>. An equation can be member of a
<A HREF=r38_0302.html>list</A>
and you may assign an equation to a variable. Elementary arithmetic is supported
for equations: if
<A HREF=r38_0283.html>evallhseqp</A> 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.
<P> <H3>
examples: </H3>
<P><PRE><TT>
on evallhseqp;
u:=x+y=1$
v:=2x-y=0$
2*u-v;
- 3*y=-2
ws/3;
2
y=--
3
</TT></PRE><P><P>
<P>
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
<A HREF=r38_0163.html>map</A> operator.
<P>
<P>
<A NAME=FIRST>
<TITLE>FIRST</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FIRST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>first</em> operator returns the first element of a
<A HREF=r38_0302.html>list</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>first</em>(<list>) or <em>first</em> <list>
<P>
<P>
<P>
<list> must be a non-empty list to avoid an error message.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>
<A NAME=FOR>
<TITLE>FOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>for</em> command is used for iterative loops. There are many
possible forms it can take.
<P>
<P>
<P><PRE><TT>
/
/ |STEP <number> UNTIL|
|<var>:=<number>| |<number>|
FOR| | : | |<action> <exprn>
| / |
|EACH <var> IN <list> |
/
where <action> ::= DO|PRODUCT|SUM|COLLECT|JOIN.
</TT></PRE><P><var> can be any valid REDUCE identifier except <em>t</em> o
r
<em>nil</em>, <inc>, <start> and <stop> can be any expression
that evaluates to a positive or negative integer. <list> must be a
valid
<A HREF=r38_0302.html>list</A> 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
<A HREF=r38_0038.html>group</A> (<em><<</em>...<em>>></em>) or
<A HREF=r38_0041.html>block</A>
(
<A HREF=r38_0040.html>begin</A>...
<A HREF=r38_0044.html>end</A>) statement.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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;
2 2 2
Q + R + S
for i := 1:4 collect 1/i;
1 1 1
{1,-,-,-}
2 3 4
for i := 1:3 join list solve(x**2 + i*x + 1,x);
SQRT(3)*I + 1
{{X= --------------,
2
SQRT(3)*I - 1
X= --------------}
2
{X=-1},
SQRT(5) + 3 SQRT(5) - 3
{X= - -----------,X=-----------}}
2 2
</TT></PRE><P>The behavior of each of the five action words follows:
<P>
<P>
<P><PRE><TT>
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
</TT></PRE><P>For number-driven <em>for</em> 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
<em>for</em> statement, and does not affect the value of an identifier with
the same name. For list-driven <em>for</em> statements, if the list is
empty, the action statement is not executed, but no error occurs.
<P>
<P>
You can use nested <em>for</em> statements, with the inner <em>for</em>
statement after the action keyword. You must make sure that your inner
statement returns an expression that the outer statement can handle.
<P>
<P>
<P>
<A NAME=FOREACH>
<TITLE>FOREACH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FOREACH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
<em>foreach</em>is a synonym for the <em>for each</em> variant of the
<A HREF=r38_0047.html>for</A> construct. It is designed to iterate down a list,
and an
error will occur if a list is not used. The use of <em>for each</em> is
preferred to <em>foreach</em>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>foreach</em><variable> in <list> <action> <expression
>
<P>
<P>
where <action> ::= <em>do | product | sum | collect | join</em>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
foreach x in {q,r,s} sum x**2;
2 2 2
Q + R + S
</TT></PRE><P>
<A NAME=GEQ>
<TITLE>GEQ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GEQ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>geq</em> 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 <em>>=</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>geq</em>(<expression>,<expression>) or <expression>
<em>geq</em> <expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE expression that evaluates to a
number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em> or
<A HREF=r38_0056.html>repeat</A>...<em>until</em>.
<P>
<P>
<P>
<A NAME=GOTO>
<TITLE>GOTO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GOTO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
Inside a <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>, <em>goto</em>, or
preferably, <em>go to</em>, transfers flow of control to a labeled statement.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>go to</em><labeled_statement> or <em>goto</em> <labeled_statement
>
<P>
<P>
<P>
<labeled_statement> is of the form <label> <em>:</em><statement
>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
procedure dumb(a);
begin scalar q;
go to lab;
q := df(a**2 - sin(a),a);
write q;
lab: return a
end;
DUMB
dumb(17);
17
</TT></PRE><P><em>go to</em>can only be used inside a <em>begin</em>...<em>end
</em>
<A HREF=r38_0041.html>block</A>, and inside
the block only statements at the top level can be labeled, not ones inside
<em><<</em>...<em>>></em>,
<A HREF=r38_0228.html>while</A>...<em>do</em>, etc.
<P>
<P>
<P>
<A NAME=GREATERP>
<TITLE>GREATERP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GREATERP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>greaterp</em> logical operator returns true if its first argument is
strictly greater than its second argument. As an infix operator it is
identical with <em>></em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>greaterp</em>(<expression>,<expression>) or <expression>
<em>greaterp</em> <expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE expression that evaluates to a
number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>
or
<A HREF=r38_0056.html>repeat</A>...
<A HREF=r38_0228.html>while</A>.
<P>
<P>
<P>
<A NAME=IF>
<TITLE>IF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>if</em> command is a conditional statement that executes a statement
if a condition is true, and optionally another statement if it is not.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>if</em><condition> <em>then</em> <statement>
_ _ _ option(<em>else</em> <statement>)
<P>
<P>
<P>
<condition> must be a logical or comparison operator that evaluates to
a
<A HREF=r38_0109.html>boolean value</A>.
<statement> must be a single REDUCE statement or a
<A HREF=r38_0038.html>group</A> (<em><<</em>...<em>>></em>) or
<A HREF=r38_0041.html>block</A> (<em>begin</em>...<em>end</em>) statement.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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);
2
BB := U
</TT></PRE><P>An <em>if</em> statement may be used inside an assignment statemen
t 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
<em>else</em> clause, the value is 0 if a number is expected, and nothing
otherwise.
<P>
<P>
The <em>else</em> clause may be left out if no action is to be taken if the
condition is false.
<P>
<P>
The condition may be a compound conditional statement using
<A HREF=r38_0039.html>and</A> or
<A HREF=r38_0054.html>or</A>. If a non-conditional statement, such as a constant
, is used by
accident, it is assumed to have value true.
<P>
<P>
Be sure to use
<A HREF=r38_0038.html>group</A> or
<A HREF=r38_0041.html>block</A> statements after
<em>then</em> or <em>else</em>.
<P>
<P>
The <em>if</em> operator is right associative. The following constructions are
examples:
<P>
<P>
_ _ _ (1)
<P> <H3>
syntax: </H3>
<P>
<P>
<em>if</em><condition> <em>then</em> <em>if</em> <condition> <em>the
n</em>
<action> <em>else</em> <action>
<P>
<P>
<P>
which is equivalent to
<P> <H3>
syntax: </H3>
<P>
<P>
<em>if</em><condition> <em>then</em> (<em>if</em> <condition>
<em>then</em> <action> <em>else</em> <action>);
<P>
<P>
<P>
_ _ _ (2)
<P> <H3>
syntax: </H3>
<P>
<P>
<em>if</em><condition> <em>then</em> <action> <em>else if</em>
<condition> <em>then</em> <action> <em>else</em> <action>
<P>
<P>
<P>
which is equivalent to
<P> <H3>
syntax: </H3>
<P>
<P>
<em>if</em><condition> <em>then</em> <action> <em>else</em>
<P>
<P>
(<em>if</em> <condition> <em>then</em> <action>
<em>else</em> <action>).
<P>
<P>
<P>
<P>
<P>
<P>
<A NAME=LIST>
<TITLE>LIST</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LIST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>list</em> operator constructs a list from its arguments.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>list</em>(<item> {,<item>}*) or
<em>list</em>() to construct an empty list.
<P>
<P>
<P>
<item> can be any REDUCE scalar expression, including another list.
Left and right curly brackets can also be used instead of the operator
<em>list</em> to construct a list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
liss := list(c,b,c,{xx,yy},3x**2+7x+3,df(sin(2*x),x));
2
LISS := {C,B,C,{XX,YY},3*X + 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)};
2
LISS := {C,B,C,{XX,YY},3*X + 7*X + 3,2*COS(2*X)}
emptylis := list();
EMPTYLIS := {}
a . emptylis;
{A}
</TT></PRE><P>Lists are ordered, hierarchical structures. The elements stay wher
e 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
<A HREF=r38_0169.html>part</A> operator can be used to access elements anywhere
within a list
hierarchy. The
<A HREF=r38_0157.html>length</A> operator counts the
number of top-level elements
of its list argument; elements that are themselves lists still only
count as one element.
<P>
<P>
<P>
<A NAME=OR>
<TITLE>OR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>or</em> binary logical operator returns true if either one or
both of its arguments is true.
<P> <H3>
syntax: </H3>
<P>
<P>
<logical expression> <em>or</em> <logical expression>
<P>
<P>
<P>
<logical expression> must evaluate to true or nil.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 10;
A := 10
if a<0 or a>140 then write "not a valid human age" else
write "age = ",a;
age = 10
a := 200;
A := 200
if a < 0 or a > 140 then write "not a valid human age";
not a valid human age
</TT></PRE><P>The <em>or</em> operator is left associative: <em>x or y or z</em>
is equivalent to
<em>(x or y)</em> <em>or z</em>.
<P>
<P>
Logical operators can only be used in conditional expressions, such as
<P>
<P>
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em>
and
<A HREF=r38_0228.html>while</A>...<em>do</em>.
<em>or</em> evaluates its arguments in order and quits, returning true,
on finding the first true statement.
<P>
<P>
<P>
<A NAME=PROCEDURE>
<TITLE>PROCEDURE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PROCEDURE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>procedure</em> command allows you to define a mathematical operation as
a
function with arguments.
<P> <H3>
syntax: </H3>
<P>
<P>
_ _ _ <option> <em>procedure</em> <identifier>
(<arg>{,<arg>}+)<em>;</em><body>
<P>
<P>
<P>
The <option> may be
<A HREF=r38_0186.html>algebraic</A> or
<A HREF=r38_0221.html>symbolic</A>,
indicating the
mode under which the procedure is executed, or
<A HREF=r38_0216.html>real</A> or
<A HREF=r38_0197.html>integer</A>, indicating the type of answer expected. The d
efault 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). <identifier>
may be any valid REDUCE identifier that is not already a procedure name,
operator,
<A HREF=r38_0188.html>array</A> or
<A HREF=r38_0345.html>matrix</A>.
<arg> is a formal parameter that may be any
valid REDUCE identifier. <body> is a single statement (a
<A HREF=r38_0038.html>group</A>
or
<A HREF=r38_0041.html>block</A> statement may be used) with the desired activiti
es in it.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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;
FAC
fac(0);
1
fac(5);
120
fac(-5);
***** choose nonneg. integer only
</TT></PRE><P>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
<A HREF=r38_0199.html>let</A> statements, new definitions
under the same procedure name replace the previous definitions completely.
<P>
<P>
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.
<P>
<P>
Procedures may have none, one, or more than one parameter. A REDUCE
parameter is a formal parameter only; the use of x as a parameter in
a <em>procedure</em> definition has no connection with a value of x in
the REDUCE session, and the results of calling a procedure have no effect
on the value of x. If a procedure is called with x as a
parameter, the current value of x is used as specified in the
computation, but is not changed outside the procedure.
Making an assignment statement by <em>:=</em> with a
formal parameter on the left-hand side only changes the value of the
calling parameter within the procedure.
<P>
<P>
Using a
<A HREF=r38_0199.html>let</A> statement inside a procedure always changes the va
lue
globally: a <em>let</em> with a formal parameter makes the change to the calling
parameter. <em>let</em> statements cannot be made on local variables inside
<A HREF=r38_0040.html>begin</A>...<em>end</em>
<A HREF=r38_0041.html>block</A><em>s</em>.
When
<A HREF=r38_0189.html>clear</A> statements are used on formal
parameters, the calling variables associated with them are cleared globally too.
The use of <em>let</em> or <em>clear</em> statements inside procedures
should be done with extreme caution.
<P>
<P>
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 not be used as arguments to procedures.
<P>
<P>
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
<A HREF=r38_0199.html>let</A> statement on
the name of the procedure (i.e., <em>let noargs = noargs()</em>) after which
you can call the procedure by just its name.
<P>
<P>
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.
<P>
<P>
Procedures often have a <em>begin</em>...<em>end</em> block in them. Inside the
block, local variables are declared using <em>scalar</em>, <em>real</em> or
<em>integer</em> declarations.
The declarations must be made immediately after the word
<em>begin</em>, and if more than one type of declaration is made, they are
separated by semicolons. REDUCE currently does no type checking on local
variables; <em>real</em> and <em>integer</em> are treated just like <em>scalar
</em>.
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.
<P>
<P>
If a return value is desired from a procedure call, a specific
<A HREF=r38_0058.html>return</A> command must be the last statement executed bef
ore exiting
from the procedure. If no <em>return</em> is used, a procedure returns a
zero or no value.
<P>
<P>
Procedures are often written in a file using an editor, then the file
is input using the command
<A HREF=r38_0231.html>in</A>. 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.
<P>
<P>
<P>
<A NAME=REPEAT>
<TITLE>REPEAT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REPEAT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The
<A HREF=r38_0056.html>repeat</A> command causes repeated execution of a statemen
t
<em>until</em><P>
<P>
the given condition is found to be true. The statement is always executed
at least once.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>repeat</em><statement> <em>until</em> <condition>
<P>
<P>
<P>
<statement> can be a single statement,
<A HREF=r38_0038.html>group</A> statement, or
a <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>. <condition> must be
a logical operator that evaluates to true or nil.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
<<m := 4; repeat <<write 100*x*m;m := m-1>> until m = 0>
>;
400*X
300*X
200*X
100*X
<<m := -1; repeat <<write m; m := m-1>> until m <= 0>
>;
-1
</TT></PRE><P><em>repeat</em>must always be followed by an <em>until</em> 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 <em>m = 0</em>, it
would never have been true since <em>m</em> already had value -2 when the
condition was first evaluated.
<P>
<P>
<P>
<A NAME=REST>
<TITLE>REST</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>rest</em> operator returns a
<A HREF=r38_0053.html>list</A> containing all but the first
element of the list it is given.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>rest</em>(<list>) or <em>rest</em> <list>
<P>
<P>
<P>
<P>
<list> must be a non-empty list, but need not have more than one element.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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;
{}
</TT></PRE><P>
<A NAME=RETURN>
<TITLE>RETURN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RETURN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>return</em> command causes a value to be returned from inside a
<em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>begin</em><statements> <em>return</em> <(expression)>
<em>end</em><P>
<P>
<P>
<P>
<statements> can be any valid REDUCE statements. The value of
<expression> is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
begin write "yes"; return a end;
yes
A
procedure dumb(a);
begin if numberp(a) then return a else return 10 end;
DUMB
dumb(x);
10
dumb(-5);
-5
procedure dumb2(a);
begin c := a**2 + 2*a + 1; d := 17; c*d; return end;
DUMB2
dumb2(4);
c;
25
d;
17
</TT></PRE><P>Note in <em>dumb2</em> above that the assignments were made as req
uested, but
the product <em>c*d</em> cannot be accessed. Changing the procedure to read
<em>return c*d</em> would remedy this problem.
<P>
<P>
The <em>return</em> statement is always the last statement executed before
leaving the block. If <em>return</em> has no argument, the block is exited but
no value is returned. A block statement does not need a <em>return</em> ;
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.
<P>
<P>
The <em>return</em> command can be used inside <em><<</em>...<em>>>
</em>
<A HREF=r38_0038.html>group</A> statements and
<A HREF=r38_0052.html>if</A>...<em>then</em>...<em>else</em> commands that
are inside <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>s.
It is not valid in these constructions that are not inside
a <em>begin</em>...<em>end</em>
block. It is not valid inside
<A HREF=r38_0047.html>for</A>,
<A HREF=r38_0056.html>repeat</A>...<em>until</em> or
<A HREF=r38_0228.html>while</A>...<em>do</em>
loops in any construction. To force early termination from loops, the
<em>go to</em>(
<A HREF=r38_0050.html>goto</A>) command must be used.
When you use nested block statements, a
<em>return</em> from an inner block exits returning a value to the next-outermos
t
block, rather than all the way to the outside.
<P>
<P>
<P>
<A NAME=REVERSE>
<TITLE>REVERSE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REVERSE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>reverse</em> operator returns a
<A HREF=r38_0053.html>list</A> that is the reverse of the
list it is given.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>reverse</em>(<list>) or <em>reverse</em> <list>
<P>
<P>
<P>
<list> must be a
<A HREF=r38_0053.html>list</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
aa := {c,b,a,{x**2,z**3},y};
2 3
AA := {C,B,A,{X ,Z },Y}
reverse aa;
2 3
{Y,{X ,Z },A,B,C}
reverse(q . reverse aa);
2 3
{C,B,A,{X ,Z },Y,Q}
</TT></PRE><P><em>reverse</em>and
<A HREF=r38_0043.html>cons</A> can be used together to add a new element to
the end of a list (<em>.</em> adds its new element to the beginning). The
<em>reverse</em> 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.
<P>
<P>
<P>
<A NAME=RULE>
<TITLE>RULE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RULE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
<P>
<P>
A <em>rule</em> is an instruction to replace an algebraic expression
or a part of an expression by another one.
<P> <H3>
syntax: </H3>
<P>
<P>
<lhs> => <rhs> or
<lhs> => <rhs> <em>when</em> <cond>
<P>
<P>
<P>
<lhs> is an algebraic expression used as search pattern and
<rhs> is an algebraic expression which replaces matches of
<rhs>. <em>=></em> is the operator
<A HREF=r38_0026.html>replace</A>.
<P>
<P>
<lhs> can contain
<A HREF=r38_0061.html>free variable</A>s which are
symbols preceded by a tilde <em>~</em> in their leftmost position
in <lhs>.
A double tilde marks an
<A HREF=r38_0062.html>optional free variable</A>.
If a rule has a <em>when</em> <cond>
part it will fire only if the evaluation of <cond> has a
result
<A HREF=r38_0122.html>true</A>. <cond> may contain references to
free variables of <lhs>.
<P>
<P>
Rules can be collected in a
<A HREF=r38_0053.html>list</A> which then forms a
<em>rule list</em>. <em>Rule lists</em> can be used to collect
algebraic knowledge for a specific evaluation context.
<P>
<P>
<em>Rules</em>and <em>rule lists</em> are globally activated and
deactivated by
<A HREF=r38_0199.html>let</A>,
<A HREF=r38_0195.html>forall</A>,
<A HREF=r38_0190.html>clearrules</A>.
For a single evaluation they can be locally activate by
<A HREF=r38_0227.html>where</A>.
The active rules for an operator can be visualized by
<A HREF=r38_0178.html>showrules</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f,g,h;
let f(x) => x^2;
f(x);
2
x
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)
</TT></PRE><P>
<A NAME=Free_Variable>
<TITLE>Free_Variable</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FREE VARIABLE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
<P>
<P>
A variable preceded by a tilde is considered as <em>free variable</em>
and stands for an arbitrary part in an algebraic form during
pattern matching. Free variables occur in the left-hand sides
of
<A HREF=r38_0060.html>rule</A>s, in the side relations for
<A HREF=r38_0642.html>compact</A>
and in the first arguments of
<A HREF=r38_0163.html>map</A> and
<A HREF=r38_0177.html>select</A>
calls. See
<A HREF=r38_0060.html>rule</A> for examples.
<P>
<P>
In rules also
<A HREF=r38_0062.html>optional free variable</A>s may occur.
<P>
<P>
<A NAME=Optional_Free_Variable>
<TITLE>Optional_Free_Variable</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OPTIONAL FREE VARIABLE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
<P>
<P>
A variable preceded by a double tilde is considered as
<em>optional free variable</em><P>
<P>
and stands for an arbitrary part part in an algebraic form during
pattern matching. In contrast to ordinary
<A HREF=r38_0061.html>free variable</A>s
an operator pattern with an <em>optional free variable</em>
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
<P>
<P>
term in a sum: set to 0 if missing,
<P>
<P>
factor in a product: set to 1 if missing,
<P>
<P>
exponent: set to 1 if missing
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>Optional free variables are allowed only in the left-h
and sides
of
<A HREF=r38_0060.html>rule</A>s.
<P>
<P>
<A NAME=SECOND>
<TITLE>SECOND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SECOND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>second</em> operator returns the second element of a list.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>second</em>(<list>) or <em>second</em> <list>
<P>
<P>
<P>
<P>
<list> must be a list with at least two elements, to avoid an error
message.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>
<A NAME=SET>
<TITLE>SET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>set</em> operator is used for assignments when you want both sides of
the assignment statement to be evaluated.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>set</em>(<restricted\_expression>,<expression>)
<P>
<P>
<P>
<expression> can be any REDUCE expression; <restricted\_expression>
must be an identifier or an expression that evaluates to an identifier.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := y;
A := Y
set(a,sin(x^2));
2
SIN(X )
a;
2
SIN(X )
y;
2
SIN(X )
a := b + c;
A := B + C
set(a-c,z);
Z
b;
Z
</TT></PRE><P>Using an
<A HREF=r38_0188.html>array</A> or
<A HREF=r38_0345.html>matrix</A> reference as the first
argument to <em>set</em> has
the result of setting the contents of the designated element to
<em>set</em>'s second argument. You should be careful to avoid unwanted
side effects when you use this facility.
<P>
<P>
<P>
<A NAME=SETQ>
<TITLE>SETQ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SETQ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>setq</em> operator is an infix or prefix binary assignment operator.
It is identical to <em>:=</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>setq</em>(<restricted\_expression>,<expression>) or
<P>
<P>
<restricted\_expression> <em>setq</em> <expression>
<P>
<P>
<P>
<restricted expression> is ordinarily a single identifier, though
simple expressions may be used (see Comments below). <expression> can
be any valid REDUCE expression. If <expression> is a
<A HREF=r38_0345.html>matrix</A>
identifier, then <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.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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)
</TT></PRE><P>Embedding a <em>setq</em> statement in an expression has the side
effect of making
the assignment, as shown in the third example above.
<P>
<P>
Assignments are generally done for identifiers, but may be done for simple
expressions as well, subject to the following remarks:
<P>
<P>
_ _ _ (i)
If the left-hand side is an identifier, an operator, or a power, the rule
is added to the rule table.
<P>
<P>
_ _ _ (ii)
If the operators <em>- + /</em> appear on the left-hand side, all but the first
term of the expression is moved to the right-hand side.
<P>
<P>
_ _ _ (iii)
If the operator <em>*</em> appears on the left-hand side, any constant terms are
moved to the right-hand side, but the symbolic factors remain.
<P>
<P>
Be careful not to make a recursive <em>setq</em> assignment that is not
controlled inside a loop statement. The process of resubstitution
continues until you get a stack overflow message. <em>setq</em> can be used
to attach functionality to operators, as the <em>:=</em> does.
<P>
<P>
<P>
<A NAME=THIRD>
<TITLE>THIRD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>THIRD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>third</em> operator returns the third item of a
<A HREF=r38_0053.html>list</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>third</em>(<list>) or <em>third</em> <list>
<P>
<P>
<P>
<P>
<list> must be a list containing at least three items to avoid an error
message.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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
</TT></PRE><P>
<A NAME=WHEN>
<TITLE>WHEN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WHEN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>when</em> operator is used inside a <em>rule</em> to make the
execution of the rule depend on a boolean condition which is
evaluated at execution time. For the use see
<A HREF=r38_0060.html>rule</A>.
<P>
<P>
<A NAME=g4>
<TITLE>Syntax</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Syntax</B><MENU>
<LI><A HREF=r38_0020.html>semicolon command</A>alias= (;)<P>
<LI><A HREF=r38_0021.html>dollar command</A>alias= ($)<P>
<LI><A HREF=r38_0022.html>percent command</A>alias= (%)<P>
<LI><A HREF=r38_0023.html>dot operator</A>alias= (.)<P>
<LI><A HREF=r38_0065.html>assign operator</A>alias= (: =)<P>
<LI><A HREF=r38_0025.html>equalsign operator</A>alias= (=)<P>
<LI><A HREF=r38_0026.html>replace operator</A>alias= (= >)<P>
<LI><A HREF=r38_0027.html>plussign operator</A>alias= (+)<P>
<LI><A HREF=r38_0028.html>minussign operator</A>alias= (-)<P>
<LI><A HREF=r38_0029.html>asterisk operator</A>alias= (*)<P>
<LI><A HREF=r38_0030.html>slash operator</A>alias= (/)<P>
<LI><A HREF=r38_0031.html>power operator</A>alias= (* *)<P>
<LI><A HREF=r38_0032.html>caret operator</A>alias= (^)<P>
<LI><A HREF=r38_0033.html>geqsign operator</A>alias= (> =)<P>
<LI><A HREF=r38_0034.html>greater operator</A>alias= (>)<P>
<LI><A HREF=r38_0035.html>leqsign operator</A>alias= (< =)<P>
<LI><A HREF=r38_0036.html>less operator</A>alias= (<)<P>
<LI><A HREF=r38_0037.html>tilde operator</A>alias= (~)<P>
<LI><A HREF=r38_0038.html>group command</A>alias= (< <)<P>
<LI><A HREF=r38_0039.html>AND operator</A><P>
<LI><A HREF=r38_0040.html>BEGIN command</A><P>
<LI><A HREF=r38_0041.html>block command</A><P>
<LI><A HREF=r38_0042.html>COMMENT command</A><P>
<LI><A HREF=r38_0043.html>CONS operator</A><P>
<LI><A HREF=r38_0044.html>END command</A><P>
<LI><A HREF=r38_0045.html>EQUATION type</A><P>
<LI><A HREF=r38_0046.html>FIRST operator</A><P>
<LI><A HREF=r38_0047.html>FOR command</A><P>
<LI><A HREF=r38_0048.html>FOREACH command</A><P>
<LI><A HREF=r38_0049.html>GEQ operator</A><P>
<LI><A HREF=r38_0050.html>GOTO command</A><P>
<LI><A HREF=r38_0051.html>GREATERP operator</A><P>
<LI><A HREF=r38_0052.html>IF command</A><P>
<LI><A HREF=r38_0053.html>LIST operator</A><P>
<LI><A HREF=r38_0054.html>OR operator</A><P>
<LI><A HREF=r38_0055.html>PROCEDURE command</A><P>
<LI><A HREF=r38_0056.html>REPEAT command</A><P>
<LI><A HREF=r38_0057.html>REST operator</A><P>
<LI><A HREF=r38_0058.html>RETURN command</A><P>
<LI><A HREF=r38_0059.html>REVERSE operator</A><P>
<LI><A HREF=r38_0060.html>RULE type</A><P>
<LI><A HREF=r38_0061.html>Free Variable type</A><P>
<LI><A HREF=r38_0062.html>Optional Free Variable type</A><P>
<LI><A HREF=r38_0063.html>SECOND operator</A><P>
<LI><A HREF=r38_0064.html>SET operator</A><P>
<LI><A HREF=r38_0065.html>SETQ operator</A><P>
<LI><A HREF=r38_0066.html>THIRD operator</A><P>
<LI><A HREF=r38_0067.html>WHEN operator</A><P>
</MENU>
<A NAME=ARITHMETIC_OPERATIONS>
<TITLE>ARITHMETIC_OPERATIONS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARITHMETIC\_OPERATIONS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
This section considers operations defined in REDUCE that concern numbers,
or operators that can operate on numbers in addition, in most cases, to
more general expressions.
<P>
<P>
<A NAME=ABS>
<TITLE>ABS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ABS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>abs</em> operator returns the absolute value of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>abs</em>(<expression>)
<P>
<P>
<P>
<expression> can be any REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
abs(-a);
ABS(A)
abs(-5);
5
a := -10;
A := -10
abs(a);
10
abs(-a);
10
</TT></PRE><P>If the argument has had no numeric value assigned to it, such as a
n
identifier or polynomial, <em>abs</em> returns an expression involving
<em>abs</em> of its argument, doing as much simplification of the argument
as it can, such as dropping any preceding minus sign.
<P>
<P>
<P>
<A NAME=ADJPREC>
<TITLE>ADJPREC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ADJPREC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When a real number is input, it is normally truncated to the
<A HREF=r38_0214.html>precision</A> in
effect at the time the number is read. If it is desired to keep the full
precision of all numbers input, the switch <em>adjprec</em>
(for <adjust precision>) can be turned on. While on, <em>adjprec</em>
will automatically increase the precision, when necessary, to match that
of any integer or real input, and a message printed to inform the user of
the precision increase.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1.23456789012345;
1.23456789012
on adjprec;
1.23456789012345;
*** precision increased to 15
</TT></PRE><P>
<A NAME=ARG>
<TITLE>ARG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
If
<A HREF=r38_0274.html>complex</A> and
<A HREF=r38_0330.html>rounded</A> are on, and arg
evaluates to a complex number, <em>arg</em> returns the polar angle of
arg, measured in radians. Otherwise an expression in arg is
returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
arg(3+4i)
ARG(3 + 4*I)
on rounded, complex;
ws;
0.927295218002
arg a;
ARG(A)
</TT></PRE><P>
<A NAME=CEILING>
<TITLE>CEILING</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CEILING</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ceiling</em>(<expression>)
<P>
<P>
<P>
This operator returns the ceiling (i.e., the least integer greater than or
equal to its argument) if its argument has a numerical value. For
negative numbers, this is equivalent to
<A HREF=r38_0082.html>fix</A>. For non-numeric
arguments, the value is an expression in the original operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ceiling 3.4;
4
fix 3.4;
3
ceiling(-5.2);
-5
fix(-5.2);
-5
ceiling a;
CEILING(A)
</TT></PRE><P>
<A NAME=CHOOSE>
<TITLE>CHOOSE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHOOSE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>choose</em>(<m>,<m>) returns the number of ways of choosing
<m> objects from a collection of <n> distinct objects --- in other
words the binomial coefficient. If <m> and <n> are not positive
integers, or m >n, the expression is returned unchanged.
than or equal to
<P> <H3>
examples: </H3>
<P><PRE><TT>
choose(2,3);
3
choose(3,2);
CHOOSE(3,2)
choose(a,b);
CHOOSE(A,B)
</TT></PRE><P><P>
<P>
<A NAME=DEG2DMS>
<TITLE>DEG2DMS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEG2DMS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>deg2dms</em>(<expression>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <expression> is a real number,
the
operator <em>deg2dms</em> will interpret it as degrees, and convert it to a
list containing the equivalent degrees, minutes and seconds. In all other
cases, an expression in terms of the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
deg2dms 60;
DEG2DMS(60)
on rounded;
ws;
{60,0,0}
deg2dms 42.4;
{42,23,60.0}
deg2dms a;
DEG2DMS(A)
</TT></PRE><P>
<A NAME=DEG2RAD>
<TITLE>DEG2RAD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEG2RAD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>deg2rad</em>(<expression>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <expression> is a real number,
the
operator <em>deg2rad</em> will interpret it as degrees, and convert it to
the equivalent radians. In all other cases, an expression in terms of the
original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
deg2rad 60;
DEG2RAD(60)
on rounded;
ws;
1.0471975512
deg2rad a;
DEG2RAD(A)
</TT></PRE><P>
<A NAME=DIFFERENCE>
<TITLE>DIFFERENCE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DIFFERENCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>difference</em> operator may be used as either an infix or prefix binary
subtraction operator. It is identical to <em>-</em> as a binary operator.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>difference</em>(<expression>,<expression>) or
<P>
<P>
<expression> <em>difference</em> <expression>
{<em>difference</em> <expression>}*
<P>
<P>
<P>
<expression> can be a number or any other valid REDUCE expression. Matrix
expressions are allowed if they are of the same dimensions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
difference(10,4);
6
15 difference 5 difference 2;
8
a difference b;
A - B
</TT></PRE><P>The <em>difference</em> operator is left associative, as shown in
the second
example above.
<P>
<P>
<P>
<P>
<A NAME=DILOG>
<TITLE>DILOG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DILOG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>dilog</em> operator is known to the differentiation and integration
operators, but has numeric value attached only at <em>dilog(0)</em>. Dilog is
defined by
<P>
<P>
dilog(x) = -int(log(x),x)/(x-1)
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(dilog(x**2),x);
2
2*LOG(X )*X
- ------------
2
X - 1
int(dilog(x),x);
DILOG(X)*X - DILOG(X) + LOG(X)*X - X
dilog(0);
2
PI
----
6
</TT></PRE><P>
<A NAME=DMS2DEG>
<TITLE>DMS2DEG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DMS2DEG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>dms2deg</em>(<list>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <list> is a list of three real
numbers,
the operator <em>dms2deg</em> will interpret the list as degrees, minutes
and seconds and convert it to the equivalent degrees. In all other cases,
an expression in terms of the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
dms2deg {42,3,7};
DMS2DEG({42,3,7})
on rounded;
ws;
42.0519444444
dms2deg a;
DMS2DEG(A)
</TT></PRE><P>
<A NAME=DMS2RAD>
<TITLE>DMS2RAD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DMS2RAD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>dms2rad</em>(<list>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <list> is a list of three real
numbers,
the operator <em>dms2rad</em> will interpret the list as degrees, minutes
and seconds and convert it to the equivalent radians. In all other cases,
an expression in terms of the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
dms2rad {42,3,7};
DMS2RAD({42,3,7})
on rounded;
ws;
0.733944887421
dms2rad a;
DMS2RAD(A)
</TT></PRE><P>
<A NAME=FACTORIAL>
<TITLE>FACTORIAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FACTORIAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>factorial</em>(<expression>)
<P>
<P>
<P>
If the argument of <em>factorial</em> is a positive integer or zero, its
factorial is returned. Otherwise the result is expressed in terms of the
original operator. For more general operations, the
<A HREF=r38_0492.html>gamma</A> operator
is available in the
<A HREF=r38_0444.html>Special Function Package</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
factorial 4;
24
factorial 30 ;
265252859812191058636308480000000
</TT></PRE><P>
<A NAME=FIX>
<TITLE>FIX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>fix</em>(<expression>)
<P>
<P>
<P>
The operator <em>fix</em> returns the integer part of its argument, if that
argument has a numerical value. For positive numbers, this is equivalent
to
<A HREF=r38_0084.html>floor</A>, and, for negative numbers,
<A HREF=r38_0073.html>ceiling</A>. For
non-numeric arguments, the value is an expression in the original operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
fix 3.4;
3
floor 3.4;
3
ceiling 3.4;
4
fix(-5.2);
-5
floor(-5.2);
-6
ceiling(-5.2);
-5
fix(a);
FIX(A)
</TT></PRE><P>
<A NAME=FIXP>
<TITLE>FIXP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FIXP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>fixp</em> logical operator returns true if its argument is an integer.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>fixp</em>(<expression>) or <em>fixp</em> <simple\_expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE expression, <simple\_expression
>
must be a single identifier or begin with a prefix operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if fixp 1.5 then write "ok" else write "not";
not
if fixp(a) then write "ok" else write "not";
not
a := 15;
A := 15
if fixp(a) then write "ok" else write "not";
ok
</TT></PRE><P>Logical operators can only be used inside conditional expressions
such as
<em>if</em>...<em>then</em> or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=FLOOR>
<TITLE>FLOOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FLOOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>floor</em>(<expression>)
<P>
<P>
<P>
This operator returns the floor (i.e., the greatest integer less than or
equal to its argument) if its argument has a numerical value. For
positive numbers, this is equivalent to
<A HREF=r38_0082.html>fix</A>. For non-numeric
arguments, the value is an expression in the original operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
floor 3.4;
3
fix 3.4;
3
floor(-5.2);
-6
fix(-5.2);
-5
floor a;
FLOOR(A)
</TT></PRE><P>
<A NAME=EXPT>
<TITLE>EXPT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXPT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>expt</em> operator is both an infix and prefix binary exponentiation
operator. It is identical to <em>^</em> or <em>**</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>expt</em>(<expression>,<expression>)
or <expression> <em>expt</em> <expression>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a expt b;
B
A
expt(a,b);
B
A
(x+y) expt 4;
4 3 2 2 3 4
X + 4*X *Y + 6*X *Y + 4*X*Y + Y
</TT></PRE><P>Scalar expressions may be raised to fractional and floating-point
powers.
Square matrix expressions may be raised to positive powers, and also to
negative powers if non-singular.
<P>
<P>
<em>expt</em>is left associative. In other words, <em>a expt b expt c</em> is
equivalent to <em>a expt (b*c)</em>, not <em>a expt (b expt c)</em>, which
would be right associative.
<P>
<P>
<P>
<A NAME=GCD>
<TITLE>GCD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GCD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>gcd</em> operator returns the greatest common divisor of two
polynomials.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>gcd</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> must be a polynomial (or integer), otherwise an error
occurs.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
gcd(2*x**2 - 2*y**2,4*x + 4*y);
2*(X + Y)
gcd(sin(x),x**2 + 1);
1
gcd(765,68);
17
</TT></PRE><P>The operator <em>gcd</em> described here provides an explicit mean
s to find the
gcd of two expressions. The switch <em>gcd</em> described below simplifies
expressions by finding and canceling gcd's at every opportunity. When
the switch
<A HREF=r38_0286.html>ezgcd</A> is also on, gcd's are figured using the EZ GCD
algorithm, which is usually faster.
<P>
<P>
<P>
<A NAME=LN>
<TITLE>LN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ln</em>(<expression>)
<P>
<P>
<P>
<expression> can be any valid scalar REDUCE expression.
<P>
<P>
The <em>ln</em> operator returns the natural logarithm of its argument.
However, unlike
<A HREF=r38_0088.html>log</A>, there are no algebraic rules associated
with it; it will only evaluate when
<A HREF=r38_0330.html>rounded</A> is on, and the
argument is a real number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ln(x);
LN(X)
ln 4;
LN(4)
ln(e);
LN(E)
df(ln(x),x);
DF(LN(X),X)
on rounded;
ln 4;
1.38629436112
ln e;
1
</TT></PRE><P>Because of the restricted algebraic properties of <em>ln</em>, use
rs are
advised to use
<A HREF=r38_0088.html>log</A> whenever possible.
<P>
<P>
<P>
<A NAME=LOG>
<TITLE>LOG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LOG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>log</em> operator returns the natural logarithm of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>log</em>(<expression>) or <em>log</em> <expression>
<P>
<P>
<P>
<expression> can be any valid scalar REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
log(x);
LOG(X)
log 4;
LOG(4)
log(e);
1
on rounded;
log 4;
1.38629436112
</TT></PRE><P><em>log</em>returns a numeric value only when
<A HREF=r38_0330.html>rounded</A> is on. In that
case, use of a negative argument for <em>log</em> results in an error
message. No error is given on a negative argument when REDUCE is not in
that mode.
<P>
<P>
<P>
<A NAME=LOGB>
<TITLE>LOGB</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LOGB</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>logb</em>(<expression>,<integer>)
<P>
<P>
<P>
<expression> can be any valid scalar REDUCE expression.
<P>
<P>
The <em>logb</em> operator returns the logarithm of its first argument using
the second argument as base. However, unlike
<A HREF=r38_0088.html>log</A>, there are no
algebraic rules associated with it; it will only evaluate when
<A HREF=r38_0330.html>rounded</A> is on, and the first argument is a real number
.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
logb(x,2);
LOGB(X,2)
logb(4,3);
LOGB(4,3)
logb(2,2);
LOGB(2,2)
df(logb(x,3),x);
DF(LOGB(X,3),X)
on rounded;
logb(4,3);
1.26185950714
logb(2,2);
1
</TT></PRE><P>
<A NAME=MAX>
<TITLE>MAX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MAX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>max</em> is an n-ary prefix operator, which returns the largest
value in its arguments.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>max</em>(<expression>{,<expression>}*)
<P>
<P>
<P>
<P>
<expression> must evaluate to a number. <em>max</em> of an empty list
returns 0.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
max(4,6,10,-1);
10
<<a := 23;b := 2*a;c := 4**2;max(a,b,c)>>;
46
max(-5,-10,-a);
-5
</TT></PRE><P>
<A NAME=MIN>
<TITLE>MIN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MIN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>min</em> is an n-ary prefix operator, which returns the
smallest value in its arguments.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>min</em>(<expression>{,<expression>}*)
<P>
<P>
<P>
<expression> must evaluate to a number. <em>min</em> of an empty list
returns 0.
<P> <H3>
examples: </H3>
<P><PRE><TT>
min(-3,0,17,2);
-3
<<a := 23;b := 2*a;c := 4**2;min(a,b,c)>>;
16
min(5,10,a);
5
</TT></PRE><P><P>
<P>
<A NAME=MINUS>
<TITLE>MINUS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MINUS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>minus</em> operator is a unary minus, returning the negative of its
argument. It is equivalent to the unary <em>-</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>minus</em>(<expression>)
<P>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
minus(a);
- A
minus(-1);
1
minus((x+1)**4);
4 3 2
- (X + 4*X + 6*X + 4*X + 1)
</TT></PRE><P>
<A NAME=NEXTPRIME>
<TITLE>NEXTPRIME</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NEXTPRIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>nextprime</em>(<expression>)
<P>
<P>
<P>
If the argument of <em>nextprime</em> is an integer, the least prime greater
than that argument is returned. Otherwise, a type error results.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
nextprime 5001;
5003
nextprime(10^30);
1000000000000000000000000000057
nextprime a;
***** A invalid as integer
</TT></PRE><P>
<A NAME=NOCONVERT>
<TITLE>NOCONVERT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOCONVERT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
Under normal circumstances when <em>rounded</em> is on, REDUCE converts the
number 1.0 to the integer 1. If this is not desired, the switch
<em>noconvert</em> can be turned on.
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1.0000000000001;
1
on noconvert;
1.0000000000001;
1.0
</TT></PRE><P><P>
<P>
<A NAME=NORM>
<TITLE>NORM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NORM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>norm</em>(<expression>)
<P>
<P>
<P>
If <em>rounded</em> is on, and the argument is a real number, <norm>
returns its absolute value. If <em>complex</em> is also on, <norm>
returns the square root of the sum of squares of the real and imaginary
parts of the argument. In all other cases, a result is returned in
terms of the original operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
norm (-2);
NORM(-2)
on rounded;
ws;
2.0
norm(3+4i);
NORM(4*I+3)
on complex;
ws;
5.0
</TT></PRE><P>
<A NAME=PERM>
<TITLE>PERM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PERM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
perm(<expression1>,<expression2>)
<P>
<P>
<P>
If <expression1> and <expression2> evaluate to positive integers,
<em>perm</em> returns the number of permutations possible in selecting
<expression1> objects from <expression2> objects.
In other cases, an expression in the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
perm(1,1);
1
perm(3,5);
60
perm(-3,5);
PERM(-3,5)
perm(a,b);
PERM(A,B)
</TT></PRE><P>
<A NAME=PLUS>
<TITLE>PLUS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLUS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>plus</em> operator is both an infix and prefix n-ary addition
operator. It exists because of the way in which REDUCE handles such
operators internally, and is not recommended for use in algebraic mode
programming.
<A HREF=r38_0027.html>plussign</A>, which has the identical effect, should be
used instead.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>plus</em>(<expression>,<expression>{,<expression>}
*) or
<P>
<P>
<expression> <em>plus</em> <expression> {<em>plus</em> <expressio
n>}*
<P>
<P>
<P>
<expression> can be any valid REDUCE expression, including matrix
expressions of the same dimensions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a plus b plus c plus d;
A + B + C + D
4.5 plus 10;
29
--
2
plus(x**2,y**2);
2 2
X + Y
</TT></PRE><P>
<A NAME=QUOTIENT>
<TITLE>QUOTIENT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>QUOTIENT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>quotient</em> operator is both an infix and prefix binary operator that
returns the quotient of its first argument divided by its second. It is
also a unary
<A HREF=r38_0101.html>recip</A>rocal operator. It is identical to <em>/</em> and
<A HREF=r38_0030.html>slash</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>quotient</em>(<expression>,<expression>) or
<expression> <em>quotient</em> <expression> or
<em>quotient</em>(<expression>) or
<em>quotient</em> <expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE scalar expression. Matrix
expressions can also be used if the second expression is invertible and the
matrices are of the correct dimensions.
<P> <H3>
examples: </H3>
<P><PRE><TT>
quotient(a,x+1);
A
-----
X + 1
7 quotient 17;
7
--
17
on rounded;
4.5 quotient 2;
2.25
quotient(x**2 + 3*x + 2,x+1);
X + 2
matrix m,inverse;
m := mat((a,b),(c,d));
M(1,1) := A;
M(1,2) := B;
M(2,1) := C
M(2,2) := D
inverse := quotient m;
D
INVERSE(1,1) := ----------
A*D - B*C
B
INVERSE(1,2) := - ----------
A*D - B*C
C
INVERSE(2,1) := - ----------
A*D - B*C
A
INVERSE(2,2) := ----------
A*D - B*C
</TT></PRE><P><P>
<P>
The <em>quotient</em> operator is left associative: <em>a quotient b quotient c
</em>
is equivalent to <em>(a quotient b) quotient c</em>.
<P>
<P>
If a matrix argument to the unary <em>quotient</em> is not invertible, or if the
second matrix argument to the binary quotient is not invertible, an error
message is given.
<P>
<P>
<P>
<A NAME=RAD2DEG>
<TITLE>RAD2DEG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RAD2DEG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>rad2deg</em>(<expression>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <expression> is a real number,
the
operator <em>rad2deg</em> will interpret it as radians, and convert it to
the equivalent degrees. In all other cases, an expression in terms of the
original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
rad2deg 1;
RAD2DEG(1)
on rounded;
ws;
57.2957795131
rad2deg a;
RAD2DEG(A)
</TT></PRE><P>
<A NAME=RAD2DMS>
<TITLE>RAD2DMS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RAD2DMS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>rad2dms</em>(<expression>)
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, if <expression> is a real number,
the
operator <em>rad2dms</em> will interpret it as radians, and convert it to a
list containing the equivalent degrees, minutes and seconds. In all other
cases, an expression in terms of the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
rad2dms 1;
RAD2DMS(1)
on rounded;
ws;
{57,17,44.8062470964}
rad2dms a;
RAD2DMS(A)
</TT></PRE><P>
<A NAME=RECIP>
<TITLE>RECIP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RECIP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>recip</em> is the alphabetical name for the division operator <em>/</em>
or
<A HREF=r38_0030.html>slash</A> used as a unary operator. The use of <em>/</em>
is preferred.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
recip a;
1
-
A
recip 2;
1
--
2
</TT></PRE><P>
<A NAME=REMAINDER>
<TITLE>REMAINDER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REMAINDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>remainder</em> operator returns the remainder after its first
argument is divided by its second argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>remainder</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> can be any valid REDUCE polynomial, and is not limited
to numeric values.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
remainder(13,6);
1
remainder(x**2 + 3*x + 2,x+1);
0
remainder(x**3 + 12*x + 4,x**2 + 1);
11*X + 4
remainder(sin(2*x),x*y);
SIN(2*X)
</TT></PRE><P>In the default case, remainders are calculated over the integers.
If you
need the remainder with respect to another domain, it must be declared
explicitly.
<P>
<P>
If the first argument to <em>remainder</em> contains a denominator not equal to
1, an error occurs.
<P>
<P>
<P>
<A NAME=ROUND>
<TITLE>ROUND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROUND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>round</em>(<expression>)
<P>
<P>
<P>
If its argument has a numerical value, <em>round</em> rounds it to the
nearest integer. For non-numeric arguments, the value is an expression in
the original operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
round 3.4;
3
round 3.5;
4
round a;
ROUND(A)
</TT></PRE><P>
<A NAME=SETMOD>
<TITLE>SETMOD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SETMOD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>setmod</em> command sets the modulus value for subsequent
<A HREF=r38_0305.html>modular</A>
arithmetic.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>setmod</em><integer>
<P>
<P>
<P>
<integer> must be positive, and greater than 1. It need not be a prime
number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
setmod 6;
1
on modular;
16;
4
x^2 + 5x + 7;
2
X + 5*X + 1
x/3;
X
-
3
setmod 2;
6
(x+1)^4;
4
X + 1
x/3;
X
</TT></PRE><P><em>setmod</em>returns the previous modulus, or 1 if none has been
set
before. <em>setmod</em> only has effect when
<A HREF=r38_0305.html>modular</A> is on.
<P>
<P>
Modular operations are done only on numbers such as coefficients of
polynomials, not on the exponents. The modulus need not be prime.
Attempts to divide by a power of the modulus produces an error message, since th
e
operation is equivalent to dividing by 0. However, dividing by a factor
of a non-prime modulus does not produce an error message.
<P>
<P>
<P>
<A NAME=SIGN>
<TITLE>SIGN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SIGN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sign</em><expression>
<P>
<P>
<P>
<em>sign</em>tries to evaluate the sign of its argument. If this
is possible <em>sign</em> returns one of 1, 0 or -1. Otherwise, the result
is the original form or a simplified variant.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sign(-5)
-1
sign(-a^2*b)
-SIGN(B)
</TT></PRE><P>Even powers of formal expressions are assumed to be positive only
as long
as the switch
<A HREF=r38_0274.html>complex</A> is off.
<P>
<P>
<P>
<A NAME=SQRT>
<TITLE>SQRT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SQRT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sqrt</em> operator returns the square root of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>sqrt</em>(<expression>)
<P>
<P>
<P>
<expression> can be any REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sqrt(16*a^3);
4*SQRT(A)*A
sqrt(17);
SQRT(17)
on rounded;
sqrt(17);
4.12310562562
off rounded;
sqrt(a*b*c^5*d^3*27);
2
3*SQRT(D)*SQRT(C)*SQRT(B)*SQRT(A)*SQRT(3)*C *D
</TT></PRE><P><em>sqrt</em>checks its argument for squared factors and removes t
hem.
<P>
<P>
Numeric values for square roots that are not exact integers are given only
when
<A HREF=r38_0330.html>rounded</A> is on.
<P>
<P>
Please note that <em>sqrt(a**2)</em> is given as <em>a</em>, which may be
incorrect if <em>a</em> eventually has a negative value. If you are
programming a calculation in which this is a concern, you can turn on the
<A HREF=r38_0317.html>precise</A> switch, which causes the absolute value of the
square root
to be returned.
<P>
<P>
<P>
<A NAME=TIMES>
<TITLE>TIMES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TIMES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>times</em> operator is an infix or prefix n-ary multiplication
operator. It is identical to <em>*</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<expression> <em>times</em> <expression> {<em>times</em> <express
ion>}*
<P>
<P>
or <em>times</em>(<expression>,<expression> {,<expression>}*)
<P>
<P>
<P>
<expression> can be any valid REDUCE scalar or matrix expression.
Matrix expressions must be of the correct dimensions. Compatible scalar
and matrix expressions can be mixed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
var1 times var2;
VAR1*VAR2
times(6,5);
30
matrix aa,bb;
aa := mat((1),(2),(x))$
bb := mat((0,3,1))$
aa times bb times 5;
[0 15 5 ]
[ ]
[0 30 10 ]
[ ]
[0 15*X 5*X]
</TT></PRE><P>
<A NAME=g5>
<TITLE>Arithmetic Operations</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Arithmetic Operations</B><MENU>
<LI><A HREF=r38_0069.html>ARITHMETIC\_OPERATIONS introduction</A><P>
<LI><A HREF=r38_0070.html>ABS operator</A><P>
<LI><A HREF=r38_0071.html>ADJPREC switch</A><P>
<LI><A HREF=r38_0072.html>ARG operator</A><P>
<LI><A HREF=r38_0073.html>CEILING operator</A><P>
<LI><A HREF=r38_0074.html>CHOOSE operator</A><P>
<LI><A HREF=r38_0075.html>DEG2DMS operator</A><P>
<LI><A HREF=r38_0076.html>DEG2RAD operator</A><P>
<LI><A HREF=r38_0077.html>DIFFERENCE operator</A><P>
<LI><A HREF=r38_0078.html>DILOG operator</A><P>
<LI><A HREF=r38_0079.html>DMS2DEG operator</A><P>
<LI><A HREF=r38_0080.html>DMS2RAD operator</A><P>
<LI><A HREF=r38_0081.html>FACTORIAL operator</A><P>
<LI><A HREF=r38_0082.html>FIX operator</A><P>
<LI><A HREF=r38_0083.html>FIXP operator</A><P>
<LI><A HREF=r38_0084.html>FLOOR operator</A><P>
<LI><A HREF=r38_0085.html>EXPT operator</A><P>
<LI><A HREF=r38_0086.html>GCD operator</A><P>
<LI><A HREF=r38_0087.html>LN operator</A><P>
<LI><A HREF=r38_0088.html>LOG operator</A><P>
<LI><A HREF=r38_0089.html>LOGB operator</A><P>
<LI><A HREF=r38_0090.html>MAX operator</A><P>
<LI><A HREF=r38_0091.html>MIN operator</A><P>
<LI><A HREF=r38_0092.html>MINUS operator</A><P>
<LI><A HREF=r38_0093.html>NEXTPRIME operator</A><P>
<LI><A HREF=r38_0094.html>NOCONVERT switch</A><P>
<LI><A HREF=r38_0095.html>NORM operator</A><P>
<LI><A HREF=r38_0096.html>PERM operator</A><P>
<LI><A HREF=r38_0097.html>PLUS operator</A><P>
<LI><A HREF=r38_0098.html>QUOTIENT operator</A><P>
<LI><A HREF=r38_0099.html>RAD2DEG operator</A><P>
<LI><A HREF=r38_0100.html>RAD2DMS operator</A><P>
<LI><A HREF=r38_0101.html>RECIP operator</A><P>
<LI><A HREF=r38_0102.html>REMAINDER operator</A><P>
<LI><A HREF=r38_0103.html>ROUND operator</A><P>
<LI><A HREF=r38_0104.html>SETMOD command</A><P>
<LI><A HREF=r38_0105.html>SIGN operator</A><P>
<LI><A HREF=r38_0106.html>SQRT operator</A><P>
<LI><A HREF=r38_0107.html>TIMES operator</A><P>
</MENU>
<A NAME=boolean_value>
<TITLE>boolean_value</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BOOLEAN VALUE</B><P>
<P>
There are no extra symbols for the truth values true
and false. Instead,
<A HREF=r38_0014.html>nil</A> and the number zero
are interpreted as truth value false in algebraic
programs (see
<A HREF=r38_0014.html>false</A>), while any different
value is considered as true (see
<A HREF=r38_0122.html>true</A>).
<P>
<P>
<A NAME=EQUAL>
<TITLE>EQUAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EQUAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>equal</em> is an infix binary comparison
operator. It is identical with <em>=</em>. It returns
<A HREF=r38_0122.html>true</A> if its two
arguments are equal.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>equal</em> <expression>
<P>
<P>
<P>
Equality is given between floating point numbers and integers that have
the same value.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
a := 4;
A := 4
b := 4.0;
B := 4.0
if a equal b then write "true" else write "false";
true
if a equal 5 then write "true" else write "false";
false
if a equal sqrt(16) then write "true" else write "false";
true
</TT></PRE><P>Comparison operators can only be used as conditions in conditional
commands
such as <em>if</em>...<em>then</em> and <em>repeat</em>...<em>until</em>.
<equal> can also be used as a prefix operator. However, this use
is not encouraged.
<P>
<P>
<P>
<A NAME=EVENP>
<TITLE>EVENP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EVENP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>evenp</em> logical operator returns
<A HREF=r38_0122.html>true</A> if its argument is an
even integer, and
<A HREF=r38_0014.html>nil</A> if its argument is an odd integer. An error
message is returned if its argument is not an integer.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>evenp</em>(<integer>) or <em>evenp</em> <integer>
<P>
<P>
<P>
<integer> must evaluate to an integer.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
aa := 1782;
AA := 1782
if evenp aa then yes else no;
YES
if evenp(-3) then yes else no;
NO
</TT></PRE><P>Although you would not ordinarily enter an expression such as the
last
example above, note that the negative term must be enclosed in parentheses
to be correctly parsed. The <em>evenp</em> operator can only be used in
conditional statements such as <em>if</em>...<em>then</em>...<em>else</em>
or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=false>
<TITLE>false</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FALSE</B><P>
<P>
The symbol
<A HREF=r38_0014.html>nil</A> and the number zero are considered
as
<A HREF=r38_0109.html>boolean value</A> false if used in a place where
a boolean value is required. Most builtin operators return
<A HREF=r38_0014.html>nil</A> as false value. Algebraic programs use better zero
.
Note that <em>nil</em> is not printed when returned as result to
a top level evaluation.
<P>
<P>
<A NAME=FREEOF>
<TITLE>FREEOF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FREEOF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>freeof</em> logical operator returns
<A HREF=r38_0122.html>true</A> if its first argument does
not contain its second argument anywhere in its structure.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>freeof</em>(<expression>,<kernel>) or
<expression> <em>freeof</em> <kernel>
<P>
<P>
<P>
<expression> can be any valid scalar REDUCE expression, <kernel> mus
t
be a kernel expression (see <em>kernel</em>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := x + sin(y)**2 + log sin z;
2
A := LOG(SIN(Z)) + SIN(Y) + X
if freeof(a,sin(y)) then write "free" else write "not free";
not free
if freeof(a,sin(x)) then write "free" else write "not free";
free
if a freeof sin z then write "free" else write "not free";
not free
</TT></PRE><P>Logical operators can only be used in conditional expressions such
as
<P>
<P>
<em>if</em>...<em>then</em> or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=LEQ>
<TITLE>LEQ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LEQ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>leq</em> operator is a binary infix or prefix logical operator. It
returns
<A HREF=r38_0122.html>true</A> if its first argument is less than or equal to it
s second
argument. As an infix operator it is identical with <em><=</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>leq</em>(<expression>,<expression>) or <expression>
<em>leq</em> <expression>
<P>
<P>
<P>
<P>
<expression> can be any valid REDUCE expression that evaluates to a
number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 15;
A := 15
if leq(a,25) then write "yes" else write "no";
yes
if leq(a,15) then write "yes" else write "no";
yes
if leq(a,5) then write "yes" else write "no";
no
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=LESSP>
<TITLE>LESSP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LESSP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>lessp</em> operator is a binary infix or prefix logical operator. It
returns
<A HREF=r38_0122.html>true</A> if its first argument is strictly less than its s
econd
argument. As an infix operator it is identical with <em><</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>lessp</em>(<expression>,<expression>)
or <expression> <em>lessp</em> <expression>
<P>
<P>
<P>
<P>
<expression> can be any valid REDUCE expression that evaluates to a
number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 15;
A := 15
if lessp(a,25) then write "yes" else write "no";
yes
if lessp(a,15) then write "yes" else write "no";
no
if lessp(a,5) then write "yes" else write "no";
no
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=MEMBER>
<TITLE>MEMBER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MEMBER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>member</em> <list>
<P>
<P>
<P>
<em>member</em>is an infix binary comparison operator that evaluates to
<A HREF=r38_0122.html>true</A> if <expression> is
<A HREF=r38_0110.html>equal</A> to a member of
the
<A HREF=r38_0053.html>list</A> <list>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if a member {a,b} then 1 else 0;
1
if 1 member(1,2,3) then a else b;
a
if 1 member(1.0,2) then a else b;
b
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> or <em>while</em>...<em>do</em>.
<member> can also be used as a prefix operator. However, this use
is not encouraged. Finally,
<A HREF=r38_0110.html>equal</A> (<em>=</em>) is used for the test
within the list, so expressions must be of the same type to match.
<P>
<P>
<P>
<A NAME=NEQ>
<TITLE>NEQ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NEQ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>neq</em> is an infix binary comparison
operator. It returns
<A HREF=r38_0122.html>true</A> if its two
arguments are not
<A HREF=r38_0110.html>equal</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<expression> <em>neq</em> <expression>
<P>
<P>
<P>
An inequality is satisfied between floating point numbers and integers
that have the same value.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
a := 4;
A := 4
b := 4.0;
B := 4.0
if a neq b then write "true" else write "false";
false
if a neq 5 then write "true" else write "false";
true
</TT></PRE><P>Comparison operators can only be used as conditions in conditional
commands
such as <em>if</em>...<em>then</em> and <em>repeat</em>...<em>until</em>.
<neq> can also be used as a prefix operator. However, this use
is not encouraged.
<P>
<P>
<P>
<A NAME=NOT>
<TITLE>NOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>not</em> operator returns
<A HREF=r38_0122.html>true</A> if its argument evaluates to
<A HREF=r38_0014.html>nil</A>, and <em>nil</em> if its argument is <em>true</em>
.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>not</em>(<logical expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if not numberp(a) then write "indeterminate" else write a;
indeterminate;
a := 10;
A := 10
if not numberp(a) then write "indeterminate" else write a;
10
if not(numberp(a) and a < 0) then write "positive number";
positive number
</TT></PRE><P>Logical operators can only be used in conditional statements such
as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> or <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=NUMBERP>
<TITLE>NUMBERP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUMBERP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>numberp</em> operator returns
<A HREF=r38_0122.html>true</A> if its argument is a number,
and
<A HREF=r38_0014.html>nil</A> otherwise.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>numberp</em>(<expression>) or <em>numberp</em> <expression>
<P>
<P>
<P>
<expression> can be any REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
cc := 15.3;
CC := 15.3
if numberp(cc) then write "number" else write "nonnumber";
number
if numberp(cb) then write "number" else write "nonnumber";
nonnumber
</TT></PRE><P>Logical operators can only be used in conditional expressions, suc
h as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> and <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=ORDP>
<TITLE>ORDP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ORDP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>ordp</em> logical operator returns
<A HREF=r38_0122.html>true</A> if its first argument is
ordered ahead of its second argument in canonical internal ordering, or is
identical to it.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>ordp</em>(<expression1>,<expression2>)
<P>
<P>
<P>
<P>
<expression1> and <expression2> can be any valid REDUCE scalar
expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if ordp(x**2 + 1,x**3 + 3) then write "yes" else write "no";
no
if ordp(101,100) then write "yes" else write "no";
yes
if ordp(x,x) then write "yes" else write "no";
yes
</TT></PRE><P>Logical operators can only be used in conditional expressions, suc
h as
<P>
<P>
<em>if</em>...<em>then</em>...<em>else</em> and <em>while</em>...<em>do</em>.
<P>
<P>
<P>
<A NAME=PRIMEP>
<TITLE>PRIMEP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRIMEP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>primep</em>(<expression>) or <em>primep</em> <simple\_expression
>
<P>
<P>
<P>
If <expression> evaluates to a integer, <em>primep</em> returns
<A HREF=r38_0122.html>true</A> <P>
<P>
if <expression> is a prime number (i.e., a number other than 0 and
plus or minus 1 which is only exactly divisible by itself or a unit)
and
<A HREF=r38_0014.html>nil</A> otherwise.
If <expression> does not have an integer value, a type error occurs.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if primep 3 then write "yes" else write "no";
YES
if primep a then 1;
***** A invalid as integer
</TT></PRE><P>
<A NAME=TRUE>
<TITLE>TRUE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRUE</B><P>
<P>
<P>
<P>
Any value of the boolean part of a logical expression which is neither
<A HREF=r38_0014.html>nil</A> nor <em>0</em> is considered as <em>true</em>. Mos
t
builtin test and compare functions return
<A HREF=r38_0018.html>t</A> for <em>true</em>
and
<A HREF=r38_0014.html>nil</A> for <em>false</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
if member(3,{1,2,3}) then 1 else -1;
1
if floor(1.7) then 1 else -1;
1
if floor(0.7) then 1 else -1;
-1
</TT></PRE><P>
<A NAME=g6>
<TITLE>Boolean Operators</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Boolean Operators</B><MENU>
<LI><A HREF=r38_0109.html>boolean value concept</A><P>
<LI><A HREF=r38_0110.html>EQUAL operator</A><P>
<LI><A HREF=r38_0111.html>EVENP operator</A><P>
<LI><A HREF=r38_0122.html>false concept</A><P>
<LI><A HREF=r38_0113.html>FREEOF operator</A><P>
<LI><A HREF=r38_0114.html>LEQ operator</A><P>
<LI><A HREF=r38_0115.html>LESSP operator</A><P>
<LI><A HREF=r38_0116.html>MEMBER operator</A><P>
<LI><A HREF=r38_0117.html>NEQ operator</A><P>
<LI><A HREF=r38_0118.html>NOT operator</A><P>
<LI><A HREF=r38_0119.html>NUMBERP operator</A><P>
<LI><A HREF=r38_0120.html>ORDP operator</A><P>
<LI><A HREF=r38_0121.html>PRIMEP operator</A><P>
<LI><A HREF=r38_0122.html>TRUE concept</A><P>
</MENU>
<A NAME=BYE>
<TITLE>BYE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BYE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>bye</em> command ends the REDUCE session, returning control to the
program (e.g., the operating system) that called REDUCE. When you are at
the top level, the <em>bye</em> command exits REDUCE. <em>quit</em> is a
synonym for <em>bye</em>.
<P>
<P>
<A NAME=CONT>
<TITLE>CONT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The command <em>cont</em> returns control to an interactive file after a
<A HREF=r38_0128.html>pause</A> command that has been answered with <em>n</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>Suppose you are in the middle of an interactive file.
<P><PRE><TT>
factorize(x**2 + 17*x + 60);
{{X + 12,1},{X + 5,1}}
pause;
Cont? (Y or N)
n
saveas results;
factor1 := first results;
FACTOR1 := {X + 12,1}
factor2 := second results;
FACTOR2 := {X + 5,1}
cont; </TT></PRE><P> the file resumes<P><PRE><TT>
</TT></PRE><P>
<P>
<P>
A
<A HREF=r38_0128.html>pause</A> allows you to enter your own REDUCE commands, ch
ange
switch values, inquire about results, or other such activities. When you
wish to resume operation of the interactive file, use <em>cont</em>.
<P>
<P>
<P>
<P>
<A NAME=DISPLAY>
<TITLE>DISPLAY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DISPLAY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
When given a numeric argument <n>, <em>display</em> prints the <n>
most recent input statements, identified by prompt numbers. If an empty
pair of parentheses is given, or if <n> is greater than the current
number of statements, all the input statements since the beginning of
the session are printed.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>display</em>(<n>) or <em>display</em>()
<P>
<P>
<P>
<n> should be a positive integer. However, if it is a real number, the
truncated integer value is used, and if a non-numeric argument is used, all
the input statements are printed.
<P>
<P>
The statements are displayed in upper case, with lines split at semicolons or
dollar signs, as they are in editing. If long files have been input during
the session, the <em>display</em> command is slow to format these for
printing.
<P>
<P>
<P>
<A NAME=LOAD_PACKAGE>
<TITLE>LOAD_PACKAGE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LOAD\_PACKAGE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>load_package</em> command is used to load REDUCE packages, such as
<em>gentran</em> that are not automatically loaded by the system.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>load_package "</em><package\_name><em>"</em>
<P>
<P>
<P>
A package is only loaded once; subsequent calls of <em>load_package</em>
for the same package name are ignored.
<P>
<P>
<A NAME=PAUSE>
<TITLE>PAUSE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PAUSE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>pause</em> command, given in an interactive file, stops operation and
asks if you want to continue or not.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>An interactive file is running, and at some point you
see the
question<P><PRE><TT>
Cont? (Y or N)
</TT></PRE><P>If you type<P><PRE><TT>
ykey{Return}
</TT></PRE><P>the file continues to run until the next pause or the end.<P><PRE>
<TT>
</TT></PRE><P>If you type <P><PRE><TT>
nkey{Return}
</TT></PRE><P>you will get a numbered REDUCE prompt, and be allowed to
enter and execute any REDUCE statements. If you later wish to continue with
the file, type<P><PRE><TT>
cont;
</TT></PRE><P>and the file resumes.<P><PRE><TT></TT></PRE><P>
<P>
<P>
To use <em>pause</em> in your own interactive files, type
<P>
<P>
<em>pause;</em>in the file wherever you want it.
<P>
<P>
<em>pause</em>does not allow you to continue without typing either <em>y</em>
or <em>n</em>. Its use is to slow down scrolling of interactive files, or to
let you change parameters or switch settings for the calculations.
<P>
<P>
If you have stopped an interactive file at a <em>pause,</em> and do not wish to
resume the file, type <em>end;</em>. This does not end the REDUCE session, but
stops input from the file. A second <em>end;</em> ends the REDUCE session.
However, if you have pauses from more than one file stacked up, an <em>end;</em>
brings you back to the top level, not the file directly above.
<P>
<P>
A <em>pause</em> typed from the terminal has no effect.
<P>
<P>
<P>
<A NAME=QUIT>
<TITLE>QUIT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>QUIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>quit</em> command ends the REDUCE session, returning control to the
program (e.g., the operating system) that called REDUCE. When you are at
the top level, the <em>quit</em> command exits REDUCE.
<A HREF=r38_0124.html>bye</A> is a
synonym for <em>quit</em>.
<P>
<P>
<A NAME=RECLAIM>
<TITLE>RECLAIM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RECLAIM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
REDUCE's memory is in a storage structure called a heap. As REDUCE
statements execute, chunks of memory are used up. When these chunks are no
longer needed, they remain idle. When the memory is almost full,
the system executes a garbage collection, reclaiming space that is no
longer needed, and putting all the free space at one end. Depending on
the size of the image REDUCE is using,
garbage collection needs to be done more or less often. A
larger image means fewer but longer garbage collections.
Regardless of memory size,
if you ask REDUCE to do something ridiculous, like <em>factorial(2000)</em>, it
may
garbage collect many times.
<P>
<P>
<P>
<A NAME=REDERR>
<TITLE>REDERR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REDERR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>rederr</em> command allows you to print an error message from inside
a
<A HREF=r38_0055.html>procedure</A> or a
<A HREF=r38_0041.html>block</A> statement.
The calculation is gracefully terminated.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>rederr</em><message>
<P>
<P>
<P>
<message> is an error message, usually inside double quotation marks
(a
<A HREF=r38_0003.html>string</A>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
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;
fac
fac a;
***** Choose nonneg. integer only
fac 5;
120
</TT></PRE><P>The above procedure finds the factorial of its argument.
If n is not a positive integer or 0, an error message is returned.
<P>
<P>
If your procedure is executed in a file, the usual error message is
printed, followed by <em>Cont? (Y or N)</em>, just as any other error does from
a file. Although the procedure is gracefully terminated, any switch settings or
variable assignments you made before the error occurred are not undone. If you
need to clean up such items before exiting, use a group statement, with the
<em>rederr</em> command as its last statement.
<P>
<P>
<P>
<A NAME=RETRY>
<TITLE>RETRY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RETRY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>retry</em> command allows you to retry the latest statement that resulte
d
in an error message.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix a;
det a;
***** Matrix A not set
a := mat((1,2),(3,4));
A(1,1) := 1
A(1,2) := 2
A(2,1) := 3
A(2,2) := 4
retry;
-2
</TT></PRE><P><em>retry</em>remembers only the most recent statement that result
ed in an
error message. It allows you to stop and fix something obvious, then
continue on your way without retyping the original command.
<P>
<P>
<P>
<A NAME=SAVEAS>
<TITLE>SAVEAS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SAVEAS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>saveas</em> command saves the current workspace under the name of its
argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>saveas</em><identifier>
<P>
<P>
<P>
<identifier> can be any valid REDUCE identifier.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>(The numbered prompts are shown below, unlike in most
examples)<P><PRE><TT>
1: solve(x^2-3);
{x=sqrt(3),x= - sqrt(3)}
2: saveas rts(0)$
3: rts(0);
{x=sqrt(3),x= - sqrt(3)}
</TT></PRE><P>
<P>
<P>
<em>saveas</em>works only for the current workspace, the last algebraic
expression produced by REDUCE. This allows you to save a result that you
did not assign to an identifier when you originally typed the input.
For access to previous output use
<A HREF=r38_0184.html>ws</A>.
<P>
<P>
<P>
<A NAME=SHOWTIME>
<TITLE>SHOWTIME</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHOWTIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>showtime</em> command prints the elapsed system time since the last
call of this command or since the beginning of the session, if it has not
been called before.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
showtime;
Time: 1020 ms
factorize(x^4 - 8x^4 + 8x^2 - 136x - 153);
2
{X - 9,X + 17,X + 1}
showtime;
Time: 920 ms
</TT></PRE><P>The time printed is either the elapsed cpu time or the elapsed wal
l clock
time, depending on your system. <em>showtime</em> allows you to see the
system time resources REDUCE uses in its calculations. Your time readings
will of course vary from this example according to the system you use.
<P>
<P>
<P>
<A NAME=WRITE>
<TITLE>WRITE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WRITE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>write</em> command explicitly writes its arguments to the output device
(terminal or file).
<P> <H3>
syntax: </H3>
<P>
<P>
<em>write</em><item>{,<item>}*
<P>
<P>
<P>
<item> can be an expression, an assignment or a
<A HREF=r38_0003.html>string</A>
enclosed in double quotation marks (<em>"</em>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
write a, sin x, "this is a string";
ASIN(X)this is a string
write a," ",sin x," this is a string";
A SIN(X) this is a string
if not numberp(a) then write "the symbol ",a;
the symbol A
array m(10);
for i := 1:5 do write m(i) := 2*i;
M(1) := 2
M(2) := 4
M(3) := 6
M(4) := 8
M(5) := 10
m(4);
8
</TT></PRE><P>The items specified by a single <em>write</em> statement print on
a single line
unless they are too long. A printed line is always ended with a carriage
return, so the next item printed starts a new line.
<P>
<P>
When an assignment statement is printed, the assignment is also made. This
allows you to get feedback on filling slots in an array with a
<A HREF=r38_0047.html>for</A>
statement, as shown in the last example above.
<P>
<P>
<P>
<A NAME=g7>
<TITLE>General Commands</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>General Commands</B><MENU>
<LI><A HREF=r38_0124.html>BYE command</A><P>
<LI><A HREF=r38_0125.html>CONT command</A><P>
<LI><A HREF=r38_0126.html>DISPLAY command</A><P>
<LI><A HREF=r38_0127.html>LOAD\_PACKAGE command</A><P>
<LI><A HREF=r38_0128.html>PAUSE command</A><P>
<LI><A HREF=r38_0129.html>QUIT command</A><P>
<LI><A HREF=r38_0130.html>RECLAIM operator</A><P>
<LI><A HREF=r38_0131.html>REDERR command</A><P>
<LI><A HREF=r38_0132.html>RETRY command</A><P>
<LI><A HREF=r38_0133.html>SAVEAS command</A><P>
<LI><A HREF=r38_0134.html>SHOWTIME command</A><P>
<LI><A HREF=r38_0135.html>WRITE command</A><P>
</MENU>
<A NAME=APPEND>
<TITLE>APPEND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>APPEND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>append</em> operator constructs a new
<A HREF=r38_0053.html>list</A>
from the elements of its two arguments (which must be lists).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>append</em>(<list>,<list>)
<P>
<P>
<P>
<list> must be a list, though it may be the empty list (<em>{}</em>).
Any arguments beyond the first two are ignored.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
alist := {1,2,{a,b}};
ALIST := {1,2,{A,B}}
blist := {3,4,5,sin(y)};
BLIST := {3,4,5,SIN(Y)}
append(alist,blist);
{1,2,{A,B},3,4,5,SIN(Y)}
append(alist,{});
{1,2,{A,B}}
append(list z,blist);
{Z,3,4,5,SIN(Y)}
</TT></PRE><P>The new list consists of the elements of the second list appended
to the
elements of the first list. You can <em>append</em> new elements to the
beginning or end of an existing list by putting the new element in a
list (use curly braces or the operator <em>list</em>). This is
particularly helpful in an iterative loop.
<P>
<P>
<P>
<A NAME=ARBINT>
<TITLE>ARBINT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARBINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>arbint</em> is used to express arbitrary integer parts
of an expression, e.g. in the result of
<A HREF=r38_0179.html>solve</A> when
<A HREF=r38_0266.html>allbranch</A> is on.
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve(log(sin(x+3)),x);
{X=2*ARBINT(1)*PI - ASIN(1) - 3,
X=2*ARBINT(1)*PI + ASIN(1) + PI - 3}
</TT></PRE><P><P>
<P>
<A NAME=ARBCOMPLEX>
<TITLE>ARBCOMPLEX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARBCOMPLEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>arbcomplex</em> is used to express arbitrary scalar parts
of an expression, e.g. in the result of
<A HREF=r38_0179.html>solve</A> when
the solution is parametric in one of the variable.
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve({x+3=y-2z,y-3x=0},{x,y,z});
2*ARBCOMPLEX(1) + 3
{X=-------------------,
2
3*ARBCOMPLEX(1) + 3
Y=-------------------,
2
Z=ARBCOMPLEX(1)}
</TT></PRE><P><P>
<P>
<A NAME=ARGLENGTH>
<TITLE>ARGLENGTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARGLENGTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>arglength</em> returns the number of arguments of the top-level
operator in its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>arglength</em>(<expression>)
<P>
<P>
<P>
<expression> can be any valid REDUCE algebraic expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
arglength(a + b + c + d);
4
arglength(a/b/c);
2
arglength(log(sin(df(r**3*x,x))));
1
</TT></PRE><P>In the first example, <em>+</em> is an n-ary operator, so the numb
er of terms
is returned. In the second example, since <em>/</em> is a binary operator, the
argument is actually (a/b)/c, so there are two terms at the top level. In
the last example, no matter how deeply the operators are nested, there is
still only one argument at the top level.
<P>
<P>
<P>
<A NAME=COEFF>
<TITLE>COEFF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COEFF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>coeff</em> operator returns the coefficients of the powers of the
specified variable in the given expression, in a
<A HREF=r38_0053.html>list</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>coeff</em>(<expression><em>,</em><variable>)
<P>
<P>
<P>
<expression> is expected to be a polynomial expression, not a rational
expression. Rational expressions are accepted when the switch
<A HREF=r38_0322.html>ratarg</A> is on. <variable> must be a kernel. The r
esults are
returned in a list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
coeff((x+y)**3,x);
3 2
{Y ,3*Y ,3*Y,1}
coeff((x+2)**4 + sin(x),x);
{SIN(X) + 16,32,24,8,1}
high_pow;
4
low_pow;
0
ab := x**9 + sin(x)*x**7 + sqrt(y);
7 9
AB := SQRT(Y) + SIN(X)*X + X
coeff(ab,x);
{SQRT(Y),0,0,0,0,0,0,SIN(X),0,1}
</TT></PRE><P>The variables
<A HREF=r38_0010.html>high_pow</A> and
<A HREF=r38_0013.html>low_pow</A> are set to the
highest and lowest powers of the variable, respectively, appearing in the
expression.
<P>
<P>
The coefficients are put into a list, with the coefficient of the lowest
(constant) term first. You can use the usual list access methods
(<em>first</em>, <em>second</em>, <em>third</em>, <em>rest</em>, <em>length</em>
, and
<em>part</em>) to extract them. If a power does not appear in the
expression, the corresponding element of the list is zero. Terms involving
functions of the specified variable but not including powers of it (for
example in the expression <em>x**4 + 3*x**2 + tan(x)</em>) are placed in the
constant term.
<P>
<P>
Since the <em>coeff</em> command deals with the expanded form of the expression,
you may get unexpected results when
<A HREF=r38_0284.html>exp</A> is off, or when
<A HREF=r38_0287.html>factor</A> or
<A HREF=r38_0296.html>ifactor</A> are on.
<P>
<P>
If you want only a specific coefficient rather than all of them, use the
<A HREF=r38_0142.html>coeffn</A> operator.
<P>
<P>
<P>
<P>
<A NAME=COEFFN>
<TITLE>COEFFN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COEFFN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>coeffn</em> operator takes three arguments: an expression, a kernel, and
a non-negative integer. It returns the coefficient of the kernel to that
integer power, appearing in the expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>coeffn</em>(<expression>,<kernel>,<integer>)
<P>
<P>
<P>
<expression> must be a polynomial, unless
<A HREF=r38_0322.html>ratarg</A> is on which
allows rational expressions. <kernel> must be a kernel, and
<integer> must be a non-negative integer.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ff := x**7 + sin(y)*x**5 + y**4 + x + 7;
5 7 4
FF := SIN(Y)*X + X + X + Y + 7
coeffn(ff,x,5);
SIN(Y)
coeffn(ff,z,3);
0
coeffn(ff,y,0);
5 7
SIN(Y)*X + X + X + 7
rr := 1/y**2+y**3+sin(y);
2 5
SIN(Y)*Y + Y + 1
RR := --------------------
2
Y
on ratarg;
coeffn(rr,y,-2);
***** -2 invalid as COEFFN index
coeffn(rr,y,5);
1
---
2
Y
</TT></PRE><P>If the given power of the kernel does not appear in the expression
,
<em>coeffn</em> returns 0. Negative powers are never detected, even if
they appear in the expression and
<A HREF=r38_0322.html>ratarg</A> are on. <em>coeffn</em>
with an integer argument of 0 returns any terms in the expression that
do not contain the given kernel.
<P>
<P>
<P>
<A NAME=CONJ>
<TITLE>CONJ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONJ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>conj</em>(<expression>) or <em>conj</em> <simple\_expression>
<P>
<P>
<P>
This operator returns the complex conjugate of an expression, if that
argument has an numerical value. A non-numerical argument is returned as
an expression in the operators
<A HREF=r38_0173.html>repart</A> and
<A HREF=r38_0153.html>impart</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
conj(1+i);
1-I
conj(a+i*b);
REPART(A) - REPART(B)*I - IMPART(A)*I - IMPART(B)
</TT></PRE><P>
<A NAME=CONTINUED_FRACTION>
<TITLE>CONTINUED_FRACTION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONTINUED_FRACTION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>continued_fraction</em>(<num>)
or <em>continued_fraction</em>( <num>,<size>)
<P>
<P>
<P>
This operator approximates the real number <num>
(
<A HREF=r38_0323.html>rational</A> number,
<A HREF=r38_0330.html>rounded</A> number)
into a continued fraction. The result is a list of two elements: the
first one is the rational value of the approximation, the second one
is the list of terms of the continued fraction which represents the
same value according to the definition <em>t0 +1/(t1 + 1/(t2 + ...))</em>.
Precision: the second optional parameter <size> is an upper bound
for the absolute value of the result denominator. If omitted, the
approximation is performed up to the current system precision.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
continued_fraction pi;
1146408
{-------,{3,7,15,1,292,1,1,1,2,1}}
364913
continued_fraction(pi,100);
22
{--,{3,7}}
7
</TT></PRE><P>
<A NAME=DECOMPOSE>
<TITLE>DECOMPOSE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DECOMPOSE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>decompose</em> operator takes a multivariate polynomial as argument,
and returns an expression and a
<A HREF=r38_0053.html>list</A> of
<A HREF=r38_0045.html>equation</A>s from which the
original polynomial can be found by composition.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>decompose</em>(<expression>) or <em>decompose</em>
<simple\_expression>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
decompose(x^8-88*x^7+2924*x^6-43912*x^5+263431*x^4-
218900*x^3+65690*x^2-7700*x+234)
2 2 2
U + 35*U + 234, U=V + 10*V, V=X - 22*X
decompose(u^2+v^2+2u*v+1)
2
W + 1, W=U + V
</TT></PRE><P>Unlike factorization, this decomposition is not unique. Further
details can be found in V.S. Alagar, M.Tanh, <Fast Polynomial
Decomposition>, Proc. EUROCAL 1985, pp 150-153 (Springer) and J. von zur
Gathen, <Functional>
<Decomposition of Polynomials: the Tame Case>, J.
Symbolic Computation (1990) 9, 281-299.
<P>
<P>
<P>
<A NAME=DEG>
<TITLE>DEG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>deg</em> returns the highest degree of its variable argument
found in its expression argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>deg</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> is expected to be a polynomial expression, not a rational
expression. Rational expressions are accepted when the switch
<A HREF=r38_0322.html>ratarg</A> is on. <variable> must be a
<A HREF=r38_0002.html>kernel</A>. The
results are returned in a list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
deg((x+y)**5,x);
5
deg((a+b)*(c+2*d)**2,d);
2
deg(x**2 + cos(y),sin(x));
deg((x**2 + sin(x))**5,sin(x));
5
</TT></PRE><P>
<A NAME=DEN>
<TITLE>DEN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>den</em> operator returns the denominator of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>den</em>(<expression>)
<P>
<P>
<P>
<expression> is ordinarily a rational expression, but may be any valid
scalar REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := x**3 + 3*x**2 + 12*x;
2
A := X*(X + 3*X + 12)
b := 4*x*y + x*sin(x);
B := X*(SIN(X) + 4*Y)
den(a/b);
SIN(X) + 4*Y
den(aa/4 + bb/5);
20
den(100/6);
3
den(sin(x));
1
</TT></PRE><P><em>den</em>returns the denominator of the expression after it has
been
simplified by REDUCE. As seen in the examples, this includes putting
sums of rational expressions over a common denominator, and reducing
common factors where possible. If the expression does not have any
other denominator, 1 is returned.
<P>
<P>
Switch settings, such as
<A HREF=r38_0304.html>mcd</A> or
<A HREF=r38_0323.html>rational</A>, have an
effect on the denominator of an expression.
<P>
<P>
<P>
<A NAME=DF>
<TITLE>DF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>df</em> operator finds partial derivatives with respect to one or
more variables.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>df</em>(<expression><em>,</em><var>
[<em>,</em><number>]
{<em>,</em><var> [ <em>,</em><number>] } )
<P>
<P>
<P>
<expression> can be any valid REDUCE algebraic expression. <var>
must be a
<A HREF=r38_0002.html>kernel</A>, and is the differentiation variable.
<number> must be a non-negative integer.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(x**2,x);
2*X
df(x**2*y + sin(y),y);
2
COS(Y) + X
df((x+y)**10,z);
0
df(1/x**2,x,2);
6
---
4
X
df(x**4*y + sin(y),y,x,3);
24*X
for all x let df(tan(x),x) = sec(x)**2;
df(tan(3*x),x);
2
3*SEC(3*X)
</TT></PRE><P>An error message results if a non-kernel is entered as a different
iation
operator. If the optional number is omitted, it is assumed to be 1.
See the declaration
<A HREF=r38_0192.html>depend</A> to establish dependencies for implicit
differentiation.
<P>
<P>
You can define your own differentiation rules, expanding REDUCE's
capabilities, using the
<A HREF=r38_0199.html>let</A> command as shown in the last example
above. Note that once you add your own rule for differentiating a
function, it supersedes REDUCE's normal handling of that function for the
duration of the REDUCE session. If you clear the rule
(
<A HREF=r38_0190.html>clearrules</A>), you don't get back
to the previous rule.
<P>
<P>
<P>
<A NAME=EXPAND_CASES>
<TITLE>EXPAND_CASES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXPAND\_CASES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
When a
<A HREF=r38_0176.html>root_of</A> form in a result of
<A HREF=r38_0179.html>solve</A>
has been converted to a
<A HREF=r38_0168.html>one_of</A> form, <em>expand_cases</em>
can be used to convert this into form corresponding to the
normal explicit results of
<A HREF=r38_0179.html>solve</A>. See
<A HREF=r38_0176.html>root_of</A>.
<P>
<P>
<A NAME=EXPREAD>
<TITLE>EXPREAD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXPREAD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>expread</em>()
<P>
<P>
<P>
<em>expread</em>reads one well-formed expression from the current input
buffer and returns its value.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
expread(); a+b;
A + B
</TT></PRE><P>
<A NAME=FACTORIZE>
<TITLE>FACTORIZE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FACTORIZE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>factorize</em> operator factors a given expression into a list of
{factor,power} pairs.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>factorize</em>(<expression>)
<P>
<P>
<P>
<expression> should be a polynomial, otherwise an error will result.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
fff := factorize(x^3 - y^3);
2 2
{{X + X*Y + Y ,1},{X - Y,1}}
fac1 := first fff;
2 2
FAC1 := {{X + X*Y + Y ,1}
factorize(x^15 - 1);
8 7 6 5 4
{{ X - X + X - X + X - X + 1,1},
4 3 2
{X + X + X + X + 1,1},
2
{X + X + 1,1},
{X - 1,1}}
lastone := part(ws,length ws);
LASTONE := {X - 1,1}
setmod 2;
1
on modular;
factorize(x^15 - 1);
4 3 2
{{X + X + X + X + 1,1},
4 3
{X + X + 1,1},
4
{X + X + 1,1},
2
{ X + X + 1,1},
{X + 1,1}}
</TT></PRE><P>The <em>factorize</em> command returns the factor,power pairs as a
<A HREF=r38_0053.html>list</A>.
You can therefore use the usual list access methods (
<A HREF=r38_0046.html>first</A>,
<A HREF=r38_0063.html>second</A>,
<A HREF=r38_0066.html>third</A>,
<A HREF=r38_0057.html>rest</A>,
<A HREF=r38_0157.html>length</A> and
<A HREF=r38_0169.html>part</A>) to extract these pairs.
<P>
<P>
If the <expression> given to <em>factorize</em> is an integer, it will be
factored into its prime components. To factor any integer factor of a
non-numerical expression, the switch
<A HREF=r38_0296.html>ifactor</A> should be turned on.
Its default is off.
<A HREF=r38_0296.html>ifactor</A> has effect only when factoring is
explicitly done by <em>factorize</em>, not when factoring is automatically
done with the
<A HREF=r38_0287.html>factor</A> switch. If full factorization is not
needed the switch
<A HREF=r38_0301.html>limitedfactors</A> allows you to reduce the
computing time of calls to <em>factorize</em>.
<P>
<P>
Factoring can be done in a modular domain by calling <em>factorize</em> when
<A HREF=r38_0305.html>modular</A> is on. You can set the modulus with the
<A HREF=r38_0104.html>setmod</A>
command. The last example above shows factoring modulo 2.
<P>
<P>
For general comments on factoring, see comments under the switch
<A HREF=r38_0287.html>factor</A>.
<P>
<P>
<P>
<A NAME=HYPOT>
<TITLE>HYPOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HYPOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
hypot(<expression>,<expression>)
<P>
<P>
<P>
If <em>rounded</em> is on, and the two arguments evaluate to numbers, this
operator returns the square root of the sums of the squares of the
arguments in a manner that avoids intermediate overflow. In other cases,
an expression in the original operator is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hypot(3,4);
HYPOT(3,4)
on rounded;
ws;
5.0
hypot(a,b);
HYPOT(A,B)
</TT></PRE><P>
<A NAME=IMPART>
<TITLE>IMPART</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IMPART</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>impart</em>(<expression>) or <em>impart</em> <simple\_expression
>
<P>
<P>
<P>
This operator returns the imaginary part of an expression, if that
argument has an numerical value. A non-numerical argument is returned as
an expression in the operators
<A HREF=r38_0173.html>repart</A> and <em>impart</em>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
impart(1+i);
1
impart(a+i*b);
REPART(B) + IMPART(A)
</TT></PRE><P><P>
<P>
<A NAME=INT>
<TITLE>INT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>int</em> operator performs analytic integration on a variety of
functions.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>int</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> can be any scalar expression. involving polynomials, log
functions, exponential functions, or tangent or arctangent expressions.
<em>int</em> attempts expressions involving error functions, dilogarithms
and other trigonometric expressions. Integrals involving algebraic
extensions (such as square roots) may not succeed. <kernel> must be a
REDUCE
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
int(x**3 + 3,x);
3
X*(X + 12)
-----------
4
int(sin(x)*exp(2*x),x);
2*X
E *(COS(X) - 2*SIN(X))
- ------------------------
5
int(1/(x^2-2),x);
SQRT(2)*(LOG( - SQRT(2) + X) - LOG(SQRT(2) + X))
------------------------------------------------
4
int(sin(x)/(4 + cos(x)**2),x);
COS(X)
ATAN(------)
2
- ------------
2
int(1/sqrt(x^2-x),x);
SQRT(X)*SQRT(X - 1)
INT(-------------------,X)
2
X -X
</TT></PRE><P>Note that REDUCE couldn't handle the last integral with its defaul
t
integrator, since the integrand involves a square root. However,
the integral can be found using the
<A HREF=r38_0265.html>algint</A> package.
Alternatively, you could add a rule using the
<A HREF=r38_0199.html>let</A> statement
to evaluate this integral.
<P>
<P>
The arbitrary constant of integration is not shown. Definite integrals can
be found by evaluating the result at the limits of integration (use
<A HREF=r38_0330.html>rounded</A>) and subtracting the lower from the higher. Ev
aluation can
be easily done by the
<A HREF=r38_0182.html>sub</A> operator.
<P>
<P>
When <em>int</em> cannot find an integral it returns an expression
involving formal <em>int</em> expressions unless the switch
<A HREF=r38_0288.html>failhard</A> has been set. If not all of the expression
can be integrated, the switch
<A HREF=r38_0311.html>nolnr</A> controls whether a partially
integrated result should be returned or not.
<P>
<P>
<P>
<P>
<A NAME=INTERPOL>
<TITLE>INTERPOL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INTERPOL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<em>interpol</em>generates an interpolation polynomial.
<P> <H3>
syntax: </H3>
<P>
<P>
interpol(<values>,<variable>,<points>)
<P>
<P>
<P>
<values> and <points> are
<A HREF=r38_0053.html>list</A>s of equal length and
<variable> is an algebraic expression (preferably a
<A HREF=r38_0002.html>kernel</A>).
The interpolation polynomial is generated in the given variable of degree
length(<values>)-1. The unique polynomial <em>f</em> is defined by the
property that for corresponding elements <em>v</em> of <values> and
<em>p</em> of <points> the relation <em>f(p)=v</em> holds.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
f := for i:=1:4 collect(i**3-1);
F := 0,7,26,63
p := {1,2,3,4};
P := 1,2,3,4
interpol(f,x,p);
3
X - 1
</TT></PRE><P>The Aitken-Neville interpolation algorithm is used which guarantee
s a
stable result even with rounded numbers and an ill-conditioned problem.
<P>
<P>
<P>
<A NAME=LCOF>
<TITLE>LCOF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LCOF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>lcof</em> operator returns the leading coefficient of a given expression
with respect to a given variable.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>lcof</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> is ordinarily a polynomial. If
<A HREF=r38_0322.html>ratarg</A> is on,
a rational expression may also be used, otherwise an error results.
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
lcof((x+2*y)**5,y);
32
lcof((x + y*sin(x))**2 + cos(x)*sin(x)**2,sin(x));
2
COS(X) + Y
lcof(x**2 + 3*x + 17,y);
2
X + 3*X + 17
</TT></PRE><P>If the kernel does not appear in the expression, <em>lcof</em> ret
urns the
expression.
<P>
<P>
<P>
<A NAME=LENGTH>
<TITLE>LENGTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LENGTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>length</em> operator returns the number of items in a
<A HREF=r38_0053.html>list</A>, the
number of
terms in an expression, or the dimensions of an array or matrix.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>length</em>(<expr>) or <em>length</em> <expr>
<P>
<P>
<P>
<expr> can be a list structure, an array, a matrix, or a scalar expression
.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
alist := {a,b,{ww,xx,yy,zz}};
ALIST := {A,B,{WW,XX,YY,ZZ}}
length alist;
3
length third alist;
4
dlist := {d};
DLIST := {D}
length rest dlist;
0
matrix mmm(4,5);
length mmm;
{4,5}
array aaa(5,3,2);
length aaa;
{6,4,3}
eex := (x+3)**2/(x-y);
2
X + 6*X + 9
EEX := ------------
X - Y
length eex;
5
</TT></PRE><P>An item in a list that is itself a list only counts as one item. A
n error
message will be printed if <em>length</em> is called on a matrix which has
not had its dimensions set. The <em>length</em> of an array includes the
zeroth element of each dimension, showing the full number of elements
allocated. (Declaring an array A with n elements
allocates A(0),A(1),...,A(n).) The
<em>length</em> of an expression is the total number of additive terms
appearing in the numerator and denominator of the expression. Note that
subtraction of a term is represented internally as addition of a negative
term.
<P>
<P>
<P>
<A NAME=LHS>
<TITLE>LHS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LHS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>lhs</em> operator returns the left-hand side of an
<A HREF=r38_0045.html>equation</A>,
such as those
returned in a list by
<A HREF=r38_0179.html>solve</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>lhs</em>(<equation>) or <em>lhs</em> <equation>
<P>
<P>
<P>
<P>
<equation> must be an equation of the form
<P>
<P>
<em>left-hand side</em><em>=</em><em>right-hand side</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
polly := (x+3)*(x^4+2x+1);
5 4 2
POLLY := X + 3*X + 2*X + 7*X + 3
pollyroots := solve(polly,x);
POLLYROOTS := {X=ROOT F(X3 - X2 + X + 1,X ,
O )
X=-1,
X=-3}
variable := lhs first pollyroots;
VARIABLE := X
</TT></PRE><P>
<A NAME=LIMIT>
<TITLE>LIMIT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LIMIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
LIMITS is a fast limit package for REDUCE for functions which are
continuous except for computable poles and singularities, based on
some earlier work by Ian Cohen and John P. Fitch. The Truncated
Power Series package is used for non-critical points, at which
the value of the function is the constant term in the expansion
around that point. l'Hopital's rule is used in critical cases,
with preprocessing of 1-1 forms and reformatting of product forms
in order to apply l'Hopital's rule. A limited amount of bounded
arithmetic is also employed where applicable.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>limit</em>(<expr>,<var>,<limpoint>) or
<P>
<P>
<em>limit!+</em>(<expr>,<var>,<limpoint>) or
<P>
<P>
<em>limit!-</em>(<expr>,<var>,<limpoint>)
<P>
<P>
<P>
where <expr> is an expression depending of the variable <var>
(a
<A HREF=r38_0002.html>kernel</A>) and <limpoint> is the limit point.
If the limit depends upon the direction of approach to the <limpoint>,
the operators <em>limit!+</em> and <em>limit!-</em> may be used.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
limit(x*cot(x),x,0);
0
limit((2x+5)/(3x-2),x,infinity);
2
--
3
</TT></PRE><P>
<A NAME=LPOWER>
<TITLE>LPOWER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LPOWER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>lpower</em> operator returns the leading power of an expression with
respect to a kernel. 1 is returned if the expression does not depend on
the kernel.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>lpower</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> is ordinarily a polynomial. If
<A HREF=r38_0322.html>ratarg</A> is on,
a rational expression may also be used, otherwise an error results.
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
lpower((x+2*y)**6,y);
6
Y
lpower((x + cos(x))**8 + df(x**2,x),cos(x));
8
COS(X)
lpower(x**3 + 3*x,y);
1
</TT></PRE><P>
<A NAME=LTERM>
<TITLE>LTERM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LTERM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>lterm</em> operator returns the leading term of an expression with
respect to a kernel. The expression is returned if it does not depend on
the kernel.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>lterm</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> is ordinarily a polynomial. If
<A HREF=r38_0322.html>ratarg</A> is on,
a rational expression may also be used, otherwise an error results.
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
lterm((x+2*y)**6,y);
6
64*Y
lterm((x + cos(x))**8 + df(x**2,x),cos(x));
8
COS(X)
lterm(x**3 + 3*x,y);
3
X + 3X
</TT></PRE><P>
<A NAME=MAINVAR>
<TITLE>MAINVAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MAINVAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>mainvar</em> operator returns the main variable (in the system's
internal representation) of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mainvar</em>(<expression>)
<P>
<P>
<P>
<P>
<expression> is usually a polynomial, but may be any valid REDUCE
scalar expression. In the case of a rational function, the main variable
of the numerator is returned. The main variable returned is a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
test := (a + b + c)**2;
2 2 2
TEST := A + 2*A*B + 2*A*C + B + 2*B*C + C
mainvar(test);
A
korder c,b,a;
mainvar(test);
C
mainvar(2*cos(x)**2);
COS(X)
mainvar(17);
0
</TT></PRE><P>The main variable is the first variable in the canonical ordering
of
kernels. Generally, alphabetically ordered functions come first, then
alphabetically ordered identifiers (variables). Numbers come last, and as
far as <em>mainvar</em> is concerned belong in the family <em>0</em>. The
canonical ordering can be changed by the declaration
<A HREF=r38_0198.html>korder</A>, as
shown above.
<P>
<P>
<P>
<A NAME=MAP>
<TITLE>MAP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MAP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>map</em> operator applies a uniform evaluation pattern
to all members of a composite structure: a
<A HREF=r38_0345.html>matrix</A>,
a
<A HREF=r38_0053.html>list</A> or the arguments of an
<A HREF=r38_0211.html>operator</A> expression.
The evaluation pattern can be a
unary procedure, an operator, or an algebraic expression with
one free variable.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>map</em>(<function>,<object>)
<P>
<P>
<P>
<object> is a list, a matrix or an operator expression.
<P>
<P>
<function> is
the name of an operator for a single argument: the operator
is evaluated once with each element of <object> as its single argument,
<P>
<P>
or an algebraic expression with exactly one
<A HREF=r38_0061.html>free variable</A>, that is
a variable preceded by the tilde symbol: the expression
is evaluated for each element of <object> where the element is
substituted for the free variable,
<P>
<P>
or a replacement
<A HREF=r38_0060.html>rule</A> of the form
<P> <H3>
syntax: </H3>
<P>
<P>
<em>var</em>=> <em>rep</em>
<P>
<P>
<P>
where <var> is a variable (a <kernel> without subscript)
and <rep> is an expression which contains <var>.
Here <em>rep</em> is evaluated for each element of <object> where
the element is substituted for <em>var</em>. <em>var</em> may be
optionally preceded by a tilde.
<P>
<P>
The rule form for <function> is needed when more than
one free variable occurs.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
map(abs,{1,-2,a,-a});
1,2,abs(a),abs(a)
map(int(~w,x), mat((x^2,x^5),(x^4,x^5)));
[ 3 6 ]
[ x x ]
[---- ----]
[ 3 6 ]
[ ]
[ 5 6 ]
[ x x ]
[---- ----]
[ 5 6 ]
map(~w*6, x^2/3 = y^3/2 -1);
2 3
2*x =3*(y -2)
</TT></PRE><P>You can use <em>map</em> in nested expressions. It is not allowed
to
apply <em>map</em> for a non-composed object, e.g. an identifier or a number.
<P>
<P>
<P>
<A NAME=MKID>
<TITLE>MKID</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MKID</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>mkid</em> command constructs an identifier, given a stem and an identifi
er
or an integer.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mkid</em>(<stem>,<leaf>)
<P>
<P>
<P>
<stem> can be any valid REDUCE identifier that does not include escaped
special characters. <leaf> may be an integer, including one given by a
local variable in a
<A HREF=r38_0047.html>for</A> loop, or any other legal group of
characters.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
mkid(x,3);
X3
factorize(x^15 - 1);
{X - 1,
2
X + X + 1,
4 3 2
X + X + X + X + 1,
8 7 5 4 3
X - X + X - X + X - X + 1}
for i := 1:length ws do write set(mkid(f,i),part(ws,i));
8 7 5 4 3
X - X + X - X + X - X + 1
4 3 2
X + X + X + X + 1
2
X + X + 1
X - 1
</TT></PRE><P>You can use <em>mkid</em> to construct identifiers from inside pro
cedures. This
allows you to handle an unknown number of factors, or deal with variable
amounts of data. It is particularly helpful to attach identifiers to the
answers returned by <em>factorize</em> and <em>solve</em>.
<P>
<P>
<P>
<A NAME=NPRIMITIVE>
<TITLE>NPRIMITIVE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NPRIMITIVE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>nprimitive</em>(<expression>) or <em>nprimitive</em>
<simple\_expression>
<P>
<P>
<P>
This operator returns the numerically-primitive part of any scalar
expression. In other words, any overall integer factors in the expression
are removed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
nprimitive((2x+2y)^2);
2 2
X + 2*X*Y + Y
nprimitive(3*a*b*c);
3*A*B*C
</TT></PRE><P>
<A NAME=NUM>
<TITLE>NUM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>num</em> operator returns the numerator of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>num</em>(<expression>) or <em>num</em> <simple\_expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
num(100/6);
50
num(a/5 + b/6);
6*A + 5*B
num(sin(x));
SIN(X)
</TT></PRE><P><em>num</em>returns the numerator of the expression after it has b
een simplified
by REDUCE. As seen in the examples, this includes putting sums of rational
expressions over a common denominator, and reducing common factors where
possible. If the expression is not a rational expression, it is returned
unchanged.
<P>
<P>
<P>
<A NAME=ODESOLVE>
<TITLE>ODESOLVE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ODESOLVE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>odesolve</em> package is a solver for ordinary differential
equations. At the present time it has still limited capabilities:
<P>
<P>
1. it can handle only a single scalar equation presented as an
algebraic expression or equation, and
<P>
<P>
2. it can solve only first-order equations of simple types, linear
equations with constant coefficients and Euler equations.
<P>
<P>
These solvable types are exactly those for which Lie symmetry
techniques give no useful information.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>odesolve</em>(<expr>,<var1>,<var2>)
<P>
<P>
<P>
<P>
<expr> is a single scalar expression such that <expr>=0
is the ordinary differential equation (ODE for short) to be solved, or
is an equivalent
<A HREF=r38_0045.html>equation</A>.
<P>
<P>
<var1> is the name of the dependent variable,
<var2> is the name of the independent variable.
<P>
<P>
A differential in <expr> is expressed using the
<A HREF=r38_0148.html>df</A>
operator. Note that in most cases you must declare explicitly
<var1> to depend of <var2> using a
<A HREF=r38_0192.html>depend</A>
declaration -- otherwise the derivative might be evaluated to
zero on input to <em>odesolve</em>.
<P>
<P>
The returned value is a list containing the equation giving the general
solution of the ODE (for simultaneous equations this will be a
list of equations eventually). It will contain occurrences of
the operator <em>arbconst</em> for the arbitrary constants in the general
solution. The arguments of <em>arbconst</em> should be new.
A counter <em>!!arbconst</em> is used to arrange this.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
depend y,x;
% A first-order linear equation, with an initial condition
ode:=df(y,x) + y * sin x/cos x - 1/cos x$
odesolve(ode,y,x);
{y=arbconst(1)*cos(x) + sin(x)}
</TT></PRE><P>
<A NAME=ONE_OF>
<TITLE>ONE_OF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ONE\_OF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
The operator <em>one_of</em> is used to represent an indefinite choice
of one element from a finite set of objects.
<P> <H3>
examples: </H3>
<P><PRE><TT>
x=one_of{1,2,5}
</TT></PRE><P>this equation encodes that x can take one of the values
1,2 or 5<P><PRE><TT>
</TT></PRE><P>
REDUCE generates a <em>one_of</em> form in cases when an implicit
<em>root_of</em> expression could be converted to an explicit solution set.
A <em>one_of</em> form can be converted to a <em>solve</em> solution using
<A HREF=r38_0149.html>expand_cases</A>. See
<A HREF=r38_0176.html>root_of</A>.
<P>
<P>
<A NAME=PART>
<TITLE>PART</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PART</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>part</em> permits the extraction of various parts or
operators of expressions and
<A HREF=r38_0053.html>list</A><em>s</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>part</em>(<expression,integer>{,<integer>}*)
<P>
<P>
<P>
<expression> can be any valid REDUCE expression or a list,
integer may be an expression that evaluates to a positive or negative
integer or 0. A positive integer <n> picks up the n th term,
counting from the first term toward the end. A negative integer n
picks up the n th term, counting from the back toward the front. The
integer 0 picks up the operator (which is <em>LIST</em> when the expression
is a
<A HREF=r38_0053.html>list</A>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
part((x + y)**5,4);
2 3
10*X *Y
part((x + y)**5,4,2);
2
X
part((x + y)**5,4,2,1);
X
part((x + y)**5,0);
PLUS
part((x + y)**5,-5);
4
5*X *Y
part((x + y)**5,4) := sin(x);
5 4 3 2 4 5
X + 5*X *Y + 10*X *Y + SIN(X) + 5*X*Y + Y
alist := {x,y,{aa,bb,cc},x**2*sqrt(y)};
2
ALIST := {X,Y,{AA,BB,CC},SQRT(Y)*X }
part(alist,3,2);
BB
part(alist,4,0);
TIMES
</TT></PRE><P>Additional integer arguments after the first one examine the
terms recursively, as shown above. In the third line, the fourth term
is picked from the original polynomial, 10x^2y^3,
then the second term from that, x^2, and finally the first
component, x. If an integer's absolute value is too large for
the appropriate expression, a message is given.
<P>
<P>
<em>part</em>works on the form of the expression as printed, or as it would
have been printed at that point of the calculation, bearing in mind the
current switch settings. It is important to realize that the switch settings
change the operation of <em>part</em>.
<A HREF=r38_0319.html>pri</A> must be on when
<em>part</em> is used.
<P>
<P>
When <em>part</em> is used on a polynomial expression that has minus signs, the
<em>+</em> is always returned as the top-level operator. The minus is found
as a unary operator attached to the negative term.
<P>
<P>
<em>part</em>can also be used to change the relevant part of the expression or
list as shown in the sixth example line. The <em>part</em> operator returns the
changed expression, though original expression is not changed. You can
also use <em>part</em> to change the operator.
<P>
<P>
<P>
<A NAME=PF>
<TITLE>PF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
pf(<expression>,<variable>)
<P>
<P>
<P>
<em>pf</em>transforms <expression> into a
<A HREF=r38_0053.html>list</A> of partial fraction
s
with respect to the main variable, <variable>. <em>pf</em> does a
complete partial fraction decomposition, and as the algorithms used are
fairly unsophisticated (factorization and the extended Euclidean
algorithm), the code may be unacceptably slow in complicated cases.
<P> <H3>
examples: </H3>
<P><PRE><TT>
pf(2/((x+1)^2*(x+2)),x);
2 -2 2
{-----,-----,------------}
X + 2 X + 1 2
X + 2*X + 1
off exp;
pf(2/((x+1)^2*(x+2)),x);
2 - 2 2
{-----,-----,--------}
X + 2 X + 1 2
(X + 1)
for each j in ws sum j;
2
----------------
2
( + 2)*(X + 1)
</TT></PRE><P><P>
<P>
If you want the denominators in factored form, turn
<A HREF=r38_0284.html>exp</A> off, as
shown in the second example above. As shown in the final example, the
<A HREF=r38_0047.html>for</A> <em>each</em> construct can be used to recombine t
he terms.
Alternatively, one can use the operations on lists to extract any desired
term.
<P>
<P>
<P>
<A NAME=PROD>
<TITLE>PROD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PROD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>prod</em> returns
the indefinite or definite product of a given expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>prod</em>(<expr>,<k>[,<lolim> [,<uplim> ]])
<P>
<P>
<P>
<P>
where <expr> is the expression to be multiplied, <k> is the
control variable (a
<A HREF=r38_0002.html>kernel</A>), and <lolim> and <uplim>
uplim are the optional lower and upper limits. If <uplim> is
not supplied the upper limit is taken as <k>. The
Gosper algorithm is used. If there is no closed form solution,
the operator returns the input unchanged.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
prod(k/(k-2),k);
k*( - k + 1)
</TT></PRE><P>
<A NAME=REDUCT>
<TITLE>REDUCT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REDUCT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>reduct</em> operator returns the remainder of its expression after the
leading term with respect to the kernel in the second argument is removed.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>reduct</em>(<expression>,<kernel>)
<P>
<P>
<P>
<expression> is ordinarily a polynomial. If
<A HREF=r38_0322.html>ratarg</A> is on,
a rational expression may also be used, otherwise an error results.
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
reduct((x+y)**3,x);
2 2
Y*(3*X + 3*X*Y + Y )
reduct(x + sin(x)**3,sin(x));
X
reduct(x + sin(x)**3,y);
0
</TT></PRE><P>If the expression does not contain the kernel, <em>reduct</em> ret
urns 0.
<P>
<P>
<P>
<A NAME=REPART>
<TITLE>REPART</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REPART</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>repart</em>(<expression>) or <em>repart</em> <simple\_expression
>
<P>
<P>
<P>
This operator returns the real part of an expression, if that argument has an
numerical value. A non-numerical argument is returned as an expression in
the operators <em>repart</em> and
<A HREF=r38_0153.html>impart</A>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
repart(1+i);
1
repart(a+i*b);
REPART(A) - IMPART(B)
</TT></PRE><P><P>
<P>
<A NAME=RESULTANT>
<TITLE>RESULTANT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RESULTANT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>resultant</em> operator computes the resultant of two polynomials with
respect to a given variable. If the resultant is 0, the polynomials have
a root in common.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>resultant</em>(<expression>,<expression>,<kernel>)
<P>
<P>
<P>
<expression> must be a polynomial containing <kernel> ;
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
resultant(x**2 + 2*x + 1,x+1,x);
0
resultant(x**2 + 2*x + 1,x-3,x);
16
resultant(z**3 + z**2 + 5*z + 5,
z**4 - 6*z**3 + 16*z**2 - 30*z + 55,
z);
0
resultant(x**3*y + 4*x*y + 10,y**2 + 6*y + 4,y);
6 5 4 3 2
Y + 18*Y + 120*Y + 360*Y + 480*Y + 288*Y + 64
</TT></PRE><P>The resultant is the determinant of the Sylvester matrix, formed f
rom the
coefficients of the two polynomials in the following way:
<P>
<P>
Given two polynomials:
<P>
<P>
<P><PRE><TT>
n n-1
a x + a1 x + ... + an
</TT></PRE><P>and
<P>
<P>
<P><PRE><TT>
m m-1
b x + b1 x + ... + bm
</TT></PRE><P>form the (m+n)x(m+n-1) Sylvester matrix by the following means:
<P>
<P>
<P><PRE><TT>
0.......0 a a1 .......... an
0....0 a a1 .......... an 0
. . . .
a0 a1 .......... an 0.......0
0.......0 b b1 .......... bm
0....0 b b1 .......... bm 0
. . . .
b b1 .......... bm 0.......0
</TT></PRE><P>If the determinant of this matrix is 0, the two polynomials have a
common
root. Finding the resultant of large expressions is time-consuming, due
to the time needed to find a large determinant.
<P>
<P>
The sign conventions <em>resultant</em> uses are those given in the article,
``Computing in Algebraic Extensions,'' by R. Loos, appearing in
<Computer Algebra--Symbolic and Algebraic Computation>, 2nd ed.,
edited by B. Buchberger, G.E. Collins and R. Loos, and published by
Springer-Verlag, 1983.
These are:
<P>
<P>
<P><PRE><TT>
resultant(p(x),q(x),x) = (-1)^{deg p(x)*deg q(x)} * resultant(q(x),p(x),x),
resultant(a,p(x),x) = a^{deg p(x)},
resultant(a,b,x) = 1
</TT></PRE><P>where p(x) and q(x) are polynomials which have x as a variable, an
d
a and b are free of x.
<P>
<P>
Error messages are given if <em>resultant</em> is given a non-polynomial
expression, or a non-kernel variable.
<P>
<P>
<P>
<A NAME=RHS>
<TITLE>RHS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RHS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>rhs</em> operator returns the right-hand side of an
<A HREF=r38_0045.html>equation</A>,
such as those returned in a
<A HREF=r38_0053.html>list</A> by
<A HREF=r38_0179.html>solve</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>rhs</em>(<equation>) or <em>rhs</em> <equation>
<P>
<P>
<P>
<equation> must be an equation of the form left-hand side = right-hand
side.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
roots := solve(x**2 + 6*x*y + 5x + 3y**2,x);
2
SQRT(24*Y + 60*Y + 25) + 6*Y + 5
ROOTS := {X= - ---------------------------------,
2
2
SQRT(24*Y + 60*Y + 25) - 6*Y - 5
X= ---------------------------------}
2
root1 := rhs first roots;
2
SQRT(24*Y + 60*Y + 25) + 6*Y + 5
ROOT1 := - ---------------------------------
2
root2 := rhs second roots;
2
SQRT(24*Y + 60*Y + 25) - 6*Y - 5
ROOT2 := ----------------------------------
2
</TT></PRE><P>An error message is given if <em>rhs</em> is applied to something
other than an
equation.
<P>
<P>
<P>
<A NAME=ROOT_OF>
<TITLE>ROOT_OF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOT\_OF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
When the operator
<A HREF=r38_0179.html>solve</A> is unable to find an explicit solution
or if that solution would be too complicated, the result is presented
as formal root expression using the internal operator <em>root_of</em>
and a new local variable. An expression with a top level <em>root_of</em>
is implicitly a list with an unknown number of elements since we
can't always know how many solutions an equation has. If a
substitution is made into such an expression, closed form solutions
can emerge. If this occurs, the <em>root_of</em> construct is
replaced by an operator
<A HREF=r38_0168.html>one_of</A>. At this point it is
of course possible to transform the result if the original <em>solve</em>
operator expression into a standard <em>solve</em> solution. To
effect this, the operator
<A HREF=r38_0149.html>expand_cases</A> can be used.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve(a*x^7-x^2+1,x);
7 2
{x=root_of(a*x_ - x_ + 1,x_)}
sub(a=0,ws);
{x=one_of(1,-1)}
expand_cases ws;
x=1,x=-1
</TT></PRE><P>The components of <em>root_of</em> and <em>one_of</em> expressions
can be
processed as usual with operators
<A HREF=r38_0140.html>arglength</A> and
<A HREF=r38_0169.html>part</A>.
A higher power of a <em>root_of</em> expression with a polynomial
as first argument is simplified by using the polynomial as a side relation.
<P>
<P>
<A NAME=SELECT>
<TITLE>SELECT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SELECT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>select</em> operator extracts from a list
or from the arguments of an n--ary operator elements corresponding
to a boolean predicate. The predicate pattern can be a
unary procedure, an operator or an algebraic expression with
one
<A HREF=r38_0061.html>free variable</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>select</em>(<function>,<object>)
<P>
<P>
<P>
<object> is a
<A HREF=r38_0053.html>list</A>.
<P>
<P>
<function> is
the name of an operator for a single argument: the operator
is evaluated once with each element of <object> as its single argument,
<P>
<P>
or an algebraic expression with exactly one
<A HREF=r38_0061.html>free variable</A>, that is
a variable preceded by the tilde symbol: the expression
is evaluated for each element of <object> where the element is
substituted for the free variable,
<P>
<P>
or a replacement
<A HREF=r38_0060.html>rule</A> of the form
<P> <H3>
syntax: </H3>
<P>
<P>
<em>var</em>=> <em>rep</em>
<P>
<P>
<P>
where <var> is a variable (a <kernel> without subscript)
and <rep> is an expression which contains <var>.
Here <em>rep</em> is evaluated for each element of <object> where
the element is substituted for <em>var</em>. <em>var</em> may be
optionally preceded by a tilde.
<P>
<P>
The rule form for <function> is needed when more than
one free variable occurs. The evaluation result of <function> is
interpreted as
<A HREF=r38_0109.html>boolean value</A> corresponding to the conventions of
REDUCE. The result value is built with the leading operator of the
input expression.
<P> <H3>
examples: </H3>
<P><PRE><TT>
select( ~w>0 , {1,-1,2,-3,3})
{1,2,3}
q:=(part((x+y)^5,0):=list)
select(evenp deg(~w,y),q);
5 3 2 4
{x ,10*x *y ,5*x*y }
select(evenp deg(~w,x),2x^2+3x^3+4x^4);
2 4
2x +4x
</TT></PRE><P><P>
<P>
<A NAME=SHOWRULES>
<TITLE>SHOWRULES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHOWRULES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>showrules</em>(<expression>) or
<em>showrules</em> <simple\_expression>
<P>
<P>
<P>
<em>showrules</em>returns in
<A HREF=r38_0060.html>rule</A><em>-list</em> form any
<A HREF=r38_0211.html>operator</A> rules associated with its argument.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
showrules log;
{LOG(E) => 1,
LOG(1) => 0,
~X
LOG(E ) => ~X,
1
DF(LOG(~X),~X) => --}
~X
</TT></PRE><P>Such rules can then be manipulated further as with any
<A HREF=r38_0053.html>list</A>. For
example
<em>rhs first ws;</em> has the value 1.
<P>
<P>
An operator may have properties that cannot be displayed in such a form,
such as the fact it is an
<A HREF=r38_0208.html>odd</A> function, or has a definition defined
as a procedure.
<P>
<P>
<P>
<A NAME=SOLVE>
<TITLE>SOLVE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SOLVE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>solve</em> operator solves a single algebraic
<A HREF=r38_0045.html>equation</A> or a
system of simultaneous equations.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>solve</em>(<expression> [ , <kernel>]) or
<P>
<P>
<em>solve</em>({<expression>,...} [ ,{ <kernel> ,...}] )
<P>
<P>
<P>
<P>
If the number of equations equals the number of distinct kernels, the
optional kernel argument(s) may be omitted. <expression> is either a
scalar expression or an
<A HREF=r38_0045.html>equation</A>.
When more than one expression is given,
the
<A HREF=r38_0053.html>list</A> of expressions is surrounded by curly braces.
The optional list
of
<A HREF=r38_0002.html>kernel</A>s follows, also in curly braces.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sss := solve(x^2 + 7);
Unknown: X
SSS := {X= - SQRT(7)*I,
X=SQRT(7)*I}
rhs first sss;
- SQRT(7)*I
solve(sin(x^2*y),y);
2*ARBINT(1)*PI
{Y=---------------
2
X
PI*(2*ARBINT(1) + 1)
Y=--------------------}
2
X
off allbranch;
solve(sin(x**2*y),y);
{Y=0}
solve({3x + 5y = -4,2*x + y = -10},{x,y});
22 46
{{X= - --,Y=--}}
7 7
solve({x + a*y + z,2x + 5},{x,y});
5 2*Z - 5
{{X= - -,Y= - -------}}
2 2*A
ab := (x+2)^2*(x^6 + 17x + 1);
8 7 6 3 2
AB := X + 4*X + 4*X + 17*X + 69*X + 72*X + 4
www := solve(ab,x);
{X=ROOT F(X6 + 17*X + 1),X=-2}
O
root_multiplicities;
{1,2}
</TT></PRE><P>Results of the <em>solve</em> operator are returned as
<A HREF=r38_0045.html>equation</A><em>s</em>
in a
<A HREF=r38_0053.html>list</A>.
You can use the usual list access methods (
<A HREF=r38_0046.html>first</A>,
<A HREF=r38_0063.html>second</A>,
<A HREF=r38_0066.html>third</A>,
<A HREF=r38_0057.html>rest</A> and
<A HREF=r38_0169.html>part</A>) to
extract the desired equation, and then use the operators
<A HREF=r38_0175.html>rhs</A> and
<A HREF=r38_0158.html>lhs</A> to access the right-hand or left-hand expression o
f the
equation. When <em>solve</em> is unable to solve an equation, it returns the
unsolved part as the argument of <em>root_of</em>, with the variable renamed
to avoid confusion, as shown in the last example above.
<P>
<P>
For one equation, <em>solve</em> uses square-free factorization, roots of
unity, and the known inverses of the
<A HREF=r38_0088.html>log</A>,
<A HREF=r38_0259.html>sin</A>,
<A HREF=r38_0249.html>cos</A>,
<A HREF=r38_0236.html>acos</A>,
<A HREF=r38_0244.html>asin</A>, and
exponentiation operators. The quadratic, cubic and quartic formulas are
used if necessary, but these are applied only when the switch
<A HREF=r38_0292.html>fullroots</A> is set on; otherwise or when no closed form
is available
the result is returned as
<A HREF=r38_0176.html>root_of</A> expression. The switch
<A HREF=r38_0336.html>trigform</A>
determines which type of cubic and quartic formula is used.
The multiplicity of each solution is given in a list as
the system variable
<A HREF=r38_0017.html>root_multiplicities</A>. For systems of
simultaneous linear equations, matrix inversion is used. For nonlinear
systems, the Groebner basis method is used.
<P>
<P>
Linear equation system solving is influenced by the switch
<A HREF=r38_0276.html>cramer</A>.
<P>
<P>
Singular systems can be solved when the switch
<A HREF=r38_0332.html>solvesingular</A> is
on, which is the default setting. An empty list is returned the system of
equations is inconsistent. For a linear inconsistent system with parameters
the variable
<A HREF=r38_0016.html>requirements</A> constraints
conditions for the system to become consistent.
<P>
<P>
For a solvable linear and polynomial system with parameters
the variable
<A HREF=r38_0005.html>assumptions</A>
contains a list side relations for the parameters: the solution is
valid only as long as none of these expressions is zero.
<P>
<P>
If the switch
<A HREF=r38_0339.html>varopt</A> is on (default), the system rearranges the
variable sequence for minimal computation time. Without <em>varopt</em>
the user supplied variable sequence is maintained.
<P>
<P>
If the solution has free variables (dimension of the solution is greater
than zero), these are represented by
<A HREF=r38_0139.html>arbcomplex</A> expressions
as long as the switch
<A HREF=r38_0268.html>arbvars</A> is on (default). Without
<em>arbvars</em> no explicit equations are generated for free variables.
<P>
<P>
<P>
<P> <H3>
related: </H3>
<P>
_ _ _
<A HREF=r38_0266.html>allbranch</A>switch
<P>
_ _ _
<A HREF=r38_0268.html>arbvars</A> switch
<P>
_ _ _
<A HREF=r38_0005.html>assumptions</A> variable
<P>
_ _ _
<A HREF=r38_0292.html>fullroots</A> switch
<P>
_ _ _
<A HREF=r38_0016.html>requirements</A> variable
<P>
_ _ _
<A HREF=r38_0439.html>roots</A> operator
<P>
_ _ _
<A HREF=r38_0176.html>root_of</A> operator
<P>
_ _ _
<A HREF=r38_0336.html>trigform</A> switch
<P>
_ _ _
<A HREF=r38_0339.html>varopt</A> switch
<P>
<P>
<P>
<A NAME=SORT>
<TITLE>SORT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SORT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sort</em> operator sorts the elements of a list according to
an arbitrary comparison operator.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>sort</em>(<lst>,<comp>)
<P>
<P>
<P>
<lst> is a
<A HREF=r38_0053.html>list</A> of algebraic expressions.
<comp> is a comparison operator which defines a partial
ordering among the members of <lst>. <comp> may be
one of the builtin comparison operators like
<em><</em>(
<A HREF=r38_0115.html>lessp</A>), <em><=</em>(
<A HREF=r38_0114.html>leq</A>)
etc., or <comp> may be the name of a comparison procedure.
Such a procedure has two arguments, and it returns
<A HREF=r38_0122.html>true</A> if the first argument
ranges before the second one, and 0 or
<A HREF=r38_0014.html>nil</A> otherwise.
The result of <em>sort</em> is a new list which contains the
elements of <lst> in a sequence corresponding to <comp>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
procedure ce(a,b);
if evenp a and not evenp b then 1 else 0;
for i:=1:10 collect random(50)$
sort(ws,>=);
{41,38,33,30,28,25,20,17,8,5}
sort(ws,<);
{5,8,17,20,25,28,30,33,38,41}
sort(ws,ce);
{8,20,28,30,38,5,17,25,33,41}
procedure cd(a,b);
if deg(a,x)>deg(b,x) then 1 else
if deg(a,x)<deg(b,x) then 0 else
if deg(a,y)>deg(b,y) then 1 else 0;
sort({x^2,y^2,x*y},cd);
2 2
{x ,x*y,y }
</TT></PRE><P><P>
<P>
<A NAME=STRUCTR>
<TITLE>STRUCTR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STRUCTR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>structr</em> operator breaks its argument expression into named
subexpressions.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>structr</em>(<expression> [,<identifier>[,<identifier> ...
]])
<P>
<P>
<P>
<expression> may be any valid REDUCE scalar expression.
<identifier> may be any valid REDUCE <em>identifier</em>. The first
identifier
is the stem for subexpression names, the second is the name to be assigned
to the structured expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
structr(sqrt(x**2 + 2*x) + sin(x**2*z));
ANS1 + ANS2
where
2
ANS2 := SIN(X *Z)
1/2
ANS1 := ((X + 2)*X)
ans3;
ANS3
on fort;
structr((x+1)**5 + tan(x*y*z),var,aa);
VAR1=TAN(X*Y*Z)
AA=VAR1+X**5+5.*X**4+10.*X**3+10.X**2+5.*X+1
</TT></PRE><P>The second argument to <em>structr</em> is optional. If it is not
given, the
default stem <em>ANS</em> is used by REDUCE to construct names for the
subexpression. The names are only for display purposes: REDUCE does not
store the names and their values unless the switch
<A HREF=r38_0331.html>savestructr</A> is
on.
<P>
<P>
If a third argument is given, the structured expression as a whole is named by
this argument, when
<A HREF=r38_0289.html>fort</A> is on. The expression is not stored
under this
name. You can send these structured Fortran expressions to a file with the
<em>out</em> command.
<P>
<P>
<P>
<A NAME=SUB>
<TITLE>SUB</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SUB</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sub</em> operator substitutes a new expression for a kernel in an
expression.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>sub</em>(<kernel><em>=</em><expression>
{,<kernel><em>=</em><expression>}*,
<expression>) or
<P>
<P>
<em>sub</em>({<kernel><em>=</em><expression>*,
<kernel><em>=</em><em>expression</em>},<expression>)
<P>
<P>
<P>
<kernel> must be a
<A HREF=r38_0002.html>kernel</A>, <expression> can be any REDUCE
scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sub(x=3,y=4,(x+y)**3);
343
x;
X
sub({cos=sin,sin=cos},cos a+sin b)
COS(B) + SIN(A)
</TT></PRE><P>Note in the second example that operators can be replaced using th
e
<em>sub</em> operator.
<P>
<P>
<P>
<A NAME=SUM>
<TITLE>SUM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SUM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>sum</em> returns
the indefinite or definite summation of a given expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sum</em>(<expr>,<k>[,<lolim> [,<uplim> ]])
<P>
<P>
<P>
<P>
where <expr> is the expression to be added, <k> is the
control variable (a
<A HREF=r38_0002.html>kernel</A>), and <lolim> and <uplim>
are the optional lower and upper limits. If <uplim> is
not supplied the upper limit is taken as <k>. The Gosper
algorithm is used. If there is no closed form solution, the operator
returns the input unchanged.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sum(4n**3,n);
2 2
n *(n + 2*n + 1)
sum(2a+2k*r,k,0,n-1);
n*(2*a + n*r - r)
</TT></PRE><P>
<A NAME=WS>
<TITLE>WS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>ws</em> operator alone returns the last result; <em>ws</em> with a
number argument returns the results of the REDUCE statement executed after
that numbered prompt.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>ws</em>or <em>ws</em>(<number>)
<P>
<P>
<P>
<number> must be an integer between 1 and the current REDUCE prompt number
.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>(In the following examples, unlike most others, the nu
mbered
prompt is shown.)<P><PRE><TT>
1: df(sin y,y);
COS(Y)
2: ws^2;
2
COS(Y)
3: df(ws 1,y);
-SIN(Y)
</TT></PRE><P>
<P>
<P>
<em>ws</em>and <em>ws</em><em>(</em><number><em>)</em> can be used anywher
e the
expression they stand for can be used. Calling a number for which no
result was produced, such as a switch setting, will give an error message.
<P>
<P>
The current workspace always contains the results of the last REDUCE
command that produced an expression, even if several input statements
that do not produce expressions have intervened. For example, if you do
a differentiation, producing a result expression, then change several
switches, the operator <em>ws;</em> returns the results of the differentiation.
The current workspace (<em>ws</em>) can also be used inside files, though the
numbered workspace contains only the <em>in</em> command that input the file.
<P>
<P>
There are three history lists kept in your REDUCE session. The first
stores raw input, suitable for the statement editor. The second stores
parsed input, ready to execute and accessible by
<A HREF=r38_0232.html>input</A>. The
third stores results, when they are produced by statements, which are
accessible by the <em>ws</em>< n> operator. If your session is very
long, storage space begins to fill up with these expressions, so it is a
good idea to end the session once in a while, saving needed expressions to
files with the
<A HREF=r38_0133.html>saveas</A> and
<A HREF=r38_0233.html>out</A> commands.
<P>
<P>
An error message is given if a reference number has not yet been used.
<P>
<P>
<P>
<A NAME=g8>
<TITLE>Algebraic Operators</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Algebraic Operators</B><MENU>
<LI><A HREF=r38_0137.html>APPEND operator</A><P>
<LI><A HREF=r38_0138.html>ARBINT operator</A><P>
<LI><A HREF=r38_0139.html>ARBCOMPLEX operator</A><P>
<LI><A HREF=r38_0140.html>ARGLENGTH operator</A><P>
<LI><A HREF=r38_0141.html>COEFF operator</A><P>
<LI><A HREF=r38_0142.html>COEFFN operator</A><P>
<LI><A HREF=r38_0143.html>CONJ operator</A><P>
<LI><A HREF=r38_0144.html>CONTINUED_FRACTION operator</A><P>
<LI><A HREF=r38_0145.html>DECOMPOSE operator</A><P>
<LI><A HREF=r38_0146.html>DEG operator</A><P>
<LI><A HREF=r38_0147.html>DEN operator</A><P>
<LI><A HREF=r38_0148.html>DF operator</A><P>
<LI><A HREF=r38_0149.html>EXPAND\_CASES operator</A><P>
<LI><A HREF=r38_0150.html>EXPREAD operator</A><P>
<LI><A HREF=r38_0151.html>FACTORIZE operator</A><P>
<LI><A HREF=r38_0152.html>HYPOT operator</A><P>
<LI><A HREF=r38_0153.html>IMPART operator</A><P>
<LI><A HREF=r38_0154.html>INT operator</A><P>
<LI><A HREF=r38_0155.html>INTERPOL operator</A><P>
<LI><A HREF=r38_0156.html>LCOF operator</A><P>
<LI><A HREF=r38_0157.html>LENGTH operator</A><P>
<LI><A HREF=r38_0158.html>LHS operator</A><P>
<LI><A HREF=r38_0159.html>LIMIT operator</A><P>
<LI><A HREF=r38_0160.html>LPOWER operator</A><P>
<LI><A HREF=r38_0161.html>LTERM operator</A><P>
<LI><A HREF=r38_0162.html>MAINVAR operator</A><P>
<LI><A HREF=r38_0163.html>MAP operator</A><P>
<LI><A HREF=r38_0164.html>MKID command</A><P>
<LI><A HREF=r38_0165.html>NPRIMITIVE operator</A><P>
<LI><A HREF=r38_0166.html>NUM operator</A><P>
<LI><A HREF=r38_0167.html>ODESOLVE operator</A><P>
<LI><A HREF=r38_0168.html>ONE\_OF type</A><P>
<LI><A HREF=r38_0169.html>PART operator</A><P>
<LI><A HREF=r38_0170.html>PF operator</A><P>
<LI><A HREF=r38_0171.html>PROD operator</A><P>
<LI><A HREF=r38_0172.html>REDUCT operator</A><P>
<LI><A HREF=r38_0173.html>REPART operator</A><P>
<LI><A HREF=r38_0174.html>RESULTANT operator</A><P>
<LI><A HREF=r38_0175.html>RHS operator</A><P>
<LI><A HREF=r38_0176.html>ROOT\_OF operator</A><P>
<LI><A HREF=r38_0177.html>SELECT operator</A><P>
<LI><A HREF=r38_0178.html>SHOWRULES operator</A><P>
<LI><A HREF=r38_0179.html>SOLVE operator</A><P>
<LI><A HREF=r38_0180.html>SORT operator</A><P>
<LI><A HREF=r38_0181.html>STRUCTR operator</A><P>
<LI><A HREF=r38_0182.html>SUB operator</A><P>
<LI><A HREF=r38_0183.html>SUM operator</A><P>
<LI><A HREF=r38_0184.html>WS operator</A><P>
</MENU>
<A NAME=ALGEBRAIC>
<TITLE>ALGEBRAIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ALGEBRAIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>algebraic</em> command changes REDUCE's mode of operation to
algebraic. When <em>algebraic</em> is used as an operator (with an
argument inside parentheses) that argument is evaluated in algebraic
mode, but REDUCE's mode is not changed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
algebraic;
symbolic;
NIL
algebraic(x**2);
2
X
x**2;
***** The symbol X has no value.
</TT></PRE><P>REDUCE's symbolic mode does not know about most algebraic commands
.
Error messages in this mode may also depend on the particular Lisp
used for the REDUCE implementation.
<P>
<P>
<P>
<A NAME=ANTISYMMETRIC>
<TITLE>ANTISYMMETRIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ANTISYMMETRIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
When an operator is declared <em>antisymmetric</em>, its arguments are
reordered to conform to the internal ordering of the system. If an odd
number of argument interchanges are required to do this ordering,
the sign of the expression is changed.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>antisymmetric</em><identifier>{<em>,</em><identifier>}*
<P>
<P>
<P>
<identifier> is an identifier that has been declared as an operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator m,n;
antisymmetric m,n;
m(x,n(1,2));
- M( - N(2,1),X)
operator p;
antisymmetric p;
p(a,b,c);
P(A,B,C)
p(b,a,c);
- P(A,B,C)
</TT></PRE><P>If <identifier> has not been declared an operator, the flag
<em>antisymmetric</em> is still attached to it. When <identifier> is
subsequently used as an operator, the message <em>Declare</em> <identifier
>
<em>operator? (Y or N)</em> is printed. If the user replies <em>y</em>, the
antisymmetric property of the operator is used.
<P>
<P>
Note in the first example, identifiers are customarily ordered
alphabetically, while numbers are ordered from largest to smallest.
The operators may have any desired number of arguments (less than 128).
<P>
<P>
<P>
<A NAME=ARRAY>
<TITLE>ARRAY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARRAY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>array</em> declaration declares a list of identifiers to be of type
<em>array</em>, and sets all their entries to 0.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>array</em><identifier>(<dimensions>)
{<em>,</em><identifier>(<dimensions>)}*
<P>
<P>
<P>
<identifier> may be any valid REDUCE identifier. If the identifier
was already an array, a warning message is given that the array has been
redefined. <dimensions> are of form
<integer>{,<integer>}*.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
array a(2,5),b(3,3,3),c(200);
array a(3,5);
*** ARRAY A REDEFINED
a(3,4);
0
length a;
{4,6}
</TT></PRE><P>Arrays are always global, even if defined inside a procedure or bl
ock
statement. Their status as an array remains until the variable is
reset by
<A HREF=r38_0189.html>clear</A>. Arrays may not have the same names as operators
,
procedures or scalar variables.
<P>
<P>
Array elements are referred to by the usual notation: <em>a(i,j)</em>
returns the jth element of the ith row. The
<A HREF=r38_0065.html>assign</A>ment operator
<em>:=</em> is used to put values into the array. Arrays as a whole
cannot be subject to assignment by
<A HREF=r38_0199.html>let</A> or <em>:=</em> ; the
assignment operator <em>:=</em> is only valid for individual elements.
<P>
<P>
When you use
<A HREF=r38_0199.html>let</A> on an array element, the contents of that
element become the argument to <em>let</em>. Thus, if the element
contains a number or some other expression that is not a valid argument
for this command, you get an error message. If the element contains an
identifier, the identifier has the substitution rule attached to it
globally. The same behavior occurs with
<A HREF=r38_0189.html>clear</A>. If the array
element contains an identifier or simple_expression, it is cleared. Do
<not> use <em>clear</em> to try to set an array element to 0. Because
of the side effects of either <em>let</em> or <em>clear</em>, it is unwise
to apply either of these to array elements.
<P>
<P>
Array indices always start with 0, so that the declaration <em>array a(5)</em>
sets aside 6 units of space, indexed from 0 through 5, and initializes
them to 0. The
<A HREF=r38_0157.html>length</A> command returns a list of the true number of
elements in each dimension.
<P>
<P>
<P>
<A NAME=CLEAR>
<TITLE>CLEAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CLEAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>clear</em> command is used to remove assignments or remove substitution
rules from any expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>clear</em><identifier>{,<identifier>}+ or
<P>
<P>
<let-type statement> <em>clear</em> <identifier>
<P>
<P>
<P>
<identifier> can be any <em>scalar</em>,
<A HREF=r38_0345.html>matrix</A>,
or
<A HREF=r38_0188.html>array</A> variable or
<A HREF=r38_0055.html>procedure</A> name. <let-type statement> can be any
general
or specific
<A HREF=r38_0199.html>let</A> statement (see below in Comments).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
array a(2,3);
a(2,2) := 15;
A(2,2) := 15
clear a;
a(2,2);
Declare A operator? (Y or N)
let x = y + z;
sin(x);
SIN(Y + Z)
clear x;
sin(x);
SIN(X)
let x**5 = 7;
clear x;
x**5;
7
clear x**5;
x**5;
5
X
</TT></PRE><P>Although it is not a good idea, operators of the same name but tak
ing
different numbers of arguments can be defined. Using a <em>clear</em> statement
on any of these operators clears every one with the same name, even if the
number of arguments is different.
<P>
<P>
The <em>clear</em> command is used to ``forget" matrices, arrays, operators
and scalar variables, returning their identifiers to the pristine state
to be used for other purposes. When <em>clear</em> is applied to array
elements, the contents of the array element becomes the argument for
<em>clear</em>. Thus, you get an error message if the element contains a
number, or some other expression that is not a legal argument to
<em>clear</em>. If the element contains an identifier, it is cleared.
When clear is applied to matrix elements, an error message is returned
if the element evaluates to a number, otherwise there is no effect. Do
not try to use <em>clear</em> to set array or matrix elements to 0.
You will not be pleased with the results.
<P>
<P>
If you are trying to clear power or product substitution rules made with
either
<A HREF=r38_0199.html>let</A> or
<A HREF=r38_0195.html>forall</A>...<em>let</em>, you must
reproduce the rule, exactly as you typed it with the same arguments, up to
but not including the equal sign, using the word <em>clear</em> instead of
the word <em>let</em>. This is shown in the last example. Any other type of
<em>let</em> or <em>forall</em>...<em>let</em> substitution can be cleared
with just the variable or operator name.
<A HREF=r38_0205.html>match</A> behaves the same as
<A HREF=r38_0199.html>let</A> in this situation. There is a more complicated exa
mple under
<A HREF=r38_0195.html>forall</A>.
<P>
<P>
<P>
<P>
<A NAME=CLEARRULES>
<TITLE>CLEARRULES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CLEARRULES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>clearrules</em><list>{,<list>}+
<P>
<P>
<P>
The operator <em>clearrules</em> is used to remove previously defined
<A HREF=r38_0060.html>rule</A> lists from the system. <list> can be an exp
licit rule
list, or evaluate to a rule list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
trig1 := {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,
cos(~x)^2 => (1+cos(2*x))/2,
sin(~x)^2 => (1-cos(2*x))/2}$
let trig1;
cos(a)*cos(b);
COS(A - B) + COS(A + B)
-----------------------
2
clearrules trig1;
cos(a)*cos(b);
COS(A)*COS(B)
</TT></PRE><P>
<A NAME=DEFINE>
<TITLE>DEFINE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEFINE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The command <em>define</em> allows you to supply a new name for an identifier
or replace it by any valid REDUCE expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>define</em><identifier><em>=</em><substitution>
{<em>,</em><identifier><em>=</em><substitution>}*
<P>
<P>
<P>
<identifier> is any valid REDUCE identifier, <substitution> can be a
number, an identifier, an operator, a reserved word, or an expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
define is= :=, xx=y+z;
a is 10;
A := 10
xx**2;
2 2
Y + 2*Y*Z + Z
xx := 10;
Y + Z := 10
</TT></PRE><P>The renaming is done at the input level, and therefore takes prece
dence
over any other replacement or substitution declared for the same identifier.
It remains in effect until the end of the REDUCE session. Be careful with
it, since you cannot easily undo it without ending the session.
<P>
<P>
<P>
<A NAME=DEPEND>
<TITLE>DEPEND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEPEND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<em>depend</em>declares that its first argument depends on the rest of its
arguments.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>depend</em><kernel>{<em>,</em><kernel>}+
<P>
<P>
<P>
<kernel> must be a legal variable name or a prefix operator (see
<A HREF=r38_0002.html>kernel</A>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
depend y,x;
df(y**2,x);
2*DF(Y,X)*Y
depend z,cos(x),y;
df(sin(z),cos(x));
COS(Z)*DF(Z,COS(X))
df(z**2,x);
2*DF(Z,X)*Z
nodepend z,y;
df(z**2,x);
2*DF(Z,X)*Z
cc := df(y**2,x);
CC := 2*DF(Y,X)*Y
y := tan x;
Y := TAN(X);
cc;
2
2*TAN(X)*(TAN(X) + 1)
</TT></PRE><P>Dependencies can be removed by using the declaration
<A HREF=r38_0204.html>nodepend</A>.
The differentiation operator uses this information, as shown in the
examples above. Linear operators also use knowledge of dependencies
(see
<A HREF=r38_0200.html>linear</A>). Note that dependencies can be nested: Having
declared y to depend on x, and z
to depend on y, we
see that the chain rule was applied to the derivative of a function of
z with respect to x. If the explicit function of the
dependency is later entered into the system, terms with <em>DF(Y,X)</em>,
for example, are expanded when they are displayed again, as shown in the
last example. The boolean operator
<A HREF=r38_0113.html>freeof</A> allows you to
check the dependency between two algebraic objects.
<P>
<P>
<P>
<A NAME=EVEN>
<TITLE>EVEN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EVEN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>even</em><identifier>{,<identifier>}*
<P>
<P>
<P>
This declaration is used to declare an operator even in its first
argument. Expressions involving an operator declared in this manner are
transformed if the first argument contains a minus sign. Any other
arguments are not affected.
<P> <H3>
examples: </H3>
<P><PRE><TT>
even f;
f(-a)
F(A)
f(-a,-b)
F(A,-B)
</TT></PRE><P><P>
<P>
<A NAME=FACTOR_declaration>
<TITLE>FACTOR_declaration</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FACTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
When a kernel is declared by <em>factor</em>, all terms involving fixed
powers of that kernel are printed as a product of the fixed powers and
the rest of the terms.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>factor</em><kernel> {<em>,</em><kernel>}*
<P>
<P>
<P>
<kernel> must be a
<A HREF=r38_0002.html>kernel</A> or a
<A HREF=r38_0053.html>list</A> of
<em>kernel</em>s.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := (x + y + z)**2;
2 2 2
A := X + 2*X*Y + 2*X*Z + Y + 2*Y*Z + Z
factor y;
a;
2 2 2
Y + 2*Y*(X + Z) + X + 2*X*Z + Z
factor sin(x);
c := df(sin(x)**4*x**2*z,x);
4 3 2
C := 2*SIN(X) *X*Z + 4*SIN(X) *COS(X)*X *Z
remfac sin(x);
c;
3
2*SIN(X) *X*Z*(2*COS(X)*X + SIN(X))
</TT></PRE><P>Use the <em>factor</em> declaration to display variables of intere
st so that
you can see their powers more clearly, as shown in the example. Remove
this special treatment with the declaration
<A HREF=r38_0217.html>remfac</A>. The
<em>factor</em> declaration is only effective when the switch
<A HREF=r38_0319.html>pri</A>
is on.
<P>
<P>
The <em>factor</em> declaration is not a factoring command; to factor
expressions use the
<A HREF=r38_0287.html>factor</A> switch or the
<A HREF=r38_0151.html>factorize</A> command.
<P>
<P>
The <em>factor</em> declaration is helpful in such cases as Taylor polynomials
where the explicit powers of the variable are expected at the top level, not
buried in various factored forms.
<P>
<P>
Note that <em>factor</em> does not affect the order of its arguments. You
should also use
<A HREF=r38_0212.html>order</A> if this is important.
<P>
<P>
<P>
<A NAME=FORALL>
<TITLE>FORALL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FORALL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>forall</em> or (preferably) <em>for all</em> command is used as a
modifier for
<A HREF=r38_0199.html>let</A> statements, indicating the universal applicability
of the rule, with possible qualifications.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>for all</em><identifier>{,<identifier>}* <em>let</em>
<let statement>
<P>
<P>
or
<P>
<P>
<em>for all</em><identifier>{,<identifier>}*
<em>such that</em> <condition> <em>let</em> <let statement>
<P>
<P>
<P>
<identifier> may be any valid REDUCE identifier, <let statement>
can be an operator, a product or power, or a group or block statement.
<condition> must be a logical or comparison operator returning true or
false.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
for all x let f(x) = sin(x**2);
Declare F operator ? (Y or N)
y
f(a);
2
SIN(A )
operator pos;
for all x such that x>=0 let pos(x) = sqrt(x + 1);
pos(5);
SQRT(6)
pos(-5);
POS(-5)
clear pos;
pos(5);
Declare POS operator ? (Y or N)
for all a such that numberp a let x**a = 1;
x**4;
1
clear x**a;
*** X**A not found
for all a clear x**a;
x**4;
1
for all a such that numberp a clear x**a;
x**4;
4
X
</TT></PRE><P>Substitution rules defined by <em>for all</em> or <em>for
all</em>...<em>such that</em> commands that involve products or powers are
cleared by reproducing the command, with exactly the same variable names
used, up to but not including the equal sign, with
<A HREF=r38_0189.html>clear</A>
replacing <em>let</em>, as shown in the last example. Other substitutions
involving variables or operator names can be cleared with just the name,
like any other variable.
<P>
<P>
The
<A HREF=r38_0205.html>match</A> command can also be used in product and power su
bstitutions.
The syntax of its use and clearing is exactly like <em>let</em>. A <em>match
</em>
substitution only replaces the term if it is exactly like the pattern, for
example <em>match x**5 = 1</em> replaces only terms of <em>x**5</em> and not
terms of higher powers.
<P>
<P>
It is easier to declare your potential operator before defining the
<em>for all</em> rule, since the system will ask you to declare it an
operator anyway. Names of declared arrays or matrices or scalar
variables are invalid as operator names, to avoid ambiguity. Either
<em>for all</em>...<em>let</em> statements or procedures are often used to defin
e
operators. One difference is that procedures implement ``call by value"
meaning that assignments involving their formal parameters do not change
the calling variables that replace them. If you use assignment statements
on the formal parameters in a <em>for all</em>...<em>let</em> statement, the
effects are seen in the calling variables. Be careful not to redefine a
system operator unless you mean it: the statement <em>for all x let
sin(x)=0;</em> has exactly that effect, and the usual definition for sin(x) has
been lost for the remainder of the REDUCE session. <P>
<P>
<P>
<P>
<A NAME=INFIX>
<TITLE>INFIX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INFIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<em>infix</em>declares identifiers to be infix operators.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>infix</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> can be any valid REDUCE identifier, which has not already
been declared an operator, array or matrix, and is not reserved by the
system.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
infix aa;
for all x,y let aa(x,y) = cos(x)*cos(y) - sin(x)*sin(y);
x aa y;
COS(X)*COS(Y) - SIN(X)*SIN(Y)
pi/3 aa pi/2;
SQRT(3)
- -------
2
aa(pi,pi);
1
</TT></PRE><P>A
<A HREF=r38_0199.html>let</A> statement must be used to attach functionality to
the operator. Note that the operator is defined in prefix form in
the <em>let</em> statement.
After its definition, the operator may be used in either prefix or infix
mode. The above operator aa finds the cosine of the sum
of two angles by the formula
<P>
<P>
cos(x+y) = cos(x)*cos(y) - sin(x)*sin(y).
<P>
<P>
Precedence may be attached to infix operators with the
<A HREF=r38_0213.html>precedence</A> declaration.
<P>
<P>
User-defined infix operators may be used in prefix form. If they are used
in infix form, a space must be left on each side of the operator to avoid
ambiguity. Infix operators are always binary.
<P>
<P>
<P>
<A NAME=INTEGER>
<TITLE>INTEGER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INTEGER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>integer</em> declaration must be made immediately after a
<A HREF=r38_0040.html>begin</A> (or other variable declaration such as
<A HREF=r38_0216.html>real</A>
and
<A HREF=r38_0218.html>scalar</A>) and declares local integer variables. They are
initialized to 0.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>integer</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> may be any valid REDUCE identifier, except
<em>t</em> or <em>nil</em>.
<P>
<P>
Integer variables remain local, and do not share values with variables of
the same name outside the
<A HREF=r38_0040.html>begin</A>...<em>end</em> block. When the
block is finished, the variables are removed. You may use the words
<A HREF=r38_0216.html>real</A> or
<A HREF=r38_0218.html>scalar</A> in the place of <em>integer</em>.
<em>integer</em> does not indicate typechecking by the
current REDUCE; it is only for your own information. Declaration
statements must immediately follow the <em>begin</em>, without a semicolon
between <em>begin</em> and the first variable declaration.
<P>
<P>
Any variables used inside <em>begin</em>...<em>end</em> blocks that were not
declared <em>scalar</em>, <em>real</em> or <em>integer</em> are global, and any
change made to them inside the block affects their global value. Any
<A HREF=r38_0188.html>array</A> or
<A HREF=r38_0345.html>matrix</A> declared inside a block is always global.
<P>
<P>
<P>
<A NAME=KORDER>
<TITLE>KORDER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>KORDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>korder</em> declaration changes the internal canonical ordering of
kernels.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>korder</em><kernel>{<em>,</em><kernel>}*
<P>
<P>
<P>
<kernel> must be a REDUCE
<A HREF=r38_0002.html>kernel</A> or a
<A HREF=r38_0053.html>list</A> of
<em>kernel</em>s.
<P>
<P>
The declaration <em>korder</em> changes the internal ordering, but not the print
ordering, so the effects cannot be seen on output. However, in some
calculations, the order of the variables can have significant effects on the
time and space demands of a calculation. If you are doing a demanding
calculation with several kernels, you can experiment with changing the
canonical ordering to improve behavior.
<P>
<P>
The first kernel in the argument list is given the highest priority, the
second gets the next highest, and so on. Kernels not named in a
<em>korder</em> ordering otherwise. A new <em>korder</em> declaration replaces
the previous one. To return to canonical ordering, use the command
<em>korder nil</em>.
<P>
<P>
To change the print ordering, use the declaration
<A HREF=r38_0212.html>order</A>.
<P>
<P>
<P>
<A NAME=LET>
<TITLE>LET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>let</em> command defines general or specific substitution rules.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>let</em><identifier> <em>=</em> <expression>{,<identifier>
<em>=</em> <expression>}*
<P>
<P>
<P>
<identifier> can be any valid REDUCE identifier except an array, and in
some cases can be an expression; <expression> can be any valid REDUCE
expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
let a = sin(x);
b := a;
B := SIN X;
let c = a;
exp(a);
SIN(X)
E
a := x**2;
2
A := X
exp(a);
2
X
E
exp(b);
SIN(X)
E
exp(c);
2
X
E
let m + n = p;
(m + n)**5;
5
P
operator h;
let h(u,v) = u - v;
h(u,v);
U - V
h(x,y);
H(X,Y)
array q(10);
let q(1) = 15;
***** Substitution for 0 not allowed
</TT></PRE><P>The <em>let</em> command is also used to activate a <em>rule sets
</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>let</em><list>{,<list>}+
<P>
<P>
<P>
<list> can be an explicit
<A HREF=r38_0060.html>rule</A> <em>list</em>, or evaluate
to a rule list.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
trig1 := {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,
cos(~x)^2 => (1+cos(2*x))/2,
sin(~x)^2 => (1-cos(2*x))/2}$
let trig1;
cos(a)*cos(b);
COS(A - B) + COS(A + B)
------------------------
2
</TT></PRE><P>A <em>let</em> command returns no value, though the substitution r
ule is
entered. Assignment rules made by
<A HREF=r38_0065.html>assign</A> and <em>let</em>
rules are at the
same level, and cancel each other. There is a difference in their
operation, however, as shown in the first example: a <em>let</em> assignment
tracks the changes in what it is assigned to, while a <em>:=</em> assignment
is fixed at the value it originally had.
<P>
<P>
The use of expressions as left-hand sides of <em>let</em> statements is a
little complicated. The rules of operation are:
<P>
<P>
_ _ _ (i)
Expressions of the form A*B = C do not change A, B or C, but set A*B to C.
<P>
<P>
_ _ _ (ii)
Expressions of the form A+B = C substitute C - B for A, but do not change
B or C.
<P>
<P>
_ _ _ (iii)
Expressions of the form A-B = C substitute B + C for A, but do not change
B or C.
<P>
<P>
_ _ _ (iv)
Expressions of the form A/B = C substitute B*C for A, but do not change B or
C.
<P>
<P>
_ _ _ (v)
Expressions of the form A**N = C substitute C for A**N in every expression of
a power of A to N or greater. An asymptotic command such as A**N = 0 sets
all terms involving A to powers greater than or equal to N to 0. Finite
fields may be generated by requiring modular arithmetic (the
<A HREF=r38_0305.html>modular</A>
switch) and defining the primitive polynomial via a <em>let</em> statement.
<P>
<P>
<P>
<em>let</em>substitutions involving expressions are cleared by using
the
<A HREF=r38_0189.html>clear</A> command with exactly the same expression.
<P>
<P>
Note when a simple <em>let</em> statement is used to assign functionality to an
operator, it is valid only for the exact identifiers used. For the use of the
<em>let</em> command to attach more general functionality to an operator,
see
<A HREF=r38_0195.html>forall</A>.
<P>
<P>
Arrays as a whole cannot be arguments to <em>let</em> statements, but
matrices as a whole can be legal arguments, provided both arguments are
matrices. However, it is important to note that the two matrices are then
linked. Any change to an element of one matrix changes the corresponding
value in the other. Unless you want this behavior, you should not use
<em>let</em> for matrices. The assignment operator
<A HREF=r38_0065.html>assign</A> can be used
for non-tracking assignments, avoiding the side effects. Matrices are
redimensioned as needed in <em>let</em> statements.
<P>
<P>
When array or matrix elements are used as the left-hand side of <em>let</em>
statements, the contents of that element is used as the argument. When the
contents is a number or some other expression that is not a valid left-hand
side for <em>let</em>, you get an error message. If the contents is an
identifier or simple expression, the <em>let</em> rule is globally attached
to that identifier, and is in effect not only inside the array or matrix,
but everywhere. Because of such unwanted side effects, you should not
use <em>let</em> with array or matrix elements. The assignment operator
<em>:=</em> can be used to put values into array or matrix elements without
the side effects.
<P>
<P>
Local variables declared inside <em>begin</em>...<em>end</em> blocks cannot
be used as the left-hand side of <em>let</em> statements. However,
<A HREF=r38_0040.html>begin</A>...<em>end</em> blocks themselves can be used as
the
right-hand side of <em>let</em> statements. The construction:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>for all</em><vars>
<em>let</em><operator>(<vars>)<em>=</em><block>
<P>
<P>
<P>
is an alternative to the
<P> <H3>
syntax: </H3>
<P>
<P>
<em>procedure</em><name>(<vars>)<em>;</em><block>
<P>
<P>
<P>
construction. One important difference between the two constructions is that
the <vars> as formal parameters to a procedure have their global values
protected against change by the procedure, while the <vars> of a
<em>let</em> statement are changed globally by its actions.
<P>
<P>
Be careful in using a construction such as <em>let x = x + 1</em> except inside
a controlled loop statement. The process of resubstitution continues until
a stack overflow message is given.
<P>
<P>
The <em>let</em> statement may be used to make global changes to variables from
inside procedures. If <em>x</em> is a formal parameter to a procedure, the
command <em>let x = </em>... makes the change to the calling variable.
For example, if a procedure was defined by
<P><PRE><TT>
procedure f(x,y);
let x = 15;
</TT></PRE><P><P>
<P>
and the procedure was called as
<P><PRE><TT>
f(a,b);
</TT></PRE><P><P>
<P>
<em>a</em>would have its value changed to 15. Be careful when using <em>let</em>
statements inside procedures to avoid unwanted side effects.
<P>
<P>
It is also important to be careful when replacing <em>let</em> statements with
other <em>let</em> statements. The overlapping of these substitutions can be
unpredictable. Ordinarily the latest-entered rule is the first to be applied.
Sometimes the previous rule is superseded completely; other times it stays
around as a special case. The order of entering a set of related <em>let</em>
expressions is very important to their eventual behavior. The best
approach is to assume that the rules will be applied in an arbitrary order.
<P>
<P>
<P>
<A NAME=LINEAR>
<TITLE>LINEAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LINEAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
An operator can be declared linear in its first argument over powers of
its second argument by the declaration <em>linear.</em>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>linear</em><operator>{<em>,</em><operator>}*
<P>
<P>
<P>
<operator> must have been declared to be an operator. Be careful not
to use a system operator name, because this command may change its definition.
The operator being declared must have at least two arguments, and the
second one must be a
<A HREF=r38_0002.html>kernel</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f;
linear f;
f(0,x);
0
f(-y,x);
- F(1,X)*Y
f(y+z,x);
F(1,X)*(Y + Z)
f(y*z,x);
F(1,X)*Y*Z
depend z,x;
f(y*z,x);
F(Z,X)*Y
f(y/z,x);
1
F(-,X)*Y
Z
depend y,x;
f(y/z,x);
Y
F(-,X)
Z
nodepend z,x;
f(y/z,x);
F(Y,X)
------
Z
f(2*e**sin(x),x);
SIN(X)
2*F(E ,X)
</TT></PRE><P>Even when the operator has not had its functionality attached, it
exhibits
linear properties as shown in the examples. Notice the difference when
dependencies are added. Dependencies are also in effect when the operator's
first argument contains its second, as in the last line above.
<P>
<P>
For a fully-developed example of the use of linear operators, refer to the
article in the <Journal of Computational Physics>, Vol. 14 (1974), pp.
301-317, ``Analytic Computation of Some Integrals in Fourth Order Quantum
Electrodynamics," by J.A. Fox and A.C. Hearn. The article includes the
complete listing of REDUCE procedures used for this work.
<P>
<P>
<P>
<A NAME=LINELENGTH>
<TITLE>LINELENGTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LINELENGTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>linelength</em> declaration sets the length of the output line. Default
is 80.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>linelength</em><expression>
<P>
<P>
<P>
To change the linelength,
<expression> must evaluate to a positive integer less than 128
(although this varies from system to system), and should not be less than
20 or so for proper operation.
<P>
<P>
<em>linelength</em>returns the previous linelength. If you want the current
linelength value, but not change it, say <em>linelength nil</em>.
<P>
<P>
<P>
<A NAME=LISP>
<TITLE>LISP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LISP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>lisp</em> command changes REDUCE's mode of operation to symbolic. When
<em>lisp</em> is followed by an expression, that expression is evaluated in
symbolic mode, but REDUCE's mode is not changed. This command is
equivalent to
<A HREF=r38_0221.html>symbolic</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
lisp;
NIL
car '(a b c d e);
A
algebraic;
c := (lisp car '(first second))**2;
2
C := FIRST
</TT></PRE><P>
<A NAME=LISTARGP>
<TITLE>LISTARGP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LISTARGP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>listargp</em><operator>{<em>,</em><operator>}*
<P>
<P>
<P>
If an operator other than those specifically defined for lists is given a
single argument that is a
<A HREF=r38_0053.html>list</A>, then the result of this
operation will be a list in which that operator is applied to each element
of the list.
This process can be inhibited for a specific operator, or list of operators,
by using the declaration <em>listargp</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
log {a,b,c};
LOG(A),LOG(B),LOG(C)
listargp log;
log {a,b,c};
LOG(A,B,C)
</TT></PRE><P>It is possible to inhibit such distribution globally by turning on
the
switch
<A HREF=r38_0303.html>listargs</A>. In addition, if an operator has more than on
e
argument, no such distribution occurs, so <em>listargp</em> has no effect.
<P>
<P>
<P>
<A NAME=NODEPEND>
<TITLE>NODEPEND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NODEPEND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>nodepend</em> declaration removes the dependency declared with
<A HREF=r38_0192.html>depend</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>nodepend</em><dep-kernel>{,<kernel>}+
<P>
<P>
<P>
<P>
<dep-kernel> must be a kernel that has had a dependency declared upon the
one or more other kernels that are its other arguments.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
depend y,x,z;
df(sin y,x);
COS(Y)*DF(Y,X)
df(sin y,x,z);
COS(Y)*DF(Y,X,Z) - DF(Y,X)*DF(Y,Z)*SIN(Y)
nodepend y,z;
df(sin y,x);
COS(Y)*DF(Y,X)
df(sin y,x,z);
0
</TT></PRE><P>A warning message is printed if the dependency had not been declar
ed by
<em>depend</em>.
<P>
<P>
<P>
<A NAME=MATCH>
<TITLE>MATCH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATCH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>match</em> command is similar to the
<A HREF=r38_0199.html>let</A> command, except
that it matches only explicit powers in substitution.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>match</em><expr> <em>=</em> <expression>{,<expr>
<em>=</em><expression>}*
<P>
<P>
<P>
<expr> is generally a term involving powers, and is limited by
the rules for the
<A HREF=r38_0199.html>let</A> command. <expression> may be
any valid REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
match c**2*a**2 = d;
(a+c)**4;
4 3 3 4
A + 4*A *C + 4*A*C + C + 6*D
match a+b = c;
a + 2*b;
B + C
(a + b + c)**2;
2 2 2
A - B + 2*B*C + 3*C
clear a+b;
(a + b + c)**2;
2 2 2
A + 2*A*B + 2*A*C + B + 2*B*C + C
let p*r = s;
match p*q = ss;
(a + p*r)**2;
2 2
A + 2*A*S + S
(a + p*q)**2;
2 2 2
A + 2*A*SS + P *Q
</TT></PRE><P>Note in the last example that <em>a + b</em> has been explicitly m
atched
after the squaring was done, replacing each single power of <em>a</em> by
<em>c - b</em>. This kind of substitution, although following the rules, is
confusing and could lead to unrecognizable results. It is better to use
<em>match</em> with explicit powers or products only. <em>match</em> should
not be used inside procedures for the same reasons that <em>let</em> should
not be.
<P>
<P>
Unlike
<A HREF=r38_0199.html>let</A> substitutions, <em>match</em> substitutions are ex
ecuted
after all other operations are complete. The last example shows the
difference. <em>match</em> commands can be cleared by using
<A HREF=r38_0189.html>clear</A>,
with exactly the expression that the original <em>match</em> took.
<em>match</em> commands can also be done more generally with <em>for all</em>
or
<A HREF=r38_0195.html>forall</A>...<em>such that</em> commands.
<P>
<P>
<P>
<A NAME=NONCOM>
<TITLE>NONCOM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NONCOM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<em>noncom</em>declares that already-declared operators are noncommutative
under multiplication.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>noncom</em><operator>{,<operator>}*
<P>
<P>
<P>
<operator> must have been declared an
<A HREF=r38_0211.html>operator</A>, or a warning
message is given.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f,h;
noncom f;
f(a)*f(b) - f(b)*f(a);
F(A)*F(B) - F(B)*F(A)
h(a)*h(b) - h(b)*h(a);
0
operator comm;
for all x,y such that x neq y and ordp(x,y)
let f(x)*f(y) = f(y)*f(x) + comm(x,y);
f(1)*f(2);
F(1)*F(2)
f(2)*f(1);
COMM(2,1) + F(1)*F(2)
</TT></PRE><P>The last example introduces the commutator of f(x) and f(y)
for all x and y. The equality check is to prevent an infinite loop. The
operator f can have other functionality attached to it if desired, or it
can remain an indeterminate operator.
<P>
<P>
<P>
<A NAME=NONZERO>
<TITLE>NONZERO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NONZERO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>nonzero</em><identifier>{,<identifier>}*
<P>
<P>
<P>
If an
<A HREF=r38_0211.html>operator</A> <em>f</em> is declared
<A HREF=r38_0208.html>odd</A>, then <em>f(0)</em>
is replaced by zero unless <em>f</em> is also declared non zero by the
declaration <em>nonzero</em>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
odd f;
f(0)
0
nonzero f;
f(0)
F(0)
</TT></PRE><P><P>
<P>
<A NAME=ODD>
<TITLE>ODD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ODD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>odd</em><identifier>{,<identifier>}*
<P>
<P>
<P>
This declaration is used to declare an operator odd in its first
argument. Expressions involving an operator declared in this manner are
transformed if the first argument contains a minus sign. Any other
arguments are not affected.
<P> <H3>
examples: </H3>
<P><PRE><TT>
odd f;
f(-a)
-F(A)
f(-a,-b)
-F(A,-B)
f(a,-b)
F(A,-B)
</TT></PRE><P><P>
<P>
If say <em>f</em> is declared odd, then <em>f(0)</em> is replaced by zero
unless <em>f</em> is also declared non zero by the declaration
<A HREF=r38_0207.html>nonzero</A>.
<P>
<P>
<P>
<A NAME=OFF>
<TITLE>OFF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OFF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>off</em> command is used to turn switches off.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>off</em><switch>{,<switch>}*
<P>
<P>
<P>
<switch> can be any <em>switch</em> name. There is no problem if the
switch is already off. If the switch name is mistyped, an error message is
given.
<P>
<P>
<A NAME=ON>
<TITLE>ON</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ON</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>on</em> command is used to turn switches on.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>on</em><switch>{,<switch>}*
<P>
<P>
<P>
<switch> can be any <em>switch</em> name. There is no problem if the
switch is already on. If the switch name is mistyped, an error message is
given.
<P>
<P>
<A NAME=OPERATOR>
<TITLE>OPERATOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OPERATOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
Use the <em>operator</em> declaration to declare your own operators.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>operator</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> can be any valid REDUCE identifier, which is not the name
of a
<A HREF=r38_0345.html>matrix</A>,
<A HREF=r38_0188.html>array</A>, scalar variable or previously-defined
operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator dis,fac;
let dis(~x,~y) = sqrt(x^2 + y^2);
dis(1,2);
SQRT(5)
dis(a,10);
2
SQRT(A + 100)
on rounded;
dis(1.5,7.2);
7.35459040329
let fac(~n) = if n=0 then 1
else if not(fixp n and n>0)
then rederr "choose non-negative integer"
else for i := 1:n product i;
fac(5);
120
fac(-2);
***** choose non-negative integer
</TT></PRE><P>The first operator is the Euclidean distance metric, the distance
of point
(x,y) from the origin. The second operator is the factorial.
<P>
<P>
Operators can have various properties assigned to them; they can be
declared
<A HREF=r38_0196.html>infix</A>,
<A HREF=r38_0200.html>linear</A>,
<A HREF=r38_0222.html>symmetric</A>,
<A HREF=r38_0187.html>antisymmetric</A>, or
<A HREF=r38_0206.html>noncom</A><em>mutative</em>.
The default operator is prefix, nonlinear, and commutative.
Precedence can also be assigned to operators using the declaration
<A HREF=r38_0213.html>precedence</A>.
<P>
<P>
Functionality is assigned to an operator by a
<A HREF=r38_0199.html>let</A> statement or
a
<A HREF=r38_0195.html>forall</A>...<em>let</em> statement,
(or possibly by a procedure with the name
of the operator). Be careful not to redefine a system operator by
accident. REDUCE permits you to redefine system operators, giving you a
warning message that the operator was already defined. This flexibility
allows you to add mathematical rules that do what you want them to do, but
can produce odd or erroneous behavior if you are not careful.
<P>
<P>
You can declare operators from inside
<A HREF=r38_0055.html>procedure</A>s, as long as they
are not local variables. Operators defined inside procedures are global.
A formal parameter may be declared as an operator, and has the effect of
declaring the calling variable as the operator.
<P>
<P>
<P>
<A NAME=ORDER>
<TITLE>ORDER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ORDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>order</em> declaration changes the order of precedence of kernels for
display purposes only.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>order</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<kernel> must be a valid
<A HREF=r38_0002.html>kernel</A> or
<A HREF=r38_0211.html>operator</A> name
complete with argument or a
<A HREF=r38_0053.html>list</A> of such objects.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x + y + z + cos(a);
COS(A) + X + Y + Z
order z,y,x,cos(a);
x + y + z + cos(a);
Z + Y + X + COS(A)
(x + y)**2;
2 2
Y + 2*Y*X + X
order nil;
(z + cos(z))**2;
2 2
COS(Z) + 2*COS(Z)*Z + Z
</TT></PRE><P><em>order</em>affects the printing order of the identifiers only;
internal
order is unchanged. Change internal order of evaluation with the
declaration
<A HREF=r38_0198.html>korder</A>. You can use <em>order</em> to feature variable
s
or functions you are particularly interested in.
<P>
<P>
Declarations made with <em>order</em> are cumulative: kernels in new order
declarations are ordered behind those in previous declarations, and
previous declarations retain their relative order. Of course, specific
kernels named in new declarations are removed from previous ones and given
the new priority. Return to the standard canonical printing order with the
statement <em>order nil</em>.
<P>
<P>
The print order specified by <em>order</em> commands is not in effect if the
switch
<A HREF=r38_0319.html>pri</A> is off.
<P>
<P>
<P>
<A NAME=PRECEDENCE>
<TITLE>PRECEDENCE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRECEDENCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>precedence</em> declaration attaches a precedence to an infix operator.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>precedence</em><operator>,<known\_operator>
<P>
<P>
<P>
<operator> should have been declared an operator but may be a REDUCE
identifier that is not already an operator, array, or matrix.
<known\_operator> must be a system infix operator or have had its
precedence already declared.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f,h;
precedence f,+;
precedence h,*;
a + f(1,2)*c;
(1 F 2)*C + A
a + h(1,2)*c;
1 H 2*C + A
a*1 f 2*c;
A F 2*C
a*1 h 2*c;
1 H 2*A*C
</TT></PRE><P>The operator whose precedence is being declared is inserted into t
he infix
operator precedence list at the next higher place than <known\_operator>.
<P>
<P>
Attaching a precedence to an operator has the side effect of declaring the
operator to be infix. If the identifier argument for <em>precedence</em> has
not been declared to be an operator, an attempt to use it causes an error
message. After declaring it to be an operator, it becomes an infix operator
with the precedence previously given. Infix operators may be used in prefix
form; if they are used in infix form, a space must be left on each side of
the operator to avoid ambiguity. Declared infix operators are always binary.
<P>
<P>
To see the infix operator precedence list, enter symbolic mode and type
<em>preclis!*;</em>. The lowest precedence operator is listed first.
<P>
<P>
All prefix operators have precedence higher than infix operators.
<P>
<P>
<P>
<A NAME=PRECISION>
<TITLE>PRECISION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRECISION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>precision</em> declaration sets the number of decimal places used when
<A HREF=r38_0330.html>rounded</A> is on. Default is system dependent, and normal
ly about 12.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>precision</em>(<integer>) or <em>precision</em> <integer>
<P>
<P>
<P>
<integer> must be a positive integer. When <integer> is 0, the
current precision is displayed, but not changed. There is no upper limit,
but precision of greater than several hundred causes unpleasantly slow
operation on numeric calculations.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
7/9;
0.777777777778
precision 20;
20
7/9;
0.77777777777777777778
sin(pi/4);
0.7071067811865475244
</TT></PRE><P>Trailing zeroes are dropped, so sometimes fewer than 20 decimal pl
aces are
printed as in the last example. Turn on the switch
<A HREF=r38_0291.html>fullprec</A> if
you want to print all significant digits. The
<A HREF=r38_0330.html>rounded</A> mode
carries calculations to two more places than given by <em>precision</em>, and
rounds off.
<P>
<P>
<P>
<A NAME=PRINT_PRECISION>
<TITLE>PRINT_PRECISION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRINT\_PRECISION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>print_precision</em>(<integer>)
or <em>print_precision</em> <integer>
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, numbers are normally printed to the spec
ified
precision. If the user wishes to print such numbers with less precision,
the printing precision can be set by the declaration <em>print_precision</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1/3;
0.333333333333
print_precision 5;
1/3
0.33333
</TT></PRE><P>
<A NAME=REAL>
<TITLE>REAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>real</em> declaration must be made immediately after a
<A HREF=r38_0040.html>begin</A> (or other variable declaration such as
<A HREF=r38_0197.html>integer</A>
and
<A HREF=r38_0218.html>scalar</A>) and declares local integer variables. They are
initialized to zero.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>real</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> may be any valid REDUCE identifier, except
<em>t</em> or <em>nil</em>.
<P>
<P>
Real variables remain local, and do not share values with variables of the
same name outside the
<A HREF=r38_0040.html>begin</A>...<em>end</em> block. When the
block is finished, the variables are removed. You may use the words
<A HREF=r38_0197.html>integer</A> or
<A HREF=r38_0218.html>scalar</A> in the place of <em>real</em>.
<em>real</em> does not indicate typechecking by the current REDUCE; it is
only for your own information. Declaration statements must immediately
follow the <em>begin</em>, without a semicolon between <em>begin</em> and the
first variable declaration.
<P>
<P>
Any variables used inside a <em>begin</em>...<em>end</em>
<A HREF=r38_0041.html>block</A>
that were not declared <em>scalar</em>, <em>real</em> or <em>integer</em> are
global, and any change made to them inside the block affects their global
value. Any
<A HREF=r38_0188.html>array</A> or
<A HREF=r38_0345.html>matrix</A> declared inside a block is always
global.
<P>
<P>
<P>
<A NAME=REMFAC>
<TITLE>REMFAC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REMFAC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>remfac</em> declaration removes the special factoring treatment of its
arguments that was declared with
<A HREF=r38_0287.html>factor</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>remfac</em><kernel>{,<kernel>}+
<P>
<P>
<P>
<kernel> must be a
<A HREF=r38_0002.html>kernel</A> or
<A HREF=r38_0211.html>operator</A> name that
was declared as special with the
<A HREF=r38_0287.html>factor</A> declaration.
<P>
<P>
<A NAME=SCALAR>
<TITLE>SCALAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SCALAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>scalar</em> declaration must be made immediately after a
<A HREF=r38_0040.html>begin</A> (or other variable declaration such as
<A HREF=r38_0197.html>integer</A>
and
<A HREF=r38_0216.html>real</A>) and declares local scalar variables. They are
initialized to 0.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>scalar</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> may be any valid REDUCE identifier, except <em>t</em> or
<em>nil</em>.
<P>
<P>
Scalar variables remain local, and do not share values with variables of
the same name outside the
<A HREF=r38_0040.html>begin</A>...<em>end</em>
<A HREF=r38_0041.html>block</A>.
When the block is finished, the variables are removed. You may use the
words
<A HREF=r38_0216.html>real</A> or
<A HREF=r38_0197.html>integer</A> in the place of <em>scalar</em>.
<em>real</em> and <em>integer</em> do not indicate typechecking by the current
REDUCE; they are only for your own information. Declaration statements
must immediately follow the <em>begin</em>, without a semicolon between
<em>begin</em> and the first variable declaration.
<P>
<P>
Any variables used inside <em>begin</em>...<em>end</em> blocks that were not
declared <em>scalar</em>, <em>real</em> or <em>integer</em> are global, and any
change made to them inside the block affects their global value. Arrays
declared inside a block are always global.
<P>
<P>
<P>
<A NAME=SCIENTIFIC_NOTATION>
<TITLE>SCIENTIFIC_NOTATION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SCIENTIFIC\_NOTATION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>scientific_notation</em>(<m>) or
<em>scientific_notation</em>({<m>,<n>})
<P>
<P>
<P>
<m> and <n> are positive integers.
<em>scientific_notation</em> 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.,
12345.6. Numbers with more than five digits are printed in scientific
notation, e.g., 1.234567E+5. Similarly, by default, any number with
eleven or more zeros after the decimal point is printed in scientific
notation.
<P>
<P>
When <em>scientific_notation</em> is called with the numerical argument
m a number with more than m digits before the decimal point,
or m or more zeros after the decimal point, is printed in scientific
notation. When <em>scientific_notation</em> is called with a list
{<m>,<n>}, a number with more than m digits before the
decimal point, or n or more zeros after the decimal point is
printed in scientific notation.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
12345.6;
12345.6
123456.5;
1.234565e+5
0.00000000000000012;
1.2e-16
scientific_notation 20;
5,11
5: 123456.7;
123456.7
0.00000000000000012;
0.00000000000000012
</TT></PRE><P>
<A NAME=SHARE>
<TITLE>SHARE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHARE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>share</em> declaration allows access to its arguments by both
algebraic and symbolic modes.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>share</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> can be any valid REDUCE identifier.
<P>
<P>
Programming in
<A HREF=r38_0221.html>symbolic</A> as well as algebraic mode allows
you a wider range
of techniques than just algebraic mode alone. Expressions do not cross the
boundary since they have different representations, unless the <em>share</em>
declaration is used. For more information on using symbolic mode, see
the <REDUCE User's Manual>, and the <Standard Lisp Report>.
<P>
<P>
You should be aware that a previously-declared array is destroyed by the
<em>share</em> declaration. Scalar variables retain their values. You can
share a declared
<A HREF=r38_0345.html>matrix</A> that has not yet
been dimensioned so that it can be
used by both modes. Values that are later put into the matrix are
accessible from symbolic mode too, but not by the usual matrix reference
mechanism. In symbolic mode, a matrix is stored as a list whose first
element is
<A HREF=r38_0343.html>MAT</A>, and whose next elements are the rows of the matri
x
stored as lists of the individual elements. Access in symbolic mode is by
the operators
<A HREF=r38_0046.html>first</A>,
<A HREF=r38_0063.html>second</A>,
<A HREF=r38_0066.html>third</A> and
<A HREF=r38_0057.html>rest</A>.
<P>
<P>
<P>
<A NAME=SYMBOLIC>
<TITLE>SYMBOLIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SYMBOLIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>symbolic</em> command changes REDUCE's mode of operation to symbolic.
When <em>symbolic</em> is followed by an expression, that expression is
evaluated in symbolic mode, but REDUCE's mode is not changed. It is
equivalent to the
<A HREF=r38_0202.html>lisp</A> command.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
symbolic;
NIL
cdr '(a b c);
(B C)
algebraic;
x + symbolic car '(y z);
X + Y
</TT></PRE><P>
<A NAME=SYMMETRIC>
<TITLE>SYMMETRIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SYMMETRIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
When an operator is declared <em>symmetric</em>, its arguments are reordered
to conform to the internal ordering of the system.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>symmetric</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> is an identifier that has been declared an operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator m,n;
symmetric m,n;
m(y,a,sin(x));
M(SIN(X),A,Y)
n(z,m(b,a,q));
N(M(A,B,Q),Z)
</TT></PRE><P>If <identifier> has not been declared to be an operator, the
flag
<em>symmetric</em> is still attached to it. When <identifier> is
subsequently used as an operator, the message <em>Declare</em><identifier>
<em>operator ? (Y or N)</em> is printed. If the user replies <em>y</em>, the
symmetric property of the operator is used.
<P>
<P>
<P>
<A NAME=TR>
<TITLE>TR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>tr</em> declaration is used to trace system or user-written procedures.
It is only useful to those with a good knowledge of both Lisp and the
internal formats used by REDUCE.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>tr</em><name>{,<name>}*
<P>
<P>
<P>
<name> is the name of a REDUCE system procedure or one of your own
procedures.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>The system procedure <em>prepsq</em> is traced,
which prepares REDUCE standard
forms for printing by converting them to a Lisp prefix form.<P><PRE><TT>
tr prepsq;
(PREPSQ)
x**2 + y;
PREPSQ entry:
Arg 1: (((((X . 2) . 1) ((Y . 1) . 1)) . 1)
PREPSQ return value = (PLUS (EXPT X 2) Y)
PREPSQ entry:
Arg 1: (1 . 1)
PREPSQ return value = 1
2
X + Y
untr prepsq;
(PREPSQ)
</TT></PRE><P>
<P>
<P>
This example is for a PSL-based system; the above format will vary if
other Lisp systems are used.
<P>
<P>
When a procedure is traced, the first lines show entry to the procedure and
the arguments it is given. The value returned by the procedure is printed
upon exit. If you are tracing several procedures, with a call to one of
them inside the other, the inner trace will be indented showing procedure
nesting. There are no trace options. However, the format of the trace
depends on the underlying Lisp system used. The trace can be removed with
the command
<A HREF=r38_0224.html>untr</A>. Note that <em>trace</em>, below, is a matrix
operator, while <em>tr</em> does procedure tracing.
<P>
<P>
<P>
<A NAME=UNTR>
<TITLE>UNTR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>UNTR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
<P>
<P>
The <em>untr</em> declaration is used to remove a trace from system or
user-written procedures declared with
<A HREF=r38_0223.html>tr</A>. It is only useful to
those with a good knowledge of both Lisp and the internal formats used by
REDUCE.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>untr</em><name>{,<name>}*
<P>
<P>
<P>
<name> is the name of a REDUCE system procedure or one of your own
procedures that has previously been the argument of a <em>tr</em>
declaration.
<P>
<P>
<A NAME=VARNAME>
<TITLE>VARNAME</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VARNAME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The declaration <em>varname</em> instructs REDUCE to use its argument as the
default Fortran (when
<A HREF=r38_0289.html>fort</A> is on) or
<A HREF=r38_0181.html>structr</A> identifier
and identifier stem, rather than using <em>ANS</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>varname</em><identifier>
<P>
<P>
<P>
<identifier> can be any combination of one or more alphanumeric
characters. Try to avoid REDUCE reserved words.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
varname ident;
IDENT
on fort;
x**2 + 1;
IDENT=X**2+1.
off fort,exp;
structr(((x+y)**2 + z)**3);
3
IDENT2
where
2
IDENT2 := IDENT1 + Z
IDENT1 := X + Y
</TT></PRE><P>
<A HREF=r38_0284.html>exp</A>was turned off so that
<A HREF=r38_0181.html>structr</A> could show the
structure. If <em>exp</em> had been on, the expression would have been
expanded into a polynomial.
<P>
<P>
<P>
<A NAME=WEIGHT>
<TITLE>WEIGHT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WEIGHT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>weight</em> command is used to attach weights to kernels for asymptotic
constraints.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>weight</em><kernel> <em>=</em><number>
<P>
<P>
<P>
<kernel> must be a REDUCE
<A HREF=r38_0002.html>kernel</A>, <number> must be a
positive integer, not 0.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := (x+y)**4;
4 3 2 2 3 4
A := X + 4*X *Y + 6*X *Y + 4*X*Y + Y
weight x=2,y=3;
wtlevel 8;
a;
4
X
wtlevel 10;
a;
2 2 2
X *(6*Y + 4*X*Y + X )
int(x**2,x);
***** X invalid as KERNEL
</TT></PRE><P>Weights and
<A HREF=r38_0229.html>wtlevel</A> are used for asymptotic constraints, where
higher-order terms are considered insignificant.
<P>
<P>
Weights are originally equivalent to 0 until set by a <em>weight</em>
command. To remove a weight from a kernel, use the
<A HREF=r38_0189.html>clear</A>
command. Weights once assigned cannot be changed without clearing the
identifier. Once a weight is assigned to a kernel, it is no longer a
kernel and cannot be used in any REDUCE commands or operators that require
kernels, until the weight is cleared. Note that terms are ordered by
greatest weight.
<P>
<P>
The weight level of the system is set by
<A HREF=r38_0229.html>wtlevel</A>, initially at
2. Since no kernels have weights, no effect from <em>wtlevel</em> can be
seen. Once you assign weights to kernels, you must set <em>wtlevel</em>
correctly for the desired operation. When weighted variables appear in a
term, their weights are summed for the total weight of the term (powers of
variables multiply their weights). When a term exceeds the weight level
of the system, it is discarded from the result expression.
<P>
<P>
<P>
<A NAME=WHERE>
<TITLE>WHERE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WHERE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>where</em> operator provides an infix notation for one-time
substitutions for kernels in expressions.
<P> <H3>
syntax: </H3>
<P>
<P>
<expression> <em>where</em> <kernel>
<em>=</em><expression>
{,<kernel> <em>=</em><expression>}*
<P>
<P>
<P>
<expression> can be any REDUCE scalar expression, <kernel> must
be a
<A HREF=r38_0002.html>kernel</A>. Alternatively a
<A HREF=r38_0060.html>rule</A> or a <em>rule list</em>
can be a member of the right-hand part of a <em>where</em> expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x**2 + 17*x*y + 4*y**2 where x=1,y=2;
51
for i := 1:5 collect x**i*q where q= for j := 1:i product j;
2 3 4 5
{X,2*X ,6*X ,24*X ,120*X }
x**2 + y + z where z=y**3,y=3;
2 3
X + Y + 3
</TT></PRE><P>Substitution inside a <em>where</em> expression has no effect upon
the values
of the kernels outside the expression. The <em>where</em> operator has the
lowest precedence of all the infix operators, which are lower than prefix
operators, so that the substitutions apply to the entire expression
preceding the <em>where</em> operator. However, <em>where</em> is applied
before command keywords such as <em>then</em>, <em>repeat</em>, or <em>do</em>.
<P>
<P>
A
<A HREF=r38_0060.html>rule</A> or a <em>rule set</em> in the right-hand part of
the
<em>where</em> expression act as if the rules were activated by
<A HREF=r38_0199.html>let</A>
immediately before the evaluation of the expression and deactivated
by
<A HREF=r38_0190.html>clearrules</A> immediately afterwards.
<P>
<P>
<em>where</em>gives you a natural notation for auxiliary variables in
expressions. As the second example shows, the substitute expression can be
a command to be evaluated. The substitute assignments are made in
parallel, rather than sequentially, as the last example shows. The
expression resulting from the first round of substitutions is not
reexamined to see if any further such substitutions can be made.
<em>where</em> can also be used to define auxiliary variables in
<A HREF=r38_0055.html>procedure</A> definitions.
<P>
<P>
<P>
<A NAME=WHILE>
<TITLE>WHILE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WHILE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>while</em> command causes a statement to be repeatedly executed until a
given condition is true. If the condition is initially false, the statement
is not executed at all.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>while</em><condition> <em>do</em> <statement>
<P>
<P>
<P>
<condition> is given by a logical operator, <statement> must be a
single REDUCE statement, or a
<A HREF=r38_0038.html>group</A> (<em><<</em>...<em>>></em>) or
<A HREF=r38_0040.html>begin</A>...<em>end</em>
<A HREF=r38_0041.html>block</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := 10;
A := 10
while a <= 12 do <<write a; a := a + 1>>;
10
11
12
while a < 5 do <<write a; a := a + 1>>;
nothing is printed
</TT></PRE><P>
<A NAME=WTLEVEL>
<TITLE>WTLEVEL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WTLEVEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
In conjunction with
<A HREF=r38_0226.html>weight</A>, <em>wtlevel</em> is used to implement
asymptotic constraints. Its default value is 2.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>wtlevel</em><expression>
<P>
<P>
<P>
To change the weight level, <expression> must evaluate to a positive
integer that is the greatest weight term to be retained in expressions
involving kernels with weight assignments. <em>wtlevel</em> returns the
new weight level. If you want the current weight level, but not
change it, say <em>wtlevel nil</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x+y)**4;
4 3 2 2 3 4
X + 4*X *Y + 6*X *Y + 4*X*Y + Y
weight x=2,y=3;
wtlevel 8;
(x+y)**4;
4
X
wtlevel 10;
(x+y)**4;
2 2 2
X *(6*Y + 4*X*Y + X )
int(x**2,x);
***** X invalid as KERNEL
</TT></PRE><P><em>wtlevel</em>is used in conjunction with the command
<A HREF=r38_0226.html>weight</A> to
enable asymptotic constraints. Weight of a term is computed by multiplying
the weights of each variable in it by the power to which it has been
raised, and adding the resulting weights for each variable. If the weight
of the term is greater than <em>wtlevel</em>, the term is dropped from the
expression, and not used in any further computation involving the
expression.
<P>
<P>
Once a weight has been attached to a
<A HREF=r38_0002.html>kernel</A>, it is no longer
recognized by the system as a kernel, though still a variable. It cannot
be used in REDUCE commands and operators that need kernels. The weight
attachment can be undone with a
<A HREF=r38_0189.html>clear</A> command. <em>wtlevel</em> can
be changed as desired.
<P>
<P>
<P>
<A NAME=g9>
<TITLE>Declarations</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Declarations</B><MENU>
<LI><A HREF=r38_0186.html>ALGEBRAIC command</A><P>
<LI><A HREF=r38_0187.html>ANTISYMMETRIC declaration</A><P>
<LI><A HREF=r38_0188.html>ARRAY declaration</A><P>
<LI><A HREF=r38_0189.html>CLEAR command</A><P>
<LI><A HREF=r38_0190.html>CLEARRULES command</A><P>
<LI><A HREF=r38_0191.html>DEFINE command</A><P>
<LI><A HREF=r38_0192.html>DEPEND declaration</A><P>
<LI><A HREF=r38_0193.html>EVEN declaration</A><P>
<LI><A HREF=r38_0194.html>FACTOR declaration</A><P>
<LI><A HREF=r38_0195.html>FORALL command</A><P>
<LI><A HREF=r38_0196.html>INFIX declaration</A><P>
<LI><A HREF=r38_0197.html>INTEGER declaration</A><P>
<LI><A HREF=r38_0198.html>KORDER declaration</A><P>
<LI><A HREF=r38_0199.html>LET command</A><P>
<LI><A HREF=r38_0200.html>LINEAR declaration</A><P>
<LI><A HREF=r38_0201.html>LINELENGTH declaration</A><P>
<LI><A HREF=r38_0202.html>LISP command</A><P>
<LI><A HREF=r38_0203.html>LISTARGP declaration</A><P>
<LI><A HREF=r38_0204.html>NODEPEND declaration</A><P>
<LI><A HREF=r38_0205.html>MATCH command</A><P>
<LI><A HREF=r38_0206.html>NONCOM declaration</A><P>
<LI><A HREF=r38_0207.html>NONZERO declaration</A><P>
<LI><A HREF=r38_0208.html>ODD declaration</A><P>
<LI><A HREF=r38_0209.html>OFF command</A><P>
<LI><A HREF=r38_0210.html>ON command</A><P>
<LI><A HREF=r38_0211.html>OPERATOR declaration</A><P>
<LI><A HREF=r38_0212.html>ORDER declaration</A><P>
<LI><A HREF=r38_0213.html>PRECEDENCE declaration</A><P>
<LI><A HREF=r38_0214.html>PRECISION declaration</A><P>
<LI><A HREF=r38_0215.html>PRINT\_PRECISION declaration</A><P>
<LI><A HREF=r38_0216.html>REAL declaration</A><P>
<LI><A HREF=r38_0217.html>REMFAC declaration</A><P>
<LI><A HREF=r38_0218.html>SCALAR declaration</A><P>
<LI><A HREF=r38_0219.html>SCIENTIFIC\_NOTATION declaration</A><P>
<LI><A HREF=r38_0220.html>SHARE declaration</A><P>
<LI><A HREF=r38_0221.html>SYMBOLIC command</A><P>
<LI><A HREF=r38_0222.html>SYMMETRIC declaration</A><P>
<LI><A HREF=r38_0223.html>TR declaration</A><P>
<LI><A HREF=r38_0224.html>UNTR declaration</A><P>
<LI><A HREF=r38_0225.html>VARNAME declaration</A><P>
<LI><A HREF=r38_0226.html>WEIGHT command</A><P>
<LI><A HREF=r38_0227.html>WHERE operator</A><P>
<LI><A HREF=r38_0228.html>WHILE command</A><P>
<LI><A HREF=r38_0229.html>WTLEVEL command</A><P>
</MENU>
<A NAME=IN>
<TITLE>IN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>in</em> command takes a list of file names and inputs each file into
the system.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>in</em><filename>{,<filename>}*
<P>
<P>
<P>
<filename> must be in the current directory, or be a valid pathname.
If the file name is not an identifier, double quote marks (<em>"</em>) are
needed around the file name.
<P>
<P>
A message is given if the file cannot be found, or has a mistake
in it.
<P>
<P>
Ending the command with a semicolon causes the file to be echoed to the
screen; ending it with a dollar sign does not echo the file. If you want
some but not all of a file echoed, turn the switch
<A HREF=r38_0281.html>echo</A> on or off
in the file.
<P>
<P>
An efficient way to develop procedures in REDUCE is to write them into a file
using a system editor of your choice, and then input the
files into an active REDUCE session. REDUCE reparses the procedure as
it takes information from the file, overwriting the previous procedure
definition. When it accepts the procedure, it echoes its name to the screen.
Data can also be input to the system from files.
<P>
<P>
Files to be read in should always end in
<A HREF=r38_0044.html>end</A><em>;</em> to avoid
end-of-file problems. Note that this is an additional <em>end;</em> to any
ending procedures in the file.
<P>
<P>
<P>
<A NAME=INPUT>
<TITLE>INPUT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INPUT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>input</em> command returns the input expression to the REDUCE numbered
prompt that is its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>input</em>(<number>) or <em>input</em> <number>
<P>
<P>
<P>
<P>
<number> must be between 1 and the current REDUCE prompt number.
<P>
<P>
An expression brought back by <em>input</em> can be reexecuted with new
values or switch settings, or used as an argument in another expression.
The command
<A HREF=r38_0184.html>ws</A> brings back the results of a numbered REDUCE
statement. Two lists contain every input and every output statement since
the beginning of the session. If your session is very long, storage space
begins to fill up with these expressions, so it is a good idea to end the
session once in a while, saving needed expressions to files with the
<A HREF=r38_0133.html>saveas</A> and
<A HREF=r38_0233.html>out</A> commands.
<P>
<P>
Switch settings and
<A HREF=r38_0199.html>let</A> statements can also be reexecuted by using
<em>input</em>.
<P>
<P>
An error message is given if a number is called for that has not yet been used.
<P>
<P>
<P>
<A NAME=OUT>
<TITLE>OUT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OUT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>out</em> command directs output to the filename that is its argument,
until another <em>out</em> changes the output file, or
<A HREF=r38_0234.html>shut</A> closes it.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>out</em><filename> or <em>out "</em><pathname> <em>"
</em> or <em>out t</em>
<P>
<P>
<P>
<filename> must be in the current directory, or be a valid complete
file description for your system. If the file name is not
in the current directory, quote marks are needed around the file name.
If the file already exists, a message is printed allowing you to decide
whether to supersede the contents of the file with new material.
<P>
<P>
To restore output to the terminal, type <em>out t</em>, or
<A HREF=r38_0234.html>shut</A> the
file. When you use <em>out t</em>, the file remains available, and if you
open it again (with another <em>out</em>), new material is appended rather
than overwriting.
<P>
<P>
To write a file using <em>out</em> that can be input at a later time, the
switch
<A HREF=r38_0308.html>nat</A> must be turned off, so that the standard linear fo
rm
is saved that can be read in by
<A HREF=r38_0231.html>in</A>. If <em>nat</em> is on, exponents
are printed on the line above the expression, which causes trouble
when REDUCE tries to read the file.
<P>
<P>
There is a slight complication if you are using the <em>out</em> command from
inside a file to create another file. The
<A HREF=r38_0281.html>echo</A> switch is normally
off at the top-level and on while reading files (so you can see what is
being read in). If you create a file using <em>out</em> at the top-level,
the result lines are printed into the file as you want them. But if you
create such a file from inside a file, the <em>echo</em> switch is on, and
every line is echoed, first as you typed it, then as REDUCE parsed it, and
then once more for the file. Therefore, when you create a file from
a file, you need to turn <em>echo</em> off explicitly before the <em>out</em>
command, and turn it back on when you <em>shut</em> the created file, so your
executing file echoes as it should. This behavior also means that as you
watch the file execute, you cannot see the lines that are being put into
the <em>out</em> file. As soon as you turn <em>echo</em> on, you can see
output again.
<P>
<P>
<P>
<A NAME=SHUT>
<TITLE>SHUT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHUT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The <em>shut</em> command closes output files.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>shut</em><filename>{,<filename>}*
<P>
<P>
<P>
<filename> must have been a file opened by
<A HREF=r38_0233.html>out</A>.
<P>
<P>
A file that has been opened by
<A HREF=r38_0233.html>out</A> must be <em>shut</em> before it is
brought in by
<A HREF=r38_0231.html>in</A>. Files that have been opened by <em>out</em> should
always be <em>shut</em> before the end of the REDUCE session, to avoid either
loss of information or the printing of extraneous information into the file.
In most systems, terminating a session by
<A HREF=r38_0124.html>bye</A> closes all open
output files.
<P>
<P>
<P>
<A NAME=g10>
<TITLE>Input and Output</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Input and Output</B><MENU>
<LI><A HREF=r38_0231.html>IN command</A><P>
<LI><A HREF=r38_0232.html>INPUT command</A><P>
<LI><A HREF=r38_0233.html>OUT command</A><P>
<LI><A HREF=r38_0234.html>SHUT command</A><P>
</MENU>
<A NAME=ACOS>
<TITLE>ACOS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACOS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>acos</em> operator returns the arccosine of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acos</em>(<expression>) or <em>acos</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
acos(ab);
ACOS(AB)
acos 15;
ACOS(15)
df(acos(x*y),x);
2 2
SQRT( - X *Y + 1)*Y
--------------------
2 2
X *Y - 1
on rounded;
res := acos(sqrt(2)/2);
RES := 0.785398163397
res-pi/4;
0
</TT></PRE><P>An explicit numeric value is not given unless the switch
<A HREF=r38_0330.html>rounded</A> is
on and the argument has an absolute numeric value less than or equal to 1.
<P>
<P>
<P>
<A NAME=ACOSH>
<TITLE>ACOSH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACOSH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<em>acosh</em>represents the hyperbolic arccosine of its argument. It takes
an arbitrary scalar expression as its argument. The derivative of
<em>acosh</em> is known to the system. Numerical values may also be found by
turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acosh</em>(<expression>) or <em>acosh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
acosh a;
ACOSH(A)
acosh(0);
ACOSH(0)
df(acosh(a**2),a);
4
2*SQRT(A - 1)*A
----------------
4
A - 1
int(acosh(x),x);
INT(ACOSH(X),X)
</TT></PRE><P>You may attach functionality by defining <em>acosh</em> to be the
inverse of
<em>cosh</em>. This is done by the commands
<P><PRE><TT>
put('cosh,'inverse,'acosh);
put('acosh,'inverse,'cosh);
</TT></PRE><P><P>
<P>
You can write a procedure to attach integrals or other
functions to <em>acosh</em>. You may wish to add a check to see that its
argument is properly restricted.
<P>
<P>
<P>
<A NAME=ACOT>
<TITLE>ACOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<em>acot</em>represents the arccotangent of its argument. It takes
an arbitrary scalar expression as its argument. The derivative of
<em>acot</em> is known to the system. Numerical values may also be found by
turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acot</em>(<expression>) or <em>acot</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
You can add functionality yourself with <em>let</em> and procedures.
<P>
<P>
<A NAME=ACOTH>
<TITLE>ACOTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACOTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<em>acoth</em>represents the inverse hyperbolic cotangent of its argument.
It takes an arbitrary scalar expression as its argument. The derivative
of <em>acoth</em> is known to the system. Numerical values may also be found
by turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acoth</em>(<expression>) or <em>acoth</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array,
matrix or vector expression. <simple\_expression> must be a single
identifier or begin with a prefix operator name. You can add
functionality yourself with <em>let</em> and procedures.
<P>
<P>
<A NAME=ACSC>
<TITLE>ACSC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACSC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>acsc</em> operator returns the arccosecant of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acsc</em>(<expression>) or <em>acsc</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
acsc(ab);
ACSC(AB)
acsc 15;
ACSC(15)
df(acsc(x*y),x);
2 2
-SQRT(X *Y - 1)
----------------
2 2
X*(X *Y - 1)
on rounded;
res := acsc(2/sqrt(3));
RES := 1.0471975512
res-pi/3;
0
</TT></PRE><P>An explicit numeric value is not given unless the switch <em>round
ed</em> is
on and the argument has an absolute numeric value less than or equal to 1.
<P>
<P>
<P>
<A NAME=ACSCH>
<TITLE>ACSCH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ACSCH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>acsch</em> operator returns the hyperbolic arccosecant of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>acsch</em>(<expression>) or <em>acsch</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
acsch(ab);
ACSCH(AB)
acsch 15;
ACSCH(15)
df(acsch(x*y),x);
2 2
-SQRT(X *Y + 1)
----------------
2 2
X*(X *Y + 1)
on rounded;
res := acsch(3);
RES := 0.327450150237
</TT></PRE><P>An explicit numeric value is not given unless the switch <em>round
ed</em> is
on and the argument has an absolute numeric value less than or equal to 1.
<P>
<P>
<P>
<A NAME=ASEC>
<TITLE>ASEC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASEC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>asec</em> operator returns the arccosecant of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>asec</em>(<expression>) or <em>asec</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
asec(ab);
ASEC(AB)
asec 15;
ASEC(15)
df(asec(x*y),x);
2 2
SQRT(X *Y - 1)
---------------
2 2
X*(X *Y - 1)
on rounded;
res := asec sqrt(2);
RES := 0.785398163397
res-pi/4;
0
</TT></PRE><P>An explicit numeric value is not given unless the switch <em>round
ed</em> is
on and the argument has an absolute numeric value greater or equal to 1.
<P>
<P>
<P>
<A NAME=ASECH>
<TITLE>ASECH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASECH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<em>asech</em>represents the hyperbolic arccosecant of its argument. It takes
an arbitrary scalar expression as its argument. The derivative of
<em>asech</em> is known to the system. Numerical values may also be found by
turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>asech</em>(<expression>) or <em>asech</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
asech a;
ASECH(A)
asech(1);
0
df(acosh(a**2),a);
4
2*SQRT(- A + 1)
----------------
4
A*(A - 1)
int(asech(x),x);
INT(ASECH(X),X)
</TT></PRE><P>You may attach functionality by defining <em>asech</em> to be the
inverse of
<em>sech</em>. This is done by the commands
<P><PRE><TT>
put('sech,'inverse,'asech);
put('asech,'inverse,'sech);
</TT></PRE><P><P>
<P>
You can write a procedure to attach integrals or other
functions to <em>asech</em>. You may wish to add a check to see that its
argument is properly restricted.
<P>
<P>
<P>
<A NAME=ASIN>
<TITLE>ASIN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASIN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>asin</em> operator returns the arcsine of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>asin</em>(<expression>) or <em>asin</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
asin(givenangle);
ASIN(GIVENANGLE)
asin(5);
ASIN(5)
df(asin(2*x),x);
2
2*SQRT( - 4*X + 1))
- --------------------
2
4*X - 1
on rounded;
asin .5;
0.523598775598
asin(sqrt(3));
ASIN(1.73205080757)
asin(sqrt(3)/2);
1.04719755120
</TT></PRE><P>A numeric value is not returned by <em>asin</em> unless the switch
<em>rounded</em> is on and its argument has an absolute value less than or
equal to 1.
<P>
<P>
<P>
<A NAME=ASINH>
<TITLE>ASINH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASINH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>asinh</em> operator returns the hyperbolic arcsine of its argument.
The derivative of <em>asinh</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>asinh</em>(<expression>) or <em>asinh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
asinh d;
ASINH(D)
asinh(1);
ASINH(1)
df(asinh(2*x),x);
2
2*SQRT(4*X + 1))
-----------------
2
4*X + 1
</TT></PRE><P>You may attach further functionality by defining <em>asinh</em> to
be the
inverse of <em>sinh</em>. This is done by the commands
<P><PRE><TT>
put('sinh,'inverse,'asinh);
put('asinh,'inverse,'sinh);
</TT></PRE><P><P>
<P>
A numeric value is not returned by <em>asinh</em> unless the switch
<em>rounded</em> is on and its argument evaluates to a number.
<P>
<P>
<P>
<A NAME=ATAN>
<TITLE>ATAN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ATAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>atan</em> operator returns the arctangent of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>atan</em>(<expression>) or <em>atan</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
atan(middle);
ATAN(MIDDLE)
on rounded;
atan 45;
1.54857776147
off rounded;
int(atan(x),x);
2
2*ATAN(X)*X - LOG(X + 1)
-------------------------
2
df(atan(y**2),y);
2*Y
-------
4
Y + 1
</TT></PRE><P>A numeric value is not returned by <em>atan</em> unless the switch
<A HREF=r38_0330.html>rounded</A> is on and its argument evaluates to a number.
<P>
<P>
<P>
<A NAME=ATANH>
<TITLE>ATANH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ATANH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>atanh</em> operator returns the hyperbolic arctangent of its argument.
The derivative of <em>asinh</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>atanh</em>(<expression>) or <em>atanh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
atanh aa;
ATANH(AA)
atanh(1);
ATANH(1)
df(atanh(x*y),y);
- X
----------
2 2
X *Y - 1
</TT></PRE><P>A numeric value is not returned by <em>asinh</em> unless the switc
h
<em>rounded</em> is on and its argument evaluates to a number.
You may attach additional functionality by defining <em>atanh</em> to be the
inverse of <em>tanh</em>. This is done by the commands
<P>
<P>
<P><PRE><TT>
put('tanh,'inverse,'atanh);
put('atanh,'inverse,'tanh);
</TT></PRE><P><P>
<P>
<A NAME=ATAN2>
<TITLE>ATAN2</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ATAN2</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>atan2</em>(<expression>,<expression>)
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression. In
<A HREF=r38_0330.html>rounded</A> mode, if a numerical value exists, <em>atan2
</em> returns
the principal value of the arc tangent of the second argument divided by
the first in the range [-pi,+pi] radians, using the signs of both
arguments to determine the quadrant of the return value. An expression in
terms of <em>atan2</em> is returned in other cases.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
atan2(3,2);
ATAN2(3,2);
on rounded;
atan2(3,2);
0.982793723247
atan2(a,b);
ATAN2(A,B);
atan2(1,0);
1.57079632679
</TT></PRE><P><em>atan2</em>returns a numeric value only if
<A HREF=r38_0330.html>rounded</A> is on. Then
<em>atan2</em> is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<P>
<A NAME=COS>
<TITLE>COS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>cos</em> operator returns the cosine of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cos</em>(<expression>) or <em>cos</em> <simple\_expression>
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression,
<simple\_expression> is a single identifier or begins with a prefix
operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
cos abc;
COS(ABC)
cos(pi);
-1
cos 4;
COS(4)
on rounded;
cos(4);
- 0.653643620864
cos log 5;
- 0.0386319699339
</TT></PRE><P><em>cos</em>returns a numeric value only if
<A HREF=r38_0330.html>rounded</A> is on. Then the
cosine is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<P>
<A NAME=COSH>
<TITLE>COSH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COSH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>cosh</em> operator returns the hyperbolic cosine of its argument.
The derivative of <em>cosh</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cosh</em>(<expression>) or <em>cosh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
cosh b;
COSH(B)
cosh(0);
1
df(cosh(x*y),x);
SINH(X*Y)*Y
int(cosh(x),x);
SINH(X)
</TT></PRE><P>You may attach further functionality by defining its inverse (see
<A HREF=r38_0237.html>acosh</A>).
A numeric value is not returned by <em>cosh</em> unless the switch
<A HREF=r38_0330.html>rounded</A> is on and its argument evaluates to a number.
<P>
<P>
<P>
<P>
<A NAME=COT>
<TITLE>COT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>cot</em> represents the cotangent of its argument. It takes an arbitrary
scalar expression as its argument. The derivative of <em>acot</em> and some
simple properties are known to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cot</em>(<expression>) or <em>cot</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression. <simple\_expression
>
must be a single identifier or begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
cot(a)*tan(a);
COT(A)*TAN(A))
cot(1);
COT(1)
df(cot(2*x),x);
2
- 2*(COT(2*X) + 1)
</TT></PRE><P>Numerical values of expressions involving <em>cot</em> may be foun
d by
turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P>
<P>
<A NAME=COTH>
<TITLE>COTH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COTH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>coth</em> operator returns the hyperbolic cotangent of its argument.
The derivative of <em>coth</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>coth</em>(<expression>) or <em>coth</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression. <simple\_expression
>
must be a single identifier or begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(coth(x*y),x);
2
- Y*(COTH(X*Y) - 1)
coth acoth z;
Z
</TT></PRE><P>You can write
<A HREF=r38_0199.html>let</A> statements and procedures to add further
functionality to <em>coth</em> if you wish. Numerical values of expressions
involving <em>coth</em> may also be found by turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P>
<P>
<A NAME=CSC>
<TITLE>CSC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CSC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>csc</em> operator returns the cosecant of its argument.
The derivative of <em>csc</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>csc</em>(<expression>) or <em>csc</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression. <simple\_expression
>
must be a single identifier or begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
csc(q)*sin(q);
CSC(Q)*SIN(Q)
df(csc(x*y),x);
-COT(X*Y)*CSC(X*Y)*Y
</TT></PRE><P>You can write
<A HREF=r38_0199.html>let</A> statements and procedures to add further
functionality to <em>csc</em> if you wish. Numerical values of expressions
involving <em>csc</em> may also be found by turning on the switch
<A HREF=r38_0330.html>rounded</A>.
<P>
<P>
<P>
<P>
<A NAME=CSCH>
<TITLE>CSCH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CSCH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>cosh</em> operator returns the hyperbolic cosecant of its argument.
The derivative of <em>csch</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>csch</em>(<expression>) or <em>csch</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
csch b;
CSCH(B)
csch(0);
0
df(csch(x*y),x);
- COTH(X*Y)*CSCH(X*Y)*Y
int(csch(x),x);
INT(CSCH(X),X)
</TT></PRE><P>A numeric value is not returned by <em>csch</em> unless the switch
<A HREF=r38_0330.html>rounded</A> is on and its argument evaluates to a number.
<P>
<P>
<P>
<A NAME=ERF>
<TITLE>ERF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ERF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>erf</em> operator represents the error function, defined by
<P>
<P>
erf(x) = (2/sqrt(pi))*int(e^(-x^2),x)
<P>
<P>
A limited number of its properties are known to the system, including the
fact that it is an odd function. Its derivative is known, and from this,
some integrals may be computed. However, a complete integration procedure
for this operator is not currently included.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
erf(0);
0
erf(-a);
- ERF(A)
df(erf(x**2),x);
4*SQRT(PI)*X
------------
4
X
E *PI
int(erf(x),x);
2
X
E *ERF(X)*PI*X + SQRT(PI)
---------------------------
2
X
E *PI
</TT></PRE><P>
<A NAME=EXP>
<TITLE>EXP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>exp</em> operator returns <em>e</em> raised to the power of its argument
.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>exp</em>(<expression>) or <em>exp</em> <simple\_expression>
<P>
<P>
<P>
<expression> can be any valid REDUCE scalar expression.
<simple\_expression> must be a single identifier or begin with a
prefix operator.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
exp(sin(x));
SIN X
E
exp(11);
11
E
on rounded;
exp sin(pi/3);
2.37744267524
</TT></PRE><P>Numeric values are returned only when <em>rounded</em> is on.
The single letter <em>e</em> with the exponential operator <em>^</em> or
<em>**</em> may be substituted for <em>exp</em> without change of function.
<P>
<P>
<P>
<A NAME=SEC>
<TITLE>SEC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SEC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>sec</em> operator returns the secant of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sec</em>(<expression>) or <em>sec</em> <simple\_expression>
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression,
<simple\_expression> is a single identifier or begins with a prefix
operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sec abc;
SEC(ABC)
sec(pi);
-1
sec 4;
SEC(4)
on rounded;
sec(4);
- 1.52988565647
sec log 5;
- 25.8852966005
</TT></PRE><P><em>sec</em>returns a numeric value only if
<A HREF=r38_0330.html>rounded</A> is on. Then the
secant is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<A NAME=SECH>
<TITLE>SECH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SECH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sech</em> operator returns the hyperbolic secant of its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sech</em>(<expression>) or <em>sech</em> <simple\_expression>
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression,
<simple\_expression> is a single identifier or begins with a prefix
operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sech abc;
SECH(ABC)
sech(0);
1
sech 4;
SECH(4)
on rounded;
sech(4);
0.0366189934737
sech log 5;
0.384615384615
</TT></PRE><P><em>sech</em>returns a numeric value only if
<A HREF=r38_0330.html>rounded</A> is on. Then the
expression is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<A NAME=SIN>
<TITLE>SIN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SIN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sin</em> operator returns the sine of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>sin</em>(<expression>) or <em>sin</em> <simple\_expression>
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression,
<simple\_expression> is a single identifier or begins with a prefix
operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sin aa;
SIN(AA)
sin(pi/2);
1
on rounded;
sin 3;
0.14112000806
sin(pi/2);
1.0
</TT></PRE><P><em>sin</em>returns a numeric value only if <em>rounded</em> is on
.
Then the sine is calculated to the current degree of floating point precision.
The argument in this case is assumed to be in radians.
<P>
<P>
<P>
<A NAME=SINH>
<TITLE>SINH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SINH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>sinh</em> operator returns the hyperbolic sine of its argument.
The derivative of <em>sinh</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sinh</em>(<expression>) or <em>sinh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sinh b;
SINH(B)
sinh(0);
0
df(sinh(x**2),x);
2
2*COSH(X )*X
int(sinh(4*x),x);
COSH(4*X)
---------
4
on rounded;
sinh 4;
27.2899171971
</TT></PRE><P>You may attach further functionality by defining its inverse (see
<A HREF=r38_0245.html>asinh</A>).
A numeric value is not returned by <em>sinh</em> unless the switch
<A HREF=r38_0330.html>rounded</A> is on and its argument evaluates to a number.
<P>
<P>
<P>
<A NAME=TAN>
<TITLE>TAN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>tan</em> operator returns the tangent of its argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>tan</em>(<expression>) or <em>tan</em> <simple\_expression>
<P>
<P>
<P>
<P>
<expression> is any valid scalar REDUCE expression,
<simple\_expression> is a single identifier or begins with a prefix
operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
tan a;
TAN(A)
tan(pi/5);
PI
TAN(--)
5
on rounded;
tan(pi/5);
0.726542528005
</TT></PRE><P><em>tan</em>returns a numeric value only if <em>rounded</em> is on
. Then the
tangent is calculated to the current degree of floating point accuracy.
<P>
<P>
When
<A HREF=r38_0330.html>rounded</A> is on,
no check is made to see if the argument of <em>tan</em> is a multiple of
pi/2, for which the tangent goes to positive or negative infinity.
(Of course, since REDUCE uses a fixed-point representation of pi/2,
it produces a large but not infinite number.) You need to make a check for
multiples of pi/2 in any program you use that might possibly ask
for the tangent of such a quantity.
<P>
<P>
<P>
<A NAME=TANH>
<TITLE>TANH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TANH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>tanh</em> operator returns the hyperbolic tangent of its argument.
The derivative of <em>tanh</em> and some simple transformations are known
to the system.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>tanh</em>(<expression>) or <em>tanh</em> <simple\_expression>
<P>
<P>
<P>
<expression> may be any scalar REDUCE expression, not an array, matrix or
vector expression. <simple\_expression> must be a single identifier or
begin with a prefix operator name.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
tanh b;
TANH(B)
tanh(0);
0
df(tanh(x*y),x);
2
Y*( - TANH(X*Y) + 1)
int(tanh(x),x);
2*X
LOG(E + 1) - X
on rounded; tanh 2;
0.964027580076
</TT></PRE><P>You may attach further functionality by defining its inverse (see
<A HREF=r38_0247.html>atanh</A>).
A numeric value is not returned by <em>tanh</em> unless the switch
<A HREF=r38_0330.html>rounded</A> is on and its argument evaluates to a number.
<P>
<P>
<P>
<A NAME=g11>
<TITLE>Elementary Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Elementary Functions</B><MENU>
<LI><A HREF=r38_0236.html>ACOS operator</A><P>
<LI><A HREF=r38_0237.html>ACOSH operator</A><P>
<LI><A HREF=r38_0238.html>ACOT operator</A><P>
<LI><A HREF=r38_0239.html>ACOTH operator</A><P>
<LI><A HREF=r38_0240.html>ACSC operator</A><P>
<LI><A HREF=r38_0241.html>ACSCH operator</A><P>
<LI><A HREF=r38_0242.html>ASEC operator</A><P>
<LI><A HREF=r38_0243.html>ASECH operator</A><P>
<LI><A HREF=r38_0244.html>ASIN operator</A><P>
<LI><A HREF=r38_0245.html>ASINH operator</A><P>
<LI><A HREF=r38_0246.html>ATAN operator</A><P>
<LI><A HREF=r38_0247.html>ATANH operator</A><P>
<LI><A HREF=r38_0248.html>ATAN2 operator</A><P>
<LI><A HREF=r38_0249.html>COS operator</A><P>
<LI><A HREF=r38_0250.html>COSH operator</A><P>
<LI><A HREF=r38_0251.html>COT operator</A><P>
<LI><A HREF=r38_0252.html>COTH operator</A><P>
<LI><A HREF=r38_0253.html>CSC operator</A><P>
<LI><A HREF=r38_0254.html>CSCH operator</A><P>
<LI><A HREF=r38_0255.html>ERF operator</A><P>
<LI><A HREF=r38_0256.html>EXP operator</A><P>
<LI><A HREF=r38_0257.html>SEC operator</A><P>
<LI><A HREF=r38_0258.html>SECH operator</A><P>
<LI><A HREF=r38_0259.html>SIN operator</A><P>
<LI><A HREF=r38_0260.html>SINH operator</A><P>
<LI><A HREF=r38_0261.html>TAN operator</A><P>
<LI><A HREF=r38_0262.html>TANH operator</A><P>
</MENU>
<A NAME=SWITCHES>
<TITLE>SWITCHES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SWITCHES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
Switches are set on or off using the commands
<A HREF=r38_0210.html>on</A> or
<A HREF=r38_0209.html>off</A>, respectively.
The default setting of the switches described in this section is
<A HREF=r38_0209.html>off</A> unless stated otherwise.
<P>
<P>
<A NAME=ALGINT>
<TITLE>ALGINT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ALGINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>algint</em> switch is on, the algebraic integration module (which
must be loaded from the REDUCE library) is used for integration.
<P>
<P>
Loading <em>algint</em> from the library automatically turns on the
<em>algint</em> switch. An error message will be given if <em>algint</em> is
turned on when the <em>algint</em> has not been loaded from the library.
<P>
<P>
<P>
<A NAME=ALLBRANCH>
<TITLE>ALLBRANCH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ALLBRANCH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
When <em>allbranch</em> is on, the operator
<A HREF=r38_0179.html>solve</A> selects all
branches of solutions.
When <em>allbranch</em> is off, it selects only the principal
branches. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve(log(sin(x+3)),x);
{X=2*ARBINT(1)*PI - ASIN(1) - 3,
X=2*ARBINT(1)*PI + ASIN(1) + PI - 3}
off allbranch;
solve(log(sin(x+3)),x);
X=ASIN(1) - 3
</TT></PRE><P>
<A HREF=r38_0138.html>arbint</A>(1) indicates an arbitrary integer, which is giv
en a
unique identifier by REDUCE, showing that there are infinitely many
solutions of this type. When <em>allbranch</em> is off, the single
canonical solution is given.
<P>
<P>
<P>
<A NAME=ALLFAC>
<TITLE>ALLFAC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ALLFAC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The <em>allfac</em> switch, when on, causes REDUCE to factor out automatically
common products in the output of expressions. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x + x*y**3 + x**2*cos(z);
3
X*(COS(Z)*X + Y + 1)
off allfac;
x + x*y**3 + x**2*cos(z);
2 3
COS(Z)*X + X*Y + X
</TT></PRE><P>The <em>allfac</em> switch has no effect when <em>pri</em> is off.
Although the
switch setting stays as it was, printing behavior is as if it were off.
<P>
<P>
<P>
<A NAME=ARBVARS>
<TITLE>ARBVARS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARBVARS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>arbvars</em> is on, the solutions of singular or underdetermined
systems of equations are presented in terms of arbitrary complex variables
(see
<A HREF=r38_0139.html>arbcomplex</A>). Otherwise, the solution is parametrized i
n
terms of some of the input variables. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve({2x + y,4x + 2y},{x,y});
arbcomplex(1)
{{x= - -------------,y=arbcomplex(1)}}
2
solve({sqrt(x)+ y**3-1},{x,y});
6 3
{{y=arbcomplex(2),x=y - 2*y + 1}}
off arbvars;
solve({2x + y,4x + 2y},{x,y});
y
{{x= - -}}
2
solve({sqrt(x)+ y**3-1},{x,y});
6 3
{{x=y - 2*y + 1}}
</TT></PRE><P>With <em>arbvars</em> off, the return value <em>{{}}</em> means th
at the
equations given to
<A HREF=r38_0179.html>solve</A> imply no relation among the input
variables.
<P>
<P>
<P>
<A NAME=BALANCED_MOD>
<TITLE>BALANCED_MOD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BALANCED\_MOD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
<A HREF=r38_0305.html>modular</A>numbers are normally produced in the range [0,.
..<n>),
where
<n> is the current modulus. With <em>balanced_mod</em> on, the range
[-<n>/2,<n>/2], or more precisely
[-floor((<n>-1)/2), ceiling((<n>-1)/2)], is used instead.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
setmod 7;
1
on modular;
4;
4
on balanced_mod;
4;
-3
</TT></PRE><P>
<A NAME=BFSPACE>
<TITLE>BFSPACE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BFSPACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Floating point numbers are normally printed in a compact notation (either
fixed point or in scientific notation if
<A HREF=r38_0219.html>SCIENTIFIC_NOTATION</A>
has been used). In some (but not all) cases, it helps comprehensibility
if spaces are inserted in the number at regular intervals. The switch
<em>bfspace</em>, if on, will cause a blank to be inserted in the number after
every five characters.
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1.2345678;
1.2345678
on bfspace;
1.2345678;
1.234 5678
</TT></PRE><P><P>
<P>
<em>bfspace</em>is normally off.
<P>
<P>
<P>
<A NAME=COMBINEEXPT>
<TITLE>COMBINEEXPT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMBINEEXPT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
REDUCE is in general poor at surd simplification. However, when the
switch <em>combineexpt</em> is on, the system attempts to combine
exponentials whenever possible.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
3^(1/2)*3^(1/3)*3^(1/6);
1/3 1/6
SQRT(3)*3 *3
on combineexpt;
ws;
1
</TT></PRE><P>
<A NAME=COMBINELOGS>
<TITLE>COMBINELOGS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMBINELOGS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
In many cases it is desirable to expand product arguments of logarithms,
or collect a sum of logarithms into a single logarithm. Since these are
inverse operations, it is not possible to provide rules for doing both at
the same time and preserve the REDUCE concept of idempotent evaluation.
As an alternative, REDUCE provides two switches
<A HREF=r38_0285.html>expandlogs</A> and
<em>combinelogs</em> to carry out these operations.
<P> <H3>
examples: </H3>
<P><PRE><TT>
on expandlogs;
log(x*y);
LOG(X) + LOG(Y)
on combinelogs;
ws;
LOG(X*Y)
</TT></PRE><P><P>
<P>
At the present time, it is possible to have both switches on at once,
which could lead to infinite recursion. However, an expression is
switched from one form to the other in this case. Users should not rely
on this behavior, since it may change in the next release.
<P>
<P>
<P>
<A NAME=COMP>
<TITLE>COMP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>comp</em> is on, any succeeding function definitions are compiled
into a faster-running form. Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>The following procedure finds Fibonacci numbers recurs
ively.
Create a new file ``refib" in your current directory with the following
lines in it:<P><PRE><TT>
procedure refib(n);
if fixp n and n >= 0 then
if n <= 1 then 1
else refib(n-1) + refib(n-2)
else rederr "nonnegative integer only";
end;
</TT></PRE><P>Now load REDUCE and run the following:<P><PRE><TT>
on time;
Time: 100 ms
in "refib"$
Time: 0 ms
REFIB
Time: 260 ms
Time: 20 ms
refib(80);
37889062373143906
Time: 14840 ms
on comp;
Time: 80 ms
in "refib"$
Time: 20 ms
REFIB
Time: 640 ms
refib(80);
37889062373143906
Time: 10940 ms
</TT></PRE><P>
<P>
<P>
Note that the compiled procedure runs faster. Your time messages will
differ depending upon which system you have. Compiled functions remain so
for the duration of the REDUCE session, and are then lost. They must be
recompiled if wanted in another session. With the switch
<A HREF=r38_0333.html>time</A> on
as shown above, the CPU time used in executing the command is returned in
milliseconds. Be careful not to leave <em>comp</em> on unless you want it,
as it makes the processing of procedures much slower.
<P>
<P>
<P>
<P>
<A NAME=COMPLEX>
<TITLE>COMPLEX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMPLEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>complex</em> switch is on, full complex arithmetic is used in
simplification, function evaluation, and factorization. Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
factorize(a**2 + b**2);
2 2
{{A + B ,1}}
on complex;
factorize(a**2 + b**2);
{{A + I*B,1},{A - I*B,1}}
(x**2 + y**2)/(x + i*y);
X - I*Y
on rounded;
*** Domain mode COMPLEX changed to COMPLEX_FLOAT
sqrt(-17);
4.12310562562*I
log(7*i);
1.94591014906 + 1.57079632679*I
</TT></PRE><P>Complex floating-point can be done by turning on
<A HREF=r38_0330.html>rounded</A> in
addition to <em>complex</em>. With <em>complex</em> off however, REDUCE knows
that i is the square root of -1 but will not
carry out more complicated complex operations. If you want complex
denominators cleared by multiplication by their conjugates, turn on the
switch
<A HREF=r38_0324.html>rationalize</A>.
<P>
<P>
<P>
<A NAME=CREF>
<TITLE>CREF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CREF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The switch <em>cref</em> invokes the CREF cross-reference program that
processes a set of procedure definitions to produce a summary of their
entry points, undefined procedures, non-local variables and so on. The
program will also check that procedures are called with a consistent
number of arguments, and print a diagnostic message otherwise.
<P>
<P>
The output is alphabetized on the first seven characters of each function
name.
<P>
<P>
To invoke the cross-reference program, <em>cref</em> is first turned on.
This causes the program to load and the cross-referencing process to
begin. After all the required definitions are loaded, turning <em>cref</em>
off will cause a cross-reference listing to be produced.
<P>
<P>
Algebraic procedures in REDUCE are treated as if they were symbolic, so
that algebraic constructs will actually appear as calls to symbolic
functions, such as <em>aeval</em>.
<P>
<P>
<P>
<A NAME=CRAMER>
<TITLE>CRAMER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CRAMER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>cramer</em> switch is on,
<A HREF=r38_0345.html>matrix</A> inversion
and linear equation
solving (operator
<A HREF=r38_0179.html>solve</A>) is done by Cramer's rule, through exterior
multiplication. Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on time;
Time: 80 ms
off output;
Time: 100 ms
mm := mat((a,b,c,d,f),(a,a,c,f,b),(b,c,a,c,d), (c,c,a,b,f),
(d,a,d,e,f));
Time: 300 ms
inverse := 1/mm;
Time: 18460 ms
on cramer;
Time: 80 ms
cramersinv := 1/mm;
Time: 9260 ms
</TT></PRE><P>Your time readings will vary depending on the REDUCE version you u
se.
After you invert the matrix, turn on
<A HREF=r38_0314.html>output</A> and ask for one of
the elements of the inverse matrix, such as <em>cramersinv(3,2)</em>, so that
you can see the size of the expressions produced.
<P>
<P>
Inversion of matrices and the solution of linear equations with dense
symbolic entries in many variables is generally considerably faster with
<em>cramer</em> on. However, inversion of numeric-valued matrices is
slower. Consider the matrices you're inverting before deciding whether to
turn <em>cramer</em> on or off. A substantial portion of the time in matrix
inversion is given to formatting the results for printing. To save this
time, turn <em>output</em> off, as shown in this example or terminate the
expression with a dollar sign instead of a semicolon. The results are
still available to you in the workspace associated with your prompt
number, or you can assign them to an identifier for further use.
<P>
<P>
<P>
<A NAME=DEFN>
<TITLE>DEFN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEFN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the switch <em>defn</em> is on, the Standard Lisp equivalent of the
input statement or procedure is printed, but not evaluated. Default is
<em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on defn;
17/3;
(AEVAL (LIST 'QUOTIENT 17 3))
df(sin(x),x,2);
(AEVAL (LIST 'DF (LIST 'SIN 'X) 'X 2))
procedure coshval(a);
begin scalar g;
g := (exp(a) + exp(-a))/2;
return g
end;
(AEVAL
(PROGN
(FLAG '(COSHVAL) 'OPFN)
(DE COSHVAL (A)
(PROG (G)
(SETQ G
(AEVAL
(LIST
'QUOTIENT
(LIST
'PLUS
(LIST 'EXP A)
(LIST 'EXP (LIST 'MINUS A)))
2)))
(RETURN G)))) )
coshval(1);
(AEVAL (LIST 'COSHVAL 1))
off defn;
coshval(1);
Declare COSHVAL operator? (Y or N)
n
procedure coshval(a);
begin scalar g;
g := (exp(a) + exp(-a))/2;
return g
end;
COSHVAL
on rounded;
coshval(1);
1.54308063482
</TT></PRE><P>The above function <em>coshval</em> finds the hyperbolic cosine (c
osh) of its
argument. When <em>defn</em> is on, you can see the Standard Lisp equivalent
of the function, but it is not entered into the system as shown by the
message <em>Declare COSHVAL operator?</em>. It must be reentered with
<em>defn</em> off to be recognized. This procedure is used as an example; a
more efficient procedure would eliminate the unnecessary local variable
with
<P><PRE><TT>
procedure coshval(a);
(exp(a) + exp(-a))/2;
</TT></PRE><P><P>
<P>
<P>
<P>
<A NAME=DEMO>
<TITLE>DEMO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEMO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The <em>demo</em> switch is used for interactive files, causing the system
to pause after each command in the file until you type a <em>Return</em>.
Default is <em>off</em>.
<P>
<P>
The switch <em>demo</em> has no effect on top level interactive
statements. Use it when you want to slow down operations in a file so
you can see what is happening.
<P>
<P>
You can either include the <em>on demo</em> command in the file, or enter
it from the top level before bringing in any file. Unlike the
<A HREF=r38_0128.html>pause</A> command, <em>on demo</em> does not permit you to
interrupt
the file for questions of your own.
<P>
<P>
<P>
<P>
<A NAME=DFPRINT>
<TITLE>DFPRINT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DFPRINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>dfprint</em> is on, expressions in the differentiation operator
<A HREF=r38_0148.html>df</A> are printed in a more ``natural'' notation, with th
e
differentiation variables appearing as subscripts. In addition, if the
switch
<A HREF=r38_0310.html>noarg</A> is on (the default), the arguments of the
differentiated operator are suppressed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f;
df(f x,x);
DF(F(X),X);
on dfprint;
ws;
F
X
df(f(x,y),x,y);
F
Y
off noarg;
ws;
F(X,Y)
X
</TT></PRE><P>
<A NAME=DIV>
<TITLE>DIV</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DIV</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>div</em> is on, the system divides any simple factors found in
the denominator of an expression into the numerator. Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on div;
a := x**2/y**2;
2 -2
A := X *Y
b := a/(3*z);
1 2 -2 -1
B := -*X *Y *Z
3
off div;
a;
2
X
---
2
Y
b;
2
X
-------
2
3*Y *Z
</TT></PRE><P>The <em>div</em> switch only has effect when the
<A HREF=r38_0319.html>pri</A> switch is on.
When <em>pri</em> is off, regardless of the setting of <em>div</em>, the
printing behavior is as if <em>div</em> were off.
<P>
<P>
<P>
<A NAME=ECHO>
<TITLE>ECHO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ECHO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The <em>echo</em> switch is normally off for top-level entry, and on when files
are brought in. If <em>echo</em> is turned on at the top level, your input
statements are echoed to the screen (thus appearing twice). Default
<em>off</em> (but note default <em>on</em> for files).
<P>
<P>
If you want to display certain portions of a file and not others, use the
commands <em>off echo</em> and <em>on echo</em> inside the file. If you want
no display of the file, use the input command
<P>
<P>
<em>in</em> filename<em>$</em>
<P>
<P>
rather than using the semicolon delimiter.
<P>
<P>
Be careful when you use commands within a file to generate another file.
Since <em>echo</em> is on for files, the output file echoes input statements
(unlike its behavior from the top level). You should explicitly turn off
<em>echo</em> when writing output, and turn it back on when you're done.
<P>
<P>
<P>
<A NAME=ERRCONT>
<TITLE>ERRCONT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ERRCONT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>errcont</em> switch is on, error conditions do not stop file
execution. Error messages will be printed whether <em>errcont</em> is on or
off.
<P>
<P>
Default is <em>off</em>.
<P>
<P>
The following describes what happens when an error occurs in a file under
each setting of <em>errcont</em> and <em>int</em>:
<P>
<P>
Both off: Message is printed and parsing continues, but no further
statements are executed; no commands from keyboard accepted except bye or
end;
<P>
<P>
<em>errcont</em>off, <em>int</em> on: Message is printed, and you are asked
if you wish to continue. (This is the default behavior);
<P>
<P>
<em>errcont</em>on, <em>int</em> off: Message is printed, and file continues
to execute without pause;
<P>
<P>
Both on: Message is printed, and file continues to execute without pause.
<P>
<P>
<P>
<P>
<A NAME=EVALLHSEQP>
<TITLE>EVALLHSEQP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EVALLHSEQP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Under normal circumstances, the right-hand-side of an
<A HREF=r38_0045.html>equation</A>
is evaluated but not the left-hand-side. This also applies to any
substitutions made by the
<A HREF=r38_0182.html>sub</A> operator. If both sides are to be
evaluated, the switch <em>evallhseqp</em> should be turned on.
<P>
<P>
<A NAME=EXP_switch>
<TITLE>EXP_switch</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>exp</em> switch is on, powers and products of expressions are
expanded. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x+1)**3;
3 2
X + 3*X + 3*X + 1
(a + b*i)*(c + d*i);
A*C + A*D*I + B*C*I - B*D
off exp;
(x+1)**3;
3
(X + 1)
(a + b*i)*(c + d*i);
(A + B*I)*(C + D*I)
length((x+1)**2/(y+1));
2
</TT></PRE><P>Note that REDUCE knows that i^2 = -1.
When <em>exp</em> is off, equivalent expressions may not simplify to the same
form, although zero expressions still simplify to zero. Several operators
that expect a polynomial argument behave differently when <em>exp</em> is
off, such as
<A HREF=r38_0157.html>length</A>. Be cautious about leaving <em>exp</em> off.
<P>
<P>
<P>
<A NAME=EXPANDLOGS>
<TITLE>EXPANDLOGS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXPANDLOGS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
In many cases it is desirable to expand product arguments of logarithms,
or collect a sum of logarithms into a single logarithm. Since these are
inverse operations, it is not possible to provide rules for doing both at
the same time and preserve the REDUCE concept of idempotent evaluation.
As an alternative, REDUCE provides two switches <em>expandlogs</em> and
<A HREF=r38_0272.html>combinelogs</A> to carry out these operations. Both are of
f by default.
<P> <H3>
examples: </H3>
<P><PRE><TT>
on expandlogs;
log(x*y);
LOG(X) + LOG(Y)
on combinelogs;
ws;
LOG(X*Y)
</TT></PRE><P><P>
<P>
At the present time, it is possible to have both switches on at once,
which could lead to infinite recursion. However, an expression is
switched from one form to the other in this case. Users should not rely
on this behavior, since it may change in the next release.
<P>
<P>
<P>
<A NAME=EZGCD>
<TITLE>EZGCD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EZGCD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>ezgcd</em> and
<A HREF=r38_0086.html>gcd</A> are on, greatest common divisors are
computed using the EZ GCD algorithm that uses modular arithmetic (and is
usually faster). Default is <em>off</em>.
<P>
<P>
As a side effect of the gcd calculation, the expressions involved are
factored, though not the heavy-duty factoring of
<A HREF=r38_0151.html>factorize</A>. The
EZ GCD algorithm was introduced in a paper by J. Moses and D.Y.Y. Yun in
<Proceedings of the ACM>, 1973, pp. 159-166.
<P>
<P>
Note that the
<A HREF=r38_0086.html>gcd</A> switch must also be on for <em>ezgcd</em> to have
effect.
<P>
<P>
<P>
<A NAME=FACTOR>
<TITLE>FACTOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FACTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>factor</em> switch is on, input expressions and results are
automatically factored.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on factor;
aa := 3*x**3*a + 6*x**2*y*a + 3*x**3*b + 6*x**2*y*b
+ x*y*a + 2*y**2*a + x*y*b + 2*y**2*b;
2
AA := (A + B)*(3*X + Y)*(X + 2*Y)
off factor;
aa;
3 2 2 3 2
3*A*X + 6*A*X *Y + A*X*Y + 2*A*Y + 3*B*X + 6*B*X *Y
+ B*X*Y + 2*B*Y^{2}
on factor;
ab := x**2 - 2;
2
AB := X - 2
</TT></PRE><P>REDUCE factors univariate and multivariate polynomials with
integer coefficients, finding any factors that also have integer coefficients.
The factoring is done by reducing multivariate problems to univariate
ones with symbolic coefficients, and then solving the univariate ones modulo
small primes. The results of these calculations are merged to
determine the factors of the original polynomial. The factorizer normally
selects evaluation points and primes using a random number generator.
Thus, the detailed factoring behavior may be different each time any
particular problem is tackled.
<P>
<P>
When the <em>factor</em> switch is turned on, the
<A HREF=r38_0256.html>exp</A> switch is
turned off, and when the <em>factor</em> switch is turned off, the
<A HREF=r38_0256.html>exp</A> switch is turned on, whether it was on previously
or not.
<P>
<P>
When the switch
<A HREF=r38_0335.html>trfac</A> is on, informative messages are generated at
each call to the factorizer. The
<A HREF=r38_0334.html>trallfac</A> switch causes the
production of a more verbose trace message. It takes precedence over
<em>trfac</em> if they are both on.
<P>
<P>
To factor a polynomial explicitly and store the results, use the operator
<A HREF=r38_0151.html>factorize</A>.
<P>
<P>
<P>
<A NAME=FAILHARD>
<TITLE>FAILHARD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FAILHARD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>failhard</em> switch is on, the integration operator
<A HREF=r38_0154.html>int</A>
terminates with an error message if the integral cannot be done in closed
terms.
Default is off.
<P>
<P>
Use the <em>failhard</em> switch when you are dealing with complicated integrals
and want to know immediately if REDUCE was unable to handle them. The
integration operator sometimes returns a formal integration form that is
more complicated than the original expression, when it is unable to
complete the integration.
<P>
<P>
<P>
<A NAME=FORT>
<TITLE>FORT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FORT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>fort</em> is on, output is given Fortran-compatible syntax. Default
is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on fort;
df(sin(7*x + y),x);
ANS=7.*COS(7*X+Y)
on rounded;
b := log(sin(pi/5 + n*pi));
B=LOG(SIN(3.14159265359*N+0.628318530718))
</TT></PRE><P>REDUCE results can be written to a file (using
<A HREF=r38_0233.html>out</A>) and used as data
by Fortran programs when <em>fort</em> is in effect. <em>fort</em> knows about
correct statement length, continuation characters, defining a symbol when
it is first used, and other Fortran details.
<P>
<P>
The
<A HREF=r38_0652.html>GENTRAN</A> package offers many more possibilities than th
e
<em>fort</em> switch. It produces Fortran (or C or Ratfor) code from REDUCE
procedures or structured specifications, including facilities for producing
double precision output.
<P>
<P>
<P>
<A NAME=FORTUPPER>
<TITLE>FORTUPPER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FORTUPPER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>fortupper</em> is on, any Fortran-style output appears in upper case.
Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on fort;
df(sin(7*x + y),x);
ans=7.*cos(7*x+y)
on fortupper;
df(sin(7*x + y),x);
ANS=7.*COS(7*X+Y)
</TT></PRE><P>
<A NAME=FULLPREC>
<TITLE>FULLPREC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FULLPREC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Trailing zeroes of rounded numbers to the full system precision are
normally not printed. If this information is needed, for example to get a
more understandable indication of the accuracy of certain data, the switch
<em>fullprec</em> can be turned on.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1/2;
0.5
on fullprec;
ws;
0.500000000000
</TT></PRE><P>This is just an output options which neither influences
the accuracy of the computation nor does it give additional
information about the precision of the results.
See also
<A HREF=r38_0219.html>scientific_notation</A>.
<P>
<P>
<P>
<A NAME=FULLROOTS>
<TITLE>FULLROOTS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FULLROOTS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Since roots of cubic and quartic polynomials can often be very
messy, a switch <em>fullroots</em> controls the production
of results in closed form.
<A HREF=r38_0179.html>solve</A> will apply the
formulas for explicit forms for degrees 3 and 4 only if
<em>fullroots</em> is <em>on</em>. Otherwise the result forms
are built using
<A HREF=r38_0176.html>root_of</A>. Default is <em>off</em>.
<P>
<P>
<A NAME=GC>
<TITLE>GC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
With the <em>gc</em> switch, you can turn the garbage collection messages on
or off. The form of the message depends on the particular Lisp used for
the REDUCE implementation.
<P>
<P>
See
<A HREF=r38_0130.html>reclaim</A> for an explanation of garbage collection. REDU
CE does
garbage collection when needed even if you have turned the notices off.
<P>
<P>
<P>
<A NAME=GCD_switch>
<TITLE>GCD_switch</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GCD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>gcd</em> is on, common factors in numerators and denominators of
expressions are canceled. Default is <em>off</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(2*(f*h)**2 - f**2*g*h - (f*g)**2 - f*h**3 + f*h*g**2
- h**4 + g*h**3)/(f**2*h - f**2*g - f*h**2 + 2*f*g*h
- f*g**2 - g*h**2 + g**2*h);
2 2 2 2 2 2 3 3 4
F *G + F *G*H - 2*F *H - F*G *H + F*H - G*H + H
----------------------------------------------------
2 2 2 2 2 2
F *G - F *H + F*G - 2*F*G*H + F*H - G *H + G*H
on gcd;
ws;
2
F*G + 2*F*H + H
----------------
F + G
e2 := a*c + a*d + b*c + b*d;
E2 := A*C + A*D + B*C + B*D
off exp;
e2;
(A + B)*(C + D)
</TT></PRE><P>Even with <em>gcd</em> off, a check is automatically made for comm
on variable
and numerical products in the numerators and denominators of expression,
and the appropriate cancellations made. Thus the example demonstrating the
use of <em>gcd</em> is somewhat complicated. Note when
<A HREF=r38_0256.html>exp</A> is off,
<em>gcd</em> has the side effect of factoring the expression.
<P>
<P>
<P>
<A NAME=HORNER>
<TITLE>HORNER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HORNER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>horner</em> switch is on, polynomial expressions are printed
in Horner's form for faster and safer numerical evaluation. Default
is <em>off</em>. The leading variable of the expression is selected as
Horner variable. To select the Horner variable explicitly use the
<A HREF=r38_0198.html>korder</A> declaration.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on horner;
(13p-4q)^3;
3 2
( - 64)*q + p*(624*q + p*(( - 2028)*q + p*2197))
korder q;
ws;
3 2
2197*p + q*(( - 2028)*p + q*(624*p + q*(-64)))
</TT></PRE><P>
<A NAME=IFACTOR>
<TITLE>IFACTOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IFACTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>ifactor</em> switch is on, any integer terms appearing as a result
of the
<A HREF=r38_0151.html>factorize</A> command are factored themselves into primes.
Default
is <em>off</em>. If the argument of <em>factorize</em> is an integer,
<em>ifactor</em> has no effect, since the integer is always factored.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
factorize(4*x**2 + 28*x + 48);
{{4,1},{X + 4,1},{X + 3,1}}
factorize(22587);
{{3,1},{7529,1}}
on ifactor;
factorize(4*x**2 + 28*x + 48);
{{2,2},{X + 4,1},{X + 3,1}}
factorize(22587);
{{3,1},{7529,1}}
</TT></PRE><P>Constant terms that appear within nonconstant
polynomial factors are not factored.
<P>
<P>
The <em>ifactor</em> switch affects only factoring done specifically
with
<A HREF=r38_0151.html>factorize</A>, not on factoring done automatically when th
e
<A HREF=r38_0287.html>factor</A> switch is on.
<P>
<P>
<P>
<A NAME=INT_switch>
<TITLE>INT_switch</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The <em>int</em> switch specifies an interactive mode of operation. Default
<em>on</em>.
<P>
<P>
There is no reason to turn <em>int</em> off during interactive calculations,
since there are no benefits to be gained. If you do have <em>int</em> off
while inputting a file, and REDUCE finds an error, it prints the message
``Continuing with parsing only." In this state, REDUCE accepts only
<A HREF=r38_0044.html>end</A><em>;</em> or
<A HREF=r38_0124.html>bye</A><em>;</em> from the keyboard;
everything else is ignored, even the command <em>on int</em>.
<P>
<P>
<P>
<A NAME=INTSTR>
<TITLE>INTSTR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INTSTR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
If <em>intstr</em> (for ``internal structure'') is on, arguments of an
operator are printed in a more structured form.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f;
f(2x+2y);
F(2*X + 2*Y)
on intstr;
ws;
F(2*(X + Y))
</TT></PRE><P>
<A NAME=LCM>
<TITLE>LCM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LCM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The <em>lcm</em> switch instructs REDUCE to compute the least common multiple
of denominators whenever rational expressions occur. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
off lcm;
z := 1/(x**2 - y**2) + 1/(x-y)**2;
2*X*(X - Y)
Z := -------------------------
4 3 3 4
X - 2*X *Y + 2*X*Y - Y
on lcm;
z;
2*X*(X - Y)
-------------------------
4 3 3 4
X - 2*X *Y + 2*X*Y - Y
zz := 1/(x**2 - y**2) + 1/(x-y)**2;
2*X
ZZ := ---------------------
3 2 2 3
X - X *Y - X*Y + Y
on gcd;
z;
2*X
----------------------
3 2 2 3
X - X *Y - X*Y + Y
</TT></PRE><P>Note that <em>lcm</em> has effect only when rational expressions a
re first
combined. It does not examine existing structures for simplifications on
display. That is shown above when z is entered with
<em>lcm</em> off. It remains unsimplified even after <em>lcm</em> is turned
back on. However, a new variable containing the same expression is
simplified on entry. The switch
<A HREF=r38_0086.html>gcd</A> does examine existing
structures, as shown in the last example line above.
<P>
<P>
Full greatest common divisor calculations become expensive if work with
large rational expressions is required. A considerable savings of time
can be had if a full gcd check is made only when denominators are combined,
and only a partial check for numerators. This is the effect of the <em>lcm</em>
switch.
<P>
<P>
<P>
<A NAME=LESSSPACE>
<TITLE>LESSSPACE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LESSSPACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
You can turn on the switch <em>lessspace</em> if you want fewer
blank lines in your output.
<P>
<P>
<A NAME=LIMITEDFACTORS>
<TITLE>LIMITEDFACTORS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LIMITEDFACTORS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
To get limited factorization in cases where it is too expensive to use
full multivariate polynomial factorization, the switch
<em>limitedfactors</em> can be turned on. In that case, only ``inexpensive''
factoring operations, such as square-free factorization, will be used
when
<A HREF=r38_0151.html>factorize</A> is called.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := (y-x)^2*(y^3+2x*y+5)*(y^2-3x*y+7)$
factorize a;
2
{- 3*X*Y + Y + 7,1}
3
{2*X*Y + Y + 5,1},
{X - Y,2}}
on limitedfactors;
factorize a;
2 2 4 3 5 3 2
{- 6*X *Y - 3*X*Y + 2*X*Y - X*Y + Y + 7*Y + 5*Y + 35,1},
{X - Y,2}}
</TT></PRE><P>
<A NAME=LIST_switch>
<TITLE>LIST_switch</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LIST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
The <em>list</em> switch causes REDUCE to print each term in any sum on
separate lines.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x**2*(y**2 + 2*y) + x*(y**2 + z)/(2*a);
2 2
X*(2*A*X*Y + 4*A*X*Y + Y +Z)
------------------------------
2*A
on list;
ws;
2
(X*(2*A*X*Y
+ 4*A*X*Y
2
+ Y
+ Z))/(2*A)
</TT></PRE><P>
<A NAME=LISTARGS>
<TITLE>LISTARGS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LISTARGS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
If an operator other than those specifically defined for lists is given a
single argument that is a list, then the result of this operation will be
a list in which that operator is applied to each element of the list.
This process can be inhibited globally by turning on the switch
<em>listargs</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
log {a,b,c};
LOG(A),LOG(B),LOG(C)
on listargs;
log {a,b,c};
LOG(A,B,C)
</TT></PRE><P>It is possible to inhibit such distribution for a specific operato
r by
using the declaration
<A HREF=r38_0203.html>listargp</A>. In addition, if an operator has
more than one argument, no such distribution occurs, so <em>listargs</em>
has no effect.
<P>
<P>
<P>
<A NAME=MCD>
<TITLE>MCD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MCD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>mcd</em> is on, sums and differences of rational expressions are put
on a common denominator. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a/(x+1) + b/5;
5*A + B*X + B
-------------
5*(X + 1)
off mcd;
a/(x+1) + b/5;
-1
(X + 1) *A + 1/5*B
1/6 + 1/7;
13/42
</TT></PRE><P>Even with <em>mcd</em> off, rational expressions involving only nu
mbers are still
put over a common denominator.
<P>
<P>
Turning <em>mcd</em> off is useful when explicit negative powers are needed,
or if no greatest common divisor calculations are desired, or when
differentiating complicated rational expressions. Results when <em>mcd</em>
is off are no longer in canonical form, and expressions equivalent to zero
may not simplify to 0. Some operations, such as factoring cannot be done
while <em>mcd</em> is off. This option should therefore be used with some
caution. Turning <em>mcd</em> off is most valuable in intermediate parts of
a complicated calculation, and should be turned back on for the last stage.
<P>
<P>
<P>
<A NAME=MODULAR>
<TITLE>MODULAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MODULAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>modular</em> is on, polynomial coefficients are reduced by the
modulus set by
<A HREF=r38_0104.html>setmod</A>. If no modulus has been set, <em>modular</em>
has no effect.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
setmod 2;
1
on modular;
(x+y)**2;
2 2
X + Y
145*x**2 + 20*x**3 + 17 + 15*x*y;
2
X + X*Y + 1
</TT></PRE><P>Modular operations are only conducted on the coefficients, not the
exponents. The modulus is not restricted to being prime. When the modulus
is prime, division by a number not relatively prime to the modulus results
in a <Zero divisor> error message. When the modulus is a composite
number, division by a power of the modulus results in an error message, but
division by an integer which is a factor of the modulus does not.
The representation of modular number can be influenced by
<A HREF=r38_0269.html>balanced_mod</A>.
<P>
<P>
<P>
<A NAME=MSG>
<TITLE>MSG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MSG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>msg</em> is off, the printing of warning messages is suppressed. Error
messages are still printed.
<P>
<P>
Warning messages include those about redimensioning an
<A HREF=r38_0188.html>array</A>
or declaring an
<A HREF=r38_0211.html>operator</A> where one is expected.
<P>
<P>
<P>
<A NAME=MULTIPLICITIES>
<TITLE>MULTIPLICITIES</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MULTIPLICITIES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When
<A HREF=r38_0179.html>solve</A> is applied to a set of equations with multiple r
oots,
solution multiplicities are normally stored in the global variable
<A HREF=r38_0017.html>root_multiplicities</A> rather than the solution list. If
you want
the multiplicities explicitly displayed, the switch <em>multiplicities</em>
should be turned on. In this case, <em>root_multiplicities</em> has no value.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve(x^2=2x-1,x);
X=1
root_multiplicities;
2
on multiplicities;
solve(x^2=2x-1,x);
X=1,X=1
root_multiplicities;
</TT></PRE><P>
<A NAME=NAT>
<TITLE>NAT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NAT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>nat</em> is on, output is printed to the screen in natural form, with
raised exponents. <em>nat</em> should be turned off when outputting expressions
to a file for future input. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x + y)**3;
3 2 2 3
X + 3*X *Y + 3*X*Y + Y
off nat;
(x + y)**3;
X**3 + 3*X**2*Y + 3*X*Y**2 + Y**3$
on fort;
(x + y)**3;
ANS=X**3+3.*X**2*Y+3.*X*Y**2+Y**3
</TT></PRE><P>With <em>nat</em> off, a dollar sign is printed at the end of each
expression.
An output file written with <em>nat</em> off is ready to be read into REDUCE
using the command
<A HREF=r38_0231.html>in</A>.
<P>
<P>
<P>
<A NAME=NERO>
<TITLE>NERO</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NERO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>nero</em> is on, zero assignments (such as matrix elements) are not
printed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix a;
a := mat((1,0),(0,1));
A(1,1) := 1
A(1,2) := 0
A(2,1) := 0
A(2,2) := 1
on nero;
a;
MAT(1,1) := 1
MAT(2,2) := 1
a(1,2); </TT></PRE><P>nothing is printed.<P><PRE><TT>
b := 0; </TT></PRE><P>nothing is printed.<P><PRE><TT>
off nero;
b := 0;
B := 0
</TT></PRE><P>
<P>
<P>
<em>nero</em>is often used when dealing with large sparse matrices, to avoid
being overloaded with zero assignments.
<P>
<P>
<P>
<A NAME=NOARG>
<TITLE>NOARG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOARG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When
<A HREF=r38_0279.html>dfprint</A> is on, expressions in the differentiation oper
ator
<A HREF=r38_0148.html>df</A> are printed in a more ``natural'' notation, with th
e
differentiation variables appearing as subscripts. When <em>noarg</em>
is on (the default), the arguments of the differentiated operator are also
suppressed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
operator f;
df(f x,x);
DF(F(X),X);
on dfprint;
ws;
F
X
off noarg;
ws;
F(X)
X
</TT></PRE><P>
<A NAME=NOLNR>
<TITLE>NOLNR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOLNR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>nolnr</em> is on, the linear properties of the integration operator
<A HREF=r38_0154.html>int</A> are suppressed if the integral cannot be found in
closed terms.
<P>
<P>
REDUCE uses the linear properties of integration to attempt to break down
an integral into manageable pieces. If an integral cannot be found in
closed terms, these pieces are returned. When the <em>nolnr</em> switch is off,
as many of the pieces as possible are integrated. When it is on, if any piece
fails, the rest of them remain unevaluated.
<P>
<P>
<P>
<A NAME=NOSPLIT>
<TITLE>NOSPLIT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOSPLIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Under normal circumstances, the printing routines try to break an expression
across lines at a natural point. This is a fairly expensive process. If
you are not overly concerned about where the end-of-line breaks come, you
can speed up the printing of expressions by turning off the switch
<em>nosplit</em>. This switch is normally on.
<P>
<P>
<A NAME=NUMVAL>
<TITLE>NUMVAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUMVAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
With
<A HREF=r38_0330.html>rounded</A> on, elementary functions with numerical argume
nts
will return a numerical answer where appropriate. If you wish to inhibit
this evaluation, <em>numval</em> should be turned off. It is normally on.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
cos 3.4;
- 0.966798192579
off numval;
cos 3.4;
COS(3.4)
</TT></PRE><P>
<A NAME=OUTPUT>
<TITLE>OUTPUT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OUTPUT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>output</em> is off, no output is printed from any REDUCE calculation.
The calculations have their usual effects other than printing. Default is
<em>on</em>.
<P>
<P>
Turn output <em>off</em> if you do not wish to see output when executing
large files, or to save the time REDUCE spends formatting large expressions
for display. Results are still available with
<A HREF=r38_0184.html>ws</A>, or in their
assigned variables.
<P>
<P>
<P>
<A NAME=OVERVIEW>
<TITLE>OVERVIEW</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>OVERVIEW</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>overview</em> is on, the amount of detail reported by the factorizer
switches
<A HREF=r38_0335.html>trfac</A> and
<A HREF=r38_0334.html>trallfac</A> is reduced.
<P>
<P>
<A NAME=PERIOD>
<TITLE>PERIOD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PERIOD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>period</em> is on, periods are added after integers in
Fortran-compatible output (when
<A HREF=r38_0289.html>fort</A> is on). There is no effect
when <em>fort</em> is off. Default is <em>on</em>.
<P>
<P>
<A NAME=PRECISE>
<TITLE>PRECISE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRECISE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>precise</em> switch is on, simplification of roots of even
powers returns absolute values, a more precise answer mathematically.
Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sqrt(x**2);
X
(x**2)**(1/4);
SQRT(X)
on precise;
sqrt(x**2);
ABS(X)
(x**2)**(1/4);
SQRT(ABS(X))
</TT></PRE><P>In many types of mathematical work, simplification of powers and s
urds can
proceed by the fastest means of simplifying the exponents arithmetically.
When it is important to you that the positive root be returned, turn
<em>precise</em> on. One situation where this is important is when graphing
square-root expressions such as sqrt(x^2+y^2) to
avoid a spike caused by REDUCE simplifying
sqrt(y^2) to y when x is
zero.
<P>
<P>
<P>
<A NAME=PRET>
<TITLE>PRET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>pret</em> is on, input is printed in standard REDUCE format and then
evaluated.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on pret;
(x+1)^3;
(x + 1)**3;
3 2
X + 3*X + 3*X + 1
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;
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;
FAC
fac 5;
fac 5;
120
</TT></PRE><P>Note that all input is converted to lower case except strings (whi
ch keep
the same case) all operators with a single argument have had the
parentheses removed, and all infix operators have had a space added on each
side. In addition, syntactical constructs like
<em>if</em>...<em>then</em>...<em>else</em> are printed in a standard format.
<P>
<P>
<P>
<A NAME=PRI>
<TITLE>PRI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PRI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>pri</em> is on, the declarations
<A HREF=r38_0212.html>order</A> and
<A HREF=r38_0287.html>factor</A> can
be used, and the switches
<A HREF=r38_0267.html>allfac</A>,
<A HREF=r38_0280.html>div</A>,
<A HREF=r38_0321.html>rat</A>,
and
<A HREF=r38_0326.html>revpri</A> take effect when they are on. Default is <em>on
</em>.
<P>
<P>
Printing of expressions is faster with <em>pri</em> off. The expressions are
then returned in one standard form, without any of the display options that
can be used to feature or display various parts of the expression. You can
also gain insight into REDUCE's representation of expressions with
<em>pri</em> off.
<P>
<P>
<P>
<A NAME=RAISE>
<TITLE>RAISE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RAISE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>raise</em> is on, lower case letters are automatically converted to
upper case on input. <em>raise</em> is normally on.
<P>
<P>
This conversion affects the internal representation of the letter, and is
independent of the case with which a letter is printed, which is normally
lower case.
<P>
<P>
<P>
<A NAME=RAT>
<TITLE>RAT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RAT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>rat</em> switch is on, and kernels have been selected to display
with the
<A HREF=r38_0287.html>factor</A> declaration, the denominator is printed with ea
ch
term rather than one common denominator at the end of an expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
(x+1)/x + x**2/sin y;
3
SIN(Y)*X + SIN(Y) + X
---------------------- factor x;
SIN(Y)*X
(x+1)/x + x**2/sin y;
3
X + X*SIN(Y) + SIN(Y)
---------------------- on rat;
X*SIN(Y)
(x+1)/x + x**2/sin y;
2
X -1
------ + 1 + X
SIN(Y)
</TT></PRE><P>The <em>rat</em> switch only has effect when the
<A HREF=r38_0319.html>pri</A> switch is on.
When <em>pri</em> is off, regardless of the setting of <em>rat</em>, the
printing behavior is as if <em>rat</em> were off. <em>rat</em> only has
effect upon the display of expressions, not their internal form.
<P>
<P>
<P>
<A NAME=RATARG>
<TITLE>RATARG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RATARG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>ratarg</em> is on, rational expressions can be given to operators
such as
<A HREF=r38_0141.html>coeff</A> and
<A HREF=r38_0161.html>lterm</A> that normally require
polynomials in one of their arguments. When <em>ratarg</em> is off, rational
expressions cause an error message.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
aa := x/y**2 + 1/x + y/x**2;
3 2 3
X + X*Y + Y
AA := --------------
2 2
X *Y
coeff(aa,x);
3 2 3
X + X*Y + Y
***** -------------- invalid as POLYNOMIAL
2 2
X *Y
on ratarg;
coeff(aa,x);
Y 1 1
{--,--,0,-----}
2 2 2 2
X X X *Y
</TT></PRE><P>
<A NAME=RATIONAL>
<TITLE>RATIONAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RATIONAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>rational</em> is on, polynomial expressions with rational coefficients
are produced.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x/2 + 3*y/4;
2*X + 3*Y
---------
4
(x**2 + 5*x + 17)/2;
2
X + 5*X + 17
-------------
2
on rational;
x/2 + 3y/4;
1 3
-*(X + -*Y)
2 2
(x**2 + 5*x + 17)/2;
1 2
-*(X + 5*X + 17)
2
</TT></PRE><P>By using <em>rational</em>, polynomial expressions with rational
coefficients can be used in some commands that expect polynomials. With
<em>rational</em> off, such a polynomial becomes a rational expression, with
denominator the least common multiple of the denominators of the rational
number coefficients. <P>
<P>
<P>
<P>
<A NAME=RATIONALIZE>
<TITLE>RATIONALIZE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RATIONALIZE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>rationalize</em> switch is on, denominators of rational expressions
that contain complex numbers or root expressions are simplified by
multiplication by their conjugates.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
qq := (1+sqrt(3))/(sqrt(3)-7);
SQRT(3) + 1
QQ := -----------
SQRT(3) - 7
on rationalize;
qq;
- 4*SQRT(3) - 5
---------------
23
2/(4 + 6**(1/3));
2/3 1/3
6 - 4*6 + 16
------------------
35
(i-1)/(i+3);
2*I - 1
-------
5
off rationalize;
(i-1)/(i+3);
I - 1
------
I + 3
</TT></PRE><P>
<A NAME=RATPRI>
<TITLE>RATPRI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RATPRI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>ratpri</em> switch is on, rational expressions and fractions are
printed as two lines separated by a fraction bar, rather than in a linear
style. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
3/17;
3
--
17
2/b + 3/y;
3*B + 2*Y
---------
B*Y
off ratpri;
3/17;
3/17
2/b + 3/y;
(3*B + 2*Y)/(B*Y)
</TT></PRE><P>
<A NAME=REVPRI>
<TITLE>REVPRI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REVPRI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When the <em>revpri</em> switch is on, terms are printed in reverse order from
the normal printing order.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
x**5 + x**2 + 18 + sqrt(y);
5 2
SQRT(Y) + X + X + 18
a + b + c + w;
A + B + C + W
on revpri;
x**5 + x**2 + 18 + sqrt(y);
2 5
17 + X + X + SQRT(Y)
a + b + c + w;
W + C + B + A
</TT></PRE><P>Turn <em>revpri</em> on when you want to display a polynomial in a
scending
rather than descending order.
<P>
<P>
<P>
<A NAME=RLISP88>
<TITLE>RLISP88</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RLISP88</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Rlisp '88 is a superset of the Rlisp that has been traditionally used for
the support of REDUCE. It is fully documented in the book Marti, J.B.,
``RLISP '88: An Evolutionary Approach to Program Design and Reuse'',
World Scientific, Singapore (1993). It supports different looping
constructs from the traditional Rlisp, and treats ``-'' as a letter unless
separated by spaces. Turning on the switch <em>rlisp88</em> converts to
Rlisp '88 parsing conventions in symbolic mode, and enables the use of
Rlisp '88 extensions. Turning off the switch reverts to the traditional
Rlisp and the previous mode ( (
<A HREF=r38_0221.html>symbolic</A> or
<A HREF=r38_0186.html>algebraic</A>)
in force before <em>rlisp88</em> was turned on.
<P>
<P>
<A NAME=ROUNDALL>
<TITLE>ROUNDALL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROUNDALL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
In
<A HREF=r38_0330.html>rounded</A> mode, rational numbers are normally converted
to a
floating point representation. If <em>roundall</em> is off, this conversion
does not occur. <em>roundall</em> is normally <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
1/2;
0.5
off roundall;
</TT></PRE><P>
<A NAME=ROUNDBF>
<TITLE>ROUNDBF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROUNDBF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
When
<A HREF=r38_0330.html>rounded</A> is on, the normal defaults cause underflows to
be
converted to zero. If you really want the small number that results in
such cases, <em>roundbf</em> can be turned on.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
exp(-100000.1^2);
0
on roundbf;
exp(-100000.1^2);
1.18441281937E-4342953505
</TT></PRE><P>If a polynomial is input in
<A HREF=r38_0330.html>rounded</A> mode at the default
precision into any
<A HREF=r38_0439.html>roots</A> function, and it is not possible to
represent any of the coefficients of the polynomial precisely in the
system floating point representation, the switch <em>roundbf</em> will be
automatically turned on. All rounded computation will use the internal
bigfloat representation until the user subsequently turns <em>roundbf</em>
off. (A message is output to indicate that this condition is in effect.)
<P>
<P>
<P>
<A NAME=ROUNDED>
<TITLE>ROUNDED</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROUNDED</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>rounded</em> is on, floating-point arithmetic is enabled, with
precision initially at a system default value, which is usually 12 digits.
The precise number can be found by the command
<A HREF=r38_0214.html>precision</A>(0).
<P> <H3>
examples: </H3>
<P><PRE><TT>
pi;
PI
35/217;
5
--
31
on rounded;
pi;
3.14159265359
35/217;
0.161
sqrt(3);
1.73205080756
</TT></PRE><P><P>
<P>
If more than the default number of decimal places are required, use the
<A HREF=r38_0214.html>precision</A> command to set the required number.
<P>
<P>
<P>
<A NAME=SAVESTRUCTR>
<TITLE>SAVESTRUCTR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SAVESTRUCTR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>savestructr</em> is on, results of the
<A HREF=r38_0181.html>structr</A> command are
returned as a list whose first element is the representation for the
expression and the remaining elements are equations showing the
relationships of the generated variables.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
off exp;
structr((x+y)^3 + sin(x)^2);
ANS3
where
3 2
ANS3 := ANS1 + ANS2
ANS2 := SIN(X)
ANS1 := X + Y
ans3;
ANS3
on savestructr;
structr((x+y)^{3} + sin(x)^{2});
3 2
ANS3,ANS3=ANS1 + ANS2 ,ANS2=SIN(X),ANS1=X + Y
ans3 where rest ws;
3 2
(X + Y) + SIN(X)
</TT></PRE><P>In normal operation,
<A HREF=r38_0181.html>structr</A> is only a display command. With
<em>savestructr</em> on, you can access the various parts of the expression
produced by <em>structr</em>.
<P>
<P>
The generic system names use the stem <em>ANS</em>. You can change this to your
own stem by the command
<A HREF=r38_0225.html>varname</A>. REDUCE adds integers to this stem
to make unique identifiers.
<P>
<P>
<P>
<A NAME=SOLVESINGULAR>
<TITLE>SOLVESINGULAR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SOLVESINGULAR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>solvesingular</em> is on, singular or underdetermined systems of
linear equations are solved, using arbitrary real, complex or integer
variables in the answer. Default is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
solve({2x + y,4x + 2y},{x,y});
ARBCOMPLEX(1)
{{X= - -------------,Y=ARBCOMPLEX(1)}}
2
solve({7x + 15y - z,x - y - z},{x,y,z});
8*ARBCOMPLEX(3)
{{X=----------------
11
3*ARBCOMPLEX(3)
Y= - ----------------
11
Z=ARBCOMPLEX(3)}}
off solvesingular;
solve({2x + y,4x + 2y},{x,y});
***** SOLVE given singular equations
solve({7x + 15y - z,x - y - z},{x,y,z});
***** SOLVE given singular equations
</TT></PRE><P>The integer following the identifier
<A HREF=r38_0139.html>arbcomplex</A> above is assigned by
the system, and serves to identify the variable uniquely. It has no other
significance.
<P>
<P>
<P>
<A NAME=TIME>
<TITLE>TIME</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>time</em> is on, the system time used in executing each REDUCE
statement is printed after the answer is printed.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on time;
Time: 4940 ms
df(sin(x**2 + y),y);
2
COS(X + Y )
Time: 180 ms
solve(x**2 - 6*y,x);
{X= - SQRT(Y)*SQRT(6),
X=SQRT(Y)*SQRT(6)}
Time: 320 ms
</TT></PRE><P>When <em>time</em> is first turned on, the time since the beginnin
g of the
REDUCE session is printed. After that, the time used in computation,
(usually in milliseconds, though this is system dependent) is printed after
the results of each command. Idle time or time spent typing in commands is
not counted. If <em>time</em> is turned off, the first reading after it is
turned on again gives the time elapsed since it was turned off. The time
printed is CPU or wall clock time, depending on the system.
<P>
<P>
<P>
<A NAME=TRALLFAC>
<TITLE>TRALLFAC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRALLFAC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>trallfac</em> is on, a more detailed trace of factorizer calls is
generated.
<P>
<P>
The <em>trallfac</em> switch takes precedence over
<A HREF=r38_0335.html>trfac</A> if they are
both on. <em>trfac</em> gives a factorization trace with less detail in it.
When the
<A HREF=r38_0287.html>factor</A> switch is on also, all input polynomials are se
nt to
the factorizer automatically and trace information is generated. The
<A HREF=r38_0233.html>out</A> command saves the results of the factoring, but no
t the trace.
<P>
<P>
<P>
<A NAME=TRFAC>
<TITLE>TRFAC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRFAC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>trfac</em> is on, a narrative trace of any calls to the factorizer is
generated. Default is <em>off</em>.
<P>
<P>
When the switch
<A HREF=r38_0287.html>factor</A> is on, and <em>trfac</em> is on, every input
polynomial is sent to the factorizer, and a trace generated. With
<em>factor</em> off, only polynomials that are explicitly factored with the
command
<A HREF=r38_0151.html>factorize</A> generate trace information.
<P>
<P>
The
<A HREF=r38_0233.html>out</A> command saves the results of the factoring, but no
t
the trace. The
<A HREF=r38_0334.html>trallfac</A> switch gives trace information to a
greater level of detail.
<P>
<P>
<P>
<A NAME=TRIGFORM>
<TITLE>TRIGFORM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRIGFORM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When
<A HREF=r38_0292.html>fullroots</A> is on,
<A HREF=r38_0179.html>solve</A> will compute the
roots of a cubic or quartic polynomial is closed form. When
<em>trigform</em> is on, the roots will be expressed by trigonometric
forms. Otherwise nested surds are used. Default is <em>on</em>.
<P>
<P>
<A NAME=TRINT>
<TITLE>TRINT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>trint</em> is on, a narrative tracing various steps in the
integration process is produced.
<P>
<P>
The
<A HREF=r38_0233.html>out</A> command saves the results of the integration, but
not the
trace.
<P>
<P>
<P>
<A NAME=TRNONLNR>
<TITLE>TRNONLNR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRNONLNR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>trnonlnr</em> is on, a narrative tracing various steps in
the process for solving non-linear equations is produced.
<P>
<P>
<em>trnonlnr</em>can only be used after the solve package has been loaded
(e.g., by an explicit call of
<A HREF=r38_0127.html>load_package</A>). The
<A HREF=r38_0233.html>out</A>
command saves the results of the equation solving, but not the trace.
<P>
<P>
<P>
<A NAME=VAROPT>
<TITLE>VAROPT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VAROPT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
When <em>varopt</em> is on, the sequence of variables is optimized by
<A HREF=r38_0179.html>solve</A> with respect to execution speed. Otherwise, the
sequence
given in the call to
<A HREF=r38_0179.html>solve</A> is preserved. Default is <em>on</em>.
<P>
<P>
In combination with the switch
<A HREF=r38_0268.html>arbvars</A>, <em>varopt</em> can be used
to control variable elimination.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
off arbvars;
solve({x+2z,x-3y},{x,y,z});
x x
{{y=-,z= - -}}
3 2
solve({x*y=1,z=x},{x,y,z});
1
{{z=x,y=-}}
x
off varopt;
solve({x+2z,x-3y},{x,y,z});
2*z
{{x= - 2*z,y= - ---}}
3
solve({x*y=1,z=x},{x,y,z});
1
{{y=-,x=z}}
z
</TT></PRE><P>
<A NAME=g12>
<TITLE>General Switches</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>General Switches</B><MENU>
<LI><A HREF=r38_0264.html>SWITCHES introduction</A><P>
<LI><A HREF=r38_0265.html>ALGINT switch</A><P>
<LI><A HREF=r38_0266.html>ALLBRANCH switch</A><P>
<LI><A HREF=r38_0267.html>ALLFAC switch</A><P>
<LI><A HREF=r38_0268.html>ARBVARS switch</A><P>
<LI><A HREF=r38_0269.html>BALANCED\_MOD switch</A><P>
<LI><A HREF=r38_0270.html>BFSPACE switch</A><P>
<LI><A HREF=r38_0271.html>COMBINEEXPT switch</A><P>
<LI><A HREF=r38_0272.html>COMBINELOGS switch</A><P>
<LI><A HREF=r38_0273.html>COMP switch</A><P>
<LI><A HREF=r38_0274.html>COMPLEX switch</A><P>
<LI><A HREF=r38_0275.html>CREF switch</A><P>
<LI><A HREF=r38_0276.html>CRAMER switch</A><P>
<LI><A HREF=r38_0277.html>DEFN switch</A><P>
<LI><A HREF=r38_0278.html>DEMO switch</A><P>
<LI><A HREF=r38_0279.html>DFPRINT switch</A><P>
<LI><A HREF=r38_0280.html>DIV switch</A><P>
<LI><A HREF=r38_0281.html>ECHO switch</A><P>
<LI><A HREF=r38_0282.html>ERRCONT switch</A><P>
<LI><A HREF=r38_0283.html>EVALLHSEQP switch</A><P>
<LI><A HREF=r38_0284.html>EXP switch</A><P>
<LI><A HREF=r38_0285.html>EXPANDLOGS switch</A><P>
<LI><A HREF=r38_0286.html>EZGCD switch</A><P>
<LI><A HREF=r38_0287.html>FACTOR switch</A><P>
<LI><A HREF=r38_0288.html>FAILHARD switch</A><P>
<LI><A HREF=r38_0289.html>FORT switch</A><P>
<LI><A HREF=r38_0290.html>FORTUPPER switch</A><P>
<LI><A HREF=r38_0291.html>FULLPREC switch</A><P>
<LI><A HREF=r38_0292.html>FULLROOTS switch</A><P>
<LI><A HREF=r38_0293.html>GC switch</A><P>
<LI><A HREF=r38_0294.html>GCD switch</A><P>
<LI><A HREF=r38_0295.html>HORNER switch</A><P>
<LI><A HREF=r38_0296.html>IFACTOR switch</A><P>
<LI><A HREF=r38_0297.html>INT switch</A><P>
<LI><A HREF=r38_0298.html>INTSTR switch</A><P>
<LI><A HREF=r38_0299.html>LCM switch</A><P>
<LI><A HREF=r38_0300.html>LESSSPACE switch</A><P>
<LI><A HREF=r38_0301.html>LIMITEDFACTORS switch</A><P>
<LI><A HREF=r38_0302.html>LIST switch</A><P>
<LI><A HREF=r38_0303.html>LISTARGS switch</A><P>
<LI><A HREF=r38_0304.html>MCD switch</A><P>
<LI><A HREF=r38_0305.html>MODULAR switch</A><P>
<LI><A HREF=r38_0306.html>MSG switch</A><P>
<LI><A HREF=r38_0307.html>MULTIPLICITIES switch</A><P>
<LI><A HREF=r38_0308.html>NAT switch</A><P>
<LI><A HREF=r38_0309.html>NERO switch</A><P>
<LI><A HREF=r38_0310.html>NOARG switch</A><P>
<LI><A HREF=r38_0311.html>NOLNR switch</A><P>
<LI><A HREF=r38_0312.html>NOSPLIT switch</A><P>
<LI><A HREF=r38_0313.html>NUMVAL switch</A><P>
<LI><A HREF=r38_0314.html>OUTPUT switch</A><P>
<LI><A HREF=r38_0315.html>OVERVIEW switch</A><P>
<LI><A HREF=r38_0316.html>PERIOD switch</A><P>
<LI><A HREF=r38_0317.html>PRECISE switch</A><P>
<LI><A HREF=r38_0318.html>PRET switch</A><P>
<LI><A HREF=r38_0319.html>PRI switch</A><P>
<LI><A HREF=r38_0320.html>RAISE switch</A><P>
<LI><A HREF=r38_0321.html>RAT switch</A><P>
<LI><A HREF=r38_0322.html>RATARG switch</A><P>
<LI><A HREF=r38_0323.html>RATIONAL switch</A><P>
<LI><A HREF=r38_0324.html>RATIONALIZE switch</A><P>
<LI><A HREF=r38_0325.html>RATPRI switch</A><P>
<LI><A HREF=r38_0326.html>REVPRI switch</A><P>
<LI><A HREF=r38_0327.html>RLISP88 switch</A><P>
<LI><A HREF=r38_0328.html>ROUNDALL switch</A><P>
<LI><A HREF=r38_0329.html>ROUNDBF switch</A><P>
<LI><A HREF=r38_0330.html>ROUNDED switch</A><P>
<LI><A HREF=r38_0331.html>SAVESTRUCTR switch</A><P>
<LI><A HREF=r38_0332.html>SOLVESINGULAR switch</A><P>
<LI><A HREF=r38_0333.html>TIME switch</A><P>
<LI><A HREF=r38_0334.html>TRALLFAC switch</A><P>
<LI><A HREF=r38_0335.html>TRFAC switch</A><P>
<LI><A HREF=r38_0336.html>TRIGFORM switch</A><P>
<LI><A HREF=r38_0337.html>TRINT switch</A><P>
<LI><A HREF=r38_0338.html>TRNONLNR switch</A><P>
<LI><A HREF=r38_0339.html>VAROPT switch</A><P>
</MENU>
<A NAME=COFACTOR>
<TITLE>COFACTOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COFACTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>cofactor</em> returns the cofactor of the element in row
<row> and column <column> of a
<A HREF=r38_0345.html>matrix</A>. Errors occur
if <row> or <column> do not evaluate to integer expressions or if
the matrix is not square.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cofactor</em>(<matrix\_expression>,<row>,<column>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
cofactor(mat((a,b,c),(d,e,f),(p,q,r)),2,2);
A*R - C*P
cofactor(mat((a,b,c),(d,e,f)),1,1);
***** non-square matrix
</TT></PRE><P>
<A NAME=DET>
<TITLE>DET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>det</em> operator returns the determinant of its
(square
<A HREF=r38_0345.html>matrix</A>) argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>det</em>(<expression>) or <em>det</em> <expression>
<P>
<P>
<P>
<expression> must evaluate to a square matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix m,n;
m := mat((a,b),(c,d));
M(1,1) := A
M(1,2) := B
M(2,1) := C
M(2,2) := D
det m;
A*D - B*C
n := mat((1,2),(1,2));
N(1,1) := 1
N(1,2) := 2
N(2,1) := 1
N(2,2) := 2
det(n);
0
det(5);
5
</TT></PRE><P>Given a numerical argument, <em>det</em> returns the number. Howev
er, given a
variable name that has not been declared of type matrix, or a non-square
matrix, <em>det</em> returns an error message.
<P>
<P>
<P>
<A NAME=MAT>
<TITLE>MAT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MAT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>mat</em> operator is used to represent a two-dimensional
<A HREF=r38_0345.html>matrix</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mat</em>((<expr>{,<expr>}*) {(<expr>{<em>,</em><expr
>}*)}*)
<P>
<P>
<P>
<expr> may be any valid REDUCE scalar expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
mat((1,2),(3,4));
MAT(1,1) := 1
MAT(2,3) := 2
MAT(2,1) := 3
MAT(2,2) := 4
mat(2,1);
***** Matrix mismatch
Cont? (Y or N)
matrix qt;
qt := ws;
QT(1,1) := 1
QT(1,2) := 2
QT(2,1) := 3
QT(2,2) := 4
matrix a,b;
a := mat((x),(y),(z));
A(1,1) := X
A(2,1) := Y
A(3,1) := Z
b := mat((sin x,cos x,1));
B(1,1) := SIN(X)
B(1,2) := COS(X)
B(1,3) := 1
</TT></PRE><P>Matrices need not have a size declared (unlike arrays). <em>mat
</em>
redimensions a matrix variable as needed. It is necessary, of course,
that all rows be the same length. An anonymous matrix, as shown in the
first example, must be named before it can be referenced (note error
message). When using <em>mat</em> to fill a 1 x n
matrix, the row of values must be inside a second set of parentheses, to
eliminate ambiguity.
<P>
<P>
<P>
<A NAME=MATEIGEN>
<TITLE>MATEIGEN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATEIGEN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>mateigen</em> operator calculates the eigenvalue equation and the
corresponding eigenvectors of a
<A HREF=r38_0345.html>matrix</A>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mateigen</em>(<matrix-id>,<tag-id>)
<P>
<P>
<P>
<matrix-id> must be a declared matrix of values, and <tag-id> must b
e
a legal REDUCE identifier.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
aa := mat((2,5),(1,0))$
mateigen(aa,alpha);
2
{{ALPHA - 2*ALPHA - 5,
1,
5*ARBCOMPLEX(1)
MAT(1,1) := ---------------,
ALPHA - 2
MAT(2,1) := ARBCOMPLEX(1)
}}
charpoly := first first ws;
2
CHARPOLY := ALPHA - 2*ALPHA - 5
bb := mat((1,0,1),(1,1,0),(0,0,1))$
mateigen(bb,lamb);
{{LAMB - 1,3,
[ 0 ]
[ARBCOMPLEX(2)]
[ 0 ]
}}
</TT></PRE><P>The <em>mateigen</em> operator returns a list of lists of three
elements. The first element is a square free factor of the characteristic
polynomial; the second element is its multiplicity; and the third element
is the corresponding eigenvector. If the characteristic polynomial can be
completely factored, the product of the first elements of all the sublists
will produce the minimal polynomial. You can access the various parts of
the answer with the usual list access operators.
<P>
<P>
If the matrix is degenerate, more than one eigenvector can be produced for
the same eigenvalue, as shown by more than one arbitrary variable in the
eigenvector. The identification numbers of the arbitrary complex variables
shown in the examples above may not be the same as yours. Note that since
<em>lambda</em> is a reserved word in REDUCE, you cannot use it as a
tag-id for this operator.
<P>
<P>
<P>
<A NAME=MATRIX>
<TITLE>MATRIX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
Identifiers are declared to be of type <em>matrix</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>matrix</em><identifier> _ _ _ option (<index>,<index>)
<P>
<P>
{,<identifier> _ _ _ option
(<index>,<index>)}*
<P>
<P>
<P>
<identifier> must not be an already-defined operator or array or
the name of a scalar variable. Dimensions are optional, and if used appear
inside parentheses. <index> must be a positive integer.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix a,b(1,4),c(4,4);
b(1,1);
0
a(1,1);
***** Matrix A not set
a := mat((x0,y0),(x1,y1));
A(1,1) := X0
A(1,2) := Y0
A(2,1) := X0
A(2,2) := X1
length a;
{2,2}
b := a**2;
2
B(1,1) := X0 + X1*Y0
B(1,2) := Y0*(X0 + Y1)
B(2,1) := X1*(X0 + Y1)
2
B(2,2) := X1*Y0 + Y1
</TT></PRE><P>When a matrix variable has not been dimensioned, matrix elements c
annot be
referenced until the matrix is set by the
<A HREF=r38_0343.html>mat</A> operator. When a
matrix is dimensioned in its declaration, matrix elements are set to 0.
Matrix elements cannot stand for themselves. When you use
<A HREF=r38_0199.html>let</A> on
a matrix element, there is no effect unless the element contains a
constant, in which case an error message is returned. The same behavior
occurs with
<A HREF=r38_0189.html>clear</A>. Do <not> use
<A HREF=r38_0189.html>clear</A> to try to
set a matrix element to 0.
<A HREF=r38_0199.html>let</A> statements can be applied to
matrices as a whole, if the right-hand side of the expression is a matrix
expression, and the left-hand side identifier has been declared to be a matrix.
<P>
<P>
Arithmetical operators apply to matrices of the correct dimensions. The
operators <em>+</em> and <em>-</em> can be used with matrices of the same
dimensions. The operator <em>*</em> can be used to multiply
m x n matrices by n x p
matrices. Matrix multiplication is non-commutative. Scalars can also be
multiplied with matrices, with the result that each element of the matrix
is multiplied by the scalar. The operator <em>/</em> applied to two
matrices computes the first matrix multiplied by the inverse of the
second, if the inverse exists, and produces an error message otherwise.
Matrices can be divided by scalars, which results in dividing each element
of the matrix. Scalars can also be divided by matrices when the matrices
are invertible, and the result is the multiplication of the scalar by the
inverse of the matrix. Matrix inverses can by found by <em>1/A</em> or
<em>/A</em>, where <em>A</em> is a matrix. Square matrices can be raised to
positive integer powers, and also to negative integer powers if they are
nonsingular.
<P>
<P>
When a matrix variable is assigned to the results of a calculation, the
matrix is redimensioned if necessary.
<P>
<P>
<P>
<A NAME=NULLSPACE>
<TITLE>NULLSPACE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NULLSPACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>nullspace</em>(<matrix\_expression>)
<P>
<P>
<P>
<nullspace> calculates for its
<A HREF=r38_0345.html>matrix</A> argument,
<em>a</em>, a list of
linear independent vectors (a basis) whose linear combinations satisfy the
equation a x = 0. The basis is provided in a form such that as many
upper components as possible are isolated.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
nullspace mat((1,2,3,4),(5,6,7,8));
{
[ 1 ]
[ ]
[ 0 ]
[ ]
[ - 3]
[ ]
[ 2 ]
,
[ 0 ]
[ ]
[ 1 ]
[ ]
[ - 2]
[ ]
[ 1 ]
}
</TT></PRE><P>Note that with <em>b := nullspace a</em>, the expression <em>lengt
h b</em> is
the nullity/ of A, and that <em>second length a - length b</em>
calculates the rank/ of A. The rank of a matrix expression can
also be found more directly by the
<A HREF=r38_0347.html>rank</A> operator.
<P>
<P>
In addition to the REDUCE matrix form, <em>nullspace</em> accepts as input a
matrix given as a
<A HREF=r38_0053.html>list</A> of lists, that is interpreted as a row matrix. If
that form of input is chosen, the vectors in the result will be
represented by lists as well. This additional input syntax facilitates
the use of <em>nullspace</em> in applications different from classical linear
algebra.
<P>
<P>
<P>
<A NAME=RANK>
<TITLE>RANK</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RANK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>rank</em>(<matrix\_expression>)
<P>
<P>
<P>
<em>rank</em>calculates the rank of its matrix argument.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
rank mat((a,b,c),(d,e,f));
2
</TT></PRE><P>The argument to <em>rank</em> can also be a
<A HREF=r38_0053.html>list</A> of lists, interpreted
either as a row matrix or a set of equations. If that form of input is
chosen, the vectors in the result will be represented by lists as well.
This additional input syntax facilitates the use of <em>rank</em> in
applications different from classical linear algebra.
<P>
<P>
<P>
<A NAME=TP>
<TITLE>TP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>tp</em> operator returns the transpose of its
<A HREF=r38_0345.html>matrix</A>
argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>tp</em><identifier> or <em>tp</em>(<identifier>)
<P>
<P>
<P>
<identifier> must be a matrix, which either has had its dimensions set
in its declaration, or has had values put into it by <em>mat</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix m,n;
m := mat((1,2,3),(4,5,6))$
n := tp m;
N(1,1) := 1
N(1,2) := 4
N(2,1) := 2
N(2,2) := 5
N(3,1) := 3
N(3,2) := 6
</TT></PRE><P>In an assignment statement involving <em>tp</em>, the matrix ident
ifier on the
left-hand side is redimensioned to the correct size for the transpose.
<P>
<P>
<P>
<A NAME=TRACE>
<TITLE>TRACE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>trace</em> operator finds the trace of its
<A HREF=r38_0345.html>matrix</A> argument.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>trace</em>(<expression>) or <em>trace</em> <simple\_expression>
<P>
<P>
<P>
<expression> or <simple\_expression> must evaluate to a square
matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix a;
a := mat((x1,y1),(x2,y2))$
trace a;
X1 + Y2
</TT></PRE><P>The trace is the sum of the entries along the diagonal of a square
matrix.
Given a non-matrix expression, or a non-square matrix, <em>trace</em> returns
an error message.
<P>
<P>
<P>
<A NAME=g13>
<TITLE>Matrix Operations</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Matrix Operations</B><MENU>
<LI><A HREF=r38_0341.html>COFACTOR operator</A><P>
<LI><A HREF=r38_0342.html>DET operator</A><P>
<LI><A HREF=r38_0343.html>MAT operator</A><P>
<LI><A HREF=r38_0344.html>MATEIGEN operator</A><P>
<LI><A HREF=r38_0345.html>MATRIX declaration</A><P>
<LI><A HREF=r38_0346.html>NULLSPACE operator</A><P>
<LI><A HREF=r38_0347.html>RANK operator</A><P>
<LI><A HREF=r38_0348.html>TP operator</A><P>
<LI><A HREF=r38_0349.html>TRACE operator</A><P>
</MENU>
<A NAME=Groebner_bases>
<TITLE>Groebner_bases</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBNER BASES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
The GROEBNER package calculates <em>Groebner bases</em> using the
<em>Buchberger algorithm</em> and provides related algorithms
for arithmetic with ideal bases, such as ideal quotients,
Hilbert polynomials ( <em>Hollmann algorithm</em>),
basis conversion (
<em>Faugere-Gianni-Lazard-Mora algorithm</em>), independent
variable set ( <em>Kredel-Weispfenning algorithm</em>).
<P>
<P>
Some routines of the Groebner package are used by
<A HREF=r38_0179.html>solve</A> - in
that context the package is loaded automatically. However, if you
want to use the package by explicit calls you must load it by
<P><PRE><TT>
load_package groebner;
</TT></PRE><P><P>
<P>
For the common parameter setting of most operators in this package
see
<A HREF=r38_0352.html>ideal parameters</A>.
<P>
<P>
<A NAME=Ideal_Parameters>
<TITLE>Ideal_Parameters</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IDEAL PARAMETERS</B><P>
<P>
<P>
<P>
Most operators of the <em>Groebner</em> package compute expressions in a
polynomial ring which given as <R>[<var>,<var>,...] where
<R> is the current REDUCE coefficient domain. All algebraically
exact domains of REDUCE are supported. The package can operate over rings
and fields. The operation mode is distinguished automatically. In
general the ring mode is a bit faster than the field mode. The factoring
variant can be applied only over domains which allow you factoring of
multivariate polynomials.
<P>
<P>
The variable sequence <var> is either declared explicitly as argument
in form of a
<A HREF=r38_0053.html>list</A> in
<A HREF=r38_0354.html>torder</A>, or it is extracted
automatically from the expressions. In the second case the current REDUCE
system order is used (see
<A HREF=r38_0198.html>korder</A>) for arranging the variables.
If some kernels should play the role of formal parameters (the ground
domain <R> then is the polynomial ring over these), the variable
sequences must be given explicitly.
<P>
<P>
All REDUCE
<A HREF=r38_0002.html>kernel</A>s can be used as variables. But please note,
that all variables are considered as independent. E.g. when using
<em>sin(a)</em> and <em>cos(a)</em> as variables, the basic relation
<em>sin(a)^2+cos(a)^2-1=0</em> must be explicitly added to an equation set
because the Groebner operators don't include such knowledge automatically.
<P>
<P>
The terms (monomials) in polynomials are arranged according to the current
<A HREF=r38_0353.html>term order</A>. Note that the algebraic properties of the
computed
results only are valid as long as neither the ordering nor the variable
sequence changes.
<P>
<P>
The input expressions <exp> can be polynomials <p>, rational
functions <n>/<d> or equations <lh>=<rh> built from
polynomials or rational functions. Apart from the <em>tracing</em>
algorithms
<A HREF=r38_0398.html>groebnert</A> and
<A HREF=r38_0399.html>preducet</A>, where the equations
have a specific meaning, equations are converted to simple expressions by
taking the difference of the left-hand and right-hand sides
<lh>-<rh>=><p>. Rational functions are converted to
polynomials by converting the expression to a common denominator form
first, and then using the numerator only <n>=><p>. So eventual
zeros of the denominators are ignored.
<P>
<P>
A basis on input or output of an algorithm is coded as
<A HREF=r38_0053.html>list</A> of
expressions {<exp>,<exp>,...} .
<P>
<P>
<A NAME=Term_order>
<TITLE>Term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TERM ORDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
<P>
<P>
For all <em>Groebner</em> operations the polynomials are
represented in distributive form: a sum of terms (monomials).
The terms are ordered corresponding to the actual <em>term order</em>
which is set by the
<A HREF=r38_0354.html>torder</A> operator, and to the
actual variable sequence which is either given as explicit
parameter or by the system
<A HREF=r38_0002.html>kernel</A> order.
<P>
<P>
<A NAME=torder>
<TITLE>torder</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TORDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>torder</em> sets the actual variable sequence and term order.
<P>
<P>
1. simple term order:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder</em>(<vl>, <m>)
<P>
<P>
<P>
where <vl> is a
<A HREF=r38_0053.html>list</A> of variables (
<A HREF=r38_0002.html>kernel</A>s) and
<m> is the name of a simple
<A HREF=r38_0353.html>term order</A> mode
<A HREF=r38_0356.html>lex term order</A>,
<A HREF=r38_0357.html>gradlex term order</A>,
<A HREF=r38_0358.html>revgradlex term order</A> or another implemented parameter
less mode.
<P>
<P>
2. stepped term order:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder</em>(<vl>,<m>,<n>)
<P>
<P>
<P>
<P>
where <m> is the name of a two step term order, one of
<A HREF=r38_0359.html>gradlexgradlex term order</A>,
<A HREF=r38_0360.html>gradlexrevgradlex term order</A>,
<A HREF=r38_0361.html>lexgradlex term order</A> or
<A HREF=r38_0362.html>lexrevgradlex term order</A>, and
<n> is a positive integer.
<P>
<P>
3. weighted term order
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder</em>(<vl>, <em>weighted</em>, <n>,<n>,...);
<P>
<P>
<P>
where the <n> are positive integers, see
<A HREF=r38_0363.html>weighted term order</A>.
<P>
<P>
4. matrix term order
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder</em>(<vl>, <em>matrix</em>, <m>);
<P>
<P>
<P>
where <m> is a matrix with integer elements, see
<A HREF=r38_0355.html>torder_compile</A>.
<P>
<P>
5. compiled term order
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder</em>(<vl>, <em>co</em>);
<P>
<P>
<P>
where <co> is the name of a routine generated by
<A HREF=r38_0355.html>torder_compile</A>.
<P>
<P>
<em>torder</em>sets the variable sequence and the term order mode. If the
an empty list is used as variable sequence, the automatic variable extraction
is activated. The defaults are the empty variable list an the
<A HREF=r38_0356.html>lex term order</A>.
The previous setting is returned as a list.
<P>
<P>
Alternatively to the above syntax the arguments of <em>torder</em> may be
collected in a
<A HREF=r38_0053.html>list</A> and passed as one argument to
<em>torder</em>.
<P>
<P>
<A NAME=torder_compile>
<TITLE>torder_compile</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TORDER_COMPILE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
A matrix can be converted into
a compilable LISP program for faster execution by using
<P> <H3>
syntax: </H3>
<P>
<P>
<em>torder_compile</em>(<name>,<mat>)
<P>
<P>
<P>
where <name> is an identifier for the new term order and <mat>
is an integer matrix to be used as
<A HREF=r38_0365.html>matrix term order</A>. Afterwards
the term order can be activated by using <name> in a
<A HREF=r38_0354.html>torder</A>
expression. The resulting program is compiled if the switch
<A HREF=r38_0273.html>comp</A>
is on, or if the <em>torder_compile</em> expression is part of a compiled
module.
<P>
<P>
<A NAME=lex_term_order>
<TITLE>lex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LEX TERM ORDER</B><P>
<P>
<P>
<P>
The terms are ordered lexicographically: two terms t1 t2
are compared for their degrees
along the fixed variable sequence: t1 is higher than t2
if the first different degree is higher in t1.
This order has the <em>elimination property</em>
for <em>groebner basis</em> calculations.
If the ideal has a univariate polynomial in the last
variable the groebner basis will contain
such polynomial. <em>Lex</em> is best
suited for solving of polynomial equation systems.
<P>
<P>
<A NAME=gradlex_term_order>
<TITLE>gradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
The terms are ordered first with their total
degree, and if the total degree is identical
the comparison is
<A HREF=r38_0356.html>lex term order</A>.
With <em>groebner</em> basis calculations this term order
produces polynomials of lowest degree.
<P>
<P>
<A NAME=revgradlex_term_order>
<TITLE>revgradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REVGRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
The terms are ordered first with their total
degree (degree sum), and if the total degree is identical
the comparison is the inverse of
<A HREF=r38_0356.html>lex term order</A>.
With
<A HREF=r38_0368.html>groebner</A> and
<A HREF=r38_0391.html>groebnerf</A>
calculations this term order
is similar to
<A HREF=r38_0357.html>gradlex term order</A>; it is known
as most efficient ordering with respect to computing time.
<P>
<P>
<A NAME=gradlexgradlex_term_order>
<TITLE>gradlexgradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GRADLEXGRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
The terms are separated into two groups where the
second parameter of the
<A HREF=r38_0354.html>torder</A> call determines
the length of the first group. For a comparison first
the total degrees of both variable groups are compared.
If both are equal
<A HREF=r38_0357.html>gradlex term order</A> comparison is applied to the first
group, and if that does not decide
<A HREF=r38_0357.html>gradlex term order</A>
is applied for the second group. This order has the elimination
property for the variable groups. It can be used e.g. for
separating variables from parameters.
<P>
<P>
<A NAME=gradlexrevgradlex_term_order>
<TITLE>gradlexrevgradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GRADLEXREVGRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
Similar to
<A HREF=r38_0359.html>gradlexgradlex term order</A>, but using
<A HREF=r38_0358.html>revgradlex term order</A> for the second group.
<P>
<P>
<A NAME=lexgradlex_term_order>
<TITLE>lexgradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LEXGRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
Similar to
<A HREF=r38_0359.html>gradlexgradlex term order</A>, but using
<A HREF=r38_0356.html>lex term order</A> for the first group.
<P>
<P>
<A NAME=lexrevgradlex_term_order>
<TITLE>lexrevgradlex_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LEXREVGRADLEX TERM ORDER</B><P>
<P>
<P>
<P>
Similar to
<A HREF=r38_0359.html>gradlexgradlex term order</A>, but using
<A HREF=r38_0356.html>lex term order</A> for the first group
<A HREF=r38_0358.html>revgradlex term order</A> for the second group.
<P>
<P>
<A NAME=weighted_term_order>
<TITLE>weighted_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WEIGHTED TERM ORDER</B><P>
<P>
<P>
<P>
establishes a graduated ordering
similar to
<A HREF=r38_0357.html>gradlex term order</A>, where the exponents first are
multiplied by the given weights. If there are less weight values than
variables, the weight list is extended by ones. If the weighted degree
comparison is not decidable, the
<A HREF=r38_0356.html>lex term order</A> is used.
<P>
<P>
<A NAME=graded_term_order>
<TITLE>graded_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GRADED TERM ORDER</B><P>
<P>
<P>
<P>
establishes a cascaded term ordering: first a graduated ordering
similar to
<A HREF=r38_0357.html>gradlex term order</A> is used, where the exponents first
are
multiplied by the given weights. If there are less weight values than
variables, the weight list is extended by ones. If the weighted degree
comparison is not decidable, the term ordering described in the following
parameters of the
<A HREF=r38_0354.html>torder</A> command is used.
<P>
<P>
<A NAME=matrix_term_order>
<TITLE>matrix_term_order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATRIX TERM ORDER</B><P>
<P>
<P>
<P>
Any arbitrary term order mode can be installed by a matrix with
integer elements where the row length corresponds to the variable
number. The matrix must have at least as many rows as columns.
It must have full rank, and the top nonzero element of each column
must be positive.
<P>
<P>
The matrix <em>term order mode</em>
defines a term order where the exponent vectors of the monomials are
first multiplied by the matrix and the resulting vectors are compared
lexicographically.
<P>
<P>
If the switch
<A HREF=r38_0273.html>comp</A> is on, the matrix is converted into
a compiled LISP program for faster execution. A matrix can also be
compiled explicitly, see
<A HREF=r38_0355.html>torder_compile</A>.
<P>
<P>
<A NAME=g15>
<TITLE>Term order</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Term order</B><MENU>
<LI><A HREF=r38_0353.html>Term order introduction</A><P>
<LI><A HREF=r38_0354.html>torder operator</A><P>
<LI><A HREF=r38_0355.html>torder_compile operator</A><P>
<LI><A HREF=r38_0356.html>lex term order concept</A><P>
<LI><A HREF=r38_0357.html>gradlex term order concept</A><P>
<LI><A HREF=r38_0358.html>revgradlex term order concept</A><P>
<LI><A HREF=r38_0359.html>gradlexgradlex term order concept</A><P>
<LI><A HREF=r38_0360.html>gradlexrevgradlex term order concept</A><P>
<LI><A HREF=r38_0361.html>lexgradlex term order concept</A><P>
<LI><A HREF=r38_0362.html>lexrevgradlex term order concept</A><P>
<LI><A HREF=r38_0363.html>weighted term order concept</A><P>
<LI><A HREF=r38_0364.html>graded term order concept</A><P>
<LI><A HREF=r38_0365.html>matrix term order concept</A><P>
</MENU>
<A NAME=gvars>
<TITLE>gvars</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GVARS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>gvars</em>({<exp>,<exp>,... })
<P>
<P>
<P>
<P>
where <exp> are expressions or
<A HREF=r38_0045.html>equation</A>s.
<P>
<P>
<em>gvars</em>extracts from the expressions the
<A HREF=r38_0002.html>kernel</A><em>s</em>
which can
play the role of variables for a
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A>
calculation.
<P>
<P>
<A NAME=groebner>
<TITLE>groebner</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBNER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>groebner</em>({<em>exp</em>, ...})
<P>
<P>
<P>
<P>
where {<em>exp</em>, ... } is a list of
expressions or equations.
<P>
<P>
The operator <em>groebner</em> implements the Buchberger algorithm
for computing Groebner bases for a given set of
expressions with respect to the given set of variables in the order
given. As a side effect, the sequence of variables is stored as a REDUCE list
in the shared variable
<A HREF=r38_0371.html>gvarslast</A> - this is important in cases
where the algorithm rearranges the variable sequence because
<A HREF=r38_0370.html>groebopt</A>
is <em>on</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
groebner({x**2+y**2-1,x-y})
{X - Y,2*Y**2 -1}
</TT></PRE><P> <P> <H3>
related: </H3>
<P>
_ _ _
<A HREF=r38_0391.html>groebnerf</A>operator
<P>
_ _ _
<A HREF=r38_0371.html>gvarslast</A> variable
<P>
_ _ _
<A HREF=r38_0370.html>groebopt</A> switch
<P>
_ _ _
<A HREF=r38_0372.html>groebprereduce</A> switch
<P>
_ _ _
<A HREF=r38_0373.html>groebfullreduction</A> switch
<P>
_ _ _
<A HREF=r38_0374.html>gltbasis</A> switch
<P>
_ _ _
<A HREF=r38_0375.html>gltb</A> variable
<P>
_ _ _
<A HREF=r38_0376.html>glterms</A> variable
<P>
_ _ _
<A HREF=r38_0377.html>groebstat</A> switch
<P>
_ _ _
<A HREF=r38_0378.html>trgroeb</A> switch
<P>
_ _ _
<A HREF=r38_0379.html>trgroebs</A> switch
<P>
_ _ _
<A HREF=r38_0396.html>groebprot</A> switch
<P>
_ _ _
<A HREF=r38_0397.html>groebprotfile</A> variable
<P>
_ _ _
<A HREF=r38_0398.html>groebnert</A> operator
<P>
<P>
<P>
<A NAME=groebner_walk>
<TITLE>groebner_walk</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBNER\_WALK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>groebner_walk</em> computes a <em>lex</em> basis
from a given <em>graded</em> (or <em>weighted</em>) one.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>groebner_walk</em>(<g>)
<P>
<P>
<P>
where <g> is a <em>graded</em> basis (or <em>weighted</em> basis
with a weight vector with one repeated element) of the polynomial ideal.
<em>Groebner_walk</em> computes a sequence of monomial bases, each
time lifting the full system to a complete basis. <em>Groebner_walk</em>
should be called only in cases, where a normal <em>kex</em> computation
would take too much computer time.
<P>
<P>
The operator
<A HREF=r38_0354.html>torder</A> has to be called before in order to
define the variable sequence and the term order mode of <g>.
<P>
<P>
The variable
<A HREF=r38_0371.html>gvarslast</A> is not set.
<P>
<P>
Do not call <em>groebner_walk</em> with <em>on</em>
<A HREF=r38_0370.html>groebopt</A>.
<P>
<P>
<em>Groebner_walk</em>includes some overhead (such as e. g.
computation with division). On the other hand, sometimes
<em>groebner_walk</em> is faster than a direct <em>lex</em> computation.
<P>
<P>
<A NAME=groebopt>
<TITLE>groebopt</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBOPT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If <em>groebopt</em> is set ON, the sequence of variables is optimized
with respect to execution speed of <em>groebner</em> calculations;
note that the final list of variables is available in
<A HREF=r38_0371.html>gvarslast</A>.
By default <em>groebopt</em> is off, conserving the original variable
sequence.
<P>
<P>
An explicitly declared dependency using the
<A HREF=r38_0192.html>depend</A>
declaration supersedes the variable optimization.
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P><P>
<P>
guarantees that a will be placed in front of x and y.
<P>
<P>
<A NAME=gvarslast>
<TITLE>gvarslast</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GVARSLAST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
After a
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A> calculation
the actual variable sequence is stored in the variable
<em>gvarslast</em>. If
<A HREF=r38_0370.html>groebopt</A> is <em>on</em>
<em>gvarslast</em> shows the variable sequence after reordering.
<P>
<P>
<A NAME=groebprereduce>
<TITLE>groebprereduce</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBPREREDUCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If <em>groebprereduce</em> set ON,
<A HREF=r38_0368.html>groebner</A>
and
<A HREF=r38_0391.html>groebnerf</A> try to simplify the
input expressions: if the head term of an input expression is a
multiple of the head term of another expression, it can be reduced;
these reductions are done cyclicly as long as possible in order to
shorten the main part of the algorithm.
<P>
<P>
By default <em>groebprereduce</em> is off.
<P>
<P>
<A NAME=groebfullreduction>
<TITLE>groebfullreduction</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBFULLREDUCTION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If <em>groebfullreduction</em> set off, the polynomial reduction steps during
<A HREF=r38_0368.html>groebner</A> and
<A HREF=r38_0391.html>groebnerf</A> are limited to the pure head
term reduction; subsequent terms are reduced otherwise.
<P>
<P>
By default <em>groebfullreduction</em> is on.
<P>
<P>
<A NAME=gltbasis>
<TITLE>gltbasis</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GLTBASIS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If <em>gltbasis</em> set on, the leading terms of the result basis
of a
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A> calculation are
extracted. They are collected as a basis of monomials, which is
available as value of the global variable
<A HREF=r38_0375.html>gltb</A>.
<P>
<P>
<A NAME=gltb>
<TITLE>gltb</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GLTB</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
See
<A HREF=r38_0374.html>gltbasis</A>
<P>
<P>
<A NAME=glterms>
<TITLE>glterms</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GLTERMS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
If the expressions in a
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A>
call contain parameters (symbols
which are not member of the variable list), the share variable
<em>glterms</em> is set to a list of expression which during the
calculation were assumed to be nonzero. The calculated bases
are valid only under the assumption that all these expressions do
not vanish.
<P>
<P>
<A NAME=groebstat>
<TITLE>groebstat</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBSTAT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
if <em>groebstat</em> is on, a summary of the
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A> computation is printed
at the end
including the computing time, the number of intermediate
H polynomials and the counters for the criteria hits.
<P>
<P>
<A NAME=trgroeb>
<TITLE>trgroeb</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRGROEB</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
if <em>trgroeb</em> is on, intermediate H polynomials are
printed during a
<A HREF=r38_0368.html>groebner</A>
or
<A HREF=r38_0391.html>groebnerf</A> calculation.
<P>
<P>
<A NAME=trgroebs>
<TITLE>trgroebs</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRGROEBS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
if <em>trgroebs</em> is on, intermediate H and S polynomials are
printed during a
<A HREF=r38_0368.html>groebner</A> or
<A HREF=r38_0391.html>groebnerf</A> calculation.
<P>
<P>
<A NAME=gzerodim_>
<TITLE>gzerodim_</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GZERODIM?</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>gzerodim!?</em>(<basis>)
<P>
<P>
<P>
<P>
where <bas> is a Groebner basis in the current
<A HREF=r38_0353.html>term order</A> with the actual setting
(see
<A HREF=r38_0352.html>ideal parameters</A>).
<P>
<P>
<em>gzerodim!?</em>tests whether the ideal spanned by the given basis
has dimension zero. If yes, the number of zeros is returned,
<A HREF=r38_0014.html>nil</A> otherwise.
<P>
<P>
<A NAME=gdimension>
<TITLE>gdimension</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GDIMENSION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gdimension</em>(<bas>)
<P>
<P>
<P>
<P>
where <bas> is a
<A HREF=r38_0381.html>groebner</A> basis in the current
term order (see
<A HREF=r38_0352.html>ideal parameters</A>).
<em>gdimension</em> computes the dimension of the ideal
spanned by the given basis and returns the dimension as an integer
number. The Kredel-Weispfenning algorithm is used: the dimension
is the length of the longest independent variable set,
see
<A HREF=r38_0382.html>gindependent_sets</A>
<P>
<P>
<A NAME=gindependent_sets>
<TITLE>gindependent_sets</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GINDEPENDENT\_SETS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gindependent_sets</em>(<bas>)
<P>
<P>
<P>
<P>
where <bas> is a
<A HREF=r38_0382.html>groebner</A> basis in any <em>term order</em>
(which must be the current <em>term order</em>) with the specified
variables (see
<A HREF=r38_0352.html>ideal parameters</A>).
<P>
<P>
<em>Gindependent_sets</em>computes the maximal
left independent variable sets of the ideal, that are
the variable sets which play the role of free parameters in the
current ideal basis. Each set is a list which is a subset of the
variable list. The result is a list of these sets. For an
ideal with dimension zero the list is empty.
The Kredel-Weispfenning algorithm is used.
<P>
<P>
<A NAME=dd_groebner>
<TITLE>dd_groebner</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DD_GROEBNER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
For a homogeneous system of polynomials under
<A HREF=r38_0364.html>graded term order</A>,
<A HREF=r38_0357.html>gradlex term order</A>,
<A HREF=r38_0358.html>revgradlex term order</A> <P>
<P>
or
<A HREF=r38_0363.html>weighted term order</A>
a Groebner Base can be computed with limiting the grade
of the intermediate S polynomials:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>dd_groebner</em>(<d1>,<d2>,<plist>)
<P>
<P>
<P>
where <d1> is a non negative integer and <d2> is an integer
or ``infinity". A pair of polynomials is considered
only if the grade of the lcm of their head terms is between
<d1> and <d2>.
For the term orders <em>graded</em> or <em>weighted</em> the (first) weight
vector is used for the grade computation. Otherwise the total
degree of a term is used.
<P>
<P>
<A NAME=glexconvert>
<TITLE>glexconvert</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GLEXCONVERT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>glexconvert</em>(<bas>[,<vars>][,MAXDEG=<mx>]
[,NEWVARS=<nv>])
<P>
<P>
<P>
<P>
where <bas> is a
<A HREF=r38_0382.html>groebner</A> basis
in the current term order, <mx> (optional) is a positive
integer and <nvl> (optional) is a list of variables
(see
<A HREF=r38_0352.html>ideal parameters</A>).
<P>
<P>
The operator <em>glexconvert</em> converts the basis
of a zero-dimensional ideal (finite number
of isolated solutions) from arbitrary ordering into a basis under
<A HREF=r38_0356.html>lex term order</A>.
<P>
<P>
The parameter <newvars> defines the new variable sequence.
If omitted, the
original variable sequence is used. If only a subset of variables is
specified here, the partial ideal basis is evaluated.
<P>
<P>
If <newvars> is a list with one element, the minimal
<em>univariate polynomial</em> is computed.
<P>
<P>
<maxdeg> is an upper limit for the degrees. The algorithm stops with
an error message, if this limit is reached.
<P>
<P>
A warning occurs, if the ideal is not zero dimensional.
<P>
<P>
During the call the <em>term order</em> of the input basis must
be active.
<P>
<P>
<P>
<A NAME=greduce>
<TITLE>greduce</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GREDUCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>greduce</em>(exp, {exp1, exp2, ... , expm})
<P>
<P>
<P>
<P>
where exp is an expression, and {exp1, exp2, ... , expm} is
a list of expressions or equations.
<P>
<P>
<em>greduce</em>is functionally equivalent with a call to
<A HREF=r38_0382.html>groebner</A> and then a call to
<A HREF=r38_0386.html>preduce</A>.
<P>
<P>
<A NAME=preduce>
<TITLE>preduce</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PREDUCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>preduce</em>(<p>, {<exp>, ... })
<P>
<P>
<P>
<P>
where <p> is an expression, and {<exp>, ... } is
a list of expressions or equations.
<P>
<P>
<em>Preduce</em>computes the remainder of <em>exp</em>
modulo the given set of polynomials resp. equations.
This result is unique (canonical) only if the given set
is a <em>groebner</em> basis under the current
<A HREF=r38_0353.html>term order</A>
<P>
<P>
see also:
<A HREF=r38_0399.html>preducet</A> operator.
<P>
<P>
<A NAME=idealquotient>
<TITLE>idealquotient</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IDEALQUOTIENT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>idealquotient</em>({<exp>, ...}, <d>)
<P>
<P>
<P>
<P>
where {<exp>,...} is a list of
expressions or equations, <d> is a single expression or equation.
<P>
<P>
<em>Idealquotient</em>computes the ideal quotient:
ideal spanned by the expressions {<exp>,...}
divided by the single polynomial/expression <f>. The result
is the
<A HREF=r38_0382.html>groebner</A> basis of the quotient ideal.
<P>
<P>
<A NAME=hilbertpolynomial>
<TITLE>hilbertpolynomial</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HILBERTPOLYNOMIAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
hilbertpolynomial(<bas>)
<P>
<P>
<P>
<P>
where <bas> is a
<A HREF=r38_0382.html>groebner</A> basis in the
current
<A HREF=r38_0353.html>term order</A>.
<P>
<P>
The degree of the <em>Hilbert polynomial</em> is the
dimension of the ideal spanned by the basis. For an
ideal of dimension zero the Hilbert polynomial is a
constant which is the number of common zeros of the
ideal (including eventual multiplicities).
The <em>Hollmann algorithm</em> is used.
<P>
<P>
<A NAME=saturation>
<TITLE>saturation</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SATURATION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>saturation</em>({<exp>, ...}, <p>)
<P>
<P>
<P>
<P>
where {<exp>,...} is a list of
expressions or equations, <p> is a single polynomial.
<P>
<P>
<em>Saturation</em>computes the quotient of the polynomial <p>
and a power (with unknown but finite exponent) of the ideal built from
{<exp>, ...}. The result is the computed quotient. <em>Saturation</em>
calls
<A HREF=r38_0387.html>idealquotient</A> several times until the result does not
change
any more.
<P>
<P>
<A NAME=g16>
<TITLE>Basic Groebner operators</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Basic Groebner operators</B><MENU>
<LI><A HREF=r38_0367.html>gvars operator</A><P>
<LI><A HREF=r38_0382.html>groebner operator</A><P>
<LI><A HREF=r38_0369.html>groebner\_walk operator</A><P>
<LI><A HREF=r38_0370.html>groebopt switch</A><P>
<LI><A HREF=r38_0371.html>gvarslast variable</A><P>
<LI><A HREF=r38_0372.html>groebprereduce switch</A><P>
<LI><A HREF=r38_0373.html>groebfullreduction switch</A><P>
<LI><A HREF=r38_0374.html>gltbasis switch</A><P>
<LI><A HREF=r38_0375.html>gltb variable</A><P>
<LI><A HREF=r38_0376.html>glterms variable</A><P>
<LI><A HREF=r38_0377.html>groebstat switch</A><P>
<LI><A HREF=r38_0378.html>trgroeb switch</A><P>
<LI><A HREF=r38_0379.html>trgroebs switch</A><P>
<LI><A HREF=r38_0380.html>gzerodim? operator</A><P>
<LI><A HREF=r38_0381.html>gdimension operator</A><P>
<LI><A HREF=r38_0382.html>gindependent\_sets operator</A><P>
<LI><A HREF=r38_0383.html>dd_groebner operator</A><P>
<LI><A HREF=r38_0384.html>glexconvert operator</A><P>
<LI><A HREF=r38_0385.html>greduce operator</A><P>
<LI><A HREF=r38_0386.html>preduce operator</A><P>
<LI><A HREF=r38_0387.html>idealquotient operator</A><P>
<LI><A HREF=r38_0388.html>hilbertpolynomial operator</A><P>
<LI><A HREF=r38_0389.html>saturation operator</A><P>
</MENU>
<A NAME=groebnerf>
<TITLE>groebnerf</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBNERF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>groebnerf</em>({<exp>, ...}[,{},{<nz>, ... }]);
<P>
<P>
<P>
<P>
where {<exp>, ... } is a list of expressions or
equations, and {<nz>,... } is
an optional list of polynomials to be considered as non zero
for this calculation. An empty list must be passed as second argument
if the non-zero list is specified.
<P>
<P>
<em>groebnerf</em>tries to separate polynomials into individual factors and
to branch the computation in a recursive manner (factorization tree).
The result is a list of partial Groebner bases.
Multiplicities (one factor with a higher power, the same partial basis
twice) are deleted as early as possible in order to speed up the
calculation.
<P>
<P>
The third parameter of <em>groebnerf</em> declares some polynomials
nonzero. If any of these is found in a branch of the calculation
the branch is canceled.
<P>
<P>
<P> <H3>
example: </H3>
<P><PRE><TT>
groebnerf({ 3*x**2*y+2*x*y+y+9*x**2+5*x = 3,
2*x**3*y-x*y-y+6*x**3-2*x**2-3*x = -3,
x**3*y+x**2*y+3*x**3+2*x**2 }, {y,x});
{{Y - 3,X},
2
{2*Y + 2*X - 1,2*X - 5*X - 5}}
</TT></PRE><P> <P> <H3>
related: </H3>
<P>
_ _ _
<A HREF=r38_0393.html>groebresmax</A>variable
<P>
_ _ _
<A HREF=r38_0392.html>groebmonfac</A> variable
<P>
_ _ _
<A HREF=r38_0394.html>groebrestriction</A> variable
<P>
_ _ _
<A HREF=r38_0382.html>groebner</A> operator
<P>
_ _ _
<A HREF=r38_0371.html>gvarslast</A> variable
<P>
_ _ _
<A HREF=r38_0370.html>groebopt</A> switch
<P>
_ _ _
<A HREF=r38_0372.html>groebprereduce</A> switch
<P>
_ _ _
<A HREF=r38_0373.html>groebfullreduction</A> switch
<P>
_ _ _
<A HREF=r38_0374.html>gltbasis</A> switch
<P>
_ _ _
<A HREF=r38_0375.html>gltb</A> variable
<P>
_ _ _
<A HREF=r38_0376.html>glterms</A> variable
<P>
_ _ _
<A HREF=r38_0377.html>groebstat</A> switch
<P>
_ _ _
<A HREF=r38_0378.html>trgroeb</A> switch
<P>
_ _ _
<A HREF=r38_0379.html>trgroebs</A> switch
<P>
_ _ _
<A HREF=r38_0398.html>groebnert</A> operator
<P>
<P>
<P>
<A NAME=groebmonfac>
<TITLE>groebmonfac</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBMONFAC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
The variable <em>groebmonfac</em> is connected to
the handling of monomial factors. A monomial factor is a product
of variable powers as a factor, e.g. x**2*y in x**3*y -
2*x**2*y**2. A monomial factor represents a solution of the type
x = 0 or y = 0 with a certain multiplicity. With
<A HREF=r38_0391.html>groebnerf</A> the multiplicity of monomial factors is lowe
red
to the value of the shared variable <em>groebmonfac</em>
which by default is 1 (= monomial factors remain present, but their
multiplicity is brought down). With
<em>groebmonfac</em>:= 0
the monomial factors are suppressed completely.
<P>
<P>
<A NAME=groebresmax>
<TITLE>groebresmax</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBRESMAX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
The variable <em>groebresmax</em>
controls during
<A HREF=r38_0391.html>groebnerf</A> calculations
the number of partial results. Its default value is 300. If
more partial results are calculated, the calculation is
terminated.
<P>
<P>
<A NAME=groebrestriction>
<TITLE>groebrestriction</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBRESTRICTION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
During
<A HREF=r38_0391.html>groebnerf</A> calculations
irrelevant branches can be excluded
by setting the variable <em>groebrestriction</em>. The
following restrictions are implemented:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>groebrestriction</em>:= <em>nonnegative</em>
<P>
<P>
<em>groebrestriction</em>:= <em>positive</em>
<P>
<P>
<em>groebrestriction</em>:= <em>zeropoint</em>
<P>
<P>
<P>
With <em>nonnegative</em> branches are excluded where one
polynomial has no nonnegative real zeros; with <em>positive</em>
the restriction is sharpened to positive zeros only.
The restriction <em>zeropoint</em> excludes all branches
which do not have the origin (0,0,...0) in their solution
set.
<P>
<P>
<A NAME=g17>
<TITLE>Factorizing Groebner bases</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Factorizing Groebner bases</B><MENU>
<LI><A HREF=r38_0391.html>groebnerf operator</A><P>
<LI><A HREF=r38_0392.html>groebmonfac variable</A><P>
<LI><A HREF=r38_0393.html>groebresmax variable</A><P>
<LI><A HREF=r38_0394.html>groebrestriction variable</A><P>
</MENU>
<A NAME=groebprot>
<TITLE>groebprot</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBPROT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If <em>groebprot</em> is <em>ON</em> the computation steps during
<A HREF=r38_0386.html>preduce</A>,
<A HREF=r38_0385.html>greduce</A> and
<A HREF=r38_0382.html>groebner</A>
are collected in a list which is assigned to the variable
<A HREF=r38_0397.html>groebprotfile</A>.
<P>
<P>
<A NAME=groebprotfile>
<TITLE>groebprotfile</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBPROTFILE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
See
<A HREF=r38_0396.html>groebprot</A> switch.
<P>
<P>
<A NAME=groebnert>
<TITLE>groebnert</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GROEBNERT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>groebnert</em>({<v>=<exp>,...})
<P>
<P>
<P>
<P>
where <v> are
<A HREF=r38_0002.html>kernel</A><em>s</em> (simple or indexed variables),
<exp> are polynomials.
<P>
<P>
<em>groebnert</em>is functionally equivalent to a
<A HREF=r38_0382.html>groebner</A>
call for {<exp>,...}, but the result is a set of
equations where the left-hand sides are the basis elements while
the right-hand sides are the same values expressed as combinations
of the input formulas, expressed in terms of the names <v>
<P> <H3>
example: </H3>
<P><PRE><TT>
groebnert({p1=2*x**2+4*y**2-100,p2=2*x-y+1});
GB1 := {2*X - Y + 1=P2,
2
9*Y - 2*Y - 199= - 2*X*P2 - Y*P2 + 2*P1 + P2}
</TT></PRE><P><P>
<P>
<A NAME=preducet>
<TITLE>preducet</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PREDUCET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P> <H3>
syntax: </H3>
<P>
<P>
<em>preduce</em>(<p>,{<v>=<exp>...})
<P>
<P>
<P>
where <p> is an expression, <v> are kernels
(simple or indexed variables),
<em>exp</em> are polynomials.
<P>
<P>
<em>preducet</em>computes the remainder of <p> modulo {<exp>,...}
similar to
<A HREF=r38_0386.html>preduce</A>, but the result is an equation
which expresses the remainder as combination of the polynomials.
<P> <H3>
example: </H3>
<P><PRE><TT>
GB2 := {G1=2*X - Y + 1,G2=9*Y**2 - 2*Y - 199}
preducet(q=x**2,gb2);
- 16*Y + 208= - 18*X*G1 - 9*Y*G1 + 36*Q + 9*G1 - G2
</TT></PRE><P><P>
<P>
<A NAME=g18>
<TITLE>Tracing Groebner bases</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Tracing Groebner bases</B><MENU>
<LI><A HREF=r38_0396.html>groebprot switch</A><P>
<LI><A HREF=r38_0397.html>groebprotfile variable</A><P>
<LI><A HREF=r38_0398.html>groebnert operator</A><P>
<LI><A HREF=r38_0399.html>preducet operator</A><P>
</MENU>
<A NAME=Module>
<TITLE>Module</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MODULE</B><P>
<P>
Given a polynomial ring, e.g. R=Z[x,y,...] and an integer n>1.
The vectors with n elements of R form a free MODULE under
elementwise addition and multiplication with elements of R.
<P>
<P>
For a submodule given by a finite basis a Groebner basis
can be computed, and the facilities of the GROEBNER package
are available except the operators
<A HREF=r38_0391.html>groebnerf</A>
and <em>groesolve</em>. The vectors are encoded using auxiliary
variables which represent the unit vectors in the module.
These are declared in the share variable
<A HREF=r38_0402.html>gmodule</A>.
<P>
<P>
<A NAME=gmodule>
<TITLE>gmodule</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GMODULE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
The vectors of a free
<A HREF=r38_0401.html>module</A> over a polynomial ring R
are encoded as linear combinations with unit vectors of
M which are represented by auxiliary variables. These
must be collected in the variable <em>gmodule</em> before
any call to an operator of the Groebner package.
<P>
<P>
<P><PRE><TT>
torder({x,y,v1,v2,v3})$
gmodule := {v1,v2,v3}$
g:=groebner({x^2*v1 + y*v2,x*y*v1 - v3,2y*v1 + y*v3});
</TT></PRE><P>compute the Groebner basis of the submodule
<P>
<P>
<P><PRE><TT>
([x^2,y,0],[xy,0,-1],[0,2y,y])
</TT></PRE><P>The members of the list <em>gmodule</em> are automatically
appended to the end of the variable list, if they are not
yet members there. They take part in the actual term ordering.
<P>
<P>
<A NAME=g19>
<TITLE>Groebner Bases for Modules</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Groebner Bases for Modules</B><MENU>
<LI><A HREF=r38_0401.html>Module concept</A><P>
<LI><A HREF=r38_0402.html>gmodule variable</A><P>
</MENU>
<A NAME=gsort>
<TITLE>gsort</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GSORT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gsort</em>(<p>)
<P>
<P>
<P>
where <p> is a polynomial or a list of polynomials.
<P>
<P>
The polynomials are reordered and sorted corresponding to
the current
<A HREF=r38_0353.html>term order</A>.
<P> <H3>
examples: </H3>
<P><PRE><TT>
torder lex;
gsort(x**2+2x*y+y**2,{y,x});
y**2+2y*x+x**2
</TT></PRE><P><P>
<P>
<A NAME=gsplit>
<TITLE>gsplit</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GSPLIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gsplit</em>(<p>[,<vars>]);
<P>
<P>
<P>
where <p> is a polynomial or a list of polynomials.
<P>
<P>
The polynomial is reordered corresponding to the
the current
<A HREF=r38_0353.html>term order</A> and then
separated into leading term and reductum. Result is
a list with the leading term as first and the reductum
as second element.
<P> <H3>
examples: </H3>
<P><PRE><TT>
torder lex;
gsplit(x**2+2x*y+y**2,{y,x});
{y**2,2y*x+x**2}
</TT></PRE><P><P>
<P>
<A NAME=gspoly>
<TITLE>gspoly</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GSPOLY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gspoly</em>(<p1>,<p2>);
<P>
<P>
<P>
<P>
where <p1> and <p2> are polynomials.
<P>
<P>
The <em>subtraction</em> polynomial of p1 and p2 is computed
corresponding to the method of the Buchberger algorithm for
computing <em>groebner bases</em>: p1 and p2 are multiplied
with terms such that when subtracting them the leading terms
cancel each other.
<P>
<P>
<A NAME=g20>
<TITLE>Computing with distributive polynomials</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Computing with distributive polynomials</B><MENU>
<LI><A HREF=r38_0404.html>gsort operator</A><P>
<LI><A HREF=r38_0405.html>gsplit operator</A><P>
<LI><A HREF=r38_0406.html>gspoly operator</A><P>
</MENU>
<A NAME=g14>
<TITLE>Groebner package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Groebner package</B><MENU>
<LI><A HREF=r38_0351.html>Groebner bases introduction</A><P>
<LI><A HREF=r38_0352.html>Ideal Parameters concept</A><P>
<LI><A HREF=r38_0366.html>Term order</A><P>
<LI><A HREF=r38_0390.html>Basic Groebner operators</A><P>
<LI><A HREF=r38_0395.html>Factorizing Groebner bases</A><P>
<LI><A HREF=r38_0400.html>Tracing Groebner bases</A><P>
<LI><A HREF=r38_0403.html>Groebner Bases for Modules</A><P>
<LI><A HREF=r38_0407.html>Computing with distributive polynomials</A><P>
</MENU>
<A NAME=HEPHYS>
<TITLE>HEPHYS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HEPHYS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
The High-energy Physics package is historic for REDUCE, since REDUCE
originated as a program to aid in computations with Dirac expressions.
The commutation algebra of the gamma matrices is independent of their
representation, and is a natural subject for symbolic mathematics. Dirac
theory is applied to beta decay and the computation of
cross-sections and scattering. The high-energy physics operators are
available in the REDUCE main program, rather than as a module which must
be loaded.
<P>
<P>
<A NAME=HE_dot>
<TITLE>HE_dot</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>.</B> _ _ _ <B>HE-DOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The . operator is used to denote the scalar product of two Lorentz
four-vectors.
<P> <H3>
syntax: </H3>
<P>
<P>
<vector> <em>.</em> <vector>
<P>
<P>
<P>
<vector> must be an identifier declared to be of type <em>vector</em> to h
ave
the scalar product definition. When applied to arguments that are not
vectors, the
<A HREF=r38_0043.html>cons</A> operator is used,
whose symbol is also ``dot.''
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector aa,bb,cc;
let aa.bb = 0;
aa.bb;
0
aa.cc;
AA.CC
q := aa.cc;
Q := AA.CC
q;
AA.CC
</TT></PRE><P>Since vectors are special high-energy physics entities that do not
contain
values, the . product will not return a true scalar product. You can
assign a scalar identifier to the result of a . operation, or assign a .
operation to have the value of the scalar you supply, as shown above. Note
that the result of a . operation is a scalar, not a vector.
<P>
<P>
The metric tensor g(u,v) can be represented by <em>u.v</em>. If contraction
over the indices is required, <em>u</em> and <em>v</em> should be declared to
be of type
<A HREF=r38_0413.html>index</A>.
<P>
<P>
The dot operator has the highest precedence of the infix operators, so
expressions involving . and other operators have the scalar product
evaluated first before other operations are done.
<P>
<P>
<P>
<A NAME=EPS>
<TITLE>EPS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EPS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>eps</em> operator denotes the completely antisymmetric tensor of
order 4 and its contraction with Lorentz four-vectors, as used in
high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>eps</em>(<vector-expr>,<vector-expr>,<vector-expr>,
<vector-expr>)
<P>
<P>
<P>
<vector-expr> must be a valid vector expression, and may be an index.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector g0,g1,g2,g3;
eps(g1,g0,g2,g3);
- EPS(G0,G1,G2,G3);
eps(g1,g2,g0,g3);
EPS(G0,G1,G2,G3);
eps(g1,g2,g3,g1);
0
</TT></PRE><P>Vector identifiers are ordered alphabetically by REDUCE. When an o
dd number
of transpositions is required to restore the canonical order to the four
arguments of <em>eps</em>, the term is ordered and carries a minus sign. When an
even number of transpositions is required, the term is returned ordered and
positive. When one of the arguments is repeated, the value 0 is returned.
A contraction of the form
eps(_i j mu nu p_mu q_nu)
is represented by <em>eps(i,j,p,q)</em> when <em>i</em> and <em>j</em> have been
declared to be of type
<A HREF=r38_0413.html>index</A>.
<P>
<P>
<P>
<A NAME=G>
<TITLE>G</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>G</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>g</em> is an n-ary operator used to denote a product of gamma matrices
contracted with Lorentz four-vectors, in high-energy physics.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>g</em>(<identifier>,<vector-expr>
{,<vector-expr>}*)
<P>
<P>
<P>
<identifier> is a scalar identifier representing a fermion line
identifier, <vector-expr> can be any valid vector expression,
representing a vector or a gamma matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector aa,bb,cc;
vector a;
g(line1,aa,bb);
AA.BB
g(line2,aa,a);
0
g(id,aa,bb,cc);
0
g(li1,aa,bb) + k;
AA.BB + K
let aa.bb = m*k;
g(ln1,aa)*g(ln1,bb);
K*M
g(ln1,aa)*g(ln2,bb);
0
</TT></PRE><P>The vector <em>A</em> is reserved in arguments of <em>g</em> to de
note the
special gamma matrix gamma_5. It must be declared to
be a vector before you use it.
<P>
<P>
Gamma matrix expressions are associated with fermion lines in a Feynman
diagram. If more than one line occurs in an expression, the gamma
matrices involved are separate (operating in independent spin space), as
shown in the last two example lines above. A product of gamma matrices
associated with a single line can be entered either as a single <em>g</em>
command with several vector arguments, or as products of separate <em>g</em>
commands each with a single argument.
<P>
<P>
While the product of vectors is not defined, the product, sum and
difference of several gamma expressions are defined, as is the product of
a gamma expression with a scalar. If an expression involving gamma
matrices includes a scalar, the scalar is treated as if it were the
product of itself with a unit 4 x 4 matrix.
<P>
<P>
Dirac expressions are evaluated by computing the trace of the expression
using the commutation algebra of gamma matrices. The algorithms used are
described in articles by J. S. R. Chisholm in <Il Nuovo Cimento X,> Vol.
30, p. 426, 1963, and J. Kahane, <Journal of Mathematical Physics>,
Vol. 9, p. 1732, 1968. The trace is then divided by 4 to distinguish
between the trace of a scalar and the trace of an expression that is the
product of a scalar with a unit 4 x 4 matrix.
<P>
<P>
Trace calculations may be prevented over any line identifier by declaring it
to be
<A HREF=r38_0416.html>nospur</A>. If it is later desired to evaluate these trace
s,
the declaration can be undone with the
<A HREF=r38_0418.html>spur</A> declaration.
<P>
<P>
The notation of Bjorken and Drell, <Relativistic Quantum Mechanics,>
1964, is assumed in all operations involving gamma matrices. For an
example of the use of <em>g</em> in a calculation, see the <REDUCE
User's Manual>.
<P>
<P>
<P>
<A NAME=INDEX>
<TITLE>INDEX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INDEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The declaration <em>index</em> flags a four-vector as an index for subsequent
high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>index</em><vector-id>{,<vector-id>}*
<P>
<P>
<P>
<vector-id> must have been declared of type <em>vector</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector aa,bb,cc;
index uu;
let aa.bb = 0;
(aa.uu)*(bb.uu);
0
(aa.uu)*(cc.uu);
AA.CC
</TT></PRE><P>Index variables are used to represent contraction over components
of
vectors when scalar products are taken by the . operator, as well as
indicating contraction for the
<A HREF=r38_0411.html>eps</A> operator or metric tensor.
<P>
<P>
The special status of a vector as an index can be revoked with the
declaration
<A HREF=r38_0417.html>remind</A>. The object remains a vector, however.
<P>
<P>
<P>
<A NAME=MASS>
<TITLE>MASS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MASS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>mass</em> command associates a scalar variable as a mass with
the corresponding vector variable, in high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mass</em><vector-var><em>=</em><scalar-var>
{,<vector-var><em>=</em><scalar-var>}*
<P>
<P>
<P>
<vector-var> can be a declared vector variable; <em>mass</em> will declare
it to be of type <em>vector</em> if it is not. This may override an existing
matrix variable by that name. <scalar-var> must be a scalar variable.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector bb,cc;
mass cc=m;
mshell cc;
cc.cc;
2
M
</TT></PRE><P>Once a mass has been attached to a vector with a <em>mass</em> dec
laration,
the
<A HREF=r38_0415.html>mshell</A> declaration puts the associated particle ``on t
he mass
shell.'' Subsequent scalar (.) products of the vector with itself will be
replaced by the square of the mass expression.
<P>
<P>
<P>
<A NAME=MSHELL>
<TITLE>MSHELL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MSHELL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>mshell</em> command puts particles on the mass shell in high-energy
physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mshell</em><vector-var>{,<vector-var>}*
<P>
<P>
<P>
<vector-var> must have had a mass attached to it by a
<A HREF=r38_0414.html>mass</A>
declaration.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector v1,v2;
mass v1=m,v2=q;
mshell v1;
v1.v1;
2
M
v2.v2;
V2.V2
mshell v2;
v1.v1*v2.v2;
2 2
M *Q
</TT></PRE><P>Even though a mass is attached to a vector variable representing a
particle, the replacement does not take place until the <em>mshell</em>
declaration is given for that vector variable.
<P>
<P>
<P>
<A NAME=NOSPUR>
<TITLE>NOSPUR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NOSPUR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>nospur</em> declaration prevents the trace calculation over the given
line identifiers in high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>nospur</em><line-id>{,<line-id>}*
<P>
<P>
<P>
<line-id> is a scalar identifier that will be used as a line identifier.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vector a1,b1,c1;
g(line1,a1,b1)*g(line2,b1,c1);
A1.B1*B1.C1
nospur line2;
g(line1,a1,b1)*g(line2,b1,c1);
A1.B1*G(LINE2,B1,C1)
</TT></PRE><P>Nospur declarations can be removed by making the declaration
<A HREF=r38_0418.html>spur</A>.
<P>
<P>
<P>
<A NAME=REMIND>
<TITLE>REMIND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REMIND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>remind</em> declaration removes the special status of its arguments
as indices, which was set in the
<A HREF=r38_0413.html>index</A> declaration, in
high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>remind</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> must have been declared to be of type
<A HREF=r38_0413.html>index</A>.
<P>
<P>
<A NAME=SPUR>
<TITLE>SPUR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SPUR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>spur</em> declaration removes the special exemption from trace
calculations that was declared by
<A HREF=r38_0416.html>nospur</A>, in high-energy physics
calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>spur</em><line-id>{,<line-id>}*
<P>
<P>
<P>
<line-id> must be a line-identifier that has previously been declared
<em>nospur</em>.
<P>
<P>
<A NAME=VECDIM>
<TITLE>VECDIM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VECDIM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The command <em>vecdim</em> changes the vector dimension from 4 to an arbitrary
integer or symbol. Used in high-energy physics calculations.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>vecdim</em><dimension>
<P>
<P>
<P>
<dimension> must be either an integer or a valid scalar identifier that
does not have a floating-point value.
<P>
<P>
The
<A HREF=r38_0411.html>eps</A> operator and the gamma_5
symbol (<em>A</em>) are not properly defined in anything except four
dimensions and will print an error message if you use them that way. The
other high-energy physics operators should work without problem.
<P>
<P>
<P>
<A NAME=VECTOR>
<TITLE>VECTOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VECTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>declaration</B><P>
<P>
The <em>vector</em> declaration declares that its arguments are of type <em>vect
or</em>.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>vector</em><identifier>{,<identifier>}*
<P>
<P>
<P>
<identifier> must be a valid REDUCE identifier. It may have already been
used for a matrix, array, operator or scalar variable. After an identifier
has been declared to be a vector, it may not be used as a scalar variable.
<P>
<P>
Vectors are special entities for high-energy physics calculations. You
cannot put values into their coordinates; they do not have coordinates.
They are legal arguments for the high-energy physics operators
<A HREF=r38_0411.html>eps</A>,
<A HREF=r38_0412.html>g</A> and <em>.</em> (dot). Vector variables are
used to represent gamma matrices and gamma matrices contracted with Lorentz
4-vectors, since there are no Dirac variables per se in the system.
Vectors do follow the usual vector rules for arithmetic operations:
<em>+</em> and <em>-</em> operate upon two or more vectors, producing a
vector; <em>*</em> and <em>/</em> cannot be used between vectors; the
scalar product is represented by the . operator; and the product of a
scalar and vector expression is well defined, and is a vector.
<P>
<P>
You can represent components of vectors by including representations of unit
vectors in your system. For instance, letting <em>E0</em> represent the unit
vector (1,0,0,0), the command
<P>
<P>
<em>V1.E0 := 0;</em>would set up the substitution of zero for the first componen
t of the vector
<em>V1</em>.
<P>
<P>
Identifiers that are declared by the <em>index</em> and <em>mass</em> declaratio
ns are
automatically declared to be vectors.
<P>
<P>
The following errors can occur in calculations using the high energy
physics package:
<P>
<P>
<em>A represents only gamma5 in vector expressions</em>You have tried to use A i
n some way other than gamma5 in a
high-energy physics expression.
<P>
<P>
<P>
<em>Gamma5 not allowed unless vecdim is 4</em>You have used gamma_5 in a high-en
ergy physics
computation involving a vector dimension other than 4.
<P>
<P>
<P>
<ID> <em>has no mass</em>
<P>
<P>
One of the arguments to
<A HREF=r38_0415.html>mshell</A> has had no mass assigned to it, in
high-energy physics calculations.
<P>
<P>
<P>
<em>Missing arguments for G operator</em>A line symbol is missing in a gamma mat
rix expression in high-energy physics
calculations.
<P>
<P>
<P>
<em>Unmatched index</em><list>
<P>
<P>
The parser has found unmatched indices during the evaluation of a
gamma matrix expression in high-energy physics calculations.
<P>
<P>
<P>
<P>
<P>
<A NAME=g21>
<TITLE>High Energy Physics</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>High Energy Physics</B><MENU>
<LI><A HREF=r38_0409.html>HEPHYS introduction</A><P>
<LI><A HREF=r38_0410.html>HE-dot operator</A><P>
<LI><A HREF=r38_0411.html>EPS operator</A><P>
<LI><A HREF=r38_0412.html>G operator</A><P>
<LI><A HREF=r38_0413.html>INDEX declaration</A><P>
<LI><A HREF=r38_0414.html>MASS command</A><P>
<LI><A HREF=r38_0415.html>MSHELL command</A><P>
<LI><A HREF=r38_0416.html>NOSPUR declaration</A><P>
<LI><A HREF=r38_0417.html>REMIND declaration</A><P>
<LI><A HREF=r38_0418.html>SPUR declaration</A><P>
<LI><A HREF=r38_0419.html>VECDIM command</A><P>
<LI><A HREF=r38_0420.html>VECTOR declaration</A><P>
</MENU>
<A NAME=Numeric_Package>
<TITLE>Numeric_Package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUMERIC PACKAGE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
The numeric package supplies algorithms based on approximation
techniques of numerical mathematics. The algorithms use
the
<A HREF=r38_0330.html>rounded</A> mode arithmetic of REDUCE, including
the variable precision feature which is exploited in some
algorithms in an adaptive manner in order to reach the
desired accuracy.
<P>
<P>
<A NAME=Interval>
<TITLE>Interval</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INTERVAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
Intervals are generally coded as lower bound and
upper bound connected by the operator <em>..</em>, usually
associated to a variable in an
equation.
<P>
<P>
<P> <H3>
syntax: </H3>
<var> = (<low> .. <high>)
<P>
<P>
<P>
where <var> is a
<A HREF=r38_0002.html>kernel</A> and <low>, <high> are
numbers or expression which evaluate to numbers with <low><=<high
>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>means that the variable x is taken in the range from 2
.5 up to
3.5.
<P>
<P>
<A NAME=numeric_accuracy>
<TITLE>numeric_accuracy</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUMERIC ACCURACY</B><P>
<P>
The keyword parameters <em>accuracy=a</em> and <em>iterations=i</em>,
where <em>a</em>and <em>i</em> must be positive integer numbers, control the
iterative algorithms: the iteration is continued until
the local error is below 10**-a; if that is impossible
within <em>i</em> steps, the iteration is terminated with an
error message. The values reached so far are then returned
as the result.
<P>
<P>
<A NAME=TRNUMERIC>
<TITLE>TRNUMERIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRNUMERIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
Normally the algorithms produce only a minimum of printed
output during their operation. In cases of an unsuccessful
or unexpected long operation a <em>trace of the iteration</em> can be
printed by setting <em>trnumeric</em> <em>on</em>.
<P>
<P>
<A NAME=num_min>
<TITLE>num_min</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM_MIN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The Fletcher Reeves version of the <em>steepest descent</em>
algorithms is used to find the <em>minimum</em> of a
function of one or more variables. The
function must have continuous partial derivatives with respect to all
variables. The starting point of the search can be
specified; if not, random values are taken instead.
The steepest descent algorithms in general find only local
minima.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>num_min</em>(<exp>,
<var>[=<val>] [,<var>[=<val>] ...
[,accuracy=<a>] [,iterations=<i>])
<P>
<P>
or
<P>
<P>
<em>num_min</em>(exp, {
<var>[=<val>] [,<var>[=<val>] ...] }
[,accuracy=<a>] [,iterations=<i>])
<P>
<P>
<P>
where <exp> is a function expression,
<var> are the variables in <exp> and
<val> are the (optional) start values.
For <a> and <i> see
<A HREF=r38_0424.html>numeric accuracy</A>.
<P>
<P>
<em>Num_min</em>tries to find the next local minimum along the descending
path starting at the given point. The result is a
<A HREF=r38_0053.html>list</A>
with the minimum function value as first element followed by a list
of
<A HREF=r38_0045.html>equation</A><em>s</em>, where the variables are equated to
the coordinates
of the result point.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
num_min(sin(x)+x/5, x)
{4.9489585606,{X=29.643767785}}
num_min(sin(x)+x/5, x=0)
{ - 1.3342267466,{X= - 1.7721582671}}
</TT></PRE><P>
<A NAME=num_solve>
<TITLE>num_solve</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM_SOLVE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
An adaptively damped Newton iteration is used to find
an approximative root of a function (function vector) or the
solution of an
<A HREF=r38_0045.html>equation</A> (equation system). The expressions
must have continuous derivatives for all variables.
A starting point for the iteration can be given. If not given
random values are taken instead. When the number of
forms is not equal to the number of variables, the
Newton method cannot be applied. Then the minimum
of the sum of absolute squares is located instead.
<P>
<P>
With
<A HREF=r38_0274.html>complex</A> on, solutions with imaginary parts can be
found, if either the expression(s) or the starting point
contain a nonzero imaginary part.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>num_solve</em>(<exp>, <var>[=<val>][,accuracy=<a>][,
iterations=<i>])
<P>
<P>
or
<P>
<P>
<em>num_solve</em>({<exp>,...,<exp>}, <var>[=<val>],...,
<var>[=<val>]
[,accuracy=<a>][,iterations=<i>])
<P>
<P>
or
<P>
<P>
<em>num_solve</em>({<exp>,...,<exp>}, {<var>[=<val>],...
,<var>[=<val>]}
[,accuracy=<a>][,iterations=<i>])
<P>
<P>
<P>
<P>
where <exp> are function expressions,
<var> are the variables,
<val> are optional start values.
For <a> and <i> see
<A HREF=r38_0424.html>numeric accuracy</A>.
<P>
<P>
<em>num_solve</em>tries to find a zero/solution of the expression(s).
Result is a list of equations, where the variables are
equated to the coordinates of the result point.
<P>
<P>
The <em>Jacobian matrix</em> is stored as side effect the shared
variable <em>jacobian</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
num_solve({sin x=cos y, x + y = 1},{x=1,y=2});
{X= - 1.8561957251,Y=2.856195584}
jacobian;
[COS(X) SIN(Y)]
[ ]
[ 1 1 ]
</TT></PRE><P>
<A NAME=num_int>
<TITLE>num_int</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM_INT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
For the numerical evaluation of univariate integrals
over a finite interval the following strategy is used:
If
<A HREF=r38_0154.html>int</A> finds a formal antiderivative
which is bounded in the integration interval, this
is evaluated and the end points and the difference
is returned.
Otherwise a
<A HREF=r38_0431.html>Chebyshev fit</A> is computed,
starting with order 20, eventually up to order 80.
If that is recognized as sufficiently convergent
it is used for computing the integral by directly
integrating the coefficient sequence.
If none of these methods is successful, an
adaptive multilevel quadrature algorithm is used.
<P>
<P>
For multivariate integrals only the adaptive quadrature is used.
This algorithm tolerates isolated singularities.
The value <em>iterations</em> here limits the number of
local interval intersection levels.
<a> is a measure for the relative total discretization
error (comparison of order 1 and order 2 approximations).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>num_int</em>(<exp>,<var>=(<l> .. <u>)
[,<var>=(<l> .. <u>),...]
[,accuracy=<a>][,iterations=<i>])
<P>
<P>
<P>
where <exp> is the function to be integrated,
<var> are the integration variables,
<l> are the lower bounds,
<u> are the upper bounds.
<P>
<P>
Result is the value of the integral.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
num_int(sin x,x=(0 .. 3.1415926));
2.0000010334
</TT></PRE><P>
<A NAME=num_odesolve>
<TITLE>num_odesolve</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM_ODESOLVE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Runge-Kutta</em> method of order 3 finds an approximate graph for
the solution of real <em>ODE initial value problem</em>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>num_odesolve</em>(<exp>,<depvar>=<start>,
<indep>=(<from> .. <to>)
[,accuracy=<a>][,iterations=<i>])
<P>
<P>
or
<P>
<P>
<em>num_odesolve</em>({<exp>,<exp>,...},
{ <depvar>=<start>,<depvar>=<start>,...}
<indep>=(<from> .. <to>)
[,accuracy=<a>][,iterations=<i>])
<P>
<P>
<P>
<P>
where
<depvar> and <start> specify the dependent variable(s)
and the starting point value (vector),
<indep>, <from> and <to> specify the independent variable
and the integration interval (starting point and end point),
<exp> are equations or expressions which
contain the first derivative of the independent variable
with respect to the dependent variable.
<P>
<P>
The ODEs are converted to an explicit form, which then is
used for a Runge Kutta iteration over the given range. The
number of steps is controlled by the value of <i>
(default: 20). If the steps are too coarse to reach the desired
accuracy in the neighborhood of the starting point, the number is
increased automatically.
<P>
<P>
Result is a list of pairs, each representing a point of the
approximate solution of the ODE problem.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
depend(y,x);
num_odesolve(df(y,x)=y,y=1,x=(0 .. 1), iterations=5);
,{0.2,1.2214},{0.4,1.49181796},{0.6,1.8221064563},
{0.8,2.2255208258},{1.0,2.7182511366}}
</TT></PRE><P>In most cases you must declare the dependency relation
between the variables explicitly using
<A HREF=r38_0192.html>depend</A>;
otherwise the formal derivative might be converted to zero.
<P>
<P>
The operator
<A HREF=r38_0179.html>solve</A> is used to convert the form into
an explicit ODE. If that process fails or if it has no unique result,
the evaluation is stopped with an error message.
<P>
<P>
<A NAME=bounds>
<TITLE>bounds</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BOUNDS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
Upper and lower bounds of a real valued function over an
<A HREF=r38_0423.html>interval</A> or a rectangular multivariate domain are comp
uted
by the operator <em>bounds</em>. The algorithmic basis is the computation
with inequalities: starting from the interval(s) of the
variables, the bounds are propagated in the expression
using the rules for inequality computation. Some knowledge
about the behavior of special functions like ABS, SIN, COS, EXP, LOG,
fractional exponentials etc. is integrated and can be evaluated
if the operator <em>bounds</em> is called with rounded mode on
(otherwise only algebraic evaluation rules are available).
<P>
<P>
If <em>bounds</em> finds a singularity within an interval, the evaluation
is stopped with an error message indicating the problem part
of the expression.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>bounds</em>(<exp>,<var>=(<l> .. <u>)
[,<var>=(<l> .. <u>) ...])
<P>
<P>
or
<P>
<P>
<em>bounds</em>(<exp>,{<var>=(<l> .. <u>)
[,<var>=(<l> .. <u>) ...]})
<P>
<P>
<P>
<P>
where <exp> is the function to be investigated,
<var> are the variables of <exp>,
<l> and <u> specify the area as set of
<A HREF=r38_0423.html>interval</A><em>s</em>.
<P>
<P>
<em>bounds</em>computes upper and lower bounds for the expression in the
given area. An
<A HREF=r38_0423.html>interval</A> is returned.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
bounds(sin x,x=(1 .. 2));
-1 .. 1
on rounded;
bounds(sin x,x=(1 .. 2));
0.84147098481 .. 1
bounds(x**2+x,x=(-0.5 .. 0.5));
- 0.25 .. 0.75
</TT></PRE><P>
<A NAME=Chebyshev_fit>
<TITLE>Chebyshev_fit</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHEBYSHEV FIT</B><P>
<P>
<P>
<P>
The operator family <em>Chebyshev_...</em> implements approximation
and evaluation of functions by the Chebyshev method.
Let <em>T(n,a,b,x)</em> be the Chebyshev polynomial of order <em>n</em>
transformed to the interval <em>(a,b)</em>.
Then a function <em>f(x)</em> can be
approximated in <em>(a,b)</em> by a series
<P>
<P>
<P><PRE><TT>
for i := 0:n sum c(i)*T(i,a,b,x)
</TT></PRE><P>The operator <em>chebyshev_fit</em> computes this approximation an
d
returns a list, which has as first element the sum expressed
as a polynomial and as second element the sequence
of Chebyshev coefficients.
<em>Chebyshev_df</em> and <em>Chebyshev_int</em> transform a Chebyshev
coefficient list into the coefficients of the corresponding
derivative or integral respectively. For evaluating a Chebyshev
approximation at a given point in the basic interval the
operator <em>Chebyshev_eval</em> can be used.
<em>Chebyshev_eval</em> is based on a recurrence relation which is
in general more stable than a direct evaluation of the
complete polynomial.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>chebyshev_fit</em>(<fcn>,<var>=(<lo> .. <hi>),<n
>)
<P>
<P>
<em>chebyshev_eval</em>(<coeffs>,<var>=(<lo> .. <hi>),
<var>=<pt>)
<P>
<P>
<em>chebyshev_df</em>(<coeffs>,<var>=(<lo> .. <hi>))
<P>
<P>
<em>chebyshev_int</em>(<coeffs>,<var>=(<lo> .. <hi>))
<P>
<P>
<P>
where <fcn> is an algebraic expression (the target function),
<var> is the variable of <fcn>,
<lo> and <hi> are
numerical real values which describe an
<A HREF=r38_0423.html>interval</A> <lo> <<hi>,
the integer <n> is the approximation order (set to 20 if missing),
<pt> is a number in the interval and <coeffs> is
a series of Chebyshev coefficients.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
w:=chebyshev_fit(sin x/x,x=(1 .. 3),5);
3 2
w := {0.03824*x - 0.2398*x + 0.06514*x + 0.9778,
{0.8991,-0.4066,-0.005198,0.009464,-0.00009511}}
chebyshev_eval(second w, x=(1 .. 3), x=2.1);
0.4111
</TT></PRE><P>
<A NAME=num_fit>
<TITLE>num_fit</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NUM_FIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>num_fit</em> finds for a set of
points the linear combination of a given set of
functions (function basis) which approximates the
points best under the objective of the <em>least squares</em>
criterion (minimum of the sum of the squares of the deviation).
The solution is found as zero of the
gradient vector of the sum of squared errors.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>num_fit</em>(<vals>,<basis>,<var>=<pts>)
<P>
<P>
<P>
where <vals> is a list of numeric values,
<var> is a variable used for the approximation,
<pts> is a list of coordinate values which correspond to
<var>,
<basis> is a set of functions varying in <em>var</em> which is used
for the approximation.
<P>
<P>
The result is a list containing as first element the
function which approximates the given values, and as
second element a list of coefficients which were used
to build this function from the basis.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
pts:=for i:=1 step 1 until 5 collect i$
vals:=for i:=1 step 1 until 5 collect
for j:=1:i product j$
num_fit(vals,{1,x,x**2},x=pts);
2
{14.571428571*X - 61.428571429*X + 54.6,{54.6,
- 61.428571429,14.571428571}}
</TT></PRE><P>
<A NAME=g22>
<TITLE>Numeric Package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Numeric Package</B><MENU>
<LI><A HREF=r38_0422.html>Numeric Package introduction</A><P>
<LI><A HREF=r38_0423.html>Interval type</A><P>
<LI><A HREF=r38_0424.html>numeric accuracy concept</A><P>
<LI><A HREF=r38_0425.html>TRNUMERIC switch</A><P>
<LI><A HREF=r38_0426.html>num_min operator</A><P>
<LI><A HREF=r38_0427.html>num_solve operator</A><P>
<LI><A HREF=r38_0428.html>num_int operator</A><P>
<LI><A HREF=r38_0429.html>num_odesolve operator</A><P>
<LI><A HREF=r38_0430.html>bounds operator</A><P>
<LI><A HREF=r38_0431.html>Chebyshev fit concept</A><P>
<LI><A HREF=r38_0432.html>num_fit operator</A><P>
</MENU>
<A NAME=Roots_Package>
<TITLE>Roots_Package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOTS PACKAGE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
<P>
<P>
The root finding package is designed so that it can
be used to find some or all of the roots of univariate
polynomials with real or complex coefficients, to the accuracy
specified by the user.
<P>
<P>
Not all operators of <em>roots package</em> are described here. For using
the operators
<P>
<P>
<em>isolater</em>(intervals isolating real roots)
<P>
<P>
<em>rlrootno</em>(number of real roots in an interval)
<P>
<P>
<em>rootsat-prec</em>(roots at system precision)
<P>
<P>
<em>rootval</em>(result in equation form)
<P>
<P>
<em>firstroot</em>(computing only one root)
<P>
<P>
<em>getroot</em>(selecting roots from a collection)
<P>
<P>
please consult the full documentation of the package.
<P>
<P>
<A NAME=MKPOLY>
<TITLE>MKPOLY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MKPOLY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
Given a roots list as returned by
<A HREF=r38_0439.html>roots</A>,
the operator <em>mkpoly</em> constructs a
polynomial which has these numbers as roots.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>mkpoly</em><rl>
<P>
<P>
<P>
where <rl> is a
<A HREF=r38_0053.html>list</A> with equations, which
all have the same
<A HREF=r38_0002.html>kernel</A> on their left-hand sides
and numbers as right-hand sides.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
mkpoly{x=1,x=-2,x=i,x=-i};
x**4 + x**3 - x**2 + x - 2
</TT></PRE><P>Note that this polynomial is unique only up to a numeric
factor.
<P>
<P>
<A NAME=NEARESTROOT>
<TITLE>NEARESTROOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NEARESTROOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>nearestroot</em> finds one root of a polynomial
with an iteration using a given starting point.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>nearestroot</em>(<p>,<pt>)
<P>
<P>
<P>
where <p> is a univariate polynomial
and <pt> is a number.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
nearestroot(x^2+2,2);
{x=1.41421*i}
</TT></PRE><P>The minimal accuracy of the result values is controlled by
<A HREF=r38_0438.html>rootacc</A>.
<P>
<P>
<A NAME=REALROOTS>
<TITLE>REALROOTS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REALROOTS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>realroots</em> finds that real roots of a polynomial
to an accuracy that is sufficient to separate them and which is
a minimum of 6 decimal places.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>realroots</em>(<p>) or
<P>
<P>
<em>realroots</em>(<p>,<from>,<to>)
<P>
<P>
<P>
where <p> is a univariate polynomial.
The optional parameters <from> and <to> classify
an interval: if given, exactly the real roots in this
interval will be returned. <from> and <to>
can also take the values <em>infinity</em> or <em>-infinity</em>.
If omitted all real roots will be returned.
Result is a
<A HREF=r38_0053.html>list</A>
of equations which represent the roots of the polynomial at the
given accuracy.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
realroots(x^5-2);
{x=1.1487}
realroots(x^3-104*x^2+403*x-300,2,infinity);
{x=3.0,x=100.0}
realroots(x^3-104*x^2+403*x-300,-infinity,2);
{x=1}
</TT></PRE><P>The minimal accuracy of the result values is controlled by
<A HREF=r38_0438.html>rootacc</A>.
<P>
<P>
<A NAME=ROOTACC>
<TITLE>ROOTACC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOTACC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>rootacc</em> allows you to set the accuracy
up to which the roots package computes its results.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>rootacc</em>(<n>)
<P>
<P>
<P>
Here <n> is an integer value. The internal accuracy of
the <em>roots</em> package is adjusted to a value of
<em>max(6,n)</em>. The default value is <em>6</em>.
<P>
<P>
<A NAME=ROOTS>
<TITLE>ROOTS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOTS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>roots</em>
is the main top level function of the roots package.
It will find all roots, real and complex, of the polynomial p
to an accuracy that is sufficient to separate them and which is
a minimum of 6 decimal places.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>roots</em>(<p>)
<P>
<P>
<P>
where <p> is a univariate polynomial. Result is a
<A HREF=r38_0053.html>list</A>
of equations which represent the roots of the polynomial at the
given accuracy. In addition, <em>roots</em> stores
separate lists of real roots and complex roots in the global
variables
<A HREF=r38_0442.html>rootsreal</A> and
<A HREF=r38_0441.html>rootscomplex</A>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
roots(x^5-2);
{x=-0.929316 + 0.675188*i,
x=-0.929316 - 0.675188*i,
x=0.354967 + 1.09248*i,
x=0.354967 - 1.09248*i,
x=1.1487}
</TT></PRE><P>The minimal accuracy of the result values is controlled by
<A HREF=r38_0438.html>rootacc</A>.
<P>
<P>
<A NAME=ROOT_VAL>
<TITLE>ROOT_VAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOT\_VAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The operator <em>root_val</em> computes the roots of a
univariate polynomial at system precision
(or greater if required for root separation) and presents
its result as a list of numbers.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>roots</em>(<p>)
<P>
<P>
<P>
where <p> is a univariate polynomial.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
root_val(x^5-2);
{-0.929316490603 + 0.6751879524*i,
-0.929316490603 - 0.6751879524*i,
0.354967313105 + 1.09247705578*i,
0.354967313105 - 1.09247705578*i,
1.148698355}
</TT></PRE><P>
<A NAME=ROOTSCOMPLEX>
<TITLE>ROOTSCOMPLEX</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOTSCOMPLEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
When the operator
<A HREF=r38_0439.html>roots</A> is called the complex
roots are collected in the global variable <em>rootscomplex</em>
as
<A HREF=r38_0053.html>list</A>.
<P>
<P>
<A NAME=ROOTSREAL>
<TITLE>ROOTSREAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROOTSREAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
When the operator
<A HREF=r38_0439.html>roots</A> is called the real
roots are collected in the global variable <em>rootreal</em>
as
<A HREF=r38_0053.html>list</A>.
<P>
<P>
<A NAME=g23>
<TITLE>Roots Package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Roots Package</B><MENU>
<LI><A HREF=r38_0434.html>Roots Package introduction</A><P>
<LI><A HREF=r38_0435.html>MKPOLY operator</A><P>
<LI><A HREF=r38_0436.html>NEARESTROOT operator</A><P>
<LI><A HREF=r38_0437.html>REALROOTS operator</A><P>
<LI><A HREF=r38_0438.html>ROOTACC operator</A><P>
<LI><A HREF=r38_0439.html>ROOTS operator</A><P>
<LI><A HREF=r38_0440.html>ROOT\_VAL operator</A><P>
<LI><A HREF=r38_0441.html>ROOTSCOMPLEX variable</A><P>
<LI><A HREF=r38_0442.html>ROOTSREAL variable</A><P>
</MENU>
<A NAME=Special_Function_Package>
<TITLE>Special_Function_Package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SPECIAL FUNCTION PACKAGE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B>
<P>
<P>
The REDUCE <em>Special Function Package</em> supplies extended
algebraic and numeric support for a wide class of objects.
This package was released together with REDUCE 3.5 (October 1993)
for the first time, a major update is released with REDUCE 3.6.
<P>
<P>
The functions included in this package are in most cases (unless otherwise
stated) defined and named like in the book by Abramowitz and Stegun:
Handbook of Mathematical Functions, Dover Publications.
<P>
<P>
The aim is to collect as much information on the special functions
and simplification capabilities as possible,
i.e. algebraic simplifications and numeric (rounded mode) code, limits
of the functions together
with the definitions of the functions, which are in most cases a power
series, a (definite) integral and/or a differential equation.
<P>
<P>
What can be found: Some famous constants, a variety of Bessel functions,
special polynomials,
the Gamma function, the (Riemann) Zeta function, Elliptic Functions, Elliptic
Integrals, 3J symbols (Clebsch-Gordan coefficients) and integral functions.
<P>
<P>
What is missing: Mathieu functions, LerchPhi, etc..
The information about the special functions which solve certain
differential equation is very limited.
In several cases numerical approximation is restricted to real
arguments or is missing completely.
<P>
<P>
The implementation of this package uses REDUCE rule sets to a large extent,
which guarantees a high 'readability' of the functions definitions in the
source file directory. It makes extensions to the special
functions code easy in most cases too. To look at these rules
it may be convenient to use the showrules operator e.g.
<P>
<P>
<A HREF=r38_0178.html>showrules</A>Besseli;
<P>
<P>
.
<P>
<P>
Some evaluations are improved if the special function package is loaded,
e.g. some (infinite) sums and products leading to expressions including
special functions are known in this case.
<P>
<P>
Note: The special function package has to be loaded explicitly by calling
<P><PRE><TT>
load_package specfn;
</TT></PRE><P><P>
<P>
The functions
<A HREF=r38_0530.html>MeijerG</A> and
<A HREF=r38_0529.html>hypergeometric</A> require
additionally
<P><PRE><TT>
load_package specfn2;
</TT></PRE><P><P>
<P>
<A NAME=Constants>
<TITLE>Constants</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONSTANTS</B><P>
<P>
<P>
<P>
There are a few constants known to the special function package, namely
<P>
<P>
_ _ _ <em>Euler's constant </em>(which can be computed as -
<A HREF=r38_0494.html>Psi</A>(1)) and
<P>
_ _ _ <em>Khinchin's constant</em> (which is defined in Khinchin's book
``Continued Fractions'') and
<P>
_ _ _ <em>Golden_Ratio</em> (which can be computed as (1 + sqrt 5)/2) and
<P>
_ _ _ <em>Catalan's constant</em> (which is known as an infinite sum of recipro
cal
powers)
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
Euler_Gamma;
0.577215664902
Khinchin;
2.68545200107
Catalan
0.915965594177
Golden_Ratio
1.61803398875
</TT></PRE><P>
<A NAME=BERNOULLI>
<TITLE>BERNOULLI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BERNOULLI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>bernoulli</em> operator returns the nth Bernoulli number.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Bernoulli</em>(<integer>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
bernoulli 20;
- 174611 / 330
bernoulli 17;
0
</TT></PRE><P>All Bernoulli numbers with odd indices except for 1 are zero.
<P>
<P>
<P>
<A NAME=BERNOULLIP>
<TITLE>BERNOULLIP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BERNOULLIP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>BernoulliP</em> operator returns the nth Bernoulli Polynomial
evaluated at x.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>BernoulliP</em>(<integer>,<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
BernoulliP(3,z);
2
z*(2*z - 3*z + 1)/2
BernoulliP(10,3);
338585 / 66
</TT></PRE><P>The value of the nth Bernoulli Polynomial at 0 is the nth Bernoull
i number.
<P>
<P>
<P>
<A NAME=EULER>
<TITLE>EULER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EULER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EULER</em> operator returns the nth Euler number.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Euler</em>(<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Euler 20;
370371188237525
Euler 0;
1
</TT></PRE><P>The <em>Euler</em> numbers are evaluated by a recursive algorithm
which
makes it hard to compute Euler numbers above say 200.
<P>
<P>
Euler numbers appear in the coefficients of the power series
representation of 1/cos(z).
<P>
<P>
<P>
<A NAME=EULERP>
<TITLE>EULERP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EULERP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EulerP</em> operator returns the nth Euler Polynomial.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>EulerP</em>(<integer>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EulerP(2,xx);
xx*(xx - 1)
EulerP(10,3);
2046
</TT></PRE><P>The Euler numbers are the values of the Euler Polynomials at 1/2
multiplied by 2**n.
<P>
<P>
<P>
<A NAME=ZETA>
<TITLE>ZETA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ZETA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Zeta</em> operator returns Riemann's Zeta function,
<P>
<P>
Zeta (z) := sum(1/(k**z),k,1,infinity)
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Zeta</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Zeta(2);
2
pi / 6
on rounded;
Zeta 1.01;
100.577943338
</TT></PRE><P>Numerical computation for the Zeta function for arguments close to
1 are
tedious, because the series is converging very slowly. In this case a formula
(e.g. found in Bender/Orzag: Advanced Mathematical Methods for
Scientists and Engineers, McGraw-Hill) is used.
<P>
<P>
No numerical approximation for complex arguments is done.
<P>
<P>
<P>
<A NAME=g25>
<TITLE>Bernoulli Euler Zeta</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Bernoulli Euler Zeta</B><MENU>
<LI><A HREF=r38_0446.html>BERNOULLI operator</A><P>
<LI><A HREF=r38_0447.html>BERNOULLIP operator</A><P>
<LI><A HREF=r38_0448.html>EULER operator</A><P>
<LI><A HREF=r38_0449.html>EULERP operator</A><P>
<LI><A HREF=r38_0450.html>ZETA operator</A><P>
</MENU>
<A NAME=BESSELJ>
<TITLE>BESSELJ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BESSELJ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>BesselJ</em> operator returns the Bessel function of the first kind.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>BesselJ</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
BesselJ(1/2,pi);
0
on rounded;
BesselJ(0,1);
0.765197686558
</TT></PRE><P>
<A NAME=BESSELY>
<TITLE>BESSELY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BESSELY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>BesselY</em> operator returns the Bessel function of the second kind.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>BesselY</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
BesselY (1/2,pi);
- sqrt(2) / pi
on rounded;
BesselY (1,3);
0.324674424792
</TT></PRE><P>The operator <em>BesselY</em> is also called Weber's function.
<P>
<P>
<P>
<A NAME=HANKEL1>
<TITLE>HANKEL1</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HANKEL1</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Hankel1</em> operator returns the Hankel function of the first kind.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Hankel1</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on complex;
Hankel1 (1/2,pi);
- i * sqrt(2) / pi
Hankel1 (1,pi);
besselj(1,pi) + i*bessely(1,pi)
</TT></PRE><P>The operator <em>Hankel1</em> is also called Bessel function of th
e third kind.
There is currently no numeric evaluation of Hankel functions.
<P>
<P>
<P>
<A NAME=HANKEL2>
<TITLE>HANKEL2</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HANKEL2</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Hankel2</em> operator returns the Hankel function of the second kind.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Hankel2</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on complex;
Hankel2 (1/2,pi);
- i * sqrt(2) / pi
Hankel2 (1,pi);
besselj(1,pi) - i*bessely(1,pi)
</TT></PRE><P>The operator <em>Hankel2</em> is also called Bessel function of th
e third kind.
There is currently no numeric evaluation of Hankel functions.
<P>
<P>
<P>
<A NAME=BESSELI>
<TITLE>BESSELI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BESSELI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>BesselI</em> operator returns the modified Bessel function I.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>BesselI</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
Besseli (1,1);
0.565159103992
</TT></PRE><P>The knowledge about the operator <em>BesselI</em> is currently fai
rly limited.
<P>
<P>
<P>
<A NAME=BESSELK>
<TITLE>BESSELK</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BESSELK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>BesselK</em> operator returns the modified Bessel function K.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>BesselK</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(besselk(0,x),x);
- besselk(1,x)
</TT></PRE><P>There is currently no numeric support for the operator <em>BesselK
</em>.
<P>
<P>
<P>
<A NAME=StruveH>
<TITLE>StruveH</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STRUVEH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>StruveH</em> operator returns Struve's H function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>StruveH</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
struveh(-3/2,x);
- besselj(3/2,x) / i
</TT></PRE><P>
<A NAME=StruveL>
<TITLE>StruveL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STRUVEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>StruveL</em> operator returns the modified Struve L function .
<P>
<P>
<P> <H3>
syntax: </H3>
<em>StruveL</em>(<order>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
struvel(-3/2,x);
besseli(3/2,x)
</TT></PRE><P>
<A NAME=KummerM>
<TITLE>KummerM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>KUMMERM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>KummerM</em> operator returns Kummer's M function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>KummerM</em>(<parameter>,<parameter>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
kummerm(1,1,x);
x
e
on rounded;
kummerm(1,3,1.3);
1.62046942914
</TT></PRE><P>Kummer's M function is one of the Confluent Hypergeometric functio
ns.
For reference see the
<A HREF=r38_0529.html>hypergeometric</A> operator.
<P>
<P>
<P>
<A NAME=KummerU>
<TITLE>KummerU</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>KUMMERU</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>KummerU</em> operator returns Kummer's U function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>KummerU</em>(<parameter>,<parameter>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(kummeru(1,1,x),x)
- kummeru(2,2,x)
</TT></PRE><P>Kummer's U function is one of the Confluent Hypergeometric functio
ns.
For reference see the
<A HREF=r38_0529.html>hypergeometric</A> operator.
<P>
<P>
<P>
<A NAME=WhittakerW>
<TITLE>WhittakerW</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WHITTAKERW</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>WhittakerW</em> operator returns Whittaker's W function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>WhittakerW</em>(<parameter>,<parameter>,<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
WhittakerW(2,2,2);
1
4*sqrt(2)*kummeru(-,5,2)
2
-------------------------
e
</TT></PRE><P>Whittaker's W function is one of the Confluent Hypergeometric func
tions.
For reference see the
<A HREF=r38_0529.html>hypergeometric</A> operator.
<P>
<P>
<P>
<A NAME=g26>
<TITLE>Bessel Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Bessel Functions</B><MENU>
<LI><A HREF=r38_0452.html>BESSELJ operator</A><P>
<LI><A HREF=r38_0453.html>BESSELY operator</A><P>
<LI><A HREF=r38_0454.html>HANKEL1 operator</A><P>
<LI><A HREF=r38_0455.html>HANKEL2 operator</A><P>
<LI><A HREF=r38_0456.html>BESSELI operator</A><P>
<LI><A HREF=r38_0457.html>BESSELK operator</A><P>
<LI><A HREF=r38_0458.html>StruveH operator</A><P>
<LI><A HREF=r38_0459.html>StruveL operator</A><P>
<LI><A HREF=r38_0460.html>KummerM operator</A><P>
<LI><A HREF=r38_0461.html>KummerU operator</A><P>
<LI><A HREF=r38_0462.html>WhittakerW operator</A><P>
</MENU>
<A NAME=Airy_Ai>
<TITLE>Airy_Ai</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AIRY_AI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Airy_Ai</em> operator returns the Airy Ai function for a given argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Airy_Ai</em>(<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on complex;
on rounded;
Airy_Ai(0);
0.355028053888
Airy_Ai(3.45 + 17.97i);
- 5.5561528511e+9 - 8.80397899932e+9*i
</TT></PRE><P>
<A NAME=Airy_Bi>
<TITLE>Airy_Bi</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AIRY_BI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Airy_Bi</em> operator returns the Airy Bi function for a given
argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Airy_Bi</em>(<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Airy_Bi(0);
0.614926627446
Airy_Bi(3.45 + 17.97i);
8.80397899932e+9 - 5.5561528511e+9*i
</TT></PRE><P>
<A NAME=Airy_Aiprime>
<TITLE>Airy_Aiprime</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AIRY_AIPRIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Airy_Aiprime</em> operator returns the Airy Aiprime function for a
given argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Airy_Aiprime</em>(<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Airy_Aiprime(0);
- 0.258819403793
Airy_Aiprime(3.45+17.97i);
- 3.83386421824e+19 + 2.16608828136e+19*i
</TT></PRE><P>
<A NAME=Airy_Biprime>
<TITLE>Airy_Biprime</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AIRY_BIPRIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Airy_Biprime</em> operator returns the Airy Biprime function for a
given argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Airy_Biprime</em>(<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Airy_Biprime(0);
Airy_Biprime(3.45 + 17.97i);
3.84251916792e+19 - 2.18006297399e+19*i
</TT></PRE><P>
<A NAME=g27>
<TITLE>Airy Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Airy Functions</B><MENU>
<LI><A HREF=r38_0464.html>Airy_Ai operator</A><P>
<LI><A HREF=r38_0465.html>Airy_Bi operator</A><P>
<LI><A HREF=r38_0466.html>Airy_Aiprime operator</A><P>
<LI><A HREF=r38_0467.html>Airy_Biprime operator</A><P>
</MENU>
<A NAME=JacobiSN>
<TITLE>JacobiSN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBISN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobisn</em> operator returns the Jacobi Elliptic function sn.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobisn</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobisn(0.672, 0.36)
0.609519691792
Jacobisn(1,0.9)
0.770085724907881
</TT></PRE><P>
<A NAME=JacobiCN>
<TITLE>JacobiCN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBICN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobicn</em> operator returns the Jacobi Elliptic function cn.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobicn</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobicn(7.2, 0.6)
0.837288298482018
Jacobicn(0.11, 19)
0.994403862690043 - 1.6219006985556e-16*i
</TT></PRE><P>
<A NAME=JacobiDN>
<TITLE>JacobiDN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIDN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobidn</em> operator returns the Jacobi Elliptic function dn.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobidn</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobidn(15, 0.683)
0.640574162024592
Jacobidn(0,0)
1
</TT></PRE><P>
<A NAME=JacobiCD>
<TITLE>JacobiCD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBICD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobicd</em> operator returns the Jacobi Elliptic function cd.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobicd</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobicd(1, 0.34)
0.657683337805273
Jacobicd(0.8,0.8)
0.925587311582301
</TT></PRE><P>
<A NAME=JacobiSD>
<TITLE>JacobiSD</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBISD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobisd</em> operator returns the Jacobi Elliptic function sd.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobisd</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobisd(12, 0.4)
0.357189729437272
Jacobisd(0.35,1)
- 1.17713873203043
</TT></PRE><P>
<A NAME=JacobiND>
<TITLE>JacobiND</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobind</em> operator returns the Jacobi Elliptic function nd.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobind</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobind(0.2, 17)
1.46553203037507 + 0.0000000000334032759313703*i
Jacobind(30, 0.001)
1.00048958438
</TT></PRE><P>
<A NAME=JacobiDC>
<TITLE>JacobiDC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIDC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobidc</em> operator returns the Jacobi Elliptic function dc.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobidc</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobidc(0.003,1)
1
Jacobidc(2, 0.75)
6.43472885111
</TT></PRE><P>
<A NAME=JacobiNC>
<TITLE>JacobiNC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBINC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobinc</em> operator returns the Jacobi Elliptic function nc.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobinc</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobinc(1,0)
1.85081571768093
Jacobinc(56, 0.4387)
39.304842663512
</TT></PRE><P>
<A NAME=JacobiSC>
<TITLE>JacobiSC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBISC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobisc</em> operator returns the Jacobi Elliptic function sc.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobisc</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobisc(9, 0.88)
- 1.16417697982095
Jacobisc(0.34, 7)
0.305851938390775 - 9.8768100944891e-12*i
</TT></PRE><P>
<A NAME=JacobiNS>
<TITLE>JacobiNS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBINS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobins</em> operator returns the Jacobi Elliptic function ns.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobins</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobins(3, 0.9)
1.00945801599785
Jacobins(0.887, 15)
0.683578280513975 - 0.85023411082469*i
</TT></PRE><P>
<A NAME=JacobiDS>
<TITLE>JacobiDS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIDS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobisn</em> operator returns the Jacobi Elliptic function ds.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobids</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobids(98,0.223)
- 1.061253961477
Jacobids(0.36,0.6)
2.76693172243692
</TT></PRE><P>
<A NAME=JacobiCS>
<TITLE>JacobiCS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBICS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Jacobics</em> operator returns the Jacobi Elliptic function cs.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Jacobics</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Jacobics(0, 0.767)
infinity
Jacobics(1.43, 0)
0.141734127352112
</TT></PRE><P>
<A NAME=JacobiAMPLITUDE>
<TITLE>JacobiAMPLITUDE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIAMPLITUDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>JacobiAmplitude</em> operator returns the amplitude of u.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>JacobiAmplitude</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
JacobiAmplitude(7.239, 0.427)
0.0520978301448978
JacobiAmplitude(0,0.1)
0
</TT></PRE><P>Amplitude u = asin(<em>Jacobisn(u,m)</em>)
<P>
<P>
<P>
<A NAME=AGM_FUNCTION>
<TITLE>AGM_FUNCTION</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AGM_FUNCTION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>AGM_function</em> operator returns a list of (N, AGM,
list of aNtoa0, list of bNtob0, list of cNtoc0) where a0, b0 and c0
are the initial values; N is the index number of the last term
used to generate the AGM. AGM is the Arithmetic Geometric Mean.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>AGM_function</em>(<integer>,<integer>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
AGM_function(1,1,1)
1,1,1,1,1,1,0,1
AGM_function(1, 0.1, 1.3)
{6,
2.27985615996629,
{2.27985615996629, 2.27985615996629,
2.2798561599706, 2.2798624278857,
2.28742283656583, 2.55, 1},
{2.27985615996629, 2.27985615996629,
2.27985615996198, 2.2798498920555,
2.27230201920557, 2.02484567313166, 4.1},
{0, 4.30803136219904e-12, 0.0000062679151007581,
0.00756040868012758, 0.262577163434171, - 1.55, 5.9}}
</TT></PRE><P>The other Jacobi functions use this function with initial values
a0=1, b0=sqrt(1-m), c0=sqrt(m).
<P>
<P>
<P>
<A NAME=LANDENTRANS>
<TITLE>LANDENTRANS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LANDENTRANS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>landentrans</em> operator generates the descending landen
transformation of the given imput values, returning a list of these
values; initial to final in each case.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>landentrans</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
landentrans(0,0.1)
{{0,0,0,0,0},{0.1,0.0025041751943776,
0.00000156772498954046,6.1444078 9914461e-13,0}}
</TT></PRE><P>The first list ascends in value, and the second descends in value.
<P>
<P>
<P>
<A NAME=EllipticF>
<TITLE>EllipticF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ELLIPTICF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EllipticF</em> operator returns the Elliptic Integral of the
First Kind.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>EllitpicF</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticF(0.3, 8.222)
0.3
EllipticF(7.396, 0.1)
7.58123216114307
</TT></PRE><P>The Complete Elliptic Integral of the First Kind can be found by
putting the first argument to pi/2 or by using <em>EllipticK</em>
and the second argument.
<P>
<P>
<P>
<A NAME=EllipticK>
<TITLE>EllipticK</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ELLIPTICK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EllipticK</em> operator returns the Elliptic value K.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>EllipticK</em>(<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticK(0.2)
1.65962359861053
EllipticK(4.3)
0.808442364282734 - 1.05562492399206*i
EllipticK(0.000481)
1.57098526617635
</TT></PRE><P>The <em>EllipticK</em> function is the Complete Elliptic Integral
of
the First Kind.
<P>
<P>
<P>
<A NAME=EllipticKprime>
<TITLE>EllipticKprime</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ELLIPTICKPRIME</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EllipticK'</em> operator returns the Elliptic value K(m).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>EllipticKprime</em>(<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticKprime(0.2)
2.25720532682085
EllipticKprime(4.3)
1.05562492399206
EllipticKprime(0.000481)
5.206621921966
</TT></PRE><P>The <em>EllipticKprime</em> function is the Complete Elliptic Inte
gral of
the First Kind of (1-m).
<P>
<P>
<P>
<A NAME=EllipticE>
<TITLE>EllipticE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ELLIPTICE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EllipticE</em> operator used with two arguments
returns the Elliptic Integral of the Second Kind.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>EllipticE</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticE(1.2,0.22)
1.15094019180949
EllipticE(0,4.35)
0
EllipticE(9,0.00719)
8.98312465929145
</TT></PRE><P>The Complete Elliptic Integral of the Second Kind can be obtained
by
using just the second argument, or by using pi/2 as the first argument.
<P>
<P>
<P>
The <em>EllipticE</em> operator used with one argument
returns the Elliptic value E.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>EllipticE</em>(<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticE(0.22)
1.48046637439519
EllipticE(pi/2, 0.22)
1.48046637439519
</TT></PRE><P>
<A NAME=EllipticTHETA>
<TITLE>EllipticTHETA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ELLIPTICTHETA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>EllipticTheta</em> operator returns one of the four Theta
functions. It cannot except any number other than 1,2,3 or 4 as
its first argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>EllipticTheta</em>(<integer>,<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
EllipticTheta(1, 1.4, 0.72)
0.91634775373
EllipticTheta(2, 3.9, 6.1 )
-48.0202736969 + 20.9881034377 i
EllipticTheta(3, 0.67, 0.2)
1.0083077448
EllipticTheta(4, 8, 0.75)
0.894963369304
EllipticTheta(5, 1, 0.1)
***** In EllipticTheta(a,u,m); a = 1,2,3 or 4.
</TT></PRE><P>Theta functions are important because every one of the Jacobian
Elliptic functions can be expressed as the ratio of two theta functions.
<P>
<P>
<P>
<A NAME=JacobiZETA>
<TITLE>JacobiZETA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIZETA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>JacobiZeta</em> operator returns the Jacobian function Zeta.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>JacobiZeta</em>(<expression>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
JacobiZeta(3.2, 0.8)
- 0.254536403439
JacobiZeta(0.2, 1.6)
0.171766095970451 - 0.0717028569800147*i
</TT></PRE><P>The Jacobian function Zeta is related to the Jacobian function The
ta.
But it is significantly different from Riemann's Zeta Function
<A HREF=r38_0450.html>Zeta</A>.
<P>
<P>
<P>
<A NAME=g28>
<TITLE>Jacobi's Elliptic Functions and Elliptic Integrals</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Jacobi's Elliptic Functions and Elliptic Integrals</B><MENU>
<LI><A HREF=r38_0469.html>JacobiSN operator</A><P>
<LI><A HREF=r38_0470.html>JacobiCN operator</A><P>
<LI><A HREF=r38_0471.html>JacobiDN operator</A><P>
<LI><A HREF=r38_0472.html>JacobiCD operator</A><P>
<LI><A HREF=r38_0473.html>JacobiSD operator</A><P>
<LI><A HREF=r38_0474.html>JacobiND operator</A><P>
<LI><A HREF=r38_0475.html>JacobiDC operator</A><P>
<LI><A HREF=r38_0476.html>JacobiNC operator</A><P>
<LI><A HREF=r38_0477.html>JacobiSC operator</A><P>
<LI><A HREF=r38_0478.html>JacobiNS operator</A><P>
<LI><A HREF=r38_0479.html>JacobiDS operator</A><P>
<LI><A HREF=r38_0480.html>JacobiCS operator</A><P>
<LI><A HREF=r38_0481.html>JacobiAMPLITUDE operator</A><P>
<LI><A HREF=r38_0482.html>AGM_FUNCTION operator</A><P>
<LI><A HREF=r38_0483.html>LANDENTRANS operator</A><P>
<LI><A HREF=r38_0484.html>EllipticF operator</A><P>
<LI><A HREF=r38_0485.html>EllipticK operator</A><P>
<LI><A HREF=r38_0486.html>EllipticKprime operator</A><P>
<LI><A HREF=r38_0487.html>EllipticE operator</A><P>
<LI><A HREF=r38_0488.html>EllipticTHETA operator</A><P>
<LI><A HREF=r38_0489.html>JacobiZETA operator</A><P>
</MENU>
<A NAME=POCHHAMMER>
<TITLE>POCHHAMMER</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>POCHHAMMER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Pochhammer</em> operator implements the Pochhammer notation
(shifted factorial).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Pochhammer</em>(<expression>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
pochhammer(17,4);
116280
pochhammer(1/2,z);
factorial(2*z)
--------------------
2*z
(2 *factorial(z))
</TT></PRE><P>A number of complex rules for <em>Pochhammer</em> are inactive, be
cause they
cause a huge system load in algebraic mode. If one wants to use more rules
for the simplification of Pochhammer's notation, one can do:
<P>
<P>
let special!*pochhammer!*rules;
<P>
<P>
<P>
<P>
<A NAME=GAMMA>
<TITLE>GAMMA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GAMMA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Gamma</em> operator returns the Gamma function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Gamma</em>(<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
gamma(10);
362880
gamma(1/2);
sqrt(pi)
</TT></PRE><P>
<A NAME=BETA>
<TITLE>BETA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BETA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Beta</em> operator returns the Beta function defined by
<P>
<P>
Beta (z,w) := defint(t**(z-1)* (1 - t)**(w-1),t,0,1) .
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Beta</em>(<expression>,<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Beta(2,2);
1 / 6
Beta(x,y);
gamma(x)*gamma(y) / gamma(x + y)
</TT></PRE><P>The operator <em>Beta</em> is simplified towards the
<A HREF=r38_0492.html>GAMMA</A> operator.
<P>
<P>
<P>
<A NAME=PSI>
<TITLE>PSI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PSI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Psi</em> operator returns the Psi (or DiGamma) function.
<P>
<P>
Psi(x) := df(Gamma(z),z)/ Gamma (z)
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Gamma</em>(<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Psi(3);
(2*log(2) + psi(1/2) + psi(1) + 3)/2
on rounded;
- Psi(1);
0.577215664902
</TT></PRE><P>Euler's constant can be found as - Psi(1).
<P>
<P>
<P>
<A NAME=POLYGAMMA>
<TITLE>POLYGAMMA</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>POLYGAMMA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Polygamma</em> operator returns the Polygamma function.
<P>
<P>
Polygamma(n,x) := df(Psi(z),z,n);
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Polygamma</em>(<integer>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Polygamma(1,2);
2
(pi - 6) / 6
on rounded;
Polygamma(1,2.35);
0.52849689109
</TT></PRE><P>The Polygamma function is used for simplification of the
<A HREF=r38_0450.html>ZETA</A>
function for some arguments.
<P>
<P>
<P>
<A NAME=g29>
<TITLE>Gamma and Related Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Gamma and Related Functions</B><MENU>
<LI><A HREF=r38_0491.html>POCHHAMMER operator</A><P>
<LI><A HREF=r38_0492.html>GAMMA operator</A><P>
<LI><A HREF=r38_0493.html>BETA operator</A><P>
<LI><A HREF=r38_0494.html>PSI operator</A><P>
<LI><A HREF=r38_0495.html>POLYGAMMA operator</A><P>
</MENU>
<A NAME=DILOG_extended>
<TITLE>DILOG_extended</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DILOG EXTENDED</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The package <em>specfn</em> supplies an extended support for the
<A HREF=r38_0078.html>dilog</A> operator which implements the <em>dilogarithm fu
nction</em>.
<P>
<P>
dilog(x) := - defint(log(t)/(t - 1),t,1,x);
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Dilog</em>(<order>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
defint(log(t)/(t - 1),t,1,x);
- dilog (x)
dilog 2;
2
- pi /12
on rounded;
Dilog 20;
- 5.92783972438
</TT></PRE><P>The operator <em>Dilog</em> is sometimes called Spence's Integral
for n = 2.
<P>
<P>
<P>
<A NAME=Lambert_W_function>
<TITLE>Lambert_W_function</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LAMBERT\_W FUNCTION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Lambert's W function is the inverse of the function w * e**w.
It is used in the
<A HREF=r38_0179.html>solve</A> package for equations containing
exponentials and logarithms.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Lambert_W</em>(<z>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Lambert_W(-1/e);
-1
solve(w + log(w),w);
w=lambert_w(1)
on rounded;
Lambert_W(-0.05);
- 0.0527059835515
</TT></PRE><P>The current implementation will compute the principal branch in
rounded mode only.
<P>
<P>
<P>
<A NAME=g30>
<TITLE>Miscellaneous Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Miscellaneous Functions</B><MENU>
<LI><A HREF=r38_0497.html>DILOG extended operator</A><P>
<LI><A HREF=r38_0498.html>Lambert\_W function operator</A><P>
</MENU>
<A NAME=ChebyshevT>
<TITLE>ChebyshevT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHEBYSHEVT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>ChebyshevT</em> operator computes the nth Chebyshev T Polynomial (of the
first kind).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ChebyshevT</em>(<integer>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ChebyshevT(3,xx);
2
xx*(4*xx - 3)
ChebyshevT(3,4);
244
</TT></PRE><P>Chebyshev's T polynomials are computed using the recurrence relati
on:
<P>
<P>
ChebyshevT(n,x) := 2x*ChebyshevT(n-1,x) - ChebyshevT(n-2,x) with
<P>
<P>
ChebyshevT(0,x) := 0 and ChebyshevT(1,x) := x
<P>
<P>
<P>
<A NAME=ChebyshevU>
<TITLE>ChebyshevU</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHEBYSHEVU</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>ChebyshevU</em> operator returns the nth Chebyshev U Polynomial (of the
second kind).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ChebyshevU</em>(<integer>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ChebyshevU(3,xx);
2
4*x*(2*x - 1)
ChebyshevU(3,4);
496
</TT></PRE><P>Chebyshev's U polynomials are computed using the recurrence relati
on:
<P>
<P>
ChebyshevU(n,x) := 2x*ChebyshevU(n-1,x) - ChebyshevU(n-2,x) with
<P>
<P>
ChebyshevU(0,x) := 0 and ChebyshevU(1,x) := 2x
<P>
<P>
<P>
<P>
<A NAME=HermiteP>
<TITLE>HermiteP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HERMITEP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>HermiteP</em> operator returns the nth Hermite Polynomial.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>HermiteP</em>(<integer>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
HermiteP(3,xx);
2
4*xx*(2*xx - 3)
HermiteP(3,4);
464
</TT></PRE><P>Hermite polynomials are computed using the recurrence relation:
<P>
<P>
HermiteP(n,x) := 2x*HermiteP(n-1,x) - 2*(n-1)*HermiteP(n-2,x) with
<P>
<P>
HermiteP(0,x) := 1 and HermiteP(1,x) := 2x
<P>
<P>
<P>
<P>
<A NAME=LaguerreP>
<TITLE>LaguerreP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LAGUERREP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>LaguerreP</em> operator computes the nth Laguerre Polynomial.
The two argument call of LaguerreP is a (common) abbreviation of
LaguerreP(n,0,x).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>LaguerreP</em>(<integer>,<expression>) or
<P>
<P>
<em>LaguerreP</em>(<integer>,<expression>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
LaguerreP(3,xx);
3 2
(- xx + 9*xx - 18*xx + 6)/6
LaguerreP(2,3,4);
-2
</TT></PRE><P>Laguerre polynomials are computed using the recurrence relation:
<P>
<P>
LaguerreP(n,a,x) := (2n+a-1-x)/n*LaguerreP(n-1,a,x) -
(n+a-1) * LaguerreP(n-2,a,x) with
<P>
<P>
LaguerreP(0,a,x) := 1 and LaguerreP(2,a,x) := -x+1+a
<P>
<P>
<P>
<A NAME=LegendreP>
<TITLE>LegendreP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LEGENDREP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The binary <em>LegendreP</em> operator computes the nth Legendre
Polynomial which is
a special case of the nth Jacobi Polynomial with
<P>
<P>
LegendreP(n,x) := JacobiP(n,0,0,x)
<P>
<P>
The ternary form returns the associated Legendre Polynomial (see below).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>LegendreP</em>(<integer>,<expression>) or
<P>
<P>
<em>LegendreP</em>(<integer>,<expression>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
LegendreP(3,xx);
2
xx*(5*xx - 3)
----------------
2
LegendreP(3,2,xx);
2
15*xx*( - xx + 1)
</TT></PRE><P>The ternary form of the operator <em>LegendreP</em> is the associa
ted
Legendre Polynomial defined as
<P>
<P>
P(n,m,x) = (-1)**m * (1-x**2)**(m/2) * df(LegendreP(n,x),x,m)
<P>
<P>
<P>
<A NAME=JacobiP>
<TITLE>JacobiP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>JacobiP</em> operator computes the nth Jacobi Polynomial.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>JacobiP</em>(<integer>,<expression>,<expression>,
<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
JacobiP(3,4,5,xx);
3 2
7*(65*xx - 13*xx - 13*xx + 1)
----------------------------------
8
JacobiP(3,4,5,6);
94465/8
</TT></PRE><P>
<A NAME=GegenbauerP>
<TITLE>GegenbauerP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GEGENBAUERP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>GegenbauerP</em> operator computes Gegenbauer's (ultraspherical)
polynomials.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>GegenbauerP</em>(<integer>,<expression>,<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
GegenbauerP(3,2,xx);
2
4*xx*(8*xx - 3)
GegenbauerP(3,2,4);
2000
</TT></PRE><P>
<A NAME=SolidHarmonicY>
<TITLE>SolidHarmonicY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SOLIDHARMONICY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>SolidHarmonicY</em> operator computes Solid harmonic (Laplace)
polynomials.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>SolidHarmonicY</em>(<integer>,<integer>,
<expression>,<expression>,<expression>,<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
SolidHarmonicY(3,-2,x,y,z,r2);
2 2
sqrt(105)*z*(-2*i*x*y + x - y )
---------------------------------
4*sqrt(pi)*sqrt(2)
</TT></PRE><P>
<A NAME=SphericalHarmonicY>
<TITLE>SphericalHarmonicY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SPHERICALHARMONICY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>SphericalHarmonicY</em> operator computes Spherical harmonic (Laplace)
polynomials. These are special cases of the
solid harmonic polynomials,
<A HREF=r38_0507.html>SolidHarmonicY</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>SphericalHarmonicY</em>(<integer>,<integer>,
<expression>,<expression>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
SphericalHarmonicY(3,2,theta,phi);
2 2 2
sqrt(105)*cos(theta)*sin(theta) *(cos(phi) +2*cos(phi)*sin(phi)*i-sin(phi) )
-----------------------------------------------------------------------------
4*sqrt(pi)*sqrt(2)
</TT></PRE><P>
<A NAME=g31>
<TITLE>Orthogonal Polynomials</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Orthogonal Polynomials</B><MENU>
<LI><A HREF=r38_0500.html>ChebyshevT operator</A><P>
<LI><A HREF=r38_0501.html>ChebyshevU operator</A><P>
<LI><A HREF=r38_0502.html>HermiteP operator</A><P>
<LI><A HREF=r38_0503.html>LaguerreP operator</A><P>
<LI><A HREF=r38_0504.html>LegendreP operator</A><P>
<LI><A HREF=r38_0505.html>JacobiP operator</A><P>
<LI><A HREF=r38_0506.html>GegenbauerP operator</A><P>
<LI><A HREF=r38_0507.html>SolidHarmonicY operator</A><P>
<LI><A HREF=r38_0508.html>SphericalHarmonicY operator</A><P>
</MENU>
<A NAME=Si>
<TITLE>Si</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Si</em> operator returns the Sine Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Si</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
limit(Si(x),x,infinity);
pi / 2
on rounded;
Si(0.35);
0.347626790989
</TT></PRE><P>The numeric values for the operator <em>Si</em> are computed via t
he
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=Shi>
<TITLE>Shi</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Shi</em> operator returns the hyperbolic Sine Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Shi</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(shi(x),x);
sinh(x) / x
on rounded;
Shi(0.35);
0.352390716351
</TT></PRE><P>The numeric values for the operator <em>Shi</em> are computed via
the
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=s_i>
<TITLE>s_i</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>S_I</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>s_i</em> operator returns the Sine Integral function si.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>s_i</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
s_i(xx);
(2*Si(xx) - pi) / 2
df(s_i(x),x);
sin(x) / x
</TT></PRE><P>The operator name <em>s_i</em> is simplified towards
<A HREF=r38_0510.html>SI</A>.
Since REDUCE is not case sensitive by default the name ``si'' can't be
used.
<P>
<P>
<P>
<A NAME=Ci>
<TITLE>Ci</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Ci</em> operator returns the Cosine Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Ci</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
defint(cos(t)/t,t,x,infinity);
- ci (x)
on rounded;
Ci(0.35);
- 0.50307556932
</TT></PRE><P>The numeric values for the operator <em>Ci</em> are computed via t
he
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=Chi>
<TITLE>Chi</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Chi</em> operator returns the Hyperbolic Cosine Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Chi</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
defint((cosh(t)-1)/t,t,0,x);
- log(x) + psi(1) + chi(x)
on rounded;
Chi(0.35);
- 0.44182471827
</TT></PRE><P>The numeric values for the operator <em>Chi</em> are computed via
the
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=ERF_extended>
<TITLE>ERF_extended</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ERF EXTENDED</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The special function package supplies an extended support for the
<A HREF=r38_0255.html>erf</A> operator which implements the <em>error function
</em>
<P>
<P>
defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi)
<P>
<P>
.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>erf</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
erf(-x);
- erf(x)
on rounded;
erf(0.35);
0.379382053562
</TT></PRE><P>The numeric values for the operator <em>erf</em> are computed via
the
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=erfc>
<TITLE>erfc</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ERFC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>erfc</em> operator returns the complementary Error function
<P>
<P>
1 - defint(e**(-x**2),x,0,infinity) * 2/sqrt(pi)
<P>
<P>
.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>erfc</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
erfc(xx);
- erf(xx) + 1
</TT></PRE><P>The operator <em>erfc</em> is simplified towards the
<A HREF=r38_0255.html>erf</A> operator.
<P>
<P>
<P>
<A NAME=Ei>
<TITLE>Ei</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Ei</em> operator returns the Exponential Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Ei</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
df(ei(x),x);
x
e
---
x
on rounded;
Ei(0.35);
- 0.0894340019184
</TT></PRE><P>The numeric values for the operator <em>Ei</em> are computed via t
he
power series representation, which limits the argument range.
<P>
<P>
<P>
<A NAME=Fresnel_C>
<TITLE>Fresnel_C</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FRESNEL_C</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Fresnel_C</em> operator represents Fresnel's Cosine function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Fresnel_C</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
int(cos(t^2*pi/2),t,0,x);
fresnel_c(x)
on rounded;
fresnel_c(2.1);
0.581564135061
</TT></PRE><P>The operator <em>Fresnel_C</em> has a limited numeric evaluation o
f
large values of its argument.
<P>
<P>
<P>
<A NAME=Fresnel_S>
<TITLE>Fresnel_S</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FRESNEL_S</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Fresnel_S</em> operator represents Fresnel's Sine Integral function.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Fresnel_S</em>(<expression>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
int(sin(t^2*pi/2),t,0,x);
fresnel_s(x)
on rounded;
fresnel_s(2.1);
0.374273359378
</TT></PRE><P>The operator <em>Fresnel_S</em> has a limited numeric evaluation o
f
large values of its argument.
<P>
<P>
<P>
<A NAME=g32>
<TITLE>Integral Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Integral Functions</B><MENU>
<LI><A HREF=r38_0510.html>Si operator</A><P>
<LI><A HREF=r38_0511.html>Shi operator</A><P>
<LI><A HREF=r38_0512.html>s_i operator</A><P>
<LI><A HREF=r38_0513.html>Ci operator</A><P>
<LI><A HREF=r38_0514.html>Chi operator</A><P>
<LI><A HREF=r38_0515.html>ERF extended operator</A><P>
<LI><A HREF=r38_0516.html>erfc operator</A><P>
<LI><A HREF=r38_0517.html>Ei operator</A><P>
<LI><A HREF=r38_0518.html>Fresnel_C operator</A><P>
<LI><A HREF=r38_0519.html>Fresnel_S operator</A><P>
</MENU>
<A NAME=BINOMIAL>
<TITLE>BINOMIAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BINOMIAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Binomial</em> operator returns the Binomial coefficient if both
parameter are integer and expressions involving the Gamma function otherwise.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Binomial</em>(<integer>,<integer>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Binomial(49,6);
13983816
Binomial(n,3);
gamma(n + 1)
---------------
6*gamma(n - 2)
</TT></PRE><P>The operator <em>Binomial</em> evaluates the Binomial coefficients
from
the explicit form and therefore it is not the best algorithm if you
want to compute many binomial coefficients with big indices in which
case a recursive algorithm is preferable.
<P>
<P>
<P>
<A NAME=STIRLING1>
<TITLE>STIRLING1</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STIRLING1</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Stirling1</em> operator returns the Stirling Numbers S(n,m) of the first
kind, i.e. the number of permutations of n symbols which have exactly m cycles
(divided by (-1)**(n-m)).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Stirling1</em>(<integer>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Stirling1 (17,4);
-87077748875904
Stirling1 (n,n-1);
-gamma(n+1)
-------------
2*gamma(n-1)
</TT></PRE><P>The operator <em>Stirling1</em> evaluates the Stirling numbers of
the
first kind by rulesets for special cases or by a computing the closed
form, which is a series involving the operators
<A HREF=r38_0521.html>BINOMIAL</A>
and
<A HREF=r38_0523.html>STIRLING2</A>.
<P>
<P>
<P>
<A NAME=STIRLING2>
<TITLE>STIRLING2</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STIRLING2</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Stirling1</em> operator returns the Stirling Numbers S(n,m) of the
second kind, i.e. the number of ways of partitioning a set of n elements
into m non-empty subsets.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Stirling2</em>(<integer>,<integer>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Stirling2 (17,4);
694337290
Stirling2 (n,n-1);
gamma(n+1)
-------------
2*gamma(n-1)
</TT></PRE><P>The operator <em>Stirling2</em> evaluates the Stirling numbers of
the
second kind by rulesets for special cases or by a computing the closed
form.
<P>
<P>
<P>
<A NAME=g33>
<TITLE>Combinatorial Operators</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Combinatorial Operators</B><MENU>
<LI><A HREF=r38_0521.html>BINOMIAL operator</A><P>
<LI><A HREF=r38_0522.html>STIRLING1 operator</A><P>
<LI><A HREF=r38_0523.html>STIRLING2 operator</A><P>
</MENU>
<A NAME=ThreejSymbol>
<TITLE>ThreejSymbol</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>THREEJSYMBOL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>ThreejSymbol</em> operator implements the 3j symbol.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ThreejSymbol</em>(<list of j1,m1>,<list of j2,m2>,
<list of j3,m3>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ThreejSymbol({j+1,m},{j+1,-m},{1,0});
j
( - 1) *(abs(j - m + 1) - abs(j + m + 1))
-------------------------------------------
3 2 m
2*sqrt(2*j + 9*j + 13*j + 6)*( - 1)
</TT></PRE><P>
<A NAME=Clebsch_Gordan>
<TITLE>Clebsch_Gordan</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CLEBSCH_GORDAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>Clebsch_Gordan</em> operator implements the Clebsch_Gordan
coefficients. This is closely related to the
<A HREF=r38_0525.html>Threejsymbol</A>.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Clebsch_Gordan</em>(<list of j1,m1>,<list of j2,m2>,
<list of j3,m3>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Clebsch_Gordan({2,0},{2,0},{2,0});
-2
---------
sqrt(14)
</TT></PRE><P>
<A NAME=SixjSymbol>
<TITLE>SixjSymbol</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SIXJSYMBOL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>SixjSymbol</em> operator implements the 6j symbol.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>SixjSymbol</em>(<list of j1,j2,j3>,<list of l1,l2,l3>)
<P>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
SixjSymbol({7,6,3},{2,4,6});
1
-------------
14*sqrt(858)
</TT></PRE><P>The operator <em>SixjSymbol</em> uses the
<A HREF=r38_0654.html>ineq</A> package in order
to find minima and maxima for the summation index.
<P>
<P>
<P>
<A NAME=g34>
<TITLE>3j and 6j symbols</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>3j and 6j symbols</B><MENU>
<LI><A HREF=r38_0525.html>ThreejSymbol operator</A><P>
<LI><A HREF=r38_0526.html>Clebsch_Gordan operator</A><P>
<LI><A HREF=r38_0527.html>SixjSymbol operator</A><P>
</MENU>
<A NAME=HYPERGEOMETRIC>
<TITLE>HYPERGEOMETRIC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HYPERGEOMETRIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Hypergeometric</em> operator provides simplifications for the
generalized hypergeometric functions.
The <em>Hypergeometric</em> operator is included in the package specfn2.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>hypergeometric</em>(<list of parameters>,<list of parameters>,
<argument>)
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
load specfn2;
hypergeometric ({1/2,1},{3/2},-x^2);
atan(x)
--------
x
hypergeometric ({},{},z);
z
e
</TT></PRE><P>The special case where the length of the first list is equal to 2
and
the length of the second list is equal to 1 is often called
``the hypergeometric function'' (notated as 2F1(a1,a2,b;x)).
<P>
<P>
<P>
<A NAME=MeijerG>
<TITLE>MeijerG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MEIJERG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>MeijerG</em> operator provides simplifications for Meijer's G
function. The simplifications are performed towards polynomials,
elementary or
special functions or (generalized)
<A HREF=r38_0529.html>hypergeometric</A> functions.
<P>
<P>
The <em>MeijerG</em> operator is included in the package specfn2.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>MeijerG</em>(<list of parameters>,<list of parameters>,
<argument>)
<P>
<P>
<P>
The first element of the lists has to be the list containing the
first group (mostly called ``m'' and ``n'') of parameters. This passes
the four parameters of a Meijer's G function implicitly via the
length of the lists.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
load specfn2;
MeijerG({{},1},{{0}},x);
heaviside(-x+1)
MeijerG({{}},{{1+1/4},1-1/4},(x^2)/4) * sqrt pi;
2
sqrt(2)*sin(x)*x
------------------
4*sqrt(x)
</TT></PRE><P>Many well-known functions can be written as G functions,
e.g. exponentials, logarithms, trigonometric functions, Bessel functions
and hypergeometric functions.
The formulae can be found e.g. in
<P>
<P>
A.P.Prudnikov, Yu.A.Brychkov, O.I.Marichev:
Integrals and Series, Volume 3: More special functions,
Gordon and Breach Science Publishers (1990).
<P>
<P>
<P>
<A NAME=Heaviside>
<TITLE>Heaviside</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HEAVISIDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>Heaviside</em> operator returns the Heaviside function.
<P>
<P>
Heaviside(~w) => if (w <0) then 0 else 1
<P>
<P>
when numberp w;
<P>
<P>
<P> <H3>
syntax: </H3>
<em>Heaviside</em>(<argument>)
<P>
<P>
<P>
This operator is often included in the result of the simplification
of a generalized
<A HREF=r38_0529.html>hypergeometric</A> function or a
<A HREF=r38_0530.html>MeijerG</A> function.
<P>
<P>
No simplification is done for this function.
<P>
<P>
<P>
<A NAME=erfi>
<TITLE>erfi</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ERFI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
The <em>erfi</em> operator returns the error function of an imaginary argument.
<P>
<P>
erfi(~x) => 2/sqrt(pi) * defint(e**(t**2),t,0,x);
<P>
<P>
<P> <H3>
syntax: </H3>
<em>erfi</em>(<argument>)
<P>
<P>
<P>
This operator is sometimes included in the result of the simplification
of a generalized
<A HREF=r38_0529.html>hypergeometric</A> function or a
<A HREF=r38_0530.html>MeijerG</A> function.
<P>
<P>
No simplification is done for this function.
<P>
<P>
<P>
<A NAME=g35>
<TITLE>Miscellaneous</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Miscellaneous</B><MENU>
<LI><A HREF=r38_0529.html>HYPERGEOMETRIC operator</A><P>
<LI><A HREF=r38_0530.html>MeijerG operator</A><P>
<LI><A HREF=r38_0531.html>Heaviside operator</A><P>
<LI><A HREF=r38_0532.html>erfi operator</A><P>
</MENU>
<A NAME=g24>
<TITLE>Special Functions</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Special Functions</B><MENU>
<LI><A HREF=r38_0444.html>Special Function Package introduction</A><P>
<LI><A HREF=r38_0445.html>Constants concept</A><P>
<LI><A HREF=r38_0451.html>Bernoulli Euler Zeta</A><P>
<LI><A HREF=r38_0463.html>Bessel Functions</A><P>
<LI><A HREF=r38_0468.html>Airy Functions</A><P>
<LI><A HREF=r38_0490.html>Jacobi's Elliptic Functions and Elliptic Integrals</A>
<P>
<LI><A HREF=r38_0496.html>Gamma and Related Functions</A><P>
<LI><A HREF=r38_0499.html>Miscellaneous Functions</A><P>
<LI><A HREF=r38_0509.html>Orthogonal Polynomials</A><P>
<LI><A HREF=r38_0520.html>Integral Functions</A><P>
<LI><A HREF=r38_0524.html>Combinatorial Operators</A><P>
<LI><A HREF=r38_0528.html>3j and 6j symbols</A><P>
<LI><A HREF=r38_0533.html>Miscellaneous</A><P>
</MENU>
<A NAME=TAYLOR_introduction>
<TITLE>TAYLOR_introduction</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
This short note describes a package of REDUCE procedures that allow
Taylor expansion in one or more variables and efficient manipulation
of the resulting Taylor series. Capabilities include basic operations
(addition, subtraction, multiplication and division) and also
application of certain algebraic and transcendental functions. To a
certain extent, Laurent expansion can be performed as well.
<P>
<P>
<A NAME=taylor>
<TITLE>taylor</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The <em>taylor</em> operator is used for expanding an expression into a
Taylor series.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylor</em>(<expression>
<em>,</em><var><em>,</em>
<expression><em>,</em><number>
<P>
<P>
{<em>,</em><var><em>,</em>
<expression><em>,</em><number>}*)
<P>
<P>
<P>
<expression> can be any valid REDUCE algebraic expression.
<var> must be a
<A HREF=r38_0002.html>kernel</A>, and is the expansion
variable. The <expression> following it denotes the point
about which the expansion is to take place. <number> must be a
non-negative integer and denotes the maximum expansion order. If
more than one triple is specified <em>taylor</em> will expand its
first argument independently with respect to all the variables.
Note that once the expansion has been done it is not possible to
calculate higher orders.
<P>
<P>
Instead of a
<A HREF=r38_0002.html>kernel</A>, <var> may also be a list of
kernels. In this case expansion will take place in a way so that
the sum/ of the degrees of the kernels does not exceed the
maximum expansion order. If the expansion point evaluates to the
special identifier <em>infinity</em>, <em>taylor</em> tries to expand in
a series in 1/<var>.
<P>
<P>
The expansion is performed variable per variable, i.e. in the
example above by first expanding
exp(x^2+y^2)
with respect to
<em>x</em> and then expanding every coefficient with respect to <em>y</em>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
taylor(e^(x^2+y^2),x,0,2,y,0,2);
2 2 2 2 2 2
1 + Y + X + Y *X + O(X ,Y )
taylor(e^(x^2+y^2),{x,y},0,2);
2 2 2 2
1 + Y + X + O({X ,Y })
</TT></PRE><P>The following example shows the case of a non-analytical function.
<P><PRE><TT>
taylor(x*y/(x+y),x,0,2,y,0,2);
***** Not a unit in argument to QUOTTAYLOR
</TT></PRE><P>
<P>
<P>
Note that it is not generally possible to apply the standard
reduce operators to a Taylor kernel. For example,
<A HREF=r38_0169.html>part</A>,
<A HREF=r38_0141.html>coeff</A>, or
<A HREF=r38_0142.html>coeffn</A> cannot be used. Instead, the
expression at hand has to be converted to standard form first
using the
<A HREF=r38_0547.html>taylortostandard</A> operator.
<P>
<P>
Differentiation of a Taylor expression is possible. If you
differentiate with respect to one of the Taylor variables the
order will decrease by one.
<P>
<P>
Substitution is a bit restricted: Taylor variables can only be
replaced by other kernels. There is one exception to this rule:
you can always substitute a Taylor variable by an expression that
evaluates to a constant. Note that REDUCE will not always be able
to determine that an expression is constant: an example is
sin(acos(4)).
<P>
<P>
Only simple taylor kernels can be integrated. More complicated
expressions that contain Taylor kernels as parts of themselves are
automatically converted into a standard representation by means of
the
<A HREF=r38_0547.html>taylortostandard</A> operator. In this case a suitable
warning is printed.
<P>
<P>
<P>
<P>
<A NAME=taylorautocombine>
<TITLE>taylorautocombine</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORAUTOCOMBINE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
If you set <em>taylorautocombine</em> to <em>on</em>, REDUCE
automatically combines Taylor expressions during the simplification
process. This is equivalent to applying
<A HREF=r38_0539.html>taylorcombine</A> to
every expression that contains Taylor kernels. Default is
<em>on</em>.
<P>
<P>
<A NAME=taylorautoexpand>
<TITLE>taylorautoexpand</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORAUTOEXPAND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<em>taylorautoexpand</em> makes Taylor expressions ``contagious'' in
the sense that
<A HREF=r38_0539.html>taylorcombine</A> tries to Taylor expand all
non-Taylor subexpressions and to combine the result with the rest.
Default is <em>off</em>.
<P>
<P>
<A NAME=taylorcombine>
<TITLE>taylorcombine</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORCOMBINE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
This operator tries to combine all Taylor kernels found in its
argument into one. Operations currently possible are:
<P>
<P>
_ _ _ Addition, subtraction, multiplication, and division.
<P>
_ _ _ Roots, exponentials, and logarithms.
<P>
_ _ _ Trigonometric and hyperbolic functions and their inverses.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
taylorcombine log hugo;
3
X + O(X )
taylorcombine(hugo + x);
1 2 3
(1 + X + -*X + O(X )) + X
2
on taylorautoexpand;
taylorcombine(hugo + x);
1 2 3
1 + 2*X + -*X + O(X )
2
</TT></PRE><P>Application of unary operators like <em>log</em> and <em>atan</em>
will nearly always succeed. For binary operations their arguments
have to be Taylor kernels with the same template. This means that
the expansion variable and the expansion point must match.
Expansion order is not so important, different order usually means
that one of them is truncated before doing the operation.
<P>
<P>
If
<A HREF=r38_0540.html>taylorkeeporiginal</A> is set to <em>on</em> and if all
Taylor kernels in its argument have their original expressions
kept <em>taylorcombine</em> will also combine these and store the
result as the original expression of the resulting Taylor kernel.
There is also the switch
<A HREF=r38_0538.html>taylorautoexpand</A>.
<P>
<P>
There are a few restrictions to avoid mathematically undefined
expressions: it is not possible to take the logarithm of a Taylor
kernel which has no terms (i.e. is zero), or to divide by such a
beast. There are some provisions made to detect singularities
during expansion: poles that arise because the denominator has
zeros at the expansion point are detected and properly treated,
i.e. the Taylor kernel will start with a negative power. (This
is accomplished by expanding numerator and denominator separately
and combining the results.) Essential singularities of the known
functions (see above) are handled correctly.
<P>
<P>
<P>
<A NAME=taylorkeeporiginal>
<TITLE>taylorkeeporiginal</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORKEEPORIGINAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<em>taylorkeeporiginal</em>, if set to <em>on</em>, forces the
<A HREF=r38_0536.html>taylor</A> and all Taylor kernel manipulation operators to
keep the original expression, i.e. the expression that was Taylor
expanded. All operations performed on the Taylor kernels are also
applied to this expression which can be recovered using the operator
<A HREF=r38_0541.html>taylororiginal</A>. Default is <em>off</em>.
<P>
<P>
<A NAME=taylororiginal>
<TITLE>taylororiginal</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORORIGINAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Recovers the original expression (the one that was expanded) from
the Taylor kernel that is given as its argument.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylororiginal</em>(<expression>) or
<em>taylororiginal</em> <simple_expression>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
taylororiginal hugo;
***** Taylor kernel doesn't have an original part in TAYLORORIGINAL
on taylorkeeporiginal;
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
taylororiginal hugo;
X
E
</TT></PRE><P>An error is signalled if the argument is not a Taylor kernel or if
the original expression was not kept, i.e. if
<A HREF=r38_0540.html>taylorkeeporiginal</A> was set <em>off</em> during expansi
on.
<P>
<P>
<P>
<A NAME=taylorprintorder>
<TITLE>taylorprintorder</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORPRINTORDER</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<em>taylorprintorder</em>, if set to <em>on</em>, causes the remainder
to be printed in big-O notation. Otherwise, three dots are printed.
Default is <em>on</em>.
<P>
<P>
<A NAME=taylorprintterms>
<TITLE>taylorprintterms</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORPRINTTERMS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
Only a certain number of (non-zero) coefficients are printed. If
there are more, an expression of the form <em>n terms</em> is printed
to indicate how many non-zero terms have been suppressed. The
number of terms printed is given by the value of the shared
algebraic variable <em>taylorprintterms</em>. Allowed values are
integers and the special identifier <em>all</em>. The latter setting
specifies that all terms are to be printed. The default setting is
5.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
taylor(e^(x^2+y^2),x,0,4,y,0,4);
2 1 4 2 2 2 5 5
1 + Y + -*Y + X + Y *X + (4 terms) + O(X ,Y )
2
taylorprintterms := all;
TAYLORPRINTTERMS := ALL
taylor(e^(x^2+y^2),x,0,4,y,0,4);
2 1 4 2 2 2 1 4 2 1 4 1 2 4
1 + Y + -*Y + X + Y *X + -*Y *X + -*X + -*Y *X
2 2 2 2
1 4 4 5 5
+ -*Y *X + O(X ,Y )
4
</TT></PRE><P>
<A NAME=taylorrevert>
<TITLE>taylorrevert</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORREVERT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<em>taylorrevert</em> allows reversion of a Taylor series of a
function f, i.e., to compute the first terms of the expansion of the
inverse of f from the expansion of f.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylorrevert</em>(<expression><em>,</em>
<var><em>,</em><var>)
<P>
<P>
<P>
The first argument must evaluate to a Taylor kernel with the second
argument being one of its expansion variables.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
taylor(u - u**2,u,0,5);
2 6
U - U + O(U )
taylorrevert (ws,u,x);
2 3 4 5 6
X + X + 2*X + 5*X + 14*X + O(X )
</TT></PRE><P>
<A NAME=taylorseriesp>
<TITLE>taylorseriesp</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORSERIESP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
This operator may be used to determine if its argument is a Taylor
kernel.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylorseriesp</em>(<expression>) or <em>taylorseriesp</em>
<simple_expression>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
if taylorseriesp hugo then OK;
OK
if taylorseriesp(hugo + y) then OK else NO;
NO
</TT></PRE><P>Note that this operator is subject to the same restrictions as,
e.g., <em>ordp</em> or <em>numberp</em>, i.e. it may only be used in
boolean expressions in <em>if</em> or <em>let</em> statements.
<P>
<P>
<P>
<A NAME=taylortemplate>
<TITLE>taylortemplate</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORTEMPLATE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The template of a Taylor kernel, i.e. the list of all variables
with respect to which expansion took place together with expansion
point and order can be extracted using
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylortemplate</em>(<expression>) or
<em>taylortemplate</em> <simple_expression>
<P>
<P>
<P>
This returns a list of lists with the three elements
(VAR,VAR0,ORDER). An error is signalled if the argument is not a
Taylor kernel.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
taylortemplate hugo;
{{X,0,2}}
</TT></PRE><P>
<A NAME=taylortostandard>
<TITLE>taylortostandard</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TAYLORTOSTANDARD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
This operator converts all Taylor kernels in its argument into
standard form and resimplifies the result.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>taylortostandard</em>(<expression>) or
<em>taylortostandard</em> <simple_expression>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hugo := taylor(exp(x),x,0,2);
1 2 3
HUGO := 1 + X + -*X + O(X )
2
taylortostandard hugo;
2
X + 2*X + 2
------------
2
</TT></PRE><P><P>
<A NAME=g36>
<TITLE>Taylor series</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Taylor series</B><MENU>
<LI><A HREF=r38_0535.html>TAYLOR introduction</A><P>
<LI><A HREF=r38_0536.html>taylor operator</A><P>
<LI><A HREF=r38_0537.html>taylorautocombine switch</A><P>
<LI><A HREF=r38_0538.html>taylorautoexpand switch</A><P>
<LI><A HREF=r38_0539.html>taylorcombine operator</A><P>
<LI><A HREF=r38_0540.html>taylorkeeporiginal switch</A><P>
<LI><A HREF=r38_0541.html>taylororiginal operator</A><P>
<LI><A HREF=r38_0542.html>taylorprintorder switch</A><P>
<LI><A HREF=r38_0543.html>taylorprintterms variable</A><P>
<LI><A HREF=r38_0544.html>taylorrevert operator</A><P>
<LI><A HREF=r38_0545.html>taylorseriesp operator</A><P>
<LI><A HREF=r38_0546.html>taylortemplate operator</A><P>
<LI><A HREF=r38_0547.html>taylortostandard operator</A><P>
</MENU>
<A NAME=GNUPLOT_and_REDUCE>
<TITLE>GNUPLOT_and_REDUCE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GNUPLOT AND REDUCE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
<P>
<P>
The GNUPLOT system provides easy to use graphics output
for curves or surfaces which are defined by
formulas and/or data sets. GNUPLOT supports
a great variety of output devices
such as X-windows, VGA screen, postscript, picTeX.
The REDUCE GNUPLOT package lets one use the GNUPLOT
graphical output directly from inside REDUCE, either for
the interactive display of curves/surfaces or for the production
of pictures on paper.
<P>
<P>
Note that this package may not be supported on all system
platforms.
<P>
<P>
For a detailed description you should read the GNUPLOT
system documentation, available together with the GNUPLOT
installation material from several servers by anonymous FTP.
<P>
<P>
The REDUCE developers thank the GNUPLOT people for their permission
to distribute GNUPLOT together with REDUCE.
<P>
<P>
<A NAME=Axes_names>
<TITLE>Axes_names</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AXES NAMES</B><P>
<P>
Inside REDUCE the choice of variable names for a graph is completely
free. For referring to the GNUPLOT axes the names
X and Y for 2 dimensions, X,Y and Z for 3 dimensions are used
in the usual schoolbook sense independent from the variables of
the REDUCE expression.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>
<A NAME=Pointset>
<TITLE>Pointset</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>POINTSET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>type</B><P>
<P>
<P>
<P>
A curve can be give as a set of precomputed points (a polygon)
in 2 or 3 dimensions. Such a point set is a
<A HREF=r38_0053.html>list</A>
of points, where each point is a
<A HREF=r38_0053.html>list</A> 2 (or 3)
numbers. These numbers are interpreted as <em>(x,y)</em>
(or <em>x,y,z</em>) coordinates. All points of one set must have
the same dimension.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>Also a surface in 3d can be given by precomputed point
s,
but only on a logically orthogonal mesh: the surface is defined
by a list of curves (in 3d) which must have a uniform length.
GNUPLOT then will draw an orthogonal mesh by first drawing the
given lines, and second connecting the 1st point of the 1st curve
with the 1st point of the 2nd curve, that one with the 1st point
of the 3rd curve and so on for all curves and for all indexes.
<P>
<P>
<A NAME=PLOT>
<TITLE>PLOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The command <em>plot</em> is the main entry for drawing a
picture from inside REDUCE.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>plot</em>(<spec>,<spec>,...)
<P>
<P>
<P>
where <spec> is a <function>, a <range> or an <option>.
<P>
<P>
<function>:
<P>
<P>
- an expression depending
on one unknown (e.g. <em>sin(x)</em> or two unknowns (e.g.
<em>sin(x+y)</em>,
<P>
<P>
- an equation with a function on its right-hand
side and a single name on its left-hand side (e.g.
<em>z=sin(x+y)</em> where the name on the left-hand side specifies
the dependent variable.
<P>
<P>
- a list of functions:
if in 2 dimensions the picture should have more than one
curve the expressions can be given as list (e.g. <em>{sin(x),cos(x)}</em>).
<P>
<P>
- an equation with zero left or right hand side describing
an implicit curve in two dimensions (e.g. <em>x**3+x*y**3-9x=0</em>).
<P>
<P>
- a point set: the graph can be given
as point set in 2 dimensions or a
<A HREF=r38_0551.html>pointset</A> or pointset list
in 3 dimensions.
<P>
<P>
<range>:
<P>
<P>
Each dependent and independent variable can be limited
to an interval by an equation where the left-hand side specifies
the variable and the right-hand side defines the
<A HREF=r38_0423.html>interval</A>,
e.g. <em>x=( -3 .. 5)</em>.
<P>
<P>
If omitted the independent variables
range from -10 to 10 and the dependent variable is limited only
by the precision of the IEEE floating point arithmetic.
<P>
<P>
<option>:
<P>
<P>
An option can be an equation equating a variable
and a value (in general a string), or a keyword(GNUPLOT switch).
These have to be included in the gnuplot command arguments directly.
Strings have to be enclosed in
string quotes (see
<A HREF=r38_0003.html>string</A>). Available options are:
<P>
<P>
<A HREF=r38_0554.html>title</A>: assign a heading (default: empty)
<P>
<P>
<A HREF=r38_0555.html>xlabel</A>: set label for the x axis
<P>
<P>
<A HREF=r38_0556.html>ylabel</A>: set label for the y axis
<P>
<P>
<A HREF=r38_0557.html>zlabel</A>: set label for the z axis
<P>
<P>
<A HREF=r38_0558.html>terminal</A>: select an output device
<P>
<P>
<A HREF=r38_0559.html>size</A>: rescale the picture
<P>
<P>
<A HREF=r38_0560.html>view</A>: set a viewpoint
<P>
<P>
<em>(no)</em>
<A HREF=r38_0561.html>contour</A>: 3d: add contour lines
<P>
<P>
<em>(no)</em>
<A HREF=r38_0562.html>surface</A>: 3d: draw surface (default: yes)
<P>
<P>
<em>(no)</em>
<A HREF=r38_0563.html>hidden3d</A>: 3d: remove hidden lines (default: no)
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
plot(cos x);
plot(s=sin phi,phi=(-3 .. 3));
plot(sin phi,cos phi,phi=(-3 .. 3));
plot (cos sqrt(x**2 + y**2),x=(-3 .. 3),y=(-3 .. 3),hidden3d);
plot {{0,0},{0,1},{1,1},{0,0},{1,0},{0,1},{0.5,1.5},{1,1},{1,0}};
on rounded;
w:=for j:=1:200 collect {1/j*sin j,1/j*cos j,j/200}$
plot w;
</TT></PRE><P>Additional control of the <em>plot</em> operation:
<A HREF=r38_0565.html>plotrefine</A>,
<A HREF=r38_0566.html>plot_xmesh</A>,
<A HREF=r38_0567.html>plot_ymesh</A>,
<A HREF=r38_0569.html>trplot</A>,
<A HREF=r38_0564.html>plotkeep</A>,
<A HREF=r38_0568.html>show_grid</A>.
<P>
<P>
<A NAME=PLOTRESET>
<TITLE>PLOTRESET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOTRESET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The command <em>plotreset</em> closes the current GNUPLOT windows.
The next call to
<A HREF=r38_0552.html>plot</A> will create a new one. <em>plotreset</em>
can also be used to reset the system status after technical problems.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>plotreset</em>;
<P>
<P>
<P>
<A NAME=title>
<TITLE>title</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TITLE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Assign a title to the GNUPLOT graph.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>title</em>= <string>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
title="annual revenue in 1993"
</TT></PRE><P>
<A NAME=xlabel>
<TITLE>xlabel</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>XLABEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Assign a name to to the x axis (see
<A HREF=r38_0550.html>axes names</A>).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>xlabel</em>= <string>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
xlabel="month"
</TT></PRE><P>
<A NAME=ylabel>
<TITLE>ylabel</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>YLABEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Assign a name to to the x axis (see
<A HREF=r38_0550.html>axes names</A>).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ylabel</em>= <string>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
ylabel="million forint"
</TT></PRE><P>
<A NAME=zlabel>
<TITLE>zlabel</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ZLABEL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Assign a name to to the z axis (see
<A HREF=r38_0550.html>axes names</A>).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>zlabel</em>= <string>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
zlabel="local weight"
</TT></PRE><P>
<A NAME=terminal>
<TITLE>terminal</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TERMINAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Select a different output device. The possible values here
depend highly on the facilities installed for your GNUPLOT
software.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>terminal</em>= <string>
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
terminal="x11"
</TT></PRE><P>
<A NAME=size>
<TITLE>size</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SIZE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Rescale the graph (not the window!) in x and y direction.
Default is 1.0 (no rescaling).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>size</em>= "<sx>,<sy>"
<P>
<P>
<P>
where <sx>,<sy> are floating point number not too
far from 1.0.
<P> <H3>
examples: </H3>
<P><PRE><TT>
size="0.7,1"
</TT></PRE><P><P>
<P>
<A NAME=view>
<TITLE>view</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VIEW</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
Set a new viewpoint by turning the object around the x and then
around the z axis (see
<A HREF=r38_0550.html>axes names</A>).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>view</em>= "<sx>,<sz>"
<P>
<P>
<P>
where <sx>,<sz> are floating point number representing
angles in degrees.
<P> <H3>
examples: </H3>
<P><PRE><TT>
view="30,130"
</TT></PRE><P><P>
<P>
<A NAME=contour>
<TITLE>contour</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CONTOUR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
If <em>contour</em> is member of the options for a 3d
<A HREF=r38_0552.html>plot</A>
contour lines are projected to the z=0 plane
(see
<A HREF=r38_0550.html>axes names</A>). The absence of contour lines
can be selected explicitly by including <em>nocontour</em>. Default
is <em>nocontour</em>.
<P>
<P>
<A NAME=surface>
<TITLE>surface</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SURFACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
If <em>surface</em> is member of the options for a 3d
<A HREF=r38_0552.html>plot</A>
the surface is drawn. The absence of the surface plotting
can be selected by including <em>nosurface</em>, e.g. if
only the
<A HREF=r38_0561.html>contour</A> should be visualized. Default is <em>surface
</em>.
<P>
<P>
<A NAME=hidden3d>
<TITLE>hidden3d</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HIDDEN3D</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
<A HREF=r38_0552.html>plot</A>option:
If <em>hidden3d</em> is member of the options for a 3d
<A HREF=r38_0552.html>plot</A>
hidden lines are removed from the picture. Otherwise a
surface is drawn as transparent object. Default is
<em>nohidden3d</em>. Selecting <em>hidden3d</em> increases the
computing time substantially.
<P>
<P>
<A NAME=PLOTKEEP>
<TITLE>PLOTKEEP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOTKEEP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
Normally all intermediate data sets are deleted after terminating
a plot session. If the switch <em>plotkeep</em> is set
<A HREF=r38_0210.html>on</A>,
the data sets are kept for eventual post processing independent
of REDUCE.
<P>
<P>
<A NAME=PLOTREFINE>
<TITLE>PLOTREFINE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOTREFINE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
In general
<A HREF=r38_0552.html>plot</A> tries to generate smooth pictures by evaluating
the functions at interior points until the distances are fine
enough. This can require a lot of computing time if the
single function evaluation is expensive. The refinement is
controlled by the switch <em>plotrefine</em> which is
<A HREF=r38_0210.html>on</A>
by default. When you turn it
<A HREF=r38_0209.html>off</A> the functions will
be evaluated only at the basic points (see
<A HREF=r38_0566.html>plot_xmesh</A>,
<A HREF=r38_0567.html>plot_ymesh</A>).
<P>
<P>
<A NAME=plot_xmesh>
<TITLE>plot_xmesh</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOT_XMESH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The integer value of the global variable <em>plot_xmesh</em>
defines the number of initial function evaluations in x
direction (see
<A HREF=r38_0550.html>axes names</A>) for
<A HREF=r38_0552.html>plot</A>. For 2d graphs additional
points will be used as long as
<A HREF=r38_0565.html>plotrefine</A> is <em>on</em>.
For 3d graphs this number defines also the number of mesh lines
orthogonal to the x axis.
<P>
<P>
<A NAME=plot_ymesh>
<TITLE>plot_ymesh</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PLOT_YMESH</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>variable</B><P>
<P>
<P>
<P>
The integer value of the global variable <em>plot_ymesh</em>
defines for 3d
<A HREF=r38_0552.html>plot</A> calls the number of function evaluations in y
direction (see
<A HREF=r38_0550.html>axes names</A>) and the number of mesh lines
orthogonal to the y axis.
<P>
<P>
<A NAME=SHOW_GRID>
<TITLE>SHOW_GRID</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SHOW_GRID</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
The grid for localizing an implicitly defined curve in
<A HREF=r38_0552.html>plot</A>
consists of triangles. These are computed initially equally distributed
over the x-y plane controlled by
<A HREF=r38_0566.html>plot_xmesh</A>. The grid is
refined adaptively in several levels. The final grid can be visualized
by setting on the switch <em>show_grid</em>.
<P>
<P>
<A NAME=TRPLOT>
<TITLE>TRPLOT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRPLOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
In general the interaction between REDUCE and GNUPLOT is performed
as silently as possible. However, sometimes it might be useful
to see the GNUPLOT commands generated by REDUCE, e.g. for a
postprocessing of generated data sets independent of REDUCE.
When the switch <em>trplot</em> is set on all GNUPLOT commands will
be printed to the standard output additionally.
<P>
<P>
<A NAME=g37>
<TITLE>Gnuplot package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Gnuplot package</B><MENU>
<LI><A HREF=r38_0549.html>GNUPLOT and REDUCE introduction</A><P>
<LI><A HREF=r38_0550.html>Axes names concept</A><P>
<LI><A HREF=r38_0551.html>Pointset type</A><P>
<LI><A HREF=r38_0552.html>PLOT command</A><P>
<LI><A HREF=r38_0553.html>PLOTRESET command</A><P>
<LI><A HREF=r38_0554.html>title variable</A><P>
<LI><A HREF=r38_0555.html>xlabel variable</A><P>
<LI><A HREF=r38_0556.html>ylabel variable</A><P>
<LI><A HREF=r38_0557.html>zlabel variable</A><P>
<LI><A HREF=r38_0558.html>terminal variable</A><P>
<LI><A HREF=r38_0559.html>size variable</A><P>
<LI><A HREF=r38_0560.html>view variable</A><P>
<LI><A HREF=r38_0561.html>contour switch</A><P>
<LI><A HREF=r38_0562.html>surface switch</A><P>
<LI><A HREF=r38_0563.html>hidden3d switch</A><P>
<LI><A HREF=r38_0564.html>PLOTKEEP switch</A><P>
<LI><A HREF=r38_0565.html>PLOTREFINE switch</A><P>
<LI><A HREF=r38_0566.html>plot_xmesh variable</A><P>
<LI><A HREF=r38_0567.html>plot_ymesh variable</A><P>
<LI><A HREF=r38_0568.html>SHOW_GRID switch</A><P>
<LI><A HREF=r38_0569.html>TRPLOT switch</A><P>
</MENU>
<A NAME=Linear_Algebra_package>
<TITLE>Linear_Algebra_package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LINEAR ALGEBRA PACKAGE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
<P>
<P>
This section briefly describes what's available in the Linear Algebra
package.
<P>
<P>
Note on examples: In the examples throughout this
document, the matrix A will be
<P><PRE><TT>
[1 2 3]
[4 5 6]
[7 8 9].
</TT></PRE><P><P>
<P>
The functions can be divided into four categories:
<P>
<P>
Basic matrix handling
<P>
<P>
<A HREF=r38_0573.html>add_columns</A>,
<P>
<P>
<A HREF=r38_0574.html>add_rows</A>,
<P>
<P>
<A HREF=r38_0575.html>add_to_columns</A>,
<P>
<P>
<A HREF=r38_0576.html>add_to_rows</A>,
<P>
<P>
<A HREF=r38_0577.html>augment_columns</A>,
<P>
<P>
<A HREF=r38_0581.html>char_poly</A>,
<P>
<P>
<A HREF=r38_0584.html>column_dim</A>,
<P>
<P>
<A HREF=r38_0586.html>copy_into</A>,
<P>
<P>
<A HREF=r38_0587.html>diagonal</A>,
<P>
<P>
<A HREF=r38_0588.html>extend</A>,
<P>
<P>
<A HREF=r38_0589.html>find_companion</A>,
<P>
<P>
<A HREF=r38_0590.html>get_columns</A>,
<P>
<P>
<A HREF=r38_0591.html>get_rows</A>,
<P>
<P>
<A HREF=r38_0593.html>hermitian_tp</A>,
<P>
<P>
<A HREF=r38_0600.html>matrix_augment</A>,
<P>
<P>
<A HREF=r38_0602.html>matrix_stack</A>,
<P>
<P>
<A HREF=r38_0603.html>minor</A>,
<P>
<P>
<A HREF=r38_0604.html>mult_columns</A>,
<P>
<P>
<A HREF=r38_0605.html>mult_rows</A>,
<P>
<P>
<A HREF=r38_0606.html>pivot</A>,
<P>
<P>
<A HREF=r38_0609.html>remove_columns</A>,
<P>
<P>
<A HREF=r38_0610.html>remove_rows</A>,
<P>
<P>
<A HREF=r38_0611.html>row_dim</A>,
<P>
<P>
<A HREF=r38_0612.html>rows_pivot</A>,
<P>
<P>
<A HREF=r38_0615.html>stack_rows</A>,
<P>
<P>
<A HREF=r38_0616.html>sub_matrix</A>,
<P>
<P>
<A HREF=r38_0618.html>swap_columns</A>,
<P>
<P>
<A HREF=r38_0619.html>swap_entries</A>,
<P>
<P>
<A HREF=r38_0620.html>swap_rows</A>.
<P>
<P>
Constructors -- functions that create matrices
<P>
<P>
<A HREF=r38_0578.html>band_matrix</A>,
<P>
<P>
<A HREF=r38_0579.html>block_matrix</A>,
<P>
<P>
<A HREF=r38_0580.html>char_matrix</A>,
<P>
<P>
<A HREF=r38_0583.html>coeff_matrix</A>,
<P>
<P>
<A HREF=r38_0585.html>companion</A>,
<P>
<P>
<A HREF=r38_0594.html>hessian</A>,
<P>
<P>
<A HREF=r38_0595.html>hilbert</A>,
<P>
<P>
<A HREF=r38_0596.html>jacobian</A>,
<P>
<P>
<A HREF=r38_0597.html>jordan_block</A>,
<P>
<P>
<A HREF=r38_0599.html>make_identity</A>,
<P>
<P>
<A HREF=r38_0608.html>random_matrix</A>,
<P>
<P>
<A HREF=r38_0622.html>toeplitz</A>,
<P>
<P>
<A HREF=r38_0623.html>vandermonde</A>.
<P>
<P>
High level algorithms
<P>
<P>
<A HREF=r38_0581.html>char_poly</A>,
<P>
<P>
<A HREF=r38_0582.html>cholesky</A>,
<P>
<P>
<A HREF=r38_0592.html>gram_schmidt</A>,
<P>
<P>
<A HREF=r38_0598.html>lu_decom</A>,
<P>
<P>
<A HREF=r38_0607.html>pseudo_inverse</A>,
<P>
<P>
<A HREF=r38_0613.html>simplex</A>,
<P>
<P>
<A HREF=r38_0617.html>svd</A>.
<P>
<P>
Normal Forms
<P>
<P>
There is a separate package, NORMFORM, for computing
the following matrix normal forms in REDUCE:
<P>
<P>
<A HREF=r38_0625.html>smithex</A>,
<P>
<P>
<A HREF=r38_0626.html>smithex_int</A>,
<P>
<P>
<A HREF=r38_0627.html>frobenius</A>,
<P>
<P>
<A HREF=r38_0628.html>ratjordan</A>,
<P>
<P>
<A HREF=r38_0629.html>jordansymbolic</A>,
<P>
<P>
<A HREF=r38_0630.html>jordan</A>.
<P>
<P>
Predicates
<P>
<P>
<A HREF=r38_0601.html>matrixp</A>,
<P>
<P>
<A HREF=r38_0614.html>squarep</A>,
<P>
<P>
<A HREF=r38_0621.html>symmetricp</A>.
<P>
<P>
<A NAME=fast_la>
<TITLE>fast_la</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FAST_LA</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>switch</B><P>
<P>
<P>
<P>
By turning the <em>fast_la</em> switch on, the speed of the following
functions will be increased:
<P>
<P>
<A HREF=r38_0573.html>add_columns</A>,
<P>
<P>
<A HREF=r38_0574.html>add_rows</A>,
<P>
<P>
<A HREF=r38_0577.html>augment_columns</A>,
<P>
<P>
<A HREF=r38_0584.html>column_dim</A>,
<P>
<P>
<A HREF=r38_0586.html>copy_into</A>,
<P>
<P>
<A HREF=r38_0599.html>make_identity</A>,
<P>
<P>
<A HREF=r38_0600.html>matrix_augment</A>,
<P>
<P>
<A HREF=r38_0602.html>matrix_stack</A>,
<P>
<P>
<A HREF=r38_0603.html>minor</A>,
<P>
<P>
<A HREF=r38_0604.html>mult_columns</A>,
<P>
<P>
<A HREF=r38_0605.html>mult_rows</A>,
<P>
<P>
<A HREF=r38_0606.html>pivot</A>,
<P>
<P>
<A HREF=r38_0609.html>remove_columns</A>,
<P>
<P>
<A HREF=r38_0610.html>remove_rows</A>,
<P>
<P>
<A HREF=r38_0612.html>rows_pivot</A>,
<P>
<P>
<A HREF=r38_0614.html>squarep</A>,
<P>
<P>
<A HREF=r38_0615.html>stack_rows</A>,
<P>
<P>
<A HREF=r38_0616.html>sub_matrix</A>,
<P>
<P>
<A HREF=r38_0618.html>swap_columns</A>,
<P>
<P>
<A HREF=r38_0619.html>swap_entries</A>,
<P>
<P>
<A HREF=r38_0620.html>swap_rows</A>,
<P>
<P>
<A HREF=r38_0621.html>symmetricp</A>.
<P>
<P>
The increase in speed will be negligible unless you are making a
significant number (i.e. thousands) of calls. When using this switch,
error checking is minimized. This means that illegal input may give
strange error messages. Beware.
<P>
<P>
<A NAME=add_columns>
<TITLE>add_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ADD_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Add columns, add rows:
<P> <H3>
syntax: </H3>
<P>
<P>
<em>add_columns</em>(<matrix>,<c1>,<c2>,<expr>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<c1>,<c2> :- positive integers.
<P>
<P>
<expr> :- a scalar expression.
<P>
<P>
The Operator <em>add_columns</em> replaces column <\meta{c2>} of
<matrix> by <expr> * column(<matrix>,<c1>) +
column(<matrix>,<c2>).
<P>
<P>
<em>add_rows</em>performs the equivalent task on the rows of
<matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
add_columns(A,1,2,x);
[1 x + 2 3]
[ ]
[4 4*x + 5 6]
[ ]
[7 7*x + 8 9]
add_rows(A,2,3,5);
[1 2 3 ]
[ ]
[4 5 6 ]
[ ]
[27 33 39]
</TT></PRE><P>Related functions:
<A HREF=r38_0575.html>add_to_columns</A>,
<A HREF=r38_0576.html>add_to_rows</A>,
<A HREF=r38_0604.html>mult_columns</A>,
<A HREF=r38_0605.html>mult_rows</A>.
<P>
<P>
<A NAME=add_rows>
<TITLE>add_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ADD_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0573.html>add_columns</A>.
<P>
<P>
<A NAME=add_to_columns>
<TITLE>add_to_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ADD_TO_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Add to columns, add to rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>add_to_columns</em>(<matrix>,<column\_list>,<expr>)
<P>
<P>
<P>
<matrix> :- a matrix.
<P>
<P>
<column\_list> :- a positive integer or a list of positive
integers.
<P>
<P>
<expr> :- a scalar expression.
<P>
<P>
<em>add_to_columns</em>adds <expr> to each column specified in
<column\_list> of <matrix>.
<P>
<P>
<em>add_to_rows</em>performs the equivalent task on the rows of
<matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
add_to_columns(A,{1,2},10);
[11 12 3]
[ ]
[14 15 6]
[ ]
[17 18 9]
add_to_rows(A,2,-x)
[ 1 2 3 ]
[ ]
[ - x + 4 - x + 5 - x + 6]
[ ]
[ 7 8 9 ]
</TT></PRE><P>Related functions:
<A HREF=r38_0573.html>add_columns</A>,
<A HREF=r38_0574.html>add_rows</A>,
<A HREF=r38_0605.html>mult_rows</A>,
<A HREF=r38_0604.html>mult_columns</A>.
<P>
<P>
<A NAME=add_to_rows>
<TITLE>add_to_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ADD_TO_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0575.html>add_to_columns</A>.
<P>
<P>
<A NAME=augment_columns>
<TITLE>augment_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AUGMENT_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Augment columns, stack rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>augment_columns</em>(<matrix>,<column\_list>)
<P>
<P>
<P>
<matrix> :- a matrix.
<P>
<P>
<column\_list> :- either a positive integer or a list of positive
integers.
<P>
<P>
<em>augment_columns</em>gets hold of the columns of <matrix>
specified in <em>column_list</em> and sticks them together.
<P>
<P>
<em>stack_rows</em>performs the same task on rows of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
augment_columns(A,{1,2})
[1 2]
[ ]
[4 5]
[ ]
[7 8]
stack_rows(A,{1,3})
[1 2 3]
[ ]
[7 8 9]
</TT></PRE><P>Related functions:
<A HREF=r38_0590.html>get_columns</A>,
<A HREF=r38_0591.html>get_rows</A>,
<A HREF=r38_0616.html>sub_matrix</A>.
<P>
<P>
<A NAME=band_matrix>
<TITLE>band_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BAND_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>band_matrix</em>(<expr\_list>,<square\_size>)
<P>
<P>
<P>
<expr\_list> :- either a single scalar expression or a list of
an odd number of scalar expressions.
<P>
<P>
<square\_size> :- a positive integer.
<P>
<P>
<em>band_matrix</em>creates a square matrix of dimension
<square\_size>. The diagonal consists of the middle expression
of the <expr\_list>. The expressions to the left of this fill
the required number of sub_diagonals and the expressions to the right
the super_diagonals.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
band_matrix({x,y,z},6)
[y z 0 0 0 0]
[ ]
[x y z 0 0 0]
[ ]
[0 x y z 0 0]
[ ]
[0 0 x y z 0]
[ ]
[0 0 0 x y z]
[ ]
[0 0 0 0 x y]
</TT></PRE><P>Related functions:
<A HREF=r38_0587.html>diagonal</A>.
<P>
<P>
<A NAME=block_matrix>
<TITLE>block_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BLOCK_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>block_matrix</em>(<r>,<c>,<matrix\_list>)
<P>
<P>
<P>
<r>,<c> :- positive integers.
<P>
<P>
<matrix\_list> :- a list of matrices.
<P>
<P>
<em>block_matrix</em>creates a matrix that consists of <r> by
<c> matrices filled from the <matrix\_list> row wise.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
B := make_identity(2);
[1 0]
b := [ ]
[0 1]
C := mat((5),(5));
[5]
c := [ ]
[5]
D := mat((22,33),(44,55));
[22 33]
d := [ ]
[44 55]
block_matrix(2,3,{B,C,D,D,C,B});
[1 0 5 22 33]
[ ]
[0 1 5 44 55]
[ ]
[22 33 5 1 0 ]
[ ]
[44 55 5 0 1 ]
</TT></PRE><P>
<A NAME=char_matrix>
<TITLE>char_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHAR_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>char_matrix</em>(<matrix>,<lambda>)
<P>
<P>
<P>
<matrix> :- a square matrix.
<lambda> :- a symbol or algebraic expression.
<P>
<P>
<char\_matrix> creates the characteristic matrix C of
<matrix>.
<P>
<P>
This is C = <lambda> * Id - A.
Id is the identity matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
char_matrix(A,x);
[x - 1 -2 -3 ]
[ ]
[ -4 x - 5 -6 ]
[ ]
[ -7 -8 x - 9]
</TT></PRE><P>Related functions:
<A HREF=r38_0581.html>char_poly</A>.
<P>
<P>
<A NAME=char_poly>
<TITLE>char_poly</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHAR_POLY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>char_poly</em>(<matrix>,<lambda>)
<P>
<P>
<P>
<matrix> :- a square matrix.
<P>
<P>
<lambda> :- a symbol or algebraic expression.
<P>
<P>
<em>char_poly</em>finds the characteristic polynomial of <matrix>.
This is the determinant of <lambda> * Id - A.
Id is the identity matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
char_poly(A,x);
3 2
x -15*x -18*x
</TT></PRE><P>Related functions:
<A HREF=r38_0580.html>char_matrix</A>.
<P>
<P>
<A NAME=cholesky>
<TITLE>cholesky</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHOLESKY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>cholesky</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a positive definite matrix containing numeric entries.
<P>
<P>
<em>cholesky</em>computes the cholesky decomposition of <matrix>.
<P>
<P>
It returns {L,U} where L is a lower matrix, U is an upper matrix,
A = LU, and U = L^T.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
F := mat((1,1,0),(1,3,1),(0,1,1));
[1 1 0]
[ ]
f := [1 3 1]
[ ]
[0 1 1]
on rounded;
cholesky(F);
{
[1 0 0 ]
[ ]
[1 1.41421356237 0 ]
[ ]
[0 0.707106781187 0.707106781187]
,
[1 1 0 ]
[ ]
[0 1.41421356237 0.707106781187]
[ ]
[0 0 0.707106781187]
}
</TT></PRE><P>Related functions:
<A HREF=r38_0598.html>lu_decom</A>.
<P>
<P>
<A NAME=coeff_matrix>
<TITLE>coeff_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COEFF_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>coeff_matrix</em>({<lineq\_list>})
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<lineq\_list> :- linear equations. Can be of the form equation = number
or just equation.
<P>
<P>
<em>coeff_matrix</em>creates the coefficient matrix C of the linear
equations.
<P>
<P>
It returns {C,X,B} such that CX = B.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
coeff_matrix({x+y+4*z=10,y+x-z=20,x+y+4});
{
[4 1 1]
[ ]
[-1 1 1]
[ ]
[0 1 1]
,
[z]
[ ]
[y]
[ ]
[x]
,
[10]
[ ]
[20]
[ ]
[-4]
}
</TT></PRE><P>
<A NAME=column_dim>
<TITLE>column_dim</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COLUMN_DIM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Column dimension, row dimension:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>column_dim</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a matrix.
<P>
<P>
<em>column_dim</em>finds the column dimension of <matrix>.
<P>
<P>
<em>row_dim</em>finds the row dimension of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
column_dim(A);
3
row_dim(A);
3
</TT></PRE><P>
<A NAME=companion>
<TITLE>companion</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMPANION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>companion</em>(<poly>,<x>)
<P>
<P>
<P>
<poly> :- a monic univariate polynomial in <x>.
<P>
<P>
<x> :- the variable.
<P>
<P>
<em>companion</em>creates the companion matrix C of <poly>.
<P>
<P>
This is the square matrix of dimension n, where n is the degree of
<poly> w.r.t. <x>.
<P>
<P>
The entries of C are:
<P>
<P>
C(i,n) = -coeffn(<poly>,<x>,i-1) for i = 1
... n, C(i,i-1) = 1 for i = 2 ... n and
the rest are 0.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
companion(x^4+17*x^3-9*x^2+11,x);
[0 0 0 -11]
[ ]
[1 0 0 0 ]
[ ]
[0 1 0 9 ]
[ ]
[0 0 1 -17]
</TT></PRE><P>Related functions:
<A HREF=r38_0589.html>find_companion</A>.
<P>
<P>
<A NAME=copy_into>
<TITLE>copy_into</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COPY_INTO</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>copy_into</em>(<A>,<B>,<r>,<c>)
<P>
<P>
<P>
<A>,<B> :- matrices.
<P>
<P>
<r>,<c> :- positive integers.
<P>
<P>
<em>copy_into</em>copies matrix <matrix> into <B> with
<matrix>(1,1) at <B>(<r>,<c>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
G := mat((0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0),(0,0,0,0,0));
[0 0 0 0 0]
[ ]
[0 0 0 0 0]
[ ]
g := [0 0 0 0 0]
[ ]
[0 0 0 0 0]
[ ]
[0 0 0 0 0]
copy_into(A,G,1,2);
[0 1 2 3 0]
[ ]
[0 4 5 6 0]
[ ]
[0 7 8 9 0]
[ ]
[0 0 0 0 0]
[ ]
[0 0 0 0 0]
</TT></PRE><P>Related functions:
<A HREF=r38_0577.html>augment_columns</A>,
<A HREF=r38_0588.html>extend</A>,
<A HREF=r38_0600.html>matrix_augment</A>,
<A HREF=r38_0602.html>matrix_stack</A>,
<A HREF=r38_0615.html>stack_rows</A>,
<A HREF=r38_0616.html>sub_matrix</A>.
<P>
<P>
<A NAME=diagonal>
<TITLE>diagonal</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DIAGONAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>diagonal</em>({<mat\_list>})
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<mat\_list> :- each can be either a scalar expression or a
square
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<em>diagonal</em>creates a matrix that contains the input on the
diagonal.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
H := mat((66,77),(88,99));
[66 77]
h := [ ]
[88 99]
diagonal({A,x,H});
[1 2 3 0 0 0 ]
[ ]
[4 5 6 0 0 0 ]
[ ]
[7 8 9 0 0 0 ]
[ ]
[0 0 0 x 0 0 ]
[ ]
[0 0 0 0 66 77]
[ ]
[0 0 0 0 88 99]
</TT></PRE><P>Related functions:
<A HREF=r38_0597.html>jordan_block</A>.
<P>
<P>
<A NAME=extend>
<TITLE>extend</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXTEND</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>extend</em>(<matrix>,<r>,<c>,<expr>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<r>,<c> :- positive integers.
<P>
<P>
<expr> :- algebraic expression or symbol.
<P>
<P>
<em>extend</em>returns a copy of <matrix> that has been extended by
<r> rows and <c> columns. The new entries are made equal to
<expr>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
extend(A,1,2,x);
[1 2 3 x x]
[ ]
[4 5 6 x x]
[ ]
[7 8 9 x x]
[ ]
[x x x x x]
</TT></PRE><P>Related functions:
<A HREF=r38_0586.html>copy_into</A>,
<A HREF=r38_0600.html>matrix_augment</A>,
<A HREF=r38_0602.html>matrix_stack</A>,
<A HREF=r38_0609.html>remove_columns</A>,
<A HREF=r38_0610.html>remove_rows</A>.
<P>
<P>
<A NAME=find_companion>
<TITLE>find_companion</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FIND_COMPANION</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>find_companion</em>(<matrix>,<x>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<x> :- the variable.
<P>
<P>
Given a companion matrix, <em>find_companion</em> finds the polynomial
from which it was made.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
C := companion(x^4+17*x^3-9*x^2+11,x);
[0 0 0 -11]
[ ]
[1 0 0 0 ]
c := [ ]
[0 1 0 9 ]
[ ]
[0 0 1 -17]
find_companion(C,x);
4 3 2
x +17*x -9*x +11
</TT></PRE><P>Related functions:
<A HREF=r38_0585.html>companion</A>.
<P>
<P>
<A NAME=get_columns>
<TITLE>get_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GET_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Get columns, get rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>get_columns</em>(<matrix>,<column\_list>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<c> :- either a positive integer or a list of positive
integers.
<P>
<P>
<em>get_columns</em>removes the columns of <matrix> specified in
<column\_list> and returns them as a list of column matrices.
<P>
<P>
<em>get_rows</em>performs the same task on the rows of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
get_columns(A,{1,3});
{
[1]
[ ]
[4]
[ ]
[7]
,
[3]
[ ]
[6]
[ ]
[9]
}
get_rows(A,2);
{
[4 5 6]
}
</TT></PRE><P>Related functions:
<A HREF=r38_0577.html>augment_columns</A>,
<A HREF=r38_0615.html>stack_rows</A>,
<A HREF=r38_0616.html>sub_matrix</A>.
<P>
<P>
<A NAME=get_rows>
<TITLE>get_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GET_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0590.html>get_columns</A>.
<P>
<P>
<A NAME=gram_schmidt>
<TITLE>gram_schmidt</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GRAM_SCHMIDT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>gram_schmidt</em>({<vec\_list>})
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<vec\_list> :- linearly independent vectors. Each vector must be
written as a list, eg:{1,0,0}.
<P>
<P>
<em>gram_schmidt</em>performs the gram_schmidt orthonormalization on
the input vectors.
<P>
<P>
It returns a list of orthogonal normalized vectors.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
gram_schmidt({{1,0,0},{1,1,0},{1,1,1}});
{{1,0,0},{0,1,0},{0,0,1}}
gram_schmidt({{1,2},{3,4}});
1 2 2*sqrt(5) -sqrt(5)
{{ ------- , ------- },{ --------- , -------- }}
sqrt(5) sqrt(5) 5 5
</TT></PRE><P>
<A NAME=hermitian_tp>
<TITLE>hermitian_tp</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HERMITIAN_TP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em> hermitian_tp</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<em>hermitian_tp</em>computes the hermitian transpose of <matrix>.
<P>
<P>
This is a
<A HREF=r38_0345.html>matrix</A> in which the (i,j)'th entry is the conjugate
of the (j,i)'th entry of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
J := mat((i+1,i+2,i+3),(4,5,2),(1,i,0));
[i + 1 i + 2 i + 3]
[ ]
j := [ 4 5 2 ]
[ ]
[ 1 i 0 ]
hermitian_tp(j);
[ - i + 1 4 1 ]
[ ]
[ - i + 2 5 - i]
[ ]
[ - i + 3 2 0 ]
</TT></PRE><P>Related functions:
<A HREF=r38_0348.html>tp</A>.
<P>
<P>
<A NAME=hessian>
<TITLE>hessian</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HESSIAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>hessian</em>(<expr>,<variable\_list>)
<P>
<P>
<P>
<expr> :- a scalar expression.
<P>
<P>
<variable\_list> :- either a single variable or a list of
variables.
<P>
<P>
<em>hessian</em>computes the hessian matrix of <expr> w.r.t. the
variables in <variable\_list>.
<P>
<P>
This is an n by n matrix where n is the number of variables and the
(i,j)'th entry is
<A HREF=r38_0148.html>df</A>(<expr>,<variable\_list>(i),
<variable\_list>(j)).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hessian(x*y*z+x^2,{w,x,y,z});
[0 0 0 0]
[ ]
[0 2 z y]
[ ]
[0 z 0 x]
[ ]
[0 y x 0]
</TT></PRE><P>Related functions:
<A HREF=r38_0148.html>df</A>.
<P>
<P>
<A NAME=hilbert>
<TITLE>hilbert</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>HILBERT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>hilbert</em>(<square\_size>,<expr>)
<P>
<P>
<P>
<square\_size> :- a positive integer.
<P>
<P>
<expr> :- an algebraic expression.
<P>
<P>
<em>hilbert</em>computes the square hilbert matrix of dimension
<square\_size>.
<P>
<P>
This is the symmetric matrix in which the (i,j)'th entry is
1/(i+j-<expr>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
hilbert(3,y+x);
[ - 1 - 1 - 1 ]
[----------- ----------- -----------]
[ x + y - 2 x + y - 3 x + y - 4 ]
[ ]
[ - 1 - 1 - 1 ]
[----------- ----------- -----------]
[ x + y - 3 x + y - 4 x + y - 5 ]
[ ]
[ - 1 - 1 - 1 ]
[----------- ----------- -----------]
[ x + y - 4 x + y - 5 x + y - 6 ]
</TT></PRE><P>
<A NAME=jacobian>
<TITLE>jacobian</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JACOBIAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>jacobian</em>(<expr\_list>,<variable\_list>)
<P>
<P>
<P>
<expr\_list> :- either a single algebraic expression or a list
of algebraic expressions.
<P>
<P>
<variable\_list> :- either a single variable or a list of
variables.
<P>
<P>
<em>jacobian</em>computes the jacobian matrix of <expr\_list>
w.r.t. <variable\_list>.
<P>
<P>
This is a matrix whose (i,j)'th entry is
<A HREF=r38_0148.html>df</A>(<expr\_list>
(i),<variable\_list>(j)).
<P>
<P>
The matrix is n by m where n is the number of variables and m the number
of expressions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
jacobian({x^4,x*y^2,x*y*z^3},{w,x,y,z});
[ 3 ]
[0 4*x 0 0 ]
[ ]
[ 2 ]
[0 y 2*x*y 0 ]
[ ]
[ 3 3 2]
[0 y*z x*z 3*x*y*z ]
</TT></PRE><P>Related functions:
<A HREF=r38_0594.html>hessian</A>,
<A HREF=r38_0148.html>df</A>.
<P>
<P>
<A NAME=jordan_block>
<TITLE>jordan_block</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JORDAN_BLOCK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>jordan_block</em>(<expr>,<square\_size>)
<P>
<P>
<P>
<expr> :- an algebraic expression or symbol.
<P>
<P>
<square\_size> :- a positive integer.
<P>
<P>
<em>jordan_block</em>computes the square jordan block matrix J of
dimension <square\_size>.
<P>
<P>
The entries of J are:
<P>
<P>
J(i,i) = <expr> for i=1
... n, J(i,i+1) = 1 for i=1
... n-1, and all other entries are 0.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
jordan_block(x,5);
[x 1 0 0 0]
[ ]
[0 x 1 0 0]
[ ]
[0 0 x 1 0]
[ ]
[0 0 0 x 1]
[ ]
[0 0 0 0 x]
</TT></PRE><P>Related functions:
<A HREF=r38_0587.html>diagonal</A>,
<A HREF=r38_0585.html>companion</A>.
<P>
<P>
<A NAME=lu_decom>
<TITLE>lu_decom</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LU_DECOM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>lu_decom</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A> containing either numeric entries
or imaginary entries with numeric coefficients.
<P>
<P>
<em>lu_decom</em>performs LU decomposition on <matrix>, ie: it
returns {L,U} where L is a lower diagonal
<A HREF=r38_0345.html>matrix</A>, U an
upper diagonal
<A HREF=r38_0345.html>matrix</A> and A = LU.
<P>
<P>
Caution:
<P>
<P>
The algorithm used can swap the rows of <matrix> during the
calculation. This means that LU does not equal <matrix> but a row
equivalent of it. Due to this, <em>lu_decom</em> returns {L,U,vec}.
The call <em>convert(meta{matrix</em>,vec)} will return the matrix that has
been decomposed, i.e: LU = convert(<matrix>,vec).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
K := mat((1,3,5),(-4,3,7),(8,6,4));
[1 3 5]
[ ]
k := [-4 3 7]
[ ]
[8 6 4]
on rounded;
lu := lu_decom(K);
lu := {
[8 0 0 ]
[ ]
[-4 6.0 0 ]
[ ]
[1 2.25 1.125]
,
[1 0.75 0.5]
[ ]
[0 1 1.5]
[ ]
[0 0 1 ]
,
[3 2 3]}
first lu * second lu;
[8 6.0 4.0]
[ ]
[-4 3.0 7.0]
[ ]
[1 3.0 5.0]
convert(K,third lu);
P := mat((i+1,i+2,i+3),(4,5,2),(1,i,0)); _ _ _
[i + 1 i + 2 i + 3]
[ ]
p := [ 4 5 2 ]
[ ]
[ 1 i 0 ]
lu := lu_decom(P);
lu := {
[ 1 0 0 ]
[ ]
[ 4 - 4*i + 5 0 ]
[ ]
[i + 1 3 0.414634146341*i + 2.26829268293]
,
[1 i 0 ]
[ ]
[0 1 0.19512195122*i + 0.243902439024]
[ ]
[0 0 1 ]
,
[3 2 3]}
first lu * second lu;
[ 1 i 0 ]
[ ]
[ 4 5 2.0 ]
[ ]
[i + 1 i + 2 i + 3.0]
convert(P,third lu);
[ 1 i 0 ]
[ ]
[ 4 5 2 ]
[ ]
[i + 1 i + 2 i + 3]
</TT></PRE><P>
<P>
<P>
Related functions:
<A HREF=r38_0582.html>cholesky</A>.
<P>
<P>
<A NAME=make_identity>
<TITLE>make_identity</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MAKE_IDENTITY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>make_identity</em>(<square\_size>)
<P>
<P>
<P>
<square\_size> :- a positive integer.
<P>
<P>
<em>make_identity</em>creates the identity matrix of dimension
<square\_size>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
make_identity(4);
[1 0 0 0]
[ ]
[0 1 0 0]
[ ]
[0 0 1 0]
[ ]
[0 0 0 1]
</TT></PRE><P>Related functions:
<A HREF=r38_0587.html>diagonal</A>.
<P>
<P>
<A NAME=matrix_augment>
<TITLE>matrix_augment</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATRIX_AUGMENT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Matrix augment, matrix stack:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>matrix_augment</em>{<matrix\_list>}
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<matrix\_list> :- matrices.
<P>
<P>
<em>matrix_augment</em>sticks the matrices in <matrix\_list>
together horizontally.
<P>
<P>
<em>matrix_stack</em>sticks the matrices in <matrix\_list>
together vertically.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrix_augment({A,A});
[1 2 3 1 2 3]
[ ]
[4 5 6 4 5 6]
[ ]
[7 8 9 7 8 9]
matrix_stack(A,A);
[1 2 3]
[ ]
[4 5 6]
[ ]
[7 8 9]
[ ]
[1 2 3]
[ ]
[4 5 6]
[ ]
[7 8 9]
</TT></PRE><P>Related functions:
<A HREF=r38_0577.html>augment_columns</A>,
<A HREF=r38_0615.html>stack_rows</A>,
<A HREF=r38_0616.html>sub_matrix</A>.
<P>
<P>
<A NAME=matrixp>
<TITLE>matrixp</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATRIXP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>matrixp</em>(<test\_input>)
<P>
<P>
<P>
<test\_input> :- anything you like.
<P>
<P>
<em>matrixp</em>is a boolean function that returns t if the input is a
matrix and nil otherwise.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
matrixp A;
t
matrixp(doodlesackbanana);
nil
</TT></PRE><P>Related functions:
<A HREF=r38_0614.html>squarep</A>,
<A HREF=r38_0621.html>symmetricp</A>.
<P>
<P>
<A NAME=matrix_stack>
<TITLE>matrix_stack</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MATRIX_STACK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0600.html>matrix_augment</A>.
<P>
<P>
<A NAME=minor>
<TITLE>minor</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MINOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>minor</em>(<matrix>,<r>,<c>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<r>,<c> :- positive integers.
<P>
<P>
<em>minor</em>computes the (<r>,<c>)'th minor of <matrix>.
This is created by removing the <r>'th row and the <c>'th
column from <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
minor(A,1,3);
[4 5]
[ ]
[7 8]
</TT></PRE><P>Related functions:
<A HREF=r38_0609.html>remove_columns</A>,
<A HREF=r38_0610.html>remove_rows</A>.
<P>
<P>
<A NAME=mult_columns>
<TITLE>mult_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MULT_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Mult columns, mult rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>mult_columns</em>(<matrix>,<column\_list>,<expr>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<column\_list> :- a positive integer or a list of positive
integers.
<P>
<P>
<expr> :- an algebraic expression.
<P>
<P>
<em>mult_columns</em>returns a copy of <matrix> in which the
columns specified in <column\_list> have been multiplied by
<expr>.
<P>
<P>
<em>mult_rows</em>performs the same task on the rows of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
mult_columns(A,{1,3},x);
[ x 2 3*x]
[ ]
[4*x 5 6*x]
[ ]
[7*x 8 9*x]
mult_rows(A,2,10);
[1 2 3 ]
[ ]
[40 50 60]
[ ]
[7 8 9 ]
</TT></PRE><P>Related functions:
<A HREF=r38_0575.html>add_to_columns</A>,
<A HREF=r38_0576.html>add_to_rows</A>.
<P>
<P>
<A NAME=mult_rows>
<TITLE>mult_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MULT_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0604.html>mult_columns</A>.
<P>
<P>
<A NAME=pivot>
<TITLE>pivot</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PIVOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>pivot</em>(<matrix>,<r>,<c>)
<P>
<P>
<P>
<matrix> :- a matrix.
<P>
<P>
<r>,<c> :- positive integers such that <matrix>(<r>,
<c>) neq 0.
<P>
<P>
<em>pivot</em>pivots <matrix> about it's (<r>,<c>)'th
entry.
<P>
<P>
To do this, multiples of the <r>'th row are added to every other
row in the matrix.
<P>
<P>
This means that the <c>'th column will be 0 except for the
(<r>,<c>)'th entry.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
pivot(A,2,3);
[ - 1 ]
[-1 ------ 0]
[ 2 ]
[ ]
[4 5 6]
[ ]
[ 1 ]
[1 --- 0]
[ 2 ]
</TT></PRE><P>Related functions:
<A HREF=r38_0612.html>rows_pivot</A>.
<P>
<P>
<A NAME=pseudo_inverse>
<TITLE>pseudo_inverse</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PSEUDO_INVERSE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>pseudo_inverse</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<em>pseudo_inverse</em>, also known as the Moore-Penrose inverse,
computes the pseudo inverse of <matrix>.
<P>
<P>
Given the singular value decomposition of <matrix>, i.e:
A = U*P*V^T, then the pseudo inverse A^-1 is defined by
A^-1 = V^T*P^-1*U.
<P>
<P>
Thus <matrix> * pseudo_inverse(A) = Id.
(Id is the identity matrix).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
R := mat((1,2,3,4),(9,8,7,6));
[1 2 3 4]
r := [ ]
[9 8 7 6]
on rounded;
pseudo_inverse(R);
[ - 0.199999999996 0.100000000013 ]
[ ]
[ - 0.0499999999988 0.0500000000037 ]
[ ]
[ 0.0999999999982 - 5.57825497203e-12]
[ ]
[ 0.249999999995 - 0.0500000000148 ]
</TT></PRE><P>Related functions:
<A HREF=r38_0617.html>svd</A>.
<P>
<P>
<A NAME=random_matrix>
<TITLE>random_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RANDOM_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>random_matrix</em>(<r>,<c>,<limit>)
<P>
<P>
<P>
<r>,<c>,<limit> :- positive integers.
<P>
<P>
<em>random_matrix</em>creates an <r> by <c> matrix with random
entries in the range -limit <entry <limit.
<P>
<P>
Switches:
<P>
<P>
<em>imaginary</em>:- if on then matrix entries are x+i*y where -limit <x,y
<<limit>.
<P>
<P>
<em>not_negative</em>:- if on then 0 <entry <<limit>. In the imagina
ry
case we have 0 <x,y <<limit>.
<P>
<P>
<em>only_integer</em>:- if on then each entry is an integer. In the imaginary
case x and y are integers.
<P>
<P>
<em>symmetric</em>:- if on then the matrix is symmetric.
<P>
<P>
<em>upper_matrix</em>:- if on then the matrix is upper triangular.
<P>
<P>
<em>lower_matrix</em>:- if on then the matrix is lower triangular.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
on rounded;
random_matrix(3,3,10);
[ - 8.11911717343 - 5.71677292768 0.620580830035 ]
[ ]
[ - 0.032596262422 7.1655452861 5.86742633837 ]
[ ]
[ - 9.37155438255 - 7.55636708637 - 8.88618627557]
on only_integer, not_negative, upper_matrix, imaginary;
random_matrix(4,4,10);
[70*i + 15 28*i + 8 2*i + 79 27*i + 44]
[ ]
[ 0 46*i + 95 9*i + 63 95*i + 50]
[ ]
[ 0 0 31*i + 75 14*i + 65]
[ ]
[ 0 0 0 5*i + 52 ]
</TT></PRE><P>
<A NAME=remove_columns>
<TITLE>remove_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REMOVE_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Remove columns, remove rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>remove_columns</em>(<matrix>,<column\_list>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<column\_list> :- either a positive integer or a list of positive
integers.
<P>
<P>
<em>remove_columns</em>removes the columns specified in
<column\_list> from <matrix>.
<P>
<P>
<em>remove_rows</em>performs the same task on the rows of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
remove_columns(A,2);
[1 3]
[ ]
[4 6]
[ ]
[7 9]
remove_rows(A,{1,3});
[4 5 6]
</TT></PRE><P>Related functions:
<A HREF=r38_0603.html>minor</A>.
<P>
<P>
<A NAME=remove_rows>
<TITLE>remove_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REMOVE_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0609.html>remove_columns</A>.
<P>
<P>
<A NAME=row_dim>
<TITLE>row_dim</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROW_DIM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0584.html>column_dim</A>.
<P>
<P>
<A NAME=rows_pivot>
<TITLE>rows_pivot</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ROWS_PIVOT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>rows_pivot</em>(<matrix>,<r>,<c>,{<row\_list>})
<P>
<P>
<P>
<matrix> :- a namerefmatrix.
<P>
<P>
<r>,<c> :- positive integers such that <matrix>(<r>,
<c>) neq 0.
<P>
<P>
<row\_list> :- positive integer or a list of positive integers.
<P>
<P>
<em>rows_pivot</em>performs the same task as <em>pivot</em> but applies
the pivot only to the rows specified in <row\_list>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
N := mat((1,2,3),(4,5,6),(7,8,9),(1,2,3),(4,5,6));
[1 2 3]
[ ]
[4 5 6]
[ ]
n := [7 8 9]
[ ]
[1 2 3]
[ ]
[4 5 6]
rows_pivot(N,2,3,{4,5});
[1 2 3]
[ ]
[4 5 6]
[ ]
[7 8 9]
[ ]
[ - 1 ]
[-1 ------ 0]
[ 2 ]
[ ]
[0 0 0]
</TT></PRE><P>Related functions:
<A HREF=r38_0606.html>pivot</A>.
<P>
<P>
<A NAME=simplex>
<TITLE>simplex</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SIMPLEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>simplex</em>(<max/min>,<objective function>,
{<linear inequalities>})
<P>
<P>
<P>
<max/min> :- either max or min (signifying maximize and
minimize).
<P>
<P>
<objective function> :- the function you are maximizing or
minimizing.
<P>
<P>
<linear inequalities> :- the constraint inequalities. Each one must
be of the form sum of variables (
<=,=,>=) number.
<P>
<P>
<em>simplex</em>applies the revised simplex algorithm to find the
optimal(either maximum or minimum) value of the
<objective function> under the linear inequality constraints.
<P>
<P>
It returns {optimal value,{ values of variables at this optimal}}.
<P>
<P>
The algorithm implies that all the variables are non-negative.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
simplex(max,x+y,{x>=10,y>=20,x+y<=25});
***** Error in simplex: Problem has no feasible solution
simplex(max,10x+5y+5.5z,{5x+3z<=200,x+0.1y+0.5z<=12,
0.1x+0.2y+0.3z<=9, 30x+10y+50z<=1500});
{525.0,{x=40.0,y=25.0,z=0}}
</TT></PRE><P>
<A NAME=squarep>
<TITLE>squarep</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SQUAREP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>squarep</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<em>squarep</em>is a predicate that returns t if the <matrix> is
square and nil otherwise.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
squarep(mat((1,3,5)));
nil
squarep(A);
t
</TT></PRE><P>Related functions:
<A HREF=r38_0601.html>matrixp</A>,
<A HREF=r38_0621.html>symmetricp</A>.
<P>
<P>
<A NAME=stack_rows>
<TITLE>stack_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>STACK_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0577.html>augment_columns</A>.
<P>
<P>
<A NAME=sub_matrix>
<TITLE>sub_matrix</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SUB_MATRIX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>sub_matrix</em>(<matrix>,<row\_list>,<column\_list>)
<P>
<P>
<P>
<matrix> :- a matrix.
<row\_list>, <column\_list> :- either a positive integer or a
list of positive integers.
<P>
<P>
namesub_matrix produces the matrix consisting of the intersection of
the rows specified in <row\_list> and the columns specified in
<column\_list>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
sub_matrix(A,{1,3},{2,3});
[2 3]
[ ]
[8 9]
</TT></PRE><P>Related functions:
<A HREF=r38_0577.html>augment_columns</A>,
<A HREF=r38_0615.html>stack_rows</A>.
<P>
<P>
<A NAME=svd>
<TITLE>svd</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SVD</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
Singular value decomposition:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>svd</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A> containing only numeric entries.
<P>
<P>
<em>svd</em>computes the singular value decomposition of <matrix>.
<P>
<P>
It returns
<P>
<P>
{U,P,V}
<P>
<P>
where A = U*P*V^T
<P>
<P>
and P = diag(sigma(1) ... sigma(n)).
<P>
<P>
sigma(i) for i= 1 ... n are the singular values of
<matrix>.
<P>
<P>
n is the column dimension of <matrix>.
<P>
<P>
The singular values of <matrix> are the non-negative square roots
of the eigenvalues of A^T*A.
<P>
<P>
U and V are such that U*U^T = V*V^T = V^T*V = Id.
Id is the identity matrix.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
Q := mat((1,3),(-4,3));
[1 3]
q := [ ]
[-4 3]
on rounded;
svd(Q);
{
[ 0.289784137735 0.957092029805]
[ ]
[ - 0.957092029805 0.289784137735]
,
[5.1491628629 0 ]
[ ]
[ 0 2.9130948854]
,
[ - 0.687215403194 0.726453707825 ]
[ ]
[ - 0.726453707825 - 0.687215403194]
}
</TT></PRE><P>
<A NAME=swap_columns>
<TITLE>swap_columns</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SWAP_COLUMNS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
Swap columns, swap rows:
<P>
<P>
<P> <H3>
syntax: </H3>
<em>swap_columns</em>(<matrix>,<c1>,<c2>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<c1>,<c1> :- positive integers.
<P>
<P>
<em>swap_columns</em>swaps column <c1> of <matrix> with
column <c2>.
<P>
<P>
<em>swap_rows</em>performs the same task on two rows of <matrix>.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
swap_columns(A,2,3);
[1 3 2]
[ ]
[4 6 5]
[ ]
[7 9 8]
swap_rows(A,1,3);
[7 8 9]
[ ]
[4 5 6]
[ ]
[1 2 3]
</TT></PRE><P>Related functions:
<A HREF=r38_0619.html>swap_entries</A>.
<P>
<P>
<A NAME=swap_entries>
<TITLE>swap_entries</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SWAP_ENTRIES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>swap_entries</em>(<matrix>,{<r1>,<c1>},{<r2>,
<c2>})
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<r1>,<c1>,<r2>,<c2> :- positive integers.
<P>
<P>
<em>swap_entries</em>swaps <matrix>(<r1>,<c1>) with
<matrix>(<r2>,<c2>).
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
swap_entries(A,{1,1},{3,3});
[9 2 3]
[ ]
[4 5 6]
[ ]
[7 8 1]
</TT></PRE><P>Related functions:
<A HREF=r38_0618.html>swap_columns</A>,
<A HREF=r38_0620.html>swap_rows</A>.
<P>
<P>
<A NAME=swap_rows>
<TITLE>swap_rows</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SWAP_ROWS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
see:
<A HREF=r38_0618.html>swap_columns</A>.
<P>
<P>
<A NAME=symmetricp>
<TITLE>symmetricp</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SYMMETRICP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>symmetricp</em>(<matrix>)
<P>
<P>
<P>
<matrix> :- a
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<em>symmetricp</em>is a predicate that returns t if the matrix is symmetric
and nil otherwise.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
symmetricp(make_identity(11));
t
symmetricp(A);
nil
</TT></PRE><P>Related functions:
<A HREF=r38_0601.html>matrixp</A>,
<A HREF=r38_0614.html>squarep</A>.
<P>
<P>
<A NAME=toeplitz>
<TITLE>toeplitz</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TOEPLITZ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>toeplitz</em>(<expr\_list>)
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<expr\_list> :- list of algebraic expressions.
<P>
<P>
<em>toeplitz</em>creates the toeplitz matrix from the <expr\_list>.
<P>
<P>
This is a square symmetric matrix in which the first expression is
placed on the diagonal and the i'th expression is placed on the (i-1)'th
sub and super diagonals.
<P>
<P>
It has dimension n where n is the number of expressions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
toeplitz({w,x,y,z});
[w x y z]
[ ]
[x w x y]
[ ]
[y x w x]
[ ]
[z y x w]
</TT></PRE><P>
<A NAME=vandermonde>
<TITLE>vandermonde</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>VANDERMONDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
<P>
<P>
<P> <H3>
syntax: </H3>
<em>vandermonde</em>({<expr\_list>})
<P>
<P>
<P>
(If you are feeling lazy then the braces can be omitted.)
<P>
<P>
<expr\_list> :- list of algebraic expressions.
<P>
<P>
<em>vandermonde</em>creates the vandermonde matrix from the
<expr\_list>.
<P>
<P>
This is the square matrix in which the (i,j)'th entry is
<expr\_list>(i)^(j-1).
<P>
<P>
It has dimension n where n is the number of expressions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
vandermonde({x,2*y,3*z});
[ 2 ]
[1 x x ]
[ ]
[ 2]
[1 2*y 4*y ]
[ ]
[ 2]
[1 3*z 9*z ]
</TT></PRE><P>
<A NAME=g38>
<TITLE>Linear Algebra package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Linear Algebra package</B><MENU>
<LI><A HREF=r38_0571.html>Linear Algebra package introduction</A><P>
<LI><A HREF=r38_0572.html>fast_la switch</A><P>
<LI><A HREF=r38_0573.html>add_columns operator</A><P>
<LI><A HREF=r38_0574.html>add_rows operator</A><P>
<LI><A HREF=r38_0575.html>add_to_columns operator</A><P>
<LI><A HREF=r38_0576.html>add_to_rows operator</A><P>
<LI><A HREF=r38_0577.html>augment_columns operator</A><P>
<LI><A HREF=r38_0578.html>band_matrix operator</A><P>
<LI><A HREF=r38_0579.html>block_matrix operator</A><P>
<LI><A HREF=r38_0580.html>char_matrix operator</A><P>
<LI><A HREF=r38_0581.html>char_poly operator</A><P>
<LI><A HREF=r38_0582.html>cholesky operator</A><P>
<LI><A HREF=r38_0583.html>coeff_matrix operator</A><P>
<LI><A HREF=r38_0584.html>column_dim operator</A><P>
<LI><A HREF=r38_0585.html>companion operator</A><P>
<LI><A HREF=r38_0586.html>copy_into operator</A><P>
<LI><A HREF=r38_0587.html>diagonal operator</A><P>
<LI><A HREF=r38_0588.html>extend operator</A><P>
<LI><A HREF=r38_0589.html>find_companion operator</A><P>
<LI><A HREF=r38_0590.html>get_columns operator</A><P>
<LI><A HREF=r38_0591.html>get_rows operator</A><P>
<LI><A HREF=r38_0592.html>gram_schmidt operator</A><P>
<LI><A HREF=r38_0593.html>hermitian_tp operator</A><P>
<LI><A HREF=r38_0594.html>hessian operator</A><P>
<LI><A HREF=r38_0595.html>hilbert operator</A><P>
<LI><A HREF=r38_0596.html>jacobian operator</A><P>
<LI><A HREF=r38_0597.html>jordan_block operator</A><P>
<LI><A HREF=r38_0598.html>lu_decom operator</A><P>
<LI><A HREF=r38_0599.html>make_identity operator</A><P>
<LI><A HREF=r38_0600.html>matrix_augment operator</A><P>
<LI><A HREF=r38_0601.html>matrixp operator</A><P>
<LI><A HREF=r38_0602.html>matrix_stack operator</A><P>
<LI><A HREF=r38_0603.html>minor operator</A><P>
<LI><A HREF=r38_0604.html>mult_columns operator</A><P>
<LI><A HREF=r38_0605.html>mult_rows operator</A><P>
<LI><A HREF=r38_0606.html>pivot operator</A><P>
<LI><A HREF=r38_0607.html>pseudo_inverse operator</A><P>
<LI><A HREF=r38_0608.html>random_matrix operator</A><P>
<LI><A HREF=r38_0609.html>remove_columns operator</A><P>
<LI><A HREF=r38_0610.html>remove_rows operator</A><P>
<LI><A HREF=r38_0611.html>row_dim operator</A><P>
<LI><A HREF=r38_0612.html>rows_pivot operator</A><P>
<LI><A HREF=r38_0613.html>simplex operator</A><P>
<LI><A HREF=r38_0614.html>squarep operator</A><P>
<LI><A HREF=r38_0615.html>stack_rows operator</A><P>
<LI><A HREF=r38_0616.html>sub_matrix operator</A><P>
<LI><A HREF=r38_0617.html>svd operator</A><P>
<LI><A HREF=r38_0618.html>swap_columns operator</A><P>
<LI><A HREF=r38_0619.html>swap_entries operator</A><P>
<LI><A HREF=r38_0620.html>swap_rows operator</A><P>
<LI><A HREF=r38_0621.html>symmetricp operator</A><P>
<LI><A HREF=r38_0622.html>toeplitz operator</A><P>
<LI><A HREF=r38_0623.html>vandermonde operator</A><P>
</MENU>
<A NAME=Smithex>
<TITLE>Smithex</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SMITHEX</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>smithex</em> computes the Smith normal form S of a
<A HREF=r38_0345.html>matrix</A> A (say). It returns {S,P,P^-1} where P*S*P^-1 =
A.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>smithex</em>(<matrix>,<variable>)
<P>
<P>
<matrix> :- a rectangular
<A HREF=r38_0345.html>matrix</A> of univariate polynomials in
<variable>.
<variable> :- the variable.
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((x,x+1),(0,3*x^2));
[x x + 1]
[ ]
a := [ 2 ]
[0 3*x ]
smithex(a,x);
[1 0 ] [1 0] [x x + 1]
{ [ ], [ ], [ ] }
[ 3] [ 2 ] [ ]
[0 x ] [3*x 1] [-3 -3 ]
</TT></PRE><P>
<A NAME=Smithex_int>
<TITLE>Smithex_int</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SMITHEX\_INT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>smithex_int</em> performs the same task as <em>smithex</em>
but on matrices containing only integer entries. Namely,
<em>smithex_int</em> returns {S,P,P^-1} where S is the smith normal
form of the input
<A HREF=r38_0345.html>matrix</A> (A say), and P*S*P^-1 = A.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>smithex_int</em>(<matrix>)
<P>
<P>
<matrix> :- a rectangular
<A HREF=r38_0345.html>matrix</A> of integer entries.
<P>
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((9,-36,30),(-36,192,-180),(30,-180,180));
[ 9 -36 30 ]
[ ]
a := [-36 192 -180]
[ ]
[30 -180 180 ]
smithex_int(a);
[3 0 0 ] [-17 -5 -4 ] [1 -24 30 ]
[ ] [ ] [ ]
{ [0 12 0 ], [64 19 15 ], [-1 25 -30] }
[ ] [ ] [ ]
[0 0 60] [-50 -15 -12] [0 -1 1 ]
</TT></PRE><P>
<A NAME=Frobenius>
<TITLE>Frobenius</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FROBENIUS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>frobenius</em> computes the <em>frobenius</em> normal form F of
a
<A HREF=r38_0345.html>matrix</A> (A say). It returns {F,P,P^-1} where P*F*P^-1 =
A.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>frobenius</em>(<matrix>)
<P>
<P>
<matrix> :- a square
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<P>
Field Extensions:
<P>
<P>
By default, calculations are performed in the rational numbers. To
extend this field the
<A HREF=r38_0635.html>arnum</A> package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
<P>
<P>
Modular Arithmetic:
<P>
<P>
<em>Frobenius</em>can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
<A HREF=r38_0628.html>ratjordan</A> for an example.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((x,x^2),(3,5*x));
[ 2 ]
[x x ]
a := [ ]
[3 5*x]
frobenius(a);
[ 2] [1 x] [ - x ]
{ [0 - 2*x ], [ ], [1 -----] }
[ ] [0 3] [ 3 ]
[1 6*x ] [ ]
[ 1 ]
[0 --- ]
[ 3 ]
load_package arnum;
defpoly sqrt2**2-2;
a := mat((sqrt2,5),(7*sqrt2,sqrt2));
[ sqrt2 5 ]
a := [ ]
[7*sqrt2 sqrt2]
frobenius(a);
[0 35*sqrt2 - 2] [1 sqrt2 ] [ 1 ]
{ [ ], [ ], [1 - --- ] }
[1 2*sqrt2 ] [1 7*sqrt2] [ 7 ]
[ ]
[ 1 ]
[0 ----*sqrt2]
[ 14 ]
</TT></PRE><P>
<A NAME=Ratjordan>
<TITLE>Ratjordan</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RATJORDAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>ratjordan</em> computes the rational Jordan normal form R
of a
<A HREF=r38_0345.html>matrix</A> (A say). It returns {R,P,P^-1} where P*R*P^-1 =
A.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ratjordan</em>(<matrix>)
<P>
<P>
<matrix> :- a square
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<P>
Field Extensions:
<P>
<P>
By default, calculations are performed in the rational numbers. To
extend this field the <em>arnum</em> package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
See
<A HREF=r38_0627.html>frobenius</A> for an example.
<P>
<P>
Modular Arithmetic:
<P>
<P>
<em>ratjordan</em>can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((5,4*x),(2,x^2));
[5 4*x]
[ ]
a := [ 2 ]
[2 x ]
ratjordan(a);
[0 x*( - 5*x + 8)] [1 5] [ -5 ]
{ [ ], [ ], [1 -----] }
[ 2 ] [0 2] [ 2 ]
[1 x + 5 ] [ ]
[ 1 ]
[0 -----]
[ 2 ]
on modular;
setmod 23;
a := mat((12,34),(56,78));
[12 11]
a := [ ]
[10 9 ]
ratjordan(a);
[15 0] [16 8] [1 21]
{ [ ], [ ], [ ] }
[0 6] [19 4] [1 4 ]
on balanced_mod;
ratjordan(a);
[- 8 0] [ - 7 8] [1 - 2]
{ [ ], [ ], [ ] }
[ 0 6] [ - 4 4] [1 4 ]
</TT></PRE><P>
<A NAME=Jordansymbolic>
<TITLE>Jordansymbolic</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JORDANSYMBOLIC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>jordansymbolic</em> computes the Jordan normal form J
of a
<A HREF=r38_0345.html>matrix</A> (A say). It returns {J,L,P,P^-1} where
P*J*P^-1 = A. L = {ll,mm} where mm is a name and ll is a list of
irreducible factors of p(mm).
<P>
<P>
<P> <H3>
syntax: </H3>
<em>jordansymbolic</em>(<matrix>)
<P>
<P>
<matrix> :- a square
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<P>
Field Extensions:
<P>
<P>
By default, calculations are performed in the rational numbers. To
extend this field the
<A HREF=r38_0635.html>arnum</A> package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
See
<A HREF=r38_0627.html>frobenius</A> for an example.
<P>
<P>
Modular Arithmetic:
<P>
<P>
<em>jordansymbolic</em>can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
<A HREF=r38_0628.html>ratjordan</A> for an example.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((1,y),(2,5*y));
[1 y ]
a := [ ]
[2 5*y]
jordansymbolic(a);
{
[lambda11 0 ]
[ ]
[ 0 lambda12]
,
2
lambda - 5*lambda*y - lambda + 3*y,lambda,
[lambda11 - 5*y lambda12 - 5*y]
[ ]
[ 2 2 ]
,
[ 2*lambda11 - 5*y - 1 5*lambda11*y - lambda11 - y + 1 ]
[---------------------- ---------------------------------]
[ 2 2 ]
[ 25*y - 2*y + 1 2*(25*y - 2*y + 1) ]
[ ]
[ 2*lambda12 - 5*y - 1 5*lambda12*y - lambda12 - y + 1 ]
[---------------------- ---------------------------------]
[ 2 2 ]
[ 25*y - 2*y + 1 2*(25*y - 2*y + 1) ]
}
</TT></PRE><P>
<A NAME=Jordan>
<TITLE>Jordan</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>JORDAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>operator</B><P>
<P>
The operator <em>jordan</em> computes the Jordan normal form J
of a
<A HREF=r38_0345.html>matrix</A> (A say). It returns {J,P,P^-1} where P*J*P^-1 =
A.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>jordan</em>(<matrix>)
<P>
<P>
<matrix> :- a square
<A HREF=r38_0345.html>matrix</A>.
<P>
<P>
<P>
Field Extensions:
By default, calculations are performed in the rational numbers. To
extend this field the <em>arnum</em> package can be used. The package must
first be loaded by load_package arnum;. The field can now be extended
by using the defpoly command. For example, defpoly sqrt2**2-2; will
extend the field to include the square root of 2 (now defined by sqrt2).
See
<A HREF=r38_0627.html>frobenius</A> for an example.
<P>
<P>
Modular Arithmetic:
<em>Jordan</em> can also be calculated in a modular base. To do this
first type on modular;. Then setmod p; (where p is a prime) will set
the modular base of calculation to p. By further typing on balanced_mod
the answer will appear using a symmetric modular representation. See
<A HREF=r38_0628.html>ratjordan</A> for an example.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT>
a := mat((1,x),(0,x));
[1 x]
a := [ ]
[0 x]
jordan(a);
{
[1 0]
[ ]
[0 x]
,
[ 1 x ]
[------- --------------]
[ x - 1 2 ]
[ x - 2*x + 1 ]
[ ]
[ 1 ]
[ 0 ------- ]
[ x - 1 ]
,
[x - 1 - x ]
[ ]
[ 0 x - 1]
}
</TT></PRE><P>
<A NAME=g39>
<TITLE>Matrix Normal Forms</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Matrix Normal Forms</B><MENU>
<LI><A HREF=r38_0625.html>Smithex operator</A><P>
<LI><A HREF=r38_0626.html>Smithex\_int operator</A><P>
<LI><A HREF=r38_0627.html>Frobenius operator</A><P>
<LI><A HREF=r38_0628.html>Ratjordan operator</A><P>
<LI><A HREF=r38_0629.html>Jordansymbolic operator</A><P>
<LI><A HREF=r38_0630.html>Jordan operator</A><P>
</MENU>
<A NAME=Miscellaneous_Packages>
<TITLE>Miscellaneous_Packages</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MISCELLANEOUS PACKAGES</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>introduction</B><P>
<P>
REDUCE includes a large number of packages that have been contributed by
users from various fields. Some of these, together with their relevant
commands, switches and so on (e.g., the NUMERIC package), have
been described elsewhere. This section describes those packages for which
no separate help material exists. Each has its own switches, commands,
and operators, and some redefine special characters to aid in their
notation. However, the brief descriptions given here do not include all
such information. Readers are referred to the general package
documentation in this case, which can be found, along with the source
code, under the subdirectories <em>doc</em> and <em>src</em> in the
<em>reduce</em> directory. The
<A HREF=r38_0127.html>load_package</A> command is used to
load the files you wish into your system. There will be a short delay
while the package is loaded. A package cannot be unloaded. Once it
is in your system, it stays there until you end the session. Each package
also has a test file, which you will find under its name in the
<em>$reduce/xmpl</em> directory.
<P>
<P>
Finally, it should be mentioned that such user-contributed packages are
unsupported; any questions or problems should be directed to their
authors.
<P>
<P>
<A NAME=ALGINT_package>
<TITLE>ALGINT_package</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ALGINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: James H. Davenport
<P>
<P>
The <em>algint</em> package provides indefinite integration of square roots.
This package, which is an extension of the basic integration package
distributed with REDUCE, will analytically integrate a wide range of
expressions involving square roots. The
<A HREF=r38_0265.html>algint</A> switch provides for
the use of the facilities given by the package, and is automatically turned
on when the package is loaded. If you want to return to the standard
integration algorithms, turn
<A HREF=r38_0265.html>algint</A> off. An error message is given
if you try to turn the
<A HREF=r38_0265.html>algint</A> switch on when its package is not
loaded.
<P>
<P>
<A NAME=APPLYSYM>
<TITLE>APPLYSYM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>APPLYSYM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Thomas Wolf
<P>
<P>
This package provides programs APPLYSYM, QUASILINPDE and DETRAFO for
computing with infinitesimal symmetries of differential equations.
<P>
<P>
<A NAME=ARNUM>
<TITLE>ARNUM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ARNUM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Eberhard Schruefer
<P>
<P>
This package provides facilities for handling algebraic numbers as polynomial
coefficients in REDUCE calculations. It includes facilities for introducing
indeterminates to represent algebraic numbers, for calculating splitting
fields, and for factoring and finding greatest common divisors in such
domains.
<P>
<P>
<A NAME=ASSIST>
<TITLE>ASSIST</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ASSIST</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Hubert Caprasse
<P>
<P>
ASSIST contains a large number of additional general purpose functions
that allow a user to better adapt REDUCE to various calculational
strategies and to make the programming task more straightforward and more
efficient.
<P>
<P>
<A NAME=AVECTOR>
<TITLE>AVECTOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>AVECTOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: David Harper
<P>
<P>
This package provides REDUCE with the ability to perform vector algebra
using the same notation as scalar algebra. The basic algebraic operations
are supported, as are differentiation and integration of vectors with
respect to scalar variables, cross product and dot product, component
manipulation and application of scalar functions (e.g. cosine) to a vector
to yield a vector result.
<P>
<P>
<A NAME=BOOLEAN>
<TITLE>BOOLEAN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>BOOLEAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package supports the computation with boolean expressions in the
propositional calculus. The data objects are composed from algebraic
expressions connected by the infix boolean operators and, or,
implies, equiv, and the unary prefix operator not.
Boolean allows you to simplify expressions built from these
operators, and to test properties like equivalence, subset property etc.
<P>
<P>
<A NAME=CALI>
<TITLE>CALI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CALI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Hans-Gert Gr"abe
<P>
<P>
This package contains algorithms for computations in commutative algebra
closely related to the Groebner algorithm for ideals and modules. Its
heart is a new implementation of the Groebner algorithm that also allows
for the computation of syzygies. This implementation is also applicable to
submodules of free modules with generators represented as rows of a matrix.
<P>
<P>
<A NAME=CAMAL>
<TITLE>CAMAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CAMAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: John P. Fitch
<P>
<P>
This package implements in REDUCE the Fourier transform procedures of the
CAMAL package for celestial mechanics.
<P>
<P>
<A NAME=CHANGEVR>
<TITLE>CHANGEVR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CHANGEVR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: G. Ucoluk
<P>
<P>
This package provides facilities for changing the independent variables in
a differential equation. It is basically the application of the chain rule.
<P>
<P>
<A NAME=COMPACT>
<TITLE>COMPACT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>COMPACT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Anthony C. Hearn
<P>
<P>
COMPACT is a package of functions for the reduction of a polynomial in the
presence of side relations. COMPACT applies the side relations to the
polynomial so that an equivalent expression results with as few terms as
possible. For example, the evaluation of
<P>
<P>
<P><PRE><TT>
compact(s*(1-sin x^2)+c*(1-cos x^2)+sin x^2+cos x^2,
{cos x^2+sin x^2=1});
</TT></PRE><P>yields the result
<P><PRE><TT>
2 2
SIN(X) *C + COS(X) *S + 1
</TT></PRE><P><P>
<P>
The first argument to the operator <em>compact</em> is the expression
and the second is a list of side relations that can be
equations or simple expressions (implicitly equated to zero). The
kernels in the side relations may also be free variables with the
same meaning as in rules, e.g.
<P><PRE><TT>
sin_cos_identity := {cos ~w^2+sin ~w^2=1}$
compact(u,in_cos_identity);
</TT></PRE><P><P>
<P>
Also the full rule syntax with the replacement operator is allowed here.
<P>
<P>
<A NAME=CRACK>
<TITLE>CRACK</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CRACK</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Andreas Brand, Thomas Wolf
<P>
<P>
CRACK is a package for solving overdetermined systems of partial or
ordinary differential equations (PDEs, ODEs). Examples of programs which
make use of CRACK for investigating ODEs (finding symmetries, first
integrals, an equivalent Lagrangian or a ``differential factorization'') are
included.
<P>
<P>
<A NAME=CVIT>
<TITLE>CVIT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>CVIT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: V.Ilyin, A.Kryukov, A.Rodionov, A.Taranov
<P>
<P>
This package provides an alternative method for computing traces of Dirac
gamma matrices, based on an algorithm by Cvitanovich that treats gamma
matrices as 3-j symbols.
<P>
<P>
<A NAME=DEFINT>
<TITLE>DEFINT</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DEFINT</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Kerry Gaskell, Stanley M. Kameny, Winfried Neun
<P>
<P>
This package finds the definite integral of an expression in a stated
interval. It uses several techniques, including an innovative approach
based on the Meijer G-function, and contour integration.
<P>
<P>
<A NAME=DESIR>
<TITLE>DESIR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DESIR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: C. Dicrescenzo, F. Richard-Jung, E. Tournier
<P>
<P>
This package enables the basis of formal solutions to be computed for an
ordinary homogeneous differential equation with polynomial coefficients
over Q of any order, in the neighborhood of zero (regular or irregular
singular point, or ordinary point).
<P>
<P>
<A NAME=DFPART>
<TITLE>DFPART</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DFPART</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package supports computations with total and partial derivatives of
formal function objects. Such computations can be useful in the context
of differential equations or power series expansions.
<P>
<P>
<A NAME=DUMMY>
<TITLE>DUMMY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>DUMMY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Alain Dresse
<P>
<P>
This package allows a user to find the canonical form of expressions
involving dummy variables. In that way, the simplification of
polynomial expressions can be fully done. The indeterminates are general
operator objects endowed with as few properties as possible. In that way
the package may be used in a large spectrum of applications.
<P>
<P>
<A NAME=EXCALC>
<TITLE>EXCALC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EXCALC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Eberhard Schruefer
<P>
<P>
The <em>excalc</em> package is designed for easy use by all who are familiar
with the calculus of Modern Differential Geometry. The program is currently
able to handle scalar-valued exterior forms, vectors and operations between
them, as well as non-scalar valued forms (indexed forms). It is thus an ideal
tool for studying differential equations, doing calculations in general
relativity and field theories, or doing simple things such as calculating the
Laplacian of a tensor field for an arbitrary given frame.
<P>
<P>
<A NAME=FPS>
<TITLE>FPS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FPS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Wolfram Koepf, Winfried Neun
<P>
<P>
This package can expand a specific class of functions into their
corresponding Laurent-Puiseux series.
<P>
<P>
<A NAME=FIDE>
<TITLE>FIDE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>FIDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: Richard Liska
<P>
<P>
This package performs automation of the process of numerically
solving partial differential equations systems (PDES) by means of
computer algebra. For PDES solving, the finite difference method is applied.
The computer algebra system REDUCE and the numerical programming
language FORTRAN are used in the presented methodology. The main aim of
this methodology is to speed up the process of preparing numerical
programs for solving PDES. This process is quite often, especially for
complicated systems, a tedious and time consuming task.
<P>
<P>
<A NAME=GENTRAN>
<TITLE>GENTRAN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>GENTRAN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Barbara L. Gates
<P>
<P>
This package is an automatic code GENerator and TRANslator. It constructs
complete numerical programs based on sets of algorithmic specifications and
symbolic expressions. Formatted FORTRAN, RATFOR or C code can be generated
through a series of interactive commands or under the control of a template
processing routine. Large expressions can be automatically segmented into
subexpressions of manageable size, and a special file-handling mechanism
maintains stacks of open I/O channels to allow output to be sent to any
number of files simultaneously and to facilitate recursive invocation of the
whole code generation process.
<P>
<P>
<A NAME=IDEALS>
<TITLE>IDEALS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>IDEALS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package implements the basic arithmetic for polynomial ideals by
exploiting the Groebner bases package of REDUCE. In order to save
computing time all intermediate Groebner bases are stored internally such
that time consuming repetitions are inhibited.
<P>
<P>
<A NAME=INEQ>
<TITLE>INEQ</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INEQ</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package supports the operator <em>ineq_solve</em> that
attempts to solve single inequalities and sets of coupled inequalities.
<P>
<P>
<A NAME=INVBASE>
<TITLE>INVBASE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>INVBASE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Authors: A.Yu. Zharkov and Yu.A. Blinkov
<P>
<P>
Involutive bases are a new tool for solving problems in connection with
multivariate polynomials, such as solving systems of polynomial equations
and analyzing polynomial ideals. An involutive basis of a polynomial ideal
is nothing more than a special form of a redundant Groebner basis. The
construction of involutive bases reduces the problem of solving polynomial
systems to simple linear algebra.
<P>
<P>
<A NAME=LAPLACE>
<TITLE>LAPLACE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LAPLACE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: C. Kazasov, M. Spiridonova, V. Tomov
<P>
<P>
This package can calculate ordinary and inverse Laplace transforms of
expressions.
<P>
<P>
<A NAME=LIE>
<TITLE>LIE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>LIE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Authors: Carsten and Franziska Sch"obel
<P>
<P>
<em>Lie</em>is a package of functions for the classification of real
n-dimensional Lie algebras. It consists of two modules: <em>liendmc1</em>
and <em>lie1234</em>. With the help of the functions in the <em>liendmcl</em>
module, real n-dimensional Lie algebras L with a derived algebra
L^(1) of dimension 1 can be classified.
<P>
<P>
<A NAME=MODSR>
<TITLE>MODSR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>MODSR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package supports solve (M_SOLVE) and roots (M_ROOTS) operators for
modular polynomials and modular polynomial systems. The moduli need not
be primes. M_SOLVE requires a modulus to be set. M_ROOTS takes the
modulus as a second argument. For example:
<P>
<P>
<P><PRE><TT>
on modular; setmod 8;
m_solve(2x=4); -> {{X=2},{X=6}}
m_solve({x^2-y^3=3});
-> {{X=0,Y=5}, {X=2,Y=1}, {X=4,Y=5}, {X=6,Y=1}}
m_solve({x=2,x^2-y^3=3}); -> {{X=2,Y=1}}
off modular;
m_roots(x^2-1,8); -> {1,3,5,7}
m_roots(x^3-x,7); -> {0,1,6}
</TT></PRE><P>
<A NAME=NCPOLY>
<TITLE>NCPOLY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>NCPOLY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Herbert Melenk, Joachim Apel
<P>
<P>
This package allows the user to set up automatically a consistent
environment for computing in an algebra where the non--commutativity is
defined by Lie-bracket commutators. The package uses the REDUCE
<em>noncom</em> mechanism for elementary polynomial arithmetic; the commutator
rules are automatically computed from the Lie brackets.
<P>
<P>
<A NAME=ORTHOVEC>
<TITLE>ORTHOVEC</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ORTHOVEC</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: James W. Eastwood
<P>
<P>
<em>orthovec</em>is a collection of REDUCE procedures and operations which
provide a simple-to-use environment for the manipulation of scalars and
vectors. Operations include addition, subtraction, dot and cross
products, division, modulus, div, grad, curl, laplacian, differentiation,
integration, and Taylor expansion.
<P>
<P>
<A NAME=PHYSOP>
<TITLE>PHYSOP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PHYSOP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: Mathias Warns
<P>
<P>
This package has been designed to meet the requirements of theoretical
physicists looking for a computer algebra tool to perform complicated
calculations in quantum theory with expressions containing operators.
These operations consist mainly of the calculation of commutators between
operator expressions and in the evaluations of operator matrix elements in
some abstract space.
<P>
<P>
<A NAME=PM>
<TITLE>PM</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>PM</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Kevin McIsaac
<P>
<P>
PM is a general pattern matcher similar in style to those found in systems
such as SMP and Mathematica, and is based on the pattern matcher described
in Kevin McIsaac, ``Pattern Matching Algebraic Identities'', SIGSAM Bulletin,
19 (1985), 4-13.
<P>
<P>
<A NAME=RANDPOLY>
<TITLE>RANDPOLY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RANDPOLY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Francis J. Wright
<P>
<P>
This package is based on a port of the Maple random polynomial
generator together with some support facilities for the generation
of random numbers and anonymous procedures.
<P>
<P>
<A NAME=REACTEQN>
<TITLE>REACTEQN</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>REACTEQN</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Herbert Melenk
<P>
<P>
This package allows a user to transform chemical reaction systems into
ordinary differential equation systems (ODE) corresponding to the laws of
pure mass action.
<P>
<P>
<A NAME=RESET>
<TITLE>RESET</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RESET</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: John Fitch
<P>
<P>
This package defines a command command RESETREDUCE that works through the
history of previous commands, and clears any values which have been
assigned, plus any rules, arrays and the like. It also sets the various
switches to their initial values. It is not complete, but does work for
most things that cause a gradual loss of space. It would be relatively
easy to make it interactive, so allowing for selective resetting.
<P>
<P>
<A NAME=RESIDUE>
<TITLE>RESIDUE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RESIDUE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: Wolfram Koepf
<P>
<P>
This package supports the calculation of residues of arbitrary
expressions.
<P>
<P>
<A NAME=RLFI>
<TITLE>RLFI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>RLFI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Richard Liska
<P>
<P>
This package
adds LaTeX syntax
to REDUCE. Text generated by REDUCE in this mode can be directly
used in LaTeX source
documents. Various
mathematical constructions are supported by the interface including
subscripts, superscripts, font changing, Greek letters, divide-bars,
integral and sum signs, derivatives, and so on.
<P>
<P>
<A NAME=SCOPE>
<TITLE>SCOPE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SCOPE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: J.A. van Hulzen
<P>
<P>
SCOPE is a package for the production of an optimized form of a set of
expressions. It applies an heuristic search for common (sub)expressions
to almost any set of proper REDUCE assignment statements. The output is
obtained as a sequence of assignment statements. <em>gentran</em> is used to
facilitate expression output.
<P>
<P>
<A NAME=SETS>
<TITLE>SETS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SETS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: Francis J. Wright
<P>
<P>
The SETS package provides algebraic-mode support for set operations on
lists regarded as sets (or representing explicit sets) and on implicit
sets represented by identifiers.
<P>
<P>
<A NAME=SPDE>
<TITLE>SPDE</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SPDE</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Fritz Schwartz
<P>
<P>
The package <em>spde</em> provides a set of functions which may be used to
determine the symmetry group of Lie- or point-symmetries of a given system of
partial differential equations. In many cases the determining system is
solved completely automatically. In other cases the user has to provide
additional input information for the solution algorithm to terminate.
<P>
<P>
<A NAME=SYMMETRY>
<TITLE>SYMMETRY</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>SYMMETRY</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Author: Karin Gatermann
<P>
<P>
This package computes symmetry-adapted bases and block diagonal forms of
matrices which have the symmetry of a group. The package is the
implementation of the theory of linear representations for small finite
groups such as the dihedral groups.
<P>
<P>
<A NAME=TPS>
<TITLE>TPS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TPS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Alan Barnes, Julian Padget
<P>
<P>
This package implements formal Laurent series expansions in one variable
using the domain mechanism of REDUCE. This means that power series
objects can be added, multiplied, differentiated etc., like other first
class objects in the system. A lazy evaluation scheme is used and thus
terms of the series are not evaluated until they are required for printing
or for use in calculating terms in other power series. The series are
extendible giving the user the impression that the full infinite series is
being manipulated. The errors that can sometimes occur using series that
are truncated at some fixed depth (for example when a term in the required
series depends on terms of an intermediate series beyond the truncation
depth) are thus avoided.
<P>
<P>
<A NAME=TRI>
<TITLE>TRI</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRI</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Werner Antweiler
<P>
<P>
This package provides facilities written in REDUCE-Lisp for typesetting
REDUCE formulas
using TeX. The
TeX-REDUCE-Interface incorporates three levels
of TeX output:
without line breaking, with line breaking, and
with line breaking plus indentation.
<P>
<P>
<A NAME=TRIGSIMP>
<TITLE>TRIGSIMP</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>TRIGSIMP</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Wolfram Koepf
<P>
<P>
TRIGSIMP is a useful tool for all kinds of trigonometric and hyperbolic
simplification and factorization. There are three procedures included in
TRIGSIMP: <em>trigsimp</em>, <em>trigfactorize</em> and <em>triggcd</em>. The
first is for finding simplifications of trigonometric or hyperbolic
expressions with many options, the second for factorizing them and the
third for finding the greatest common divisor of two trigonometric or
hyperbolic polynomials.
<P>
<P>
<A NAME=XCOLOR>
<TITLE>XCOLOR</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>XCOLOR</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: A. Kryukov
<P>
<P>
This package calculates the color factor in non-abelian gauge field
theories using an algorithm due to Cvitanovich.
<P>
<P>
<A NAME=XIDEAL>
<TITLE>XIDEAL</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>XIDEAL</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: David Hartley
<P>
<P>
<em>xideal</em>constructs Groebner bases for solving the left ideal
membership problem: Groebner left ideal bases or GLIBs. For graded
ideals, where each form is homogeneous in degree, the distinction between
left and right ideals vanishes. Furthermore, if the generating forms are
all homogeneous, then the Groebner bases for the non-graded and graded
ideals are identical. In this case, <em>xideal</em> is able to save time by
truncating the Groebner basis at some maximum degree if desired.
<P>
<P>
<A NAME=WU>
<TITLE>WU</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>WU</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Author: Russell Bradford
<P>
<P>
This is a simple implementation of the Wu algorithm implemented in REDUCE
working directly from ``A Zero Structure Theorem for
Polynomial-Equations-Solving,'' Wu Wen-tsun, Institute of Systems Science,
Academia Sinica, Beijing.
<P>
<P>
<A NAME=ZEILBERG>
<TITLE>ZEILBERG</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ZEILBERG</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
<P>
<P>
Authors: Gregor St"olting and Wolfram Koepf
<P>
<P>
This package is a careful implementation of the Gosper and Zeilberger
algorithms for indefinite and definite summation of hypergeometric terms,
respectively. Extensions of these algorithms are also included that are
valid for ratios of products of powers,
factorials, gamma function
terms, binomial coefficients, and shifted factorials that are
rational-linear in their arguments.
<P>
<P>
<A NAME=ZTRANS>
<TITLE>ZTRANS</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ZTRANS</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>package</B><P>
<P>
Authors: Wolfram Koepf, Lisa Temme
<P>
<P>
This package is an implementation of the Z-transform of a sequence.
This is the discrete analogue of the Laplace Transform.
<P>
<P>
<A NAME=g40>
<TITLE>Miscellaneous Packages</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Miscellaneous Packages</B><MENU>
<LI><A HREF=r38_0632.html>Miscellaneous Packages introduction</A><P>
<LI><A HREF=r38_0633.html>ALGINT package</A><P>
<LI><A HREF=r38_0634.html>APPLYSYM package</A><P>
<LI><A HREF=r38_0635.html>ARNUM package</A><P>
<LI><A HREF=r38_0636.html>ASSIST package</A><P>
<LI><A HREF=r38_0637.html>AVECTOR package</A><P>
<LI><A HREF=r38_0638.html>BOOLEAN package</A><P>
<LI><A HREF=r38_0639.html>CALI package</A><P>
<LI><A HREF=r38_0640.html>CAMAL package</A><P>
<LI><A HREF=r38_0641.html>CHANGEVR package</A><P>
<LI><A HREF=r38_0642.html>COMPACT package</A><P>
<LI><A HREF=r38_0643.html>CRACK package</A><P>
<LI><A HREF=r38_0644.html>CVIT package</A><P>
<LI><A HREF=r38_0645.html>DEFINT package</A><P>
<LI><A HREF=r38_0646.html>DESIR package</A><P>
<LI><A HREF=r38_0647.html>DFPART package</A><P>
<LI><A HREF=r38_0648.html>DUMMY package</A><P>
<LI><A HREF=r38_0649.html>EXCALC package</A><P>
<LI><A HREF=r38_0650.html>FPS package</A><P>
<LI><A HREF=r38_0651.html>FIDE package</A><P>
<LI><A HREF=r38_0652.html>GENTRAN package</A><P>
<LI><A HREF=r38_0653.html>IDEALS package</A><P>
<LI><A HREF=r38_0654.html>INEQ package</A><P>
<LI><A HREF=r38_0655.html>INVBASE package</A><P>
<LI><A HREF=r38_0656.html>LAPLACE package</A><P>
<LI><A HREF=r38_0657.html>LIE package</A><P>
<LI><A HREF=r38_0658.html>MODSR package</A><P>
<LI><A HREF=r38_0659.html>NCPOLY package</A><P>
<LI><A HREF=r38_0660.html>ORTHOVEC package</A><P>
<LI><A HREF=r38_0661.html>PHYSOP package</A><P>
<LI><A HREF=r38_0662.html>PM package</A><P>
<LI><A HREF=r38_0663.html>RANDPOLY package</A><P>
<LI><A HREF=r38_0664.html>REACTEQN package</A><P>
<LI><A HREF=r38_0665.html>RESET package</A><P>
<LI><A HREF=r38_0666.html>RESIDUE package</A><P>
<LI><A HREF=r38_0667.html>RLFI package</A><P>
<LI><A HREF=r38_0668.html>SCOPE package</A><P>
<LI><A HREF=r38_0669.html>SETS package</A><P>
<LI><A HREF=r38_0670.html>SPDE package</A><P>
<LI><A HREF=r38_0671.html>SYMMETRY package</A><P>
<LI><A HREF=r38_0672.html>TPS package</A><P>
<LI><A HREF=r38_0673.html>TRI package</A><P>
<LI><A HREF=r38_0674.html>TRIGSIMP package</A><P>
<LI><A HREF=r38_0675.html>XCOLOR package</A><P>
<LI><A HREF=r38_0676.html>XIDEAL package</A><P>
<LI><A HREF=r38_0677.html>WU package</A><P>
<LI><A HREF=r38_0678.html>ZEILBERG package</A><P>
<LI><A HREF=r38_0679.html>ZTRANS package</A><P>
</MENU>
<A NAME=ED>
<TITLE>ED</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>ED</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
The <em>ed</em> command invokes a simple line editor for REDUCE input
statements.
<P>
<P>
<P> <H3>
syntax: </H3>
<em>ed</em><integer> or <em>ed</em>
<P>
<P>
<P>
<em>ed</em>called with no argument edits the last input statement. If
<integer> is greater than or equal to the current line number, an error
message is printed. Reenter a proper <em>ed</em> command or return to the
top level with a semicolon.
<P>
<P>
The editor formats REDUCE's version of the desired input statement,
dividing it into lines at semicolons and dollar signs. The statement is
printed at the beginning of the edit session. The editor works on one
line at a time, and has a pointer (shown by <em>^</em>) to the current
character of that line. When the session begins, the pointer is at the
left hand side of the first line. The editing prompt is <em>></em>.
<P>
<P>
The following commands are available. They may be entered in either upper
or lower case. All commands are activated by the carriage return, which
also prints out the current line after changes. Several commands can be
placed on a single line, except that commands terminated by an <em>ESC</em>
must be the last command before the carriage return.
<P>
<P>
_ _ _ b
Move pointer to beginning of current line.
<P>
<P>
_ _ _ d<digit>
Delete current character and next (digit-1) characters. An error message
is printed if anything other than a single digit follows d. If there are
fewer than <digit> characters left on the line, all but the final
dollar sign or semicolon is removed. To delete a line completely, use the
k command.
<P>
<P>
_ _ _ e
End the current session, causing the edited expression to be reparsed by
REDUCE.
<P>
<P>
_ _ _ f<char>
Find the next occurrence of the character <char> to the right of the
pointer on the current line and move the pointer to it. If the character is
not found, an error message is printed and the pointer remains in its
original position. Other lines are not searched. The f command is not
case-sensitive.
<P>
<P>
_ _ _ i<string><em>ESC</em>
Insert <string> in front of pointer. The <em>ESC</em> key is your
delimiter for the input string. No other command may follow this one on
the same line.
<P>
<P>
_ _ _ k
Kill rest of the current line, including the semicolon or dollar sign
terminator. If there are characters remaining on the current line, and it
is the last line of the input statement, a semicolon is added to the line
as a terminator for REDUCE. If the current line is now empty, one of the
following actions is performed: If there is a following line, it becomes
the current line and the pointer is placed at its first character. If the
current line was the final line of the statement, and there is a previous
line, the previous line becomes the current line. If the current line was
the only line of the statement, and it is empty, a single semicolon is
inserted for REDUCE to parse.
<P>
<P>
_ _ _ l
Finish editing this line and move to the last previous line. An error message
is printed if there is no previous line.
<P>
<P>
_ _ _ n
Finish editing this line and move to the next line. An error message is
printed if there is no next line.
<P>
<P>
_ _ _ p
Print out all the lines of the statement. Then a dotted line is printed, and
the current line is reprinted, with the pointer under it.
<P>
<P>
_ _ _ q
Quit the editing session without saving the changes. If a semicolon is
entered after q, a new line prompt is given, otherwise REDUCE prompts you
for another command. Whatever you type in to the prompt appearing after
the q is entered is stored as the input for the line number in which you
called the edit. Thus if you enter a semicolon, neither
<A HREF=r38_0232.html>input</A>
<em>ed</em> will find anything under the current number.
<P>
<P>
_ _ _ r<char>
Replace the character at the pointer by <char>.
<P>
<P>
_ _ _ s<string><em>ESC</em>
Search for the first occurrence of <string> to the right of the
pointer on the current line and move the pointer to its first character.
The <em>ESC</em> key is your delimiter for the input string. The s function
does not search other lines of the statement. If the string is not found,
an error message is printed and the pointer remains in its original
position. The s command is not case-sensitive. No other command may
follow this one on the same line.
<P>
<P>
_ _ _ x <or space>
Move the pointer one character to the right. If the pointer is already at
the end of the line, an error message is printed.
<P>
<P>
_ _ _ - <(minus)>
Move the pointer one character to the left. If the pointer is already at the
beginning of the line, an error message is printed.
<P>
<P>
_ _ _ ?
Display the Help menu, showing the commands and their actions.
<P>
<P>
<P> <H3>
examples: </H3>
<P><PRE><TT></TT></PRE><P>(Line numbers are shown in the following examples)<P>
<PRE><TT>
2: >>x**2 + y;
X^{2} + Y
3: >>ed 2;
X**2 + Y;
^
For help, type '?'
?- (Enter three spaces and key{Return})
X**2 + Y;
^
?- r5
X**5 + Y;
^
?- fY
X**5 + Y;
^
?- iabc (Terminate with key{ESC} and key{Return})
X**5 + abcY;
^
?- ----
X**5 + abcY;
^
?- fbd2
X**5 + aY;
^
?- b
X**5 + aY;
^
?- e
AY + X^{5}
4: >>procedure dumb(a);
>>write a;
DUMB
5: >>dumb(17);
17
6: >>ed 4;
PROCEDURE DUMB (A);
^
WRITE A;
?- fArBn
WRITE A;
^
?- ibegin scalar a; a := b + 10; (Type a space, key{ESC}, and key{Return})
begin scalar a; a := b + 10; WRITE A;
?- f;i end key{ESC}, key{Return}
begin scalar b; b := a + 10; WRITE A end;
^
?- p
PROCEDURE DUMB (B);
begin scalar b; b := a + 10; WRITE A end;
- - - - - - - - - -
begin scalar b; b := a + 10; WRITE A end;
^
?- e
DUMB
7: >>dumb(17);
27
8: >>
</TT></PRE><P>
<P>
<P>
Note that REDUCE reparsed the procedure <em>dumb</em> and updated the
definition.
<P>
<P>
Since REDUCE divides the expression to be edited into lines at semicolons or
dollar sign terminators, some lines may occupy more than one line of screen
space. If the pointer is directly beneath the last line of text, it
refers to the top line of text. If there is a blank line between the
last line of text and the pointer, it refers to the second line
of text, and likewise for cases of greater than two lines of text. In other
words, the entire REDUCE statement up to the next terminator is printed, even
if it runs to several lines, then the pointer line is printed.
<P>
<P>
You can insert new statements which contain semicolons of their own into the
current line. They are run into the current line where you placed them
until you edit the statement again. REDUCE will understand the set of
statements if the syntax is correct.
<P>
<P>
If you leave out needed closing brackets when you exit the editor, a message
is printed allowing you to redo the edit (you can edit the previous line
number and return to where you were). If you leave out a closing
double-quotation mark, an error message is printed, and the editing must be
redone from the original version; the edited version has been destroyed.
Most syntax errors which you inadvertently leave in an edited statement are
caught as usual by the REDUCE parser, and you will be able to re-edit the
statement.
<P>
<P>
When the editor processes a previous statement for your editing, escape
characters are removed. Most special characters that you may use in
identifiers are printed in legal fashion, prefixed by the exclamation
point. Be sure to treat the special character and its escape as a pair in
your editing. The characters <em>( ) # ; ' `</em> are different. Since
they have special meaning in Lisp, they are double-escaped in the editor.
It is unwise to use these characters inside identifiers anyway, due to the
probability of confusion.
<P>
<P>
If you see a Lisp error message during editing, the edit has been aborted.
Enter a semicolon and you will see a new line prompt.
<P>
<P>
Since the editor has no dependence on any window system, it can be used if you
are running REDUCE without windows.
<P>
<P>
<P>
<A NAME=EDITDEF>
<TITLE>EDITDEF</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>EDITDEF</B> _ _ _ _ _ _ _ _ _ _ _ _ <B>command</B><P>
<P>
<P>
<P>
The interactive editor
<A HREF=r38_0681.html>ed</A> may be used to edit a user-defined
procedure that has not been compiled.
<P> <H3>
syntax: </H3>
<P>
<P>
<em>editdef</em>(<em>identifier</em>)
<P>
<P>
<P>
where <em>identifier</em> is the name of the procedure. When <em>editdef</em>
is invoked, the procedure definition will be displayed in editing mode,
and may then be edited and redefined on exiting from the editor using
standard
<A HREF=r38_0681.html>ed</A> commands.
<P>
<P>
<A NAME=g41>
<TITLE>Outmoded Operations</TITLE></A>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<B>Outmoded Operations</B><MENU>
<LI><A HREF=r38_0681.html>ED command</A><P>
<LI><A HREF=r38_0682.html>EDITDEF command</A><P>
</MENU><title>r38 search index</title>
<dl compact>
<menu>
<dt>absolute value: <a href=r38_0070.html>ABS</a>
<dt>ABS operator: <a href=r38_0070.html>ABS</a>
<dt>accuracy: <a href=r38_0438.html>ROOTACC</a>
<dt>ACOSH operator: <a href=r38_0237.html>ACOSH</a>
<dt>ACOS operator: <a href=r38_0236.html>ACOS</a>
<dt>ACOTH operator: <a href=r38_0239.html>ACOTH</a>
<dt>ACOT operator: <a href=r38_0238.html>ACOT</a>
<dt>ACSCH operator: <a href=r38_0241.html>ACSCH</a>
<dt>ACSC operator: <a href=r38_0240.html>ACSC</a>
<dt>add columns operator: <a href=r38_0573.html>add columns</a>
<dt>add rows operator: <a href=r38_0574.html>add rows</a>
<dt>add to columns operator: <a href=r38_0575.html>add to columns</a>
<dt>add to rows operator: <a href=r38_0576.html>add to rows</a>
<dt>ADJPREC switch: <a href=r38_0071.html>ADJPREC</a>
<dt>AGM FUNCTION operator: <a href=r38_0482.html>AGM FUNCTION</a>
<dt>Airy Ai operator: <a href=r38_0464.html>Airy Ai</a>
<dt>Airy Aiprime operator: <a href=r38_0466.html>Airy Aiprime</a>
<dt>Airy Bi operator: <a href=r38_0465.html>Airy Bi</a>
<dt>Airy Biprime operator: <a href=r38_0467.html>Airy Biprime</a>
<dt>algebraic: <a href=r38_0008.html>EVAL MODE</a>
<dt>ALGEBRAIC command: <a href=r38_0186.html>ALGEBRAIC</a>
<dt>algebraic numbers: <a href=r38_0635.html>ARNUM</a>
<dt>ALGINT package: <a href=r38_0633.html>ALGINT package</a>
<dt>ALGINT switch: <a href=r38_0265.html>ALGINT</a>
<dt>ALLBRANCH switch: <a href=r38_0266.html>ALLBRANCH</a>
<dt>ALLFAC switch: <a href=r38_0267.html>ALLFAC</a>
<dt>AND operator: <a href=r38_0039.html>AND</a>
<dt>ANTISYMMETRIC declaration: <a href=r38_0187.html>ANTISYMMETRIC</a>
<dt>APPEND operator: <a href=r38_0137.html>APPEND</a>
<dt>APPLYSYM package: <a href=r38_0634.html>APPLYSYM</a>
<dt>approximation: <a href=r38_0144.html>CONTINUED FRACTION</a>
<dt>approximation: <a href=r38_0155.html>INTERPOL</a>
<dt>approximation: <a href=r38_0431.html>Chebyshev fit</a>
<dt>approximation: <a href=r38_0432.html>num fit</a>
<dt>ARBCOMPLEX operator: <a href=r38_0139.html>ARBCOMPLEX</a>
<dt>ARBINT operator: <a href=r38_0138.html>ARBINT</a>
<dt>arbitrary value: <a href=r38_0138.html>ARBINT</a>
<dt>arbitrary value: <a href=r38_0139.html>ARBCOMPLEX</a>
<dt>ARBVARS switch: <a href=r38_0268.html>ARBVARS</a>
<dt>arccosecant: <a href=r38_0240.html>ACSC</a>
<dt>arccosecant: <a href=r38_0241.html>ACSCH</a>
<dt>arccosecant: <a href=r38_0242.html>ASEC</a>
<dt>arccosine: <a href=r38_0236.html>ACOS</a>
<dt>arccotangent: <a href=r38_0238.html>ACOT</a>
<dt>arcsine: <a href=r38_0244.html>ASIN</a>
<dt>arctangent: <a href=r38_0246.html>ATAN</a>
<dt>ARGLENGTH operator: <a href=r38_0140.html>ARGLENGTH</a>
<dt>ARG operator: <a href=r38_0072.html>ARG</a>
<dt>argument: <a href=r38_0140.html>ARGLENGTH</a>
<dt>argument: <a href=r38_0203.html>LISTARGP</a>
<dt>argument: <a href=r38_0303.html>LISTARGS</a>
<dt>arithmetic: <a href=r38_0045.html>EQUATION</a>
<dt>ARITHMETIC OPERATIONS introduction: <a href=r38_0069.html>ARITHMETIC OPERATI
ONS</a>
<dt>ARNUM package: <a href=r38_0635.html>ARNUM</a>
<dt>ARRAY declaration: <a href=r38_0188.html>ARRAY</a>
<dt>ASECH operator: <a href=r38_0243.html>ASECH</a>
<dt>ASEC operator: <a href=r38_0242.html>ASEC</a>
<dt>ASINH operator: <a href=r38_0245.html>ASINH</a>
<dt>ASIN operator: <a href=r38_0244.html>ASIN</a>
<dt>assign: <a href=r38_0064.html>SET</a>
<dt>assign: <a href=r38_0065.html>SETQ</a>
<dt>assign operator: <a href=r38_0024.html>assign</a>
<dt>ASSIST package: <a href=r38_0636.html>ASSIST</a>
<dt>assumptions variable: <a href=r38_0005.html>assumptions</a>
<dt>asterisk operator: <a href=r38_0029.html>asterisk</a>
<dt>ATAN2 operator: <a href=r38_0248.html>ATAN2</a>
<dt>ATANH operator: <a href=r38_0247.html>ATANH</a>
<dt>ATAN operator: <a href=r38_0246.html>ATAN</a>
<dt>augment columns operator: <a href=r38_0577.html>augment columns</a>
<dt>AVECTOR package: <a href=r38_0637.html>AVECTOR</a>
<dt>Axes names concept: <a href=r38_0550.html>Axes names</a>
<dt>BALANCED MOD switch: <a href=r38_0269.html>BALANCED MOD</a>
<dt>band matrix operator: <a href=r38_0578.html>band matrix</a>
<dt>BEGIN command: <a href=r38_0040.html>BEGIN</a>
<dt>BERNOULLI operator: <a href=r38_0446.html>BERNOULLI</a>
<dt>BERNOULLIP operator: <a href=r38_0447.html>BERNOULLIP</a>
<dt>BESSELI operator: <a href=r38_0456.html>BESSELI</a>
<dt>BESSELJ operator: <a href=r38_0452.html>BESSELJ</a>
<dt>BESSELK operator: <a href=r38_0457.html>BESSELK</a>
<dt>BESSELY operator: <a href=r38_0453.html>BESSELY</a>
<dt>BETA operator: <a href=r38_0493.html>BETA</a>
<dt>BFSPACE switch: <a href=r38_0270.html>BFSPACE</a>
<dt>BINOMIAL operator: <a href=r38_0521.html>BINOMIAL</a>
<dt>block command: <a href=r38_0041.html>block</a>
<dt>block matrix operator: <a href=r38_0579.html>block matrix</a>
<dt>boolean expressions: <a href=r38_0638.html>BOOLEAN</a>
<dt>BOOLEAN package: <a href=r38_0638.html>BOOLEAN</a>
<dt>boolean value concept: <a href=r38_0109.html>boolean value</a>
<dt>bounds operator: <a href=r38_0430.html>bounds</a>
<dt>Buchberger algorithm: <a href=r38_0351.html>Groebner bases</a>
<dt>Buchberger algorithm: <a href=r38_0368.html>groebner</a>
<dt>BYE command: <a href=r38_0124.html>BYE</a>
<dt>CALI package: <a href=r38_0639.html>CALI</a>
<dt>CAMAL package: <a href=r38_0640.html>CAMAL</a>
<dt>CARD NO variable: <a href=r38_0006.html>CARD NO</a>
<dt>caret operator: <a href=r38_0032.html>caret</a>
<dt>Catalan's constant: <a href=r38_0445.html>Constants</a>
<dt>CEILING operator: <a href=r38_0073.html>CEILING</a>
<dt>celestial mechanics: <a href=r38_0640.html>CAMAL</a>
<dt>CHANGEVR package: <a href=r38_0641.html>CHANGEVR</a>
<dt>character: <a href=r38_0320.html>RAISE</a>
<dt>char matrix operator: <a href=r38_0580.html>char matrix</a>
<dt>char poly operator: <a href=r38_0581.html>char poly</a>
<dt>Chebyshev fit concept: <a href=r38_0431.html>Chebyshev fit</a>
<dt>ChebyshevT operator: <a href=r38_0500.html>ChebyshevT</a>
<dt>ChebyshevU operator: <a href=r38_0501.html>ChebyshevU</a>
<dt>chemical reaction: <a href=r38_0664.html>REACTEQN</a>
<dt>Chi operator: <a href=r38_0514.html>Chi</a>
<dt>cholesky operator: <a href=r38_0582.html>cholesky</a>
<dt>CHOOSE operator: <a href=r38_0074.html>CHOOSE</a>
<dt>Ci operator: <a href=r38_0513.html>Ci</a>
<dt>CLEAR command: <a href=r38_0189.html>CLEAR</a>
<dt>CLEARRULES command: <a href=r38_0190.html>CLEARRULES</a>
<dt>Clebsch Gordan operator: <a href=r38_0526.html>Clebsch Gordan</a>
<dt>close: <a href=r38_0234.html>SHUT</a>
<dt>code generation: <a href=r38_0652.html>GENTRAN</a>
<dt>code generation: <a href=r38_0668.html>SCOPE</a>
<dt>coefficient: <a href=r38_0141.html>COEFF</a>
<dt>coefficient: <a href=r38_0142.html>COEFFN</a>
<dt>coefficient: <a href=r38_0156.html>LCOF</a>
<dt>coeff matrix operator: <a href=r38_0583.html>coeff matrix</a>
<dt>COEFFN operator: <a href=r38_0142.html>COEFFN</a>
<dt>COEFF operator: <a href=r38_0141.html>COEFF</a>
<dt>COFACTOR operator: <a href=r38_0341.html>COFACTOR</a>
<dt>column dim operator: <a href=r38_0584.html>column dim</a>
<dt>COMBINEEXPT switch: <a href=r38_0271.html>COMBINEEXPT</a>
<dt>COMBINELOGS switch: <a href=r38_0272.html>COMBINELOGS</a>
<dt>command: <a href=r38_0020.html>semicolon</a>
<dt>command: <a href=r38_0021.html>dollar</a>
<dt>command: <a href=r38_0022.html>percent</a>
<dt>command: <a href=r38_0038.html>group</a>
<dt>command: <a href=r38_0040.html>BEGIN</a>
<dt>command: <a href=r38_0041.html>block</a>
<dt>command: <a href=r38_0042.html>COMMENT</a>
<dt>command: <a href=r38_0044.html>END</a>
<dt>command: <a href=r38_0047.html>FOR</a>
<dt>command: <a href=r38_0048.html>FOREACH</a>
<dt>command: <a href=r38_0050.html>GOTO</a>
<dt>command: <a href=r38_0052.html>IF</a>
<dt>command: <a href=r38_0055.html>PROCEDURE</a>
<dt>command: <a href=r38_0056.html>REPEAT</a>
<dt>command: <a href=r38_0058.html>RETURN</a>
<dt>command: <a href=r38_0104.html>SETMOD</a>
<dt>command: <a href=r38_0124.html>BYE</a>
<dt>command: <a href=r38_0125.html>CONT</a>
<dt>command: <a href=r38_0126.html>DISPLAY</a>
<dt>command: <a href=r38_0127.html>LOAD PACKAGE</a>
<dt>command: <a href=r38_0128.html>PAUSE</a>
<dt>command: <a href=r38_0129.html>QUIT</a>
<dt>command: <a href=r38_0131.html>REDERR</a>
<dt>command: <a href=r38_0132.html>RETRY</a>
<dt>command: <a href=r38_0133.html>SAVEAS</a>
<dt>command: <a href=r38_0134.html>SHOWTIME</a>
<dt>command: <a href=r38_0135.html>WRITE</a>
<dt>command: <a href=r38_0164.html>MKID</a>
<dt>command: <a href=r38_0186.html>ALGEBRAIC</a>
<dt>command: <a href=r38_0189.html>CLEAR</a>
<dt>command: <a href=r38_0190.html>CLEARRULES</a>
<dt>command: <a href=r38_0191.html>DEFINE</a>
<dt>command: <a href=r38_0195.html>FORALL</a>
<dt>command: <a href=r38_0199.html>LET</a>
<dt>command: <a href=r38_0202.html>LISP</a>
<dt>command: <a href=r38_0205.html>MATCH</a>
<dt>command: <a href=r38_0209.html>OFF</a>
<dt>command: <a href=r38_0210.html>ON</a>
<dt>command: <a href=r38_0221.html>SYMBOLIC</a>
<dt>command: <a href=r38_0226.html>WEIGHT</a>
<dt>command: <a href=r38_0228.html>WHILE</a>
<dt>command: <a href=r38_0229.html>WTLEVEL</a>
<dt>command: <a href=r38_0231.html>IN</a>
<dt>command: <a href=r38_0232.html>INPUT</a>
<dt>command: <a href=r38_0233.html>OUT</a>
<dt>command: <a href=r38_0234.html>SHUT</a>
<dt>command: <a href=r38_0414.html>MASS</a>
<dt>command: <a href=r38_0415.html>MSHELL</a>
<dt>command: <a href=r38_0419.html>VECDIM</a>
<dt>command: <a href=r38_0552.html>PLOT</a>
<dt>command: <a href=r38_0553.html>PLOTRESET</a>
<dt>command: <a href=r38_0681.html>ED</a>
<dt>command: <a href=r38_0682.html>EDITDEF</a>
<dt>COMMENT command: <a href=r38_0042.html>COMMENT</a>
<dt>commutative: <a href=r38_0206.html>NONCOM</a>
<dt>commutative algebra: <a href=r38_0639.html>CALI</a>
<dt>commutative algebra: <a href=r38_0653.html>IDEALS</a>
<dt>COMPACT package: <a href=r38_0642.html>COMPACT</a>
<dt>companion operator: <a href=r38_0585.html>companion</a>
<dt>compiler: <a href=r38_0273.html>COMP</a>
<dt>complementary error function: <a href=r38_0516.html>erfc</a>
<dt>complex: <a href=r38_0011.html>I</a>
<dt>complex: <a href=r38_0072.html>ARG</a>
<dt>complex: <a href=r38_0095.html>NORM</a>
<dt>complex: <a href=r38_0143.html>CONJ</a>
<dt>complex: <a href=r38_0153.html>IMPART</a>
<dt>complex: <a href=r38_0173.html>REPART</a>
<dt>complex: <a href=r38_0324.html>RATIONALIZE</a>
<dt>complex: <a href=r38_0441.html>ROOTSCOMPLEX</a>
<dt>complex: <a href=r38_0442.html>ROOTSREAL</a>
<dt>COMPLEX switch: <a href=r38_0274.html>COMPLEX</a>
<dt>composite structure: <a href=r38_0163.html>MAP</a>
<dt>COMP switch: <a href=r38_0273.html>COMP</a>
<dt>concept: <a href=r38_0109.html>boolean value</a>
<dt>concept: <a href=r38_0112.html>false</a>
<dt>concept: <a href=r38_0122.html>TRUE</a>
<dt>concept: <a href=r38_0352.html>Ideal Parameters</a>
<dt>concept: <a href=r38_0356.html>lex term order</a>
<dt>concept: <a href=r38_0357.html>gradlex term order</a>
<dt>concept: <a href=r38_0358.html>revgradlex term order</a>
<dt>concept: <a href=r38_0359.html>gradlexgradlex term order</a>
<dt>concept: <a href=r38_0360.html>gradlexrevgradlex term order</a>
<dt>concept: <a href=r38_0361.html>lexgradlex term order</a>
<dt>concept: <a href=r38_0362.html>lexrevgradlex term order</a>
<dt>concept: <a href=r38_0363.html>weighted term order</a>
<dt>concept: <a href=r38_0364.html>graded term order</a>
<dt>concept: <a href=r38_0365.html>matrix term order</a>
<dt>concept: <a href=r38_0401.html>Module</a>
<dt>concept: <a href=r38_0424.html>numeric accuracy</a>
<dt>concept: <a href=r38_0431.html>Chebyshev fit</a>
<dt>concept: <a href=r38_0445.html>Constants</a>
<dt>concept: <a href=r38_0550.html>Axes names</a>
<dt>Confluent Hypergeometric function: <a href=r38_0460.html>KummerM</a>
<dt>Confluent Hypergeometric function: <a href=r38_0461.html>KummerU</a>
<dt>Confluent Hypergeometric function: <a href=r38_0462.html>WhittakerW</a>
<dt>CONJ operator: <a href=r38_0143.html>CONJ</a>
<dt>conjugate: <a href=r38_0143.html>CONJ</a>
<dt>CONS operator: <a href=r38_0043.html>CONS</a>
<dt>constant: <a href=r38_0007.html>E</a>
<dt>constant: <a href=r38_0011.html>I</a>
<dt>constant: <a href=r38_0012.html>INFINITY</a>
<dt>constant: <a href=r38_0014.html>NIL</a>
<dt>constant: <a href=r38_0015.html>PI</a>
<dt>constant: <a href=r38_0018.html>T</a>
<dt>Constants concept: <a href=r38_0445.html>Constants</a>
<dt>CONT command: <a href=r38_0125.html>CONT</a>
<dt>CONTINUED FRACTION operator: <a href=r38_0144.html>CONTINUED FRACTION</a>
<dt>contour switch: <a href=r38_0561.html>contour</a>
<dt>copy into operator: <a href=r38_0586.html>copy into</a>
<dt>cosecant: <a href=r38_0253.html>CSC</a>
<dt>COSH operator: <a href=r38_0250.html>COSH</a>
<dt>cosine integral function: <a href=r38_0513.html>Ci</a>
<dt>COS operator: <a href=r38_0249.html>COS</a>
<dt>COTH operator: <a href=r38_0252.html>COTH</a>
<dt>COT operator: <a href=r38_0251.html>COT</a>
<dt>CRACK package: <a href=r38_0643.html>CRACK</a>
<dt>CRAMER switch: <a href=r38_0276.html>CRAMER</a>
<dt>CREF switch: <a href=r38_0275.html>CREF</a>
<dt>cross product: <a href=r38_0637.html>AVECTOR</a>
<dt>cross product: <a href=r38_0660.html>ORTHOVEC</a>
<dt>cross reference: <a href=r38_0275.html>CREF</a>
<dt>CSCH operator: <a href=r38_0254.html>CSCH</a>
<dt>CSC operator: <a href=r38_0253.html>CSC</a>
<dt>curl: <a href=r38_0660.html>ORTHOVEC</a>
<dt>CVIT package: <a href=r38_0644.html>CVIT</a>
<dt>dd groebner operator: <a href=r38_0383.html>dd groebner</a>
<dt>declaration: <a href=r38_0187.html>ANTISYMMETRIC</a>
<dt>declaration: <a href=r38_0188.html>ARRAY</a>
<dt>declaration: <a href=r38_0192.html>DEPEND</a>
<dt>declaration: <a href=r38_0193.html>EVEN</a>
<dt>declaration: <a href=r38_0194.html>FACTOR declaration</a>
<dt>declaration: <a href=r38_0196.html>INFIX</a>
<dt>declaration: <a href=r38_0197.html>INTEGER</a>
<dt>declaration: <a href=r38_0198.html>KORDER</a>
<dt>declaration: <a href=r38_0200.html>LINEAR</a>
<dt>declaration: <a href=r38_0201.html>LINELENGTH</a>
<dt>declaration: <a href=r38_0203.html>LISTARGP</a>
<dt>declaration: <a href=r38_0204.html>NODEPEND</a>
<dt>declaration: <a href=r38_0206.html>NONCOM</a>
<dt>declaration: <a href=r38_0207.html>NONZERO</a>
<dt>declaration: <a href=r38_0208.html>ODD</a>
<dt>declaration: <a href=r38_0211.html>OPERATOR</a>
<dt>declaration: <a href=r38_0212.html>ORDER</a>
<dt>declaration: <a href=r38_0213.html>PRECEDENCE</a>
<dt>declaration: <a href=r38_0214.html>PRECISION</a>
<dt>declaration: <a href=r38_0215.html>PRINT PRECISION</a>
<dt>declaration: <a href=r38_0216.html>REAL</a>
<dt>declaration: <a href=r38_0217.html>REMFAC</a>
<dt>declaration: <a href=r38_0218.html>SCALAR</a>
<dt>declaration: <a href=r38_0219.html>SCIENTIFIC NOTATION</a>
<dt>declaration: <a href=r38_0220.html>SHARE</a>
<dt>declaration: <a href=r38_0222.html>SYMMETRIC</a>
<dt>declaration: <a href=r38_0223.html>TR</a>
<dt>declaration: <a href=r38_0224.html>UNTR</a>
<dt>declaration: <a href=r38_0225.html>VARNAME</a>
<dt>declaration: <a href=r38_0345.html>MATRIX</a>
<dt>declaration: <a href=r38_0413.html>INDEX</a>
<dt>declaration: <a href=r38_0416.html>NOSPUR</a>
<dt>declaration: <a href=r38_0417.html>REMIND</a>
<dt>declaration: <a href=r38_0418.html>SPUR</a>
<dt>declaration: <a href=r38_0420.html>VECTOR</a>
<dt>DECOMPOSE operator: <a href=r38_0145.html>DECOMPOSE</a>
<dt>decomposition: <a href=r38_0046.html>FIRST</a>
<dt>decomposition: <a href=r38_0057.html>REST</a>
<dt>decomposition: <a href=r38_0063.html>SECOND</a>
<dt>decomposition: <a href=r38_0066.html>THIRD</a>
<dt>decomposition: <a href=r38_0145.html>DECOMPOSE</a>
<dt>decomposition: <a href=r38_0169.html>PART</a>
<dt>decomposition: <a href=r38_0181.html>STRUCTR</a>
<dt>DEFINE command: <a href=r38_0191.html>DEFINE</a>
<dt>definite integration: <a href=r38_0645.html>DEFINT</a>
<dt>DEFINT package: <a href=r38_0645.html>DEFINT</a>
<dt>DEFN switch: <a href=r38_0277.html>DEFN</a>
<dt>DEG2DMS operator: <a href=r38_0075.html>DEG2DMS</a>
<dt>DEG2RAD operator: <a href=r38_0076.html>DEG2RAD</a>
<dt>DEG operator: <a href=r38_0146.html>DEG</a>
<dt>degree: <a href=r38_0010.html>HIGH POW</a>
<dt>degree: <a href=r38_0013.html>LOW POW</a>
<dt>degree: <a href=r38_0146.html>DEG</a>
<dt>degrees: <a href=r38_0075.html>DEG2DMS</a>
<dt>degrees: <a href=r38_0076.html>DEG2RAD</a>
<dt>degrees: <a href=r38_0079.html>DMS2DEG</a>
<dt>degrees: <a href=r38_0080.html>DMS2RAD</a>
<dt>degrees: <a href=r38_0099.html>RAD2DEG</a>
<dt>degrees: <a href=r38_0100.html>RAD2DMS</a>
<dt>DEMO switch: <a href=r38_0278.html>DEMO</a>
<dt>denominator: <a href=r38_0147.html>DEN</a>
<dt>DEN operator: <a href=r38_0147.html>DEN</a>
<dt>depend: <a href=r38_0204.html>NODEPEND</a>
<dt>DEPEND declaration: <a href=r38_0192.html>DEPEND</a>
<dt>dependency: <a href=r38_0192.html>DEPEND</a>
<dt>derivative: <a href=r38_0148.html>DF</a>
<dt>derivative: <a href=r38_0279.html>DFPRINT</a>
<dt>derivative: <a href=r38_0310.html>NOARG</a>
<dt>DESIR package: <a href=r38_0646.html>DESIR</a>
<dt>determinant: <a href=r38_0342.html>DET</a>
<dt>DET operator: <a href=r38_0342.html>DET</a>
<dt>DF operator: <a href=r38_0148.html>DF</a>
<dt>DFPART package: <a href=r38_0647.html>DFPART</a>
<dt>DFPRINT switch: <a href=r38_0279.html>DFPRINT</a>
<dt>diagonal operator: <a href=r38_0587.html>diagonal</a>
<dt>DIFFERENCE operator: <a href=r38_0077.html>DIFFERENCE</a>
<dt>differential calculus: <a href=r38_0649.html>EXCALC</a>
<dt>differential equation: <a href=r38_0167.html>ODESOLVE</a>
<dt>differential equation: <a href=r38_0643.html>CRACK</a>
<dt>differential equation: <a href=r38_0646.html>DESIR</a>
<dt>differential equation: <a href=r38_0670.html>SPDE</a>
<dt>differential equations: <a href=r38_0634.html>APPLYSYM</a>
<dt>differential form: <a href=r38_0649.html>EXCALC</a>
<dt>dilogarithm function: <a href=r38_0078.html>DILOG</a>
<dt>dilogarithm function: <a href=r38_0497.html>DILOG extended</a>
<dt>DILOG extended operator: <a href=r38_0497.html>DILOG extended</a>
<dt>DILOG operator: <a href=r38_0078.html>DILOG</a>
<dt>Dirac algebra: <a href=r38_0644.html>CVIT</a>
<dt>DISPLAY command: <a href=r38_0126.html>DISPLAY</a>
<dt>distributive polynomials: <a href=r38_0353.html>Term order</a>
<dt>distributive polynomials: <a href=r38_0404.html>gsort</a>
<dt>distributive polynomials: <a href=r38_0405.html>gsplit</a>
<dt>distributive polynomials: <a href=r38_0406.html>gspoly</a>
<dt>div: <a href=r38_0660.html>ORTHOVEC</a>
<dt>DIV switch: <a href=r38_0280.html>DIV</a>
<dt>DMS2DEG operator: <a href=r38_0079.html>DMS2DEG</a>
<dt>DMS2RAD operator: <a href=r38_0080.html>DMS2RAD</a>
<dt>dollar command: <a href=r38_0021.html>dollar</a>
<dt>dot operator: <a href=r38_0023.html>dot</a>
<dt>dot product: <a href=r38_0637.html>AVECTOR</a>
<dt>dot product: <a href=r38_0660.html>ORTHOVEC</a>
<dt>DUMMY package: <a href=r38_0648.html>DUMMY</a>
<dt>dummy variable: <a href=r38_0648.html>DUMMY</a>
<dt>ECHO switch: <a href=r38_0281.html>ECHO</a>
<dt>E constant: <a href=r38_0007.html>E</a>
<dt>ED command: <a href=r38_0681.html>ED</a>
<dt>EDITDEF command: <a href=r38_0682.html>EDITDEF</a>
<dt>eigenvalue: <a href=r38_0344.html>MATEIGEN</a>
<dt>Ei operator: <a href=r38_0517.html>Ei</a>
<dt>EllipticE operator: <a href=r38_0487.html>EllipticE</a>
<dt>EllipticF operator: <a href=r38_0484.html>EllipticF</a>
<dt>EllipticK operator: <a href=r38_0485.html>EllipticK</a>
<dt>EllipticKprime operator: <a href=r38_0486.html>EllipticKprime</a>
<dt>EllipticTHETA operator: <a href=r38_0488.html>EllipticTHETA</a>
<dt>else: <a href=r38_0052.html>IF</a>
<dt>END command: <a href=r38_0044.html>END</a>
<dt>EPS operator: <a href=r38_0411.html>EPS</a>
<dt>equal: <a href=r38_0045.html>EQUATION</a>
<dt>EQUAL operator: <a href=r38_0110.html>EQUAL</a>
<dt>equalsign operator: <a href=r38_0025.html>equalsign</a>
<dt>equation: <a href=r38_0110.html>EQUAL</a>
<dt>equation: <a href=r38_0158.html>LHS</a>
<dt>equation: <a href=r38_0175.html>RHS</a>
<dt>equation: <a href=r38_0283.html>EVALLHSEQP</a>
<dt>equation solving: <a href=r38_0179.html>SOLVE</a>
<dt>equation solving: <a href=r38_0427.html>num solve</a>
<dt>equation system: <a href=r38_0179.html>SOLVE</a>
<dt>equation system: <a href=r38_0427.html>num solve</a>
<dt>EQUATION type: <a href=r38_0045.html>EQUATION</a>
<dt>erfc operator: <a href=r38_0516.html>erfc</a>
<dt>ERF extended operator: <a href=r38_0515.html>ERF extended</a>
<dt>erfi operator: <a href=r38_0532.html>erfi</a>
<dt>ERF operator: <a href=r38_0255.html>ERF</a>
<dt>ERRCONT switch: <a href=r38_0282.html>ERRCONT</a>
<dt>error function: <a href=r38_0255.html>ERF</a>
<dt>error function: <a href=r38_0515.html>ERF extended</a>
<dt>error function: <a href=r38_0516.html>erfc</a>
<dt>error handling: <a href=r38_0131.html>REDERR</a>
<dt>error handling: <a href=r38_0282.html>ERRCONT</a>
<dt>EULER operator: <a href=r38_0448.html>EULER</a>
<dt>EULERP operator: <a href=r38_0449.html>EULERP</a>
<dt>Euler's constant: <a href=r38_0445.html>Constants</a>
<dt>Euler's constant: <a href=r38_0494.html>PSI</a>
<dt>EVALLHSEQP switch: <a href=r38_0283.html>EVALLHSEQP</a>
<dt>EVAL MODE variable: <a href=r38_0008.html>EVAL MODE</a>
<dt>evaluation: <a href=r38_0186.html>ALGEBRAIC</a>
<dt>EVEN declaration: <a href=r38_0193.html>EVEN</a>
<dt>EVENP operator: <a href=r38_0111.html>EVENP</a>
<dt>EXCALC package: <a href=r38_0649.html>EXCALC</a>
<dt>EXPAND CASES operator: <a href=r38_0149.html>EXPAND CASES</a>
<dt>EXPANDLOGS switch: <a href=r38_0285.html>EXPANDLOGS</a>
<dt>exponential function: <a href=r38_0256.html>EXP</a>
<dt>exponential integral function: <a href=r38_0517.html>Ei</a>
<dt>exponent simplification: <a href=r38_0271.html>COMBINEEXPT</a>
<dt>EXP operator: <a href=r38_0256.html>EXP</a>
<dt>EXPREAD operator: <a href=r38_0150.html>EXPREAD</a>
<dt>EXP switch: <a href=r38_0284.html>EXP switch</a>
<dt>EXPT operator: <a href=r38_0085.html>EXPT</a>
<dt>extend operator: <a href=r38_0588.html>extend</a>
<dt>exterior calculus: <a href=r38_0649.html>EXCALC</a>
<dt>EZGCD switch: <a href=r38_0286.html>EZGCD</a>
<dt>factor: <a href=r38_0217.html>REMFAC</a>
<dt>FACTOR declaration: <a href=r38_0194.html>FACTOR declaration</a>
<dt>FACTORIAL operator: <a href=r38_0081.html>FACTORIAL</a>
<dt>factorize: <a href=r38_0296.html>IFACTOR</a>
<dt>factorize: <a href=r38_0301.html>LIMITEDFACTORS</a>
<dt>factorize: <a href=r38_0315.html>OVERVIEW</a>
<dt>factorize: <a href=r38_0334.html>TRALLFAC</a>
<dt>factorize: <a href=r38_0335.html>TRFAC</a>
<dt>FACTORIZE operator: <a href=r38_0151.html>FACTORIZE</a>
<dt>FACTOR switch: <a href=r38_0287.html>FACTOR</a>
<dt>FAILHARD switch: <a href=r38_0288.html>FAILHARD</a>
<dt>false: <a href=r38_0014.html>NIL</a>
<dt>false: <a href=r38_0122.html>TRUE</a>
<dt>false concept: <a href=r38_0112.html>false</a>
<dt>fast la switch: <a href=r38_0572.html>fast la</a>
<dt>Faugere-Gianni-Lazard-Mora algorithm: <a href=r38_0351.html>Groebner bases
</a>
<dt>FIDE package: <a href=r38_0651.html>FIDE</a>
<dt>find companion operator: <a href=r38_0589.html>find companion</a>
<dt>FIRST operator: <a href=r38_0046.html>FIRST</a>
<dt>firstroot: <a href=r38_0434.html>Roots Package</a>
<dt>FIX operator: <a href=r38_0082.html>FIX</a>
<dt>FIXP operator: <a href=r38_0083.html>FIXP</a>
<dt>Fletcher Reeves: <a href=r38_0426.html>num min</a>
<dt>floating point: <a href=r38_0214.html>PRECISION</a>
<dt>floating point: <a href=r38_0215.html>PRINT PRECISION</a>
<dt>floating point: <a href=r38_0219.html>SCIENTIFIC NOTATION</a>
<dt>floating point: <a href=r38_0270.html>BFSPACE</a>
<dt>floating point: <a href=r38_0328.html>ROUNDALL</a>
<dt>floating point: <a href=r38_0330.html>ROUNDED</a>
<dt>FLOOR operator: <a href=r38_0084.html>FLOOR</a>
<dt>FORALL command: <a href=r38_0195.html>FORALL</a>
<dt>FOR command: <a href=r38_0047.html>FOR</a>
<dt>FOREACH command: <a href=r38_0048.html>FOREACH</a>
<dt>FORTRAN: <a href=r38_0006.html>CARD NO</a>
<dt>FORTRAN: <a href=r38_0009.html>FORT WIDTH</a>
<dt>FORTRAN: <a href=r38_0289.html>FORT</a>
<dt>FORTRAN: <a href=r38_0290.html>FORTUPPER</a>
<dt>FORTRAN: <a href=r38_0652.html>GENTRAN</a>
<dt>FORT switch: <a href=r38_0289.html>FORT</a>
<dt>FORTUPPER switch: <a href=r38_0290.html>FORTUPPER</a>
<dt>FORT WIDTH variable: <a href=r38_0009.html>FORT WIDTH</a>
<dt>Fourier series: <a href=r38_0640.html>CAMAL</a>
<dt>FPS package: <a href=r38_0650.html>FPS</a>
<dt>FREEOF operator: <a href=r38_0113.html>FREEOF</a>
<dt>Free Variable type: <a href=r38_0061.html>Free Variable</a>
<dt>Fresnel C operator: <a href=r38_0518.html>Fresnel C</a>
<dt>Fresnel S operator: <a href=r38_0519.html>Fresnel S</a>
<dt>Frobenius operator: <a href=r38_0627.html>Frobenius</a>
<dt>FULLPREC switch: <a href=r38_0291.html>FULLPREC</a>
<dt>FULLROOTS switch: <a href=r38_0292.html>FULLROOTS</a>
<dt>gamma: <a href=r38_0081.html>FACTORIAL</a>
<dt>GAMMA operator: <a href=r38_0492.html>GAMMA</a>
<dt>GCD operator: <a href=r38_0086.html>GCD</a>
<dt>GCD switch: <a href=r38_0294.html>GCD switch</a>
<dt>GC switch: <a href=r38_0293.html>GC</a>
<dt>gdimension operator: <a href=r38_0381.html>gdimension</a>
<dt>GegenbauerP operator: <a href=r38_0506.html>GegenbauerP</a>
<dt>generalized hypergeometric function: <a href=r38_0529.html>HYPERGEOMETRIC
</a>
<dt>GENTRAN package: <a href=r38_0652.html>GENTRAN</a>
<dt>GEQ operator: <a href=r38_0049.html>GEQ</a>
<dt>geqsign operator: <a href=r38_0033.html>geqsign</a>
<dt>get columns operator: <a href=r38_0590.html>get columns</a>
<dt>getroot: <a href=r38_0434.html>Roots Package</a>
<dt>get rows operator: <a href=r38_0591.html>get rows</a>
<dt>gindependent sets operator: <a href=r38_0382.html>gindependent sets</a>
<dt>glexconvert operator: <a href=r38_0384.html>glexconvert</a>
<dt>gltbasis switch: <a href=r38_0374.html>gltbasis</a>
<dt>gltb variable: <a href=r38_0375.html>gltb</a>
<dt>glterms variable: <a href=r38_0376.html>glterms</a>
<dt>gmodule variable: <a href=r38_0402.html>gmodule</a>
<dt>GNUPLOT and REDUCE introduction: <a href=r38_0549.html>GNUPLOT and REDUCE
</a>
<dt>Golden Ratio: <a href=r38_0445.html>Constants</a>
<dt>G operator: <a href=r38_0412.html>G</a>
<dt>Gosper algorithm: <a href=r38_0171.html>PROD</a>
<dt>Gosper algorithm: <a href=r38_0183.html>SUM</a>
<dt>GOTO command: <a href=r38_0050.html>GOTO</a>
<dt>grad: <a href=r38_0660.html>ORTHOVEC</a>
<dt>graded term order concept: <a href=r38_0364.html>graded term order</a>
<dt>gradlexgradlex term order concept: <a href=r38_0359.html>gradlexgradlex term
order</a>
<dt>gradlexrevgradlex term order concept: <a href=r38_0360.html>gradlexrevgradle
x term order</a>
<dt>gradlex term order concept: <a href=r38_0357.html>gradlex term order</a>
<dt>gram schmidt operator: <a href=r38_0592.html>gram schmidt</a>
<dt>graphics: <a href=r38_0552.html>PLOT</a>
<dt>greater operator: <a href=r38_0034.html>greater</a>
<dt>GREATERP operator: <a href=r38_0051.html>GREATERP</a>
<dt>greatest common divisor: <a href=r38_0086.html>GCD</a>
<dt>greatest common divisor: <a href=r38_0286.html>EZGCD</a>
<dt>greatest common divisor: <a href=r38_0294.html>GCD switch</a>
<dt>greduce operator: <a href=r38_0385.html>greduce</a>
<dt>groebfullreduction switch: <a href=r38_0373.html>groebfullreduction</a>
<dt>groebmonfac variable: <a href=r38_0392.html>groebmonfac</a>
<dt>groebner: <a href=r38_0381.html>gdimension</a>
<dt>groebner: <a href=r38_0382.html>gindependent sets</a>
<dt>Groebner: <a href=r38_0639.html>CALI</a>
<dt>Groebner: <a href=r38_0653.html>IDEALS</a>
<dt>Groebner bases introduction: <a href=r38_0351.html>Groebner bases</a>
<dt>Groebner basis: <a href=r38_0676.html>XIDEAL</a>
<dt>groebnerf operator: <a href=r38_0391.html>groebnerf</a>
<dt>groebner operator: <a href=r38_0368.html>groebner</a>
<dt>groebnert operator: <a href=r38_0398.html>groebnert</a>
<dt>groebner walk operator: <a href=r38_0369.html>groebner walk</a>
<dt>groebopt switch: <a href=r38_0370.html>groebopt</a>
<dt>groebprereduce switch: <a href=r38_0372.html>groebprereduce</a>
<dt>groebprotfile variable: <a href=r38_0397.html>groebprotfile</a>
<dt>groebprot switch: <a href=r38_0396.html>groebprot</a>
<dt>groebresmax variable: <a href=r38_0393.html>groebresmax</a>
<dt>groebrestriction variable: <a href=r38_0394.html>groebrestriction</a>
<dt>groebstat switch: <a href=r38_0377.html>groebstat</a>
<dt>group command: <a href=r38_0038.html>group</a>
<dt>gsort operator: <a href=r38_0404.html>gsort</a>
<dt>gsplit operator: <a href=r38_0405.html>gsplit</a>
<dt>gspoly operator: <a href=r38_0406.html>gspoly</a>
<dt>gvarslast variable: <a href=r38_0371.html>gvarslast</a>
<dt>gvars operator: <a href=r38_0367.html>gvars</a>
<dt>gzerodim? operator: <a href=r38_0380.html>gzerodim </a>
<dt>HANKEL1 operator: <a href=r38_0454.html>HANKEL1</a>
<dt>HANKEL2 operator: <a href=r38_0455.html>HANKEL2</a>
<dt>Heaviside operator: <a href=r38_0531.html>Heaviside</a>
<dt>HE-dot operator: <a href=r38_0410.html>HE dot</a>
<dt>HEPHYS introduction: <a href=r38_0409.html>HEPHYS</a>
<dt>HermiteP operator: <a href=r38_0502.html>HermiteP</a>
<dt>hermitian tp operator: <a href=r38_0593.html>hermitian tp</a>
<dt>hessian operator: <a href=r38_0594.html>hessian</a>
<dt>hidden3d switch: <a href=r38_0563.html>hidden3d</a>
<dt>high energy physics: <a href=r38_0675.html>XCOLOR</a>
<dt>HIGH POW variable: <a href=r38_0010.html>HIGH POW</a>
<dt>hilbert operator: <a href=r38_0595.html>hilbert</a>
<dt>hilbertpolynomial operator: <a href=r38_0388.html>hilbertpolynomial</a>
<dt>history: <a href=r38_0126.html>DISPLAY</a>
<dt>Hollmann algorithm: <a href=r38_0351.html>Groebner bases</a>
<dt>Hollmann algorithm: <a href=r38_0388.html>hilbertpolynomial</a>
<dt>HORNER switch: <a href=r38_0295.html>HORNER</a>
<dt>hyperbolic arccosecant: <a href=r38_0243.html>ASECH</a>
<dt>hyperbolic arccosine: <a href=r38_0237.html>ACOSH</a>
<dt>hyperbolic arcsine: <a href=r38_0245.html>ASINH</a>
<dt>hyperbolic arctangent: <a href=r38_0247.html>ATANH</a>
<dt>hyperbolic cosecan: <a href=r38_0254.html>CSCH</a>
<dt>hyperbolic cosine: <a href=r38_0250.html>COSH</a>
<dt>hyperbolic cosine integral function: <a href=r38_0514.html>Chi</a>
<dt>hyperbolic cotangent: <a href=r38_0239.html>ACOTH</a>
<dt>hyperbolic cotangent: <a href=r38_0252.html>COTH</a>
<dt>hyperbolic secant: <a href=r38_0258.html>SECH</a>
<dt>hyperbolic sine: <a href=r38_0260.html>SINH</a>
<dt>hyperbolic sine integral function: <a href=r38_0511.html>Shi</a>
<dt>hyperbolic tangent: <a href=r38_0262.html>TANH</a>
<dt>hypergeometric function: <a href=r38_0529.html>HYPERGEOMETRIC</a>
<dt>HYPERGEOMETRIC operator: <a href=r38_0529.html>HYPERGEOMETRIC</a>
<dt>HYPOT operator: <a href=r38_0152.html>HYPOT</a>
<dt>I constant: <a href=r38_0011.html>I</a>
<dt>ideal dimension: <a href=r38_0381.html>gdimension</a>
<dt>ideal dimension: <a href=r38_0382.html>gindependent sets</a>
<dt>Ideal Parameters concept: <a href=r38_0352.html>Ideal Parameters</a>
<dt>idealquotient operator: <a href=r38_0387.html>idealquotient</a>
<dt>IDEALS package: <a href=r38_0653.html>IDEALS</a>
<dt>ideal variables: <a href=r38_0382.html>gindependent sets</a>
<dt>ideal variables: <a href=r38_0384.html>glexconvert</a>
<dt>identifier: <a href=r38_0164.html>MKID</a>
<dt>IDENTIFIER type: <a href=r38_0001.html>IDENTIFIER</a>
<dt>IFACTOR switch: <a href=r38_0296.html>IFACTOR</a>
<dt>IF command: <a href=r38_0052.html>IF</a>
<dt>imaginary part: <a href=r38_0153.html>IMPART</a>
<dt>IMPART operator: <a href=r38_0153.html>IMPART</a>
<dt>IN command: <a href=r38_0231.html>IN</a>
<dt>INDEX declaration: <a href=r38_0413.html>INDEX</a>
<dt>INEQ package: <a href=r38_0654.html>INEQ</a>
<dt>inequality: <a href=r38_0654.html>INEQ</a>
<dt>INFINITY constant: <a href=r38_0012.html>INFINITY</a>
<dt>INFIX declaration: <a href=r38_0196.html>INFIX</a>
<dt>initial value problem: <a href=r38_0429.html>num odesolve</a>
<dt>input: <a href=r38_0071.html>ADJPREC</a>
<dt>input: <a href=r38_0150.html>EXPREAD</a>
<dt>input: <a href=r38_0231.html>IN</a>
<dt>input: <a href=r38_0320.html>RAISE</a>
<dt>INPUT command: <a href=r38_0232.html>INPUT</a>
<dt>integer: <a href=r38_0073.html>CEILING</a>
<dt>integer: <a href=r38_0082.html>FIX</a>
<dt>integer: <a href=r38_0083.html>FIXP</a>
<dt>integer: <a href=r38_0084.html>FLOOR</a>
<dt>integer: <a href=r38_0103.html>ROUND</a>
<dt>integer: <a href=r38_0296.html>IFACTOR</a>
<dt>integer: <a href=r38_0316.html>PERIOD</a>
<dt>INTEGER declaration: <a href=r38_0197.html>INTEGER</a>
<dt>integral function: <a href=r38_0510.html>Si</a>
<dt>integral function: <a href=r38_0511.html>Shi</a>
<dt>integral function: <a href=r38_0512.html>s i</a>
<dt>integral function: <a href=r38_0514.html>Chi</a>
<dt>integration: <a href=r38_0154.html>INT</a>
<dt>integration: <a href=r38_0265.html>ALGINT</a>
<dt>integration: <a href=r38_0288.html>FAILHARD</a>
<dt>integration: <a href=r38_0311.html>NOLNR</a>
<dt>integration: <a href=r38_0337.html>TRINT</a>
<dt>integration: <a href=r38_0428.html>num int</a>
<dt>integration of square roots: <a href=r38_0633.html>ALGINT package</a>
<dt>interactive: <a href=r38_0126.html>DISPLAY</a>
<dt>interactive: <a href=r38_0128.html>PAUSE</a>
<dt>interactive: <a href=r38_0132.html>RETRY</a>
<dt>interactive: <a href=r38_0184.html>WS</a>
<dt>interactive: <a href=r38_0232.html>INPUT</a>
<dt>interactive: <a href=r38_0278.html>DEMO</a>
<dt>interactive: <a href=r38_0297.html>INT switch</a>
<dt>interpolation: <a href=r38_0155.html>INTERPOL</a>
<dt>interpolation: <a href=r38_0435.html>MKPOLY</a>
<dt>INTERPOL operator: <a href=r38_0155.html>INTERPOL</a>
<dt>Interval type: <a href=r38_0423.html>Interval</a>
<dt>INT operator: <a href=r38_0154.html>INT</a>
<dt>introduction: <a href=r38_0069.html>ARITHMETIC OPERATIONS</a>
<dt>introduction: <a href=r38_0264.html>SWITCHES</a>
<dt>introduction: <a href=r38_0351.html>Groebner bases</a>
<dt>introduction: <a href=r38_0353.html>Term order</a>
<dt>introduction: <a href=r38_0409.html>HEPHYS</a>
<dt>introduction: <a href=r38_0422.html>Numeric Package</a>
<dt>introduction: <a href=r38_0434.html>Roots Package</a>
<dt>introduction: <a href=r38_0444.html>Special Function Package</a>
<dt>introduction: <a href=r38_0535.html>TAYLOR introduction</a>
<dt>introduction: <a href=r38_0549.html>GNUPLOT and REDUCE</a>
<dt>introduction: <a href=r38_0571.html>Linear Algebra package</a>
<dt>introduction: <a href=r38_0632.html>Miscellaneous Packages</a>
<dt>INTSTR switch: <a href=r38_0298.html>INTSTR</a>
<dt>INT switch: <a href=r38_0297.html>INT switch</a>
<dt>INVBASE package: <a href=r38_0655.html>INVBASE</a>
<dt>isolater: <a href=r38_0434.html>Roots Package</a>
<dt>JacobiAMPLITUDE operator: <a href=r38_0481.html>JacobiAMPLITUDE</a>
<dt>Jacobian matrix: <a href=r38_0427.html>num solve</a>
<dt>jacobian operator: <a href=r38_0596.html>jacobian</a>
<dt>JacobiCD operator: <a href=r38_0472.html>JacobiCD</a>
<dt>JacobiCN operator: <a href=r38_0470.html>JacobiCN</a>
<dt>JacobiCS operator: <a href=r38_0480.html>JacobiCS</a>
<dt>JacobiDC operator: <a href=r38_0475.html>JacobiDC</a>
<dt>JacobiDN operator: <a href=r38_0471.html>JacobiDN</a>
<dt>JacobiDS operator: <a href=r38_0479.html>JacobiDS</a>
<dt>JacobiNC operator: <a href=r38_0476.html>JacobiNC</a>
<dt>JacobiND operator: <a href=r38_0474.html>JacobiND</a>
<dt>JacobiNS operator: <a href=r38_0478.html>JacobiNS</a>
<dt>JacobiP operator: <a href=r38_0505.html>JacobiP</a>
<dt>JacobiSC operator: <a href=r38_0477.html>JacobiSC</a>
<dt>JacobiSD operator: <a href=r38_0473.html>JacobiSD</a>
<dt>JacobiSN operator: <a href=r38_0469.html>JacobiSN</a>
<dt>JacobiZETA operator: <a href=r38_0489.html>JacobiZETA</a>
<dt>jordan block operator: <a href=r38_0597.html>jordan block</a>
<dt>Jordan operator: <a href=r38_0630.html>Jordan</a>
<dt>Jordansymbolic operator: <a href=r38_0629.html>Jordansymbolic</a>
<dt>kernel order: <a href=r38_0198.html>KORDER</a>
<dt>KERNEL type: <a href=r38_0002.html>KERNEL</a>
<dt>Khinchin's constant: <a href=r38_0445.html>Constants</a>
<dt>KORDER declaration: <a href=r38_0198.html>KORDER</a>
<dt>Kredel-Weispfenning algorithm: <a href=r38_0351.html>Groebner bases</a>
<dt>Kredel-Weispfenning algorithm: <a href=r38_0382.html>gindependent sets</a>
<dt>KummerM operator: <a href=r38_0460.html>KummerM</a>
<dt>KummerU operator: <a href=r38_0461.html>KummerU</a>
<dt>LaguerreP operator: <a href=r38_0503.html>LaguerreP</a>
<dt>Lambert W function operator: <a href=r38_0498.html>Lambert W function</a>
<dt>LANDENTRANS operator: <a href=r38_0483.html>LANDENTRANS</a>
<dt>LAPLACE package: <a href=r38_0656.html>LAPLACE</a>
<dt>Laplacian: <a href=r38_0660.html>ORTHOVEC</a>
<dt>Laurent-Puiseux series: <a href=r38_0650.html>FPS</a>
<dt>LCM switch: <a href=r38_0299.html>LCM</a>
<dt>LCOF operator: <a href=r38_0156.html>LCOF</a>
<dt>leading power: <a href=r38_0160.html>LPOWER</a>
<dt>leading term: <a href=r38_0161.html>LTERM</a>
<dt>least squares: <a href=r38_0432.html>num fit</a>
<dt>left-hand side: <a href=r38_0158.html>LHS</a>
<dt>LegendreP operator: <a href=r38_0504.html>LegendreP</a>
<dt>LENGTH operator: <a href=r38_0157.html>LENGTH</a>
<dt>LEQ operator: <a href=r38_0114.html>LEQ</a>
<dt>leqsign operator: <a href=r38_0035.html>leqsign</a>
<dt>less operator: <a href=r38_0036.html>less</a>
<dt>LESSP operator: <a href=r38_0115.html>LESSP</a>
<dt>LESSSPACE switch: <a href=r38_0300.html>LESSSPACE</a>
<dt>LET command: <a href=r38_0199.html>LET</a>
<dt>lexgradlex term order concept: <a href=r38_0361.html>lexgradlex term order
</a>
<dt>lexrevgradlex term order concept: <a href=r38_0362.html>lexrevgradlex term o
rder</a>
<dt>lex term order concept: <a href=r38_0356.html>lex term order</a>
<dt>l'Hopital's rule: <a href=r38_0159.html>LIMIT</a>
<dt>LHS operator: <a href=r38_0158.html>LHS</a>
<dt>LIE package: <a href=r38_0657.html>LIE</a>
<dt>Lie symmetry: <a href=r38_0670.html>SPDE</a>
<dt>LIMITEDFACTORS switch: <a href=r38_0301.html>LIMITEDFACTORS</a>
<dt>LIMIT operator: <a href=r38_0159.html>LIMIT</a>
<dt>Linear Algebra package introduction: <a href=r38_0571.html>Linear Algebra pa
ckage</a>
<dt>LINEAR declaration: <a href=r38_0200.html>LINEAR</a>
<dt>linear system: <a href=r38_0276.html>CRAMER</a>
<dt>LINELENGTH declaration: <a href=r38_0201.html>LINELENGTH</a>
<dt>lisp: <a href=r38_0277.html>DEFN</a>
<dt>lisp: <a href=r38_0327.html>RLISP88</a>
<dt>LISP command: <a href=r38_0202.html>LISP</a>
<dt>list: <a href=r38_0023.html>dot</a>
<dt>list: <a href=r38_0046.html>FIRST</a>
<dt>list: <a href=r38_0057.html>REST</a>
<dt>list: <a href=r38_0059.html>REVERSE</a>
<dt>list: <a href=r38_0063.html>SECOND</a>
<dt>list: <a href=r38_0066.html>THIRD</a>
<dt>list: <a href=r38_0116.html>MEMBER</a>
<dt>list: <a href=r38_0137.html>APPEND</a>
<dt>list: <a href=r38_0157.html>LENGTH</a>
<dt>list: <a href=r38_0177.html>SELECT</a>
<dt>LISTARGP declaration: <a href=r38_0203.html>LISTARGP</a>
<dt>LISTARGS switch: <a href=r38_0303.html>LISTARGS</a>
<dt>LIST operator: <a href=r38_0053.html>LIST</a>
<dt>LIST switch: <a href=r38_0302.html>LIST switch</a>
<dt>LN operator: <a href=r38_0087.html>LN</a>
<dt>LOAD PACKAGE command: <a href=r38_0127.html>LOAD PACKAGE</a>
<dt>logarithm: <a href=r38_0087.html>LN</a>
<dt>logarithm: <a href=r38_0088.html>LOG</a>
<dt>logarithm: <a href=r38_0089.html>LOGB</a>
<dt>logarithm: <a href=r38_0272.html>COMBINELOGS</a>
<dt>logarithm: <a href=r38_0285.html>EXPANDLOGS</a>
<dt>LOGB operator: <a href=r38_0089.html>LOGB</a>
<dt>LOG operator: <a href=r38_0088.html>LOG</a>
<dt>loop: <a href=r38_0047.html>FOR</a>
<dt>loop: <a href=r38_0048.html>FOREACH</a>
<dt>loop: <a href=r38_0056.html>REPEAT</a>
<dt>loop: <a href=r38_0228.html>WHILE</a>
<dt>LOW POW variable: <a href=r38_0013.html>LOW POW</a>
<dt>LPOWER operator: <a href=r38_0160.html>LPOWER</a>
<dt>LTERM operator: <a href=r38_0161.html>LTERM</a>
<dt>lu decom operator: <a href=r38_0598.html>lu decom</a>
<dt>main variable: <a href=r38_0162.html>MAINVAR</a>
<dt>MAINVAR operator: <a href=r38_0162.html>MAINVAR</a>
<dt>make identity operator: <a href=r38_0599.html>make identity</a>
<dt>map: <a href=r38_0177.html>SELECT</a>
<dt>MAP operator: <a href=r38_0163.html>MAP</a>
<dt>MASS command: <a href=r38_0414.html>MASS</a>
<dt>MATCH command: <a href=r38_0205.html>MATCH</a>
<dt>MATEIGEN operator: <a href=r38_0344.html>MATEIGEN</a>
<dt>MAT operator: <a href=r38_0343.html>MAT</a>
<dt>matrix: <a href=r38_0276.html>CRAMER</a>
<dt>matrix: <a href=r38_0341.html>COFACTOR</a>
<dt>matrix: <a href=r38_0342.html>DET</a>
<dt>matrix: <a href=r38_0343.html>MAT</a>
<dt>matrix: <a href=r38_0344.html>MATEIGEN</a>
<dt>matrix: <a href=r38_0346.html>NULLSPACE</a>
<dt>matrix: <a href=r38_0347.html>RANK</a>
<dt>matrix: <a href=r38_0348.html>TP</a>
<dt>matrix: <a href=r38_0349.html>TRACE</a>
<dt>matrix augment operator: <a href=r38_0600.html>matrix augment</a>
<dt>MATRIX declaration: <a href=r38_0345.html>MATRIX</a>
<dt>matrixp operator: <a href=r38_0601.html>matrixp</a>
<dt>matrix stack operator: <a href=r38_0602.html>matrix stack</a>
<dt>matrix term order concept: <a href=r38_0365.html>matrix term order</a>
<dt>maximum: <a href=r38_0090.html>MAX</a>
<dt>MAX operator: <a href=r38_0090.html>MAX</a>
<dt>MCD switch: <a href=r38_0304.html>MCD</a>
<dt>MeijerG operator: <a href=r38_0530.html>MeijerG</a>
<dt>MEMBER operator: <a href=r38_0116.html>MEMBER</a>
<dt>memory: <a href=r38_0130.html>RECLAIM</a>
<dt>memory: <a href=r38_0293.html>GC</a>
<dt>minimum: <a href=r38_0091.html>MIN</a>
<dt>minimum: <a href=r38_0426.html>num min</a>
<dt>MIN operator: <a href=r38_0091.html>MIN</a>
<dt>minor operator: <a href=r38_0603.html>minor</a>
<dt>MINUS operator: <a href=r38_0092.html>MINUS</a>
<dt>minussign operator: <a href=r38_0028.html>minussign</a>
<dt>Miscellaneous Packages introduction: <a href=r38_0632.html>Miscellaneous Pac
kages</a>
<dt>MKID command: <a href=r38_0164.html>MKID</a>
<dt>MKPOLY operator: <a href=r38_0435.html>MKPOLY</a>
<dt>MODSR package: <a href=r38_0658.html>MODSR</a>
<dt>modular: <a href=r38_0104.html>SETMOD</a>
<dt>modular: <a href=r38_0269.html>BALANCED MOD</a>
<dt>modular polynomial: <a href=r38_0658.html>MODSR</a>
<dt>MODULAR switch: <a href=r38_0305.html>MODULAR</a>
<dt>Module concept: <a href=r38_0401.html>Module</a>
<dt>MSG switch: <a href=r38_0306.html>MSG</a>
<dt>MSHELL command: <a href=r38_0415.html>MSHELL</a>
<dt>mult columns operator: <a href=r38_0604.html>mult columns</a>
<dt>MULTIPLICITIES switch: <a href=r38_0307.html>MULTIPLICITIES</a>
<dt>mult rows operator: <a href=r38_0605.html>mult rows</a>
<dt>NAT switch: <a href=r38_0308.html>NAT</a>
<dt>NCPOLY package: <a href=r38_0659.html>NCPOLY</a>
<dt>NEARESTROOT operator: <a href=r38_0436.html>NEARESTROOT</a>
<dt>NEQ operator: <a href=r38_0117.html>NEQ</a>
<dt>NERO switch: <a href=r38_0309.html>NERO</a>
<dt>Newton iteration: <a href=r38_0427.html>num solve</a>
<dt>NEXTPRIME operator: <a href=r38_0093.html>NEXTPRIME</a>
<dt>NIL constant: <a href=r38_0014.html>NIL</a>
<dt>NOARG switch: <a href=r38_0310.html>NOARG</a>
<dt>NOCONVERT switch: <a href=r38_0094.html>NOCONVERT</a>
<dt>NODEPEND declaration: <a href=r38_0204.html>NODEPEND</a>
<dt>NOLNR switch: <a href=r38_0311.html>NOLNR</a>
<dt>NONCOM declaration: <a href=r38_0206.html>NONCOM</a>
<dt>non commutative: <a href=r38_0206.html>NONCOM</a>
<dt>non-commutativity: <a href=r38_0659.html>NCPOLY</a>
<dt>NONZERO declaration: <a href=r38_0207.html>NONZERO</a>
<dt>NORM operator: <a href=r38_0095.html>NORM</a>
<dt>NOSPLIT switch: <a href=r38_0312.html>NOSPLIT</a>
<dt>NOSPUR declaration: <a href=r38_0416.html>NOSPUR</a>
<dt>NOT operator: <a href=r38_0118.html>NOT</a>
<dt>NPRIMITIVE operator: <a href=r38_0165.html>NPRIMITIVE</a>
<dt>NULLSPACE operator: <a href=r38_0346.html>NULLSPACE</a>
<dt>NUMBERP operator: <a href=r38_0119.html>NUMBERP</a>
<dt>numerator: <a href=r38_0166.html>NUM</a>
<dt>numeric accuracy concept: <a href=r38_0424.html>numeric accuracy</a>
<dt>Numeric Package introduction: <a href=r38_0422.html>Numeric Package</a>
<dt>num fit operator: <a href=r38_0432.html>num fit</a>
<dt>num int operator: <a href=r38_0428.html>num int</a>
<dt>num min operator: <a href=r38_0426.html>num min</a>
<dt>num odesolve operator: <a href=r38_0429.html>num odesolve</a>
<dt>NUM operator: <a href=r38_0166.html>NUM</a>
<dt>num solve operator: <a href=r38_0427.html>num solve</a>
<dt>NUMVAL switch: <a href=r38_0313.html>NUMVAL</a>
<dt>ODD declaration: <a href=r38_0208.html>ODD</a>
<dt>ODE: <a href=r38_0429.html>num odesolve</a>
<dt>ODESOLVE operator: <a href=r38_0167.html>ODESOLVE</a>
<dt>OFF command: <a href=r38_0209.html>OFF</a>
<dt>ON command: <a href=r38_0210.html>ON</a>
<dt>ONE OF type: <a href=r38_0168.html>ONE OF</a>
<dt>open: <a href=r38_0233.html>OUT</a>
<dt>operator: <a href=r38_0023.html>dot</a>
<dt>operator: <a href=r38_0024.html>assign</a>
<dt>operator: <a href=r38_0025.html>equalsign</a>
<dt>operator: <a href=r38_0026.html>replace</a>
<dt>operator: <a href=r38_0027.html>plussign</a>
<dt>operator: <a href=r38_0028.html>minussign</a>
<dt>operator: <a href=r38_0029.html>asterisk</a>
<dt>operator: <a href=r38_0030.html>slash</a>
<dt>operator: <a href=r38_0031.html>power</a>
<dt>operator: <a href=r38_0032.html>caret</a>
<dt>operator: <a href=r38_0033.html>geqsign</a>
<dt>operator: <a href=r38_0034.html>greater</a>
<dt>operator: <a href=r38_0035.html>leqsign</a>
<dt>operator: <a href=r38_0036.html>less</a>
<dt>operator: <a href=r38_0037.html>tilde</a>
<dt>operator: <a href=r38_0039.html>AND</a>
<dt>operator: <a href=r38_0043.html>CONS</a>
<dt>operator: <a href=r38_0046.html>FIRST</a>
<dt>operator: <a href=r38_0049.html>GEQ</a>
<dt>operator: <a href=r38_0051.html>GREATERP</a>
<dt>operator: <a href=r38_0053.html>LIST</a>
<dt>operator: <a href=r38_0054.html>OR</a>
<dt>operator: <a href=r38_0057.html>REST</a>
<dt>operator: <a href=r38_0059.html>REVERSE</a>
<dt>operator: <a href=r38_0063.html>SECOND</a>
<dt>operator: <a href=r38_0064.html>SET</a>
<dt>operator: <a href=r38_0065.html>SETQ</a>
<dt>operator: <a href=r38_0066.html>THIRD</a>
<dt>operator: <a href=r38_0067.html>WHEN</a>
<dt>operator: <a href=r38_0070.html>ABS</a>
<dt>operator: <a href=r38_0072.html>ARG</a>
<dt>operator: <a href=r38_0073.html>CEILING</a>
<dt>operator: <a href=r38_0074.html>CHOOSE</a>
<dt>operator: <a href=r38_0075.html>DEG2DMS</a>
<dt>operator: <a href=r38_0076.html>DEG2RAD</a>
<dt>operator: <a href=r38_0077.html>DIFFERENCE</a>
<dt>operator: <a href=r38_0078.html>DILOG</a>
<dt>operator: <a href=r38_0079.html>DMS2DEG</a>
<dt>operator: <a href=r38_0080.html>DMS2RAD</a>
<dt>operator: <a href=r38_0081.html>FACTORIAL</a>
<dt>operator: <a href=r38_0082.html>FIX</a>
<dt>operator: <a href=r38_0083.html>FIXP</a>
<dt>operator: <a href=r38_0084.html>FLOOR</a>
<dt>operator: <a href=r38_0085.html>EXPT</a>
<dt>operator: <a href=r38_0086.html>GCD</a>
<dt>operator: <a href=r38_0087.html>LN</a>
<dt>operator: <a href=r38_0088.html>LOG</a>
<dt>operator: <a href=r38_0089.html>LOGB</a>
<dt>operator: <a href=r38_0090.html>MAX</a>
<dt>operator: <a href=r38_0091.html>MIN</a>
<dt>operator: <a href=r38_0092.html>MINUS</a>
<dt>operator: <a href=r38_0093.html>NEXTPRIME</a>
<dt>operator: <a href=r38_0095.html>NORM</a>
<dt>operator: <a href=r38_0096.html>PERM</a>
<dt>operator: <a href=r38_0097.html>PLUS</a>
<dt>operator: <a href=r38_0098.html>QUOTIENT</a>
<dt>operator: <a href=r38_0099.html>RAD2DEG</a>
<dt>operator: <a href=r38_0100.html>RAD2DMS</a>
<dt>operator: <a href=r38_0101.html>RECIP</a>
<dt>operator: <a href=r38_0102.html>REMAINDER</a>
<dt>operator: <a href=r38_0103.html>ROUND</a>
<dt>operator: <a href=r38_0105.html>SIGN</a>
<dt>operator: <a href=r38_0106.html>SQRT</a>
<dt>operator: <a href=r38_0107.html>TIMES</a>
<dt>operator: <a href=r38_0110.html>EQUAL</a>
<dt>operator: <a href=r38_0111.html>EVENP</a>
<dt>operator: <a href=r38_0113.html>FREEOF</a>
<dt>operator: <a href=r38_0114.html>LEQ</a>
<dt>operator: <a href=r38_0115.html>LESSP</a>
<dt>operator: <a href=r38_0116.html>MEMBER</a>
<dt>operator: <a href=r38_0117.html>NEQ</a>
<dt>operator: <a href=r38_0118.html>NOT</a>
<dt>operator: <a href=r38_0119.html>NUMBERP</a>
<dt>operator: <a href=r38_0120.html>ORDP</a>
<dt>operator: <a href=r38_0121.html>PRIMEP</a>
<dt>operator: <a href=r38_0130.html>RECLAIM</a>
<dt>operator: <a href=r38_0137.html>APPEND</a>
<dt>operator: <a href=r38_0138.html>ARBINT</a>
<dt>operator: <a href=r38_0139.html>ARBCOMPLEX</a>
<dt>operator: <a href=r38_0140.html>ARGLENGTH</a>
<dt>operator: <a href=r38_0141.html>COEFF</a>
<dt>operator: <a href=r38_0142.html>COEFFN</a>
<dt>operator: <a href=r38_0143.html>CONJ</a>
<dt>operator: <a href=r38_0144.html>CONTINUED FRACTION</a>
<dt>operator: <a href=r38_0145.html>DECOMPOSE</a>
<dt>operator: <a href=r38_0146.html>DEG</a>
<dt>operator: <a href=r38_0147.html>DEN</a>
<dt>operator: <a href=r38_0148.html>DF</a>
<dt>operator: <a href=r38_0149.html>EXPAND CASES</a>
<dt>operator: <a href=r38_0150.html>EXPREAD</a>
<dt>operator: <a href=r38_0151.html>FACTORIZE</a>
<dt>operator: <a href=r38_0152.html>HYPOT</a>
<dt>operator: <a href=r38_0153.html>IMPART</a>
<dt>operator: <a href=r38_0154.html>INT</a>
<dt>operator: <a href=r38_0155.html>INTERPOL</a>
<dt>operator: <a href=r38_0156.html>LCOF</a>
<dt>operator: <a href=r38_0157.html>LENGTH</a>
<dt>operator: <a href=r38_0158.html>LHS</a>
<dt>operator: <a href=r38_0159.html>LIMIT</a>
<dt>operator: <a href=r38_0160.html>LPOWER</a>
<dt>operator: <a href=r38_0161.html>LTERM</a>
<dt>operator: <a href=r38_0162.html>MAINVAR</a>
<dt>operator: <a href=r38_0163.html>MAP</a>
<dt>operator: <a href=r38_0165.html>NPRIMITIVE</a>
<dt>operator: <a href=r38_0166.html>NUM</a>
<dt>operator: <a href=r38_0167.html>ODESOLVE</a>
<dt>operator: <a href=r38_0169.html>PART</a>
<dt>operator: <a href=r38_0170.html>PF</a>
<dt>operator: <a href=r38_0171.html>PROD</a>
<dt>operator: <a href=r38_0172.html>REDUCT</a>
<dt>operator: <a href=r38_0173.html>REPART</a>
<dt>operator: <a href=r38_0174.html>RESULTANT</a>
<dt>operator: <a href=r38_0175.html>RHS</a>
<dt>operator: <a href=r38_0176.html>ROOT OF</a>
<dt>operator: <a href=r38_0177.html>SELECT</a>
<dt>operator: <a href=r38_0178.html>SHOWRULES</a>
<dt>operator: <a href=r38_0179.html>SOLVE</a>
<dt>operator: <a href=r38_0180.html>SORT</a>
<dt>operator: <a href=r38_0181.html>STRUCTR</a>
<dt>operator: <a href=r38_0182.html>SUB</a>
<dt>operator: <a href=r38_0183.html>SUM</a>
<dt>operator: <a href=r38_0184.html>WS</a>
<dt>operator: <a href=r38_0196.html>INFIX</a>
<dt>operator: <a href=r38_0200.html>LINEAR</a>
<dt>operator: <a href=r38_0206.html>NONCOM</a>
<dt>operator: <a href=r38_0207.html>NONZERO</a>
<dt>operator: <a href=r38_0208.html>ODD</a>
<dt>operator: <a href=r38_0213.html>PRECEDENCE</a>
<dt>operator: <a href=r38_0222.html>SYMMETRIC</a>
<dt>operator: <a href=r38_0227.html>WHERE</a>
<dt>operator: <a href=r38_0236.html>ACOS</a>
<dt>operator: <a href=r38_0237.html>ACOSH</a>
<dt>operator: <a href=r38_0238.html>ACOT</a>
<dt>operator: <a href=r38_0239.html>ACOTH</a>
<dt>operator: <a href=r38_0240.html>ACSC</a>
<dt>operator: <a href=r38_0241.html>ACSCH</a>
<dt>operator: <a href=r38_0242.html>ASEC</a>
<dt>operator: <a href=r38_0243.html>ASECH</a>
<dt>operator: <a href=r38_0244.html>ASIN</a>
<dt>operator: <a href=r38_0245.html>ASINH</a>
<dt>operator: <a href=r38_0246.html>ATAN</a>
<dt>operator: <a href=r38_0247.html>ATANH</a>
<dt>operator: <a href=r38_0248.html>ATAN2</a>
<dt>operator: <a href=r38_0249.html>COS</a>
<dt>operator: <a href=r38_0250.html>COSH</a>
<dt>operator: <a href=r38_0251.html>COT</a>
<dt>operator: <a href=r38_0252.html>COTH</a>
<dt>operator: <a href=r38_0253.html>CSC</a>
<dt>operator: <a href=r38_0254.html>CSCH</a>
<dt>operator: <a href=r38_0255.html>ERF</a>
<dt>operator: <a href=r38_0256.html>EXP</a>
<dt>operator: <a href=r38_0257.html>SEC</a>
<dt>operator: <a href=r38_0258.html>SECH</a>
<dt>operator: <a href=r38_0259.html>SIN</a>
<dt>operator: <a href=r38_0260.html>SINH</a>
<dt>operator: <a href=r38_0261.html>TAN</a>
<dt>operator: <a href=r38_0262.html>TANH</a>
<dt>operator: <a href=r38_0303.html>LISTARGS</a>
<dt>operator: <a href=r38_0341.html>COFACTOR</a>
<dt>operator: <a href=r38_0342.html>DET</a>
<dt>operator: <a href=r38_0343.html>MAT</a>
<dt>operator: <a href=r38_0344.html>MATEIGEN</a>
<dt>operator: <a href=r38_0346.html>NULLSPACE</a>
<dt>operator: <a href=r38_0347.html>RANK</a>
<dt>operator: <a href=r38_0348.html>TP</a>
<dt>operator: <a href=r38_0349.html>TRACE</a>
<dt>operator: <a href=r38_0354.html>torder</a>
<dt>operator: <a href=r38_0355.html>torder compile</a>
<dt>operator: <a href=r38_0367.html>gvars</a>
<dt>operator: <a href=r38_0368.html>groebner</a>
<dt>operator: <a href=r38_0369.html>groebner walk</a>
<dt>operator: <a href=r38_0380.html>gzerodim </a>
<dt>operator: <a href=r38_0381.html>gdimension</a>
<dt>operator: <a href=r38_0382.html>gindependent sets</a>
<dt>operator: <a href=r38_0383.html>dd groebner</a>
<dt>operator: <a href=r38_0384.html>glexconvert</a>
<dt>operator: <a href=r38_0385.html>greduce</a>
<dt>operator: <a href=r38_0386.html>preduce</a>
<dt>operator: <a href=r38_0387.html>idealquotient</a>
<dt>operator: <a href=r38_0388.html>hilbertpolynomial</a>
<dt>operator: <a href=r38_0389.html>saturation</a>
<dt>operator: <a href=r38_0391.html>groebnerf</a>
<dt>operator: <a href=r38_0398.html>groebnert</a>
<dt>operator: <a href=r38_0399.html>preducet</a>
<dt>operator: <a href=r38_0404.html>gsort</a>
<dt>operator: <a href=r38_0405.html>gsplit</a>
<dt>operator: <a href=r38_0406.html>gspoly</a>
<dt>operator: <a href=r38_0410.html>HE dot</a>
<dt>operator: <a href=r38_0411.html>EPS</a>
<dt>operator: <a href=r38_0412.html>G</a>
<dt>operator: <a href=r38_0426.html>num min</a>
<dt>operator: <a href=r38_0427.html>num solve</a>
<dt>operator: <a href=r38_0428.html>num int</a>
<dt>operator: <a href=r38_0429.html>num odesolve</a>
<dt>operator: <a href=r38_0430.html>bounds</a>
<dt>operator: <a href=r38_0432.html>num fit</a>
<dt>operator: <a href=r38_0435.html>MKPOLY</a>
<dt>operator: <a href=r38_0436.html>NEARESTROOT</a>
<dt>operator: <a href=r38_0437.html>REALROOTS</a>
<dt>operator: <a href=r38_0438.html>ROOTACC</a>
<dt>operator: <a href=r38_0439.html>ROOTS</a>
<dt>operator: <a href=r38_0440.html>ROOT VAL</a>
<dt>operator: <a href=r38_0446.html>BERNOULLI</a>
<dt>operator: <a href=r38_0447.html>BERNOULLIP</a>
<dt>operator: <a href=r38_0448.html>EULER</a>
<dt>operator: <a href=r38_0449.html>EULERP</a>
<dt>operator: <a href=r38_0450.html>ZETA</a>
<dt>operator: <a href=r38_0452.html>BESSELJ</a>
<dt>operator: <a href=r38_0453.html>BESSELY</a>
<dt>operator: <a href=r38_0454.html>HANKEL1</a>
<dt>operator: <a href=r38_0455.html>HANKEL2</a>
<dt>operator: <a href=r38_0456.html>BESSELI</a>
<dt>operator: <a href=r38_0457.html>BESSELK</a>
<dt>operator: <a href=r38_0458.html>StruveH</a>
<dt>operator: <a href=r38_0459.html>StruveL</a>
<dt>operator: <a href=r38_0460.html>KummerM</a>
<dt>operator: <a href=r38_0461.html>KummerU</a>
<dt>operator: <a href=r38_0462.html>WhittakerW</a>
<dt>operator: <a href=r38_0464.html>Airy Ai</a>
<dt>operator: <a href=r38_0465.html>Airy Bi</a>
<dt>operator: <a href=r38_0466.html>Airy Aiprime</a>
<dt>operator: <a href=r38_0467.html>Airy Biprime</a>
<dt>operator: <a href=r38_0469.html>JacobiSN</a>
<dt>operator: <a href=r38_0470.html>JacobiCN</a>
<dt>operator: <a href=r38_0471.html>JacobiDN</a>
<dt>operator: <a href=r38_0472.html>JacobiCD</a>
<dt>operator: <a href=r38_0473.html>JacobiSD</a>
<dt>operator: <a href=r38_0474.html>JacobiND</a>
<dt>operator: <a href=r38_0475.html>JacobiDC</a>
<dt>operator: <a href=r38_0476.html>JacobiNC</a>
<dt>operator: <a href=r38_0477.html>JacobiSC</a>
<dt>operator: <a href=r38_0478.html>JacobiNS</a>
<dt>operator: <a href=r38_0479.html>JacobiDS</a>
<dt>operator: <a href=r38_0480.html>JacobiCS</a>
<dt>operator: <a href=r38_0481.html>JacobiAMPLITUDE</a>
<dt>operator: <a href=r38_0482.html>AGM FUNCTION</a>
<dt>operator: <a href=r38_0483.html>LANDENTRANS</a>
<dt>operator: <a href=r38_0484.html>EllipticF</a>
<dt>operator: <a href=r38_0485.html>EllipticK</a>
<dt>operator: <a href=r38_0486.html>EllipticKprime</a>
<dt>operator: <a href=r38_0487.html>EllipticE</a>
<dt>operator: <a href=r38_0488.html>EllipticTHETA</a>
<dt>operator: <a href=r38_0489.html>JacobiZETA</a>
<dt>operator: <a href=r38_0491.html>POCHHAMMER</a>
<dt>operator: <a href=r38_0492.html>GAMMA</a>
<dt>operator: <a href=r38_0493.html>BETA</a>
<dt>operator: <a href=r38_0494.html>PSI</a>
<dt>operator: <a href=r38_0495.html>POLYGAMMA</a>
<dt>operator: <a href=r38_0497.html>DILOG extended</a>
<dt>operator: <a href=r38_0498.html>Lambert W function</a>
<dt>operator: <a href=r38_0500.html>ChebyshevT</a>
<dt>operator: <a href=r38_0501.html>ChebyshevU</a>
<dt>operator: <a href=r38_0502.html>HermiteP</a>
<dt>operator: <a href=r38_0503.html>LaguerreP</a>
<dt>operator: <a href=r38_0504.html>LegendreP</a>
<dt>operator: <a href=r38_0505.html>JacobiP</a>
<dt>operator: <a href=r38_0506.html>GegenbauerP</a>
<dt>operator: <a href=r38_0507.html>SolidHarmonicY</a>
<dt>operator: <a href=r38_0508.html>SphericalHarmonicY</a>
<dt>operator: <a href=r38_0510.html>Si</a>
<dt>operator: <a href=r38_0511.html>Shi</a>
<dt>operator: <a href=r38_0512.html>s i</a>
<dt>operator: <a href=r38_0513.html>Ci</a>
<dt>operator: <a href=r38_0514.html>Chi</a>
<dt>operator: <a href=r38_0515.html>ERF extended</a>
<dt>operator: <a href=r38_0516.html>erfc</a>
<dt>operator: <a href=r38_0517.html>Ei</a>
<dt>operator: <a href=r38_0518.html>Fresnel C</a>
<dt>operator: <a href=r38_0519.html>Fresnel S</a>
<dt>operator: <a href=r38_0521.html>BINOMIAL</a>
<dt>operator: <a href=r38_0522.html>STIRLING1</a>
<dt>operator: <a href=r38_0523.html>STIRLING2</a>
<dt>operator: <a href=r38_0525.html>ThreejSymbol</a>
<dt>operator: <a href=r38_0526.html>Clebsch Gordan</a>
<dt>operator: <a href=r38_0527.html>SixjSymbol</a>
<dt>operator: <a href=r38_0529.html>HYPERGEOMETRIC</a>
<dt>operator: <a href=r38_0530.html>MeijerG</a>
<dt>operator: <a href=r38_0531.html>Heaviside</a>
<dt>operator: <a href=r38_0532.html>erfi</a>
<dt>operator: <a href=r38_0536.html>taylor</a>
<dt>operator: <a href=r38_0539.html>taylorcombine</a>
<dt>operator: <a href=r38_0541.html>taylororiginal</a>
<dt>operator: <a href=r38_0544.html>taylorrevert</a>
<dt>operator: <a href=r38_0545.html>taylorseriesp</a>
<dt>operator: <a href=r38_0546.html>taylortemplate</a>
<dt>operator: <a href=r38_0547.html>taylortostandard</a>
<dt>operator: <a href=r38_0573.html>add columns</a>
<dt>operator: <a href=r38_0574.html>add rows</a>
<dt>operator: <a href=r38_0575.html>add to columns</a>
<dt>operator: <a href=r38_0576.html>add to rows</a>
<dt>operator: <a href=r38_0577.html>augment columns</a>
<dt>operator: <a href=r38_0578.html>band matrix</a>
<dt>operator: <a href=r38_0579.html>block matrix</a>
<dt>operator: <a href=r38_0580.html>char matrix</a>
<dt>operator: <a href=r38_0581.html>char poly</a>
<dt>operator: <a href=r38_0582.html>cholesky</a>
<dt>operator: <a href=r38_0583.html>coeff matrix</a>
<dt>operator: <a href=r38_0584.html>column dim</a>
<dt>operator: <a href=r38_0585.html>companion</a>
<dt>operator: <a href=r38_0586.html>copy into</a>
<dt>operator: <a href=r38_0587.html>diagonal</a>
<dt>operator: <a href=r38_0588.html>extend</a>
<dt>operator: <a href=r38_0589.html>find companion</a>
<dt>operator: <a href=r38_0590.html>get columns</a>
<dt>operator: <a href=r38_0591.html>get rows</a>
<dt>operator: <a href=r38_0592.html>gram schmidt</a>
<dt>operator: <a href=r38_0593.html>hermitian tp</a>
<dt>operator: <a href=r38_0594.html>hessian</a>
<dt>operator: <a href=r38_0595.html>hilbert</a>
<dt>operator: <a href=r38_0596.html>jacobian</a>
<dt>operator: <a href=r38_0597.html>jordan block</a>
<dt>operator: <a href=r38_0598.html>lu decom</a>
<dt>operator: <a href=r38_0599.html>make identity</a>
<dt>operator: <a href=r38_0600.html>matrix augment</a>
<dt>operator: <a href=r38_0601.html>matrixp</a>
<dt>operator: <a href=r38_0602.html>matrix stack</a>
<dt>operator: <a href=r38_0603.html>minor</a>
<dt>operator: <a href=r38_0604.html>mult columns</a>
<dt>operator: <a href=r38_0605.html>mult rows</a>
<dt>operator: <a href=r38_0606.html>pivot</a>
<dt>operator: <a href=r38_0607.html>pseudo inverse</a>
<dt>operator: <a href=r38_0608.html>random matrix</a>
<dt>operator: <a href=r38_0609.html>remove columns</a>
<dt>operator: <a href=r38_0610.html>remove rows</a>
<dt>operator: <a href=r38_0611.html>row dim</a>
<dt>operator: <a href=r38_0612.html>rows pivot</a>
<dt>operator: <a href=r38_0613.html>simplex</a>
<dt>operator: <a href=r38_0614.html>squarep</a>
<dt>operator: <a href=r38_0615.html>stack rows</a>
<dt>operator: <a href=r38_0616.html>sub matrix</a>
<dt>operator: <a href=r38_0617.html>svd</a>
<dt>operator: <a href=r38_0618.html>swap columns</a>
<dt>operator: <a href=r38_0619.html>swap entries</a>
<dt>operator: <a href=r38_0620.html>swap rows</a>
<dt>operator: <a href=r38_0621.html>symmetricp</a>
<dt>operator: <a href=r38_0622.html>toeplitz</a>
<dt>operator: <a href=r38_0623.html>vandermonde</a>
<dt>operator: <a href=r38_0625.html>Smithex</a>
<dt>operator: <a href=r38_0626.html>Smithex int</a>
<dt>operator: <a href=r38_0627.html>Frobenius</a>
<dt>operator: <a href=r38_0628.html>Ratjordan</a>
<dt>operator: <a href=r38_0629.html>Jordansymbolic</a>
<dt>operator: <a href=r38_0630.html>Jordan</a>
<dt>OPERATOR declaration: <a href=r38_0211.html>OPERATOR</a>
<dt>optimization: <a href=r38_0668.html>SCOPE</a>
<dt>Optional Free Variable type: <a href=r38_0062.html>Optional Free Variable
</a>
<dt>order: <a href=r38_0120.html>ORDP</a>
<dt>order: <a href=r38_0198.html>KORDER</a>
<dt>ORDER declaration: <a href=r38_0212.html>ORDER</a>
<dt>ORDP operator: <a href=r38_0120.html>ORDP</a>
<dt>OR operator: <a href=r38_0054.html>OR</a>
<dt>ORTHOVEC package: <a href=r38_0660.html>ORTHOVEC</a>
<dt>OUT command: <a href=r38_0233.html>OUT</a>
<dt>Outmoded Operations: <a href=r38_0682.html>EDITDEF</a>
<dt>output: <a href=r38_0006.html>CARD NO</a>
<dt>output: <a href=r38_0009.html>FORT WIDTH</a>
<dt>output: <a href=r38_0135.html>WRITE</a>
<dt>output: <a href=r38_0178.html>SHOWRULES</a>
<dt>output: <a href=r38_0194.html>FACTOR declaration</a>
<dt>output: <a href=r38_0201.html>LINELENGTH</a>
<dt>output: <a href=r38_0212.html>ORDER</a>
<dt>output: <a href=r38_0215.html>PRINT PRECISION</a>
<dt>output: <a href=r38_0217.html>REMFAC</a>
<dt>output: <a href=r38_0219.html>SCIENTIFIC NOTATION</a>
<dt>output: <a href=r38_0233.html>OUT</a>
<dt>output: <a href=r38_0234.html>SHUT</a>
<dt>output: <a href=r38_0267.html>ALLFAC</a>
<dt>output: <a href=r38_0270.html>BFSPACE</a>
<dt>output: <a href=r38_0278.html>DEMO</a>
<dt>output: <a href=r38_0279.html>DFPRINT</a>
<dt>output: <a href=r38_0280.html>DIV</a>
<dt>output: <a href=r38_0281.html>ECHO</a>
<dt>output: <a href=r38_0287.html>FACTOR</a>
<dt>output: <a href=r38_0295.html>HORNER</a>
<dt>output: <a href=r38_0298.html>INTSTR</a>
<dt>output: <a href=r38_0300.html>LESSSPACE</a>
<dt>output: <a href=r38_0306.html>MSG</a>
<dt>output: <a href=r38_0308.html>NAT</a>
<dt>output: <a href=r38_0309.html>NERO</a>
<dt>output: <a href=r38_0310.html>NOARG</a>
<dt>output: <a href=r38_0312.html>NOSPLIT</a>
<dt>output: <a href=r38_0316.html>PERIOD</a>
<dt>output: <a href=r38_0318.html>PRET</a>
<dt>output: <a href=r38_0319.html>PRI</a>
<dt>output: <a href=r38_0321.html>RAT</a>
<dt>output: <a href=r38_0325.html>RATPRI</a>
<dt>output: <a href=r38_0326.html>REVPRI</a>
<dt>output: <a href=r38_0667.html>RLFI</a>
<dt>output: <a href=r38_0673.html>TRI</a>
<dt>OUTPUT switch: <a href=r38_0314.html>OUTPUT</a>
<dt>OVERVIEW switch: <a href=r38_0315.html>OVERVIEW</a>
<dt>package: <a href=r38_0127.html>LOAD PACKAGE</a>
<dt>package: <a href=r38_0633.html>ALGINT package</a>
<dt>package: <a href=r38_0634.html>APPLYSYM</a>
<dt>package: <a href=r38_0635.html>ARNUM</a>
<dt>package: <a href=r38_0636.html>ASSIST</a>
<dt>package: <a href=r38_0637.html>AVECTOR</a>
<dt>package: <a href=r38_0638.html>BOOLEAN</a>
<dt>package: <a href=r38_0639.html>CALI</a>
<dt>package: <a href=r38_0640.html>CAMAL</a>
<dt>package: <a href=r38_0641.html>CHANGEVR</a>
<dt>package: <a href=r38_0642.html>COMPACT</a>
<dt>package: <a href=r38_0643.html>CRACK</a>
<dt>package: <a href=r38_0644.html>CVIT</a>
<dt>package: <a href=r38_0645.html>DEFINT</a>
<dt>package: <a href=r38_0646.html>DESIR</a>
<dt>package: <a href=r38_0647.html>DFPART</a>
<dt>package: <a href=r38_0648.html>DUMMY</a>
<dt>package: <a href=r38_0649.html>EXCALC</a>
<dt>package: <a href=r38_0650.html>FPS</a>
<dt>package: <a href=r38_0651.html>FIDE</a>
<dt>package: <a href=r38_0652.html>GENTRAN</a>
<dt>package: <a href=r38_0653.html>IDEALS</a>
<dt>package: <a href=r38_0654.html>INEQ</a>
<dt>package: <a href=r38_0655.html>INVBASE</a>
<dt>package: <a href=r38_0656.html>LAPLACE</a>
<dt>package: <a href=r38_0657.html>LIE</a>
<dt>package: <a href=r38_0658.html>MODSR</a>
<dt>package: <a href=r38_0659.html>NCPOLY</a>
<dt>package: <a href=r38_0660.html>ORTHOVEC</a>
<dt>package: <a href=r38_0661.html>PHYSOP</a>
<dt>package: <a href=r38_0662.html>PM</a>
<dt>package: <a href=r38_0663.html>RANDPOLY</a>
<dt>package: <a href=r38_0664.html>REACTEQN</a>
<dt>package: <a href=r38_0665.html>RESET</a>
<dt>package: <a href=r38_0666.html>RESIDUE</a>
<dt>package: <a href=r38_0667.html>RLFI</a>
<dt>package: <a href=r38_0668.html>SCOPE</a>
<dt>package: <a href=r38_0669.html>SETS</a>
<dt>package: <a href=r38_0670.html>SPDE</a>
<dt>package: <a href=r38_0671.html>SYMMETRY</a>
<dt>package: <a href=r38_0672.html>TPS</a>
<dt>package: <a href=r38_0673.html>TRI</a>
<dt>package: <a href=r38_0674.html>TRIGSIMP</a>
<dt>package: <a href=r38_0675.html>XCOLOR</a>
<dt>package: <a href=r38_0676.html>XIDEAL</a>
<dt>package: <a href=r38_0677.html>WU</a>
<dt>package: <a href=r38_0678.html>ZEILBERG</a>
<dt>package: <a href=r38_0679.html>ZTRANS</a>
<dt>partial derivative: <a href=r38_0148.html>DF</a>
<dt>partial derivative: <a href=r38_0647.html>DFPART</a>
<dt>partial fraction: <a href=r38_0170.html>PF</a>
<dt>PART operator: <a href=r38_0169.html>PART</a>
<dt>pattern matching: <a href=r38_0662.html>PM</a>
<dt>PAUSE command: <a href=r38_0128.html>PAUSE</a>
<dt>percent command: <a href=r38_0022.html>percent</a>
<dt>PERIOD switch: <a href=r38_0316.html>PERIOD</a>
<dt>PERM operator: <a href=r38_0096.html>PERM</a>
<dt>permutation: <a href=r38_0096.html>PERM</a>
<dt>PF operator: <a href=r38_0170.html>PF</a>
<dt>PHYSOP package: <a href=r38_0661.html>PHYSOP</a>
<dt>PI constant: <a href=r38_0015.html>PI</a>
<dt>pivot operator: <a href=r38_0606.html>pivot</a>
<dt>plot: <a href=r38_0551.html>Pointset</a>
<dt>plot: <a href=r38_0554.html>title</a>
<dt>plot: <a href=r38_0555.html>xlabel</a>
<dt>plot: <a href=r38_0556.html>ylabel</a>
<dt>plot: <a href=r38_0557.html>zlabel</a>
<dt>plot: <a href=r38_0558.html>terminal</a>
<dt>plot: <a href=r38_0559.html>size</a>
<dt>plot: <a href=r38_0560.html>view</a>
<dt>plot: <a href=r38_0561.html>contour</a>
<dt>plot: <a href=r38_0562.html>surface</a>
<dt>plot: <a href=r38_0563.html>hidden3d</a>
<dt>plot: <a href=r38_0568.html>SHOW GRID</a>
<dt>plot: <a href=r38_0569.html>TRPLOT</a>
<dt>PLOT command: <a href=r38_0552.html>PLOT</a>
<dt>PLOTKEEP switch: <a href=r38_0564.html>PLOTKEEP</a>
<dt>PLOTREFINE switch: <a href=r38_0565.html>PLOTREFINE</a>
<dt>PLOTRESET command: <a href=r38_0553.html>PLOTRESET</a>
<dt>plot xmesh variable: <a href=r38_0566.html>plot xmesh</a>
<dt>plot ymesh variable: <a href=r38_0567.html>plot ymesh</a>
<dt>PLUS operator: <a href=r38_0097.html>PLUS</a>
<dt>plussign operator: <a href=r38_0027.html>plussign</a>
<dt>PM package: <a href=r38_0662.html>PM</a>
<dt>POCHHAMMER operator: <a href=r38_0491.html>POCHHAMMER</a>
<dt>Pointset type: <a href=r38_0551.html>Pointset</a>
<dt>polar angle: <a href=r38_0072.html>ARG</a>
<dt>POLYGAMMA operator: <a href=r38_0495.html>POLYGAMMA</a>
<dt>polynomial: <a href=r38_0010.html>HIGH POW</a>
<dt>polynomial: <a href=r38_0013.html>LOW POW</a>
<dt>polynomial: <a href=r38_0017.html>ROOT MULTIPLICITIES</a>
<dt>polynomial: <a href=r38_0086.html>GCD</a>
<dt>polynomial: <a href=r38_0102.html>REMAINDER</a>
<dt>polynomial: <a href=r38_0145.html>DECOMPOSE</a>
<dt>polynomial: <a href=r38_0146.html>DEG</a>
<dt>polynomial: <a href=r38_0151.html>FACTORIZE</a>
<dt>polynomial: <a href=r38_0155.html>INTERPOL</a>
<dt>polynomial: <a href=r38_0156.html>LCOF</a>
<dt>polynomial: <a href=r38_0160.html>LPOWER</a>
<dt>polynomial: <a href=r38_0161.html>LTERM</a>
<dt>polynomial: <a href=r38_0162.html>MAINVAR</a>
<dt>polynomial: <a href=r38_0165.html>NPRIMITIVE</a>
<dt>polynomial: <a href=r38_0172.html>REDUCT</a>
<dt>polynomial: <a href=r38_0174.html>RESULTANT</a>
<dt>polynomial: <a href=r38_0286.html>EZGCD</a>
<dt>polynomial: <a href=r38_0292.html>FULLROOTS</a>
<dt>polynomial: <a href=r38_0295.html>HORNER</a>
<dt>polynomial: <a href=r38_0301.html>LIMITEDFACTORS</a>
<dt>polynomial: <a href=r38_0322.html>RATARG</a>
<dt>polynomial: <a href=r38_0323.html>RATIONAL</a>
<dt>polynomial: <a href=r38_0336.html>TRIGFORM</a>
<dt>polynomial: <a href=r38_0352.html>Ideal Parameters</a>
<dt>polynomial: <a href=r38_0434.html>Roots Package</a>
<dt>polynomial: <a href=r38_0435.html>MKPOLY</a>
<dt>polynomial: <a href=r38_0439.html>ROOTS</a>
<dt>polynomial: <a href=r38_0440.html>ROOT VAL</a>
<dt>polynomial: <a href=r38_0639.html>CALI</a>
<dt>polynomial: <a href=r38_0653.html>IDEALS</a>
<dt>polynomial: <a href=r38_0677.html>WU</a>
<dt>power operator: <a href=r38_0031.html>power</a>
<dt>power series: <a href=r38_0650.html>FPS</a>
<dt>power series: <a href=r38_0672.html>TPS</a>
<dt>PRECEDENCE declaration: <a href=r38_0213.html>PRECEDENCE</a>
<dt>PRECISE switch: <a href=r38_0317.html>PRECISE</a>
<dt>precision: <a href=r38_0071.html>ADJPREC</a>
<dt>precision: <a href=r38_0291.html>FULLPREC</a>
<dt>PRECISION declaration: <a href=r38_0214.html>PRECISION</a>
<dt>preduce operator: <a href=r38_0386.html>preduce</a>
<dt>preducet operator: <a href=r38_0399.html>preducet</a>
<dt>PRET switch: <a href=r38_0318.html>PRET</a>
<dt>prime number: <a href=r38_0093.html>NEXTPRIME</a>
<dt>prime number: <a href=r38_0121.html>PRIMEP</a>
<dt>PRIMEP operator: <a href=r38_0121.html>PRIMEP</a>
<dt>primitive part: <a href=r38_0165.html>NPRIMITIVE</a>
<dt>PRINT PRECISION declaration: <a href=r38_0215.html>PRINT PRECISION</a>
<dt>PRI switch: <a href=r38_0319.html>PRI</a>
<dt>PROCEDURE command: <a href=r38_0055.html>PROCEDURE</a>
<dt>PROD operator: <a href=r38_0171.html>PROD</a>
<dt>product: <a href=r38_0171.html>PROD</a>
<dt>pseudo inverse operator: <a href=r38_0607.html>pseudo inverse</a>
<dt>PSI operator: <a href=r38_0494.html>PSI</a>
<dt>QUIT command: <a href=r38_0129.html>QUIT</a>
<dt>QUOTIENT operator: <a href=r38_0098.html>QUOTIENT</a>
<dt>RAD2DEG operator: <a href=r38_0099.html>RAD2DEG</a>
<dt>RAD2DMS operator: <a href=r38_0100.html>RAD2DMS</a>
<dt>radians: <a href=r38_0075.html>DEG2DMS</a>
<dt>radians: <a href=r38_0076.html>DEG2RAD</a>
<dt>radians: <a href=r38_0079.html>DMS2DEG</a>
<dt>radians: <a href=r38_0080.html>DMS2RAD</a>
<dt>radians: <a href=r38_0099.html>RAD2DEG</a>
<dt>radians: <a href=r38_0100.html>RAD2DMS</a>
<dt>RAISE switch: <a href=r38_0320.html>RAISE</a>
<dt>random matrix operator: <a href=r38_0608.html>random matrix</a>
<dt>random polynomial: <a href=r38_0663.html>RANDPOLY</a>
<dt>RANDPOLY package: <a href=r38_0663.html>RANDPOLY</a>
<dt>RANK operator: <a href=r38_0347.html>RANK</a>
<dt>RATARG switch: <a href=r38_0322.html>RATARG</a>
<dt>rational expression: <a href=r38_0147.html>DEN</a>
<dt>rational expression: <a href=r38_0166.html>NUM</a>
<dt>rational expression: <a href=r38_0170.html>PF</a>
<dt>rational expression: <a href=r38_0294.html>GCD switch</a>
<dt>rational expression: <a href=r38_0299.html>LCM</a>
<dt>rational expression: <a href=r38_0304.html>MCD</a>
<dt>rational expression: <a href=r38_0322.html>RATARG</a>
<dt>rational expression: <a href=r38_0323.html>RATIONAL</a>
<dt>rational expression: <a href=r38_0324.html>RATIONALIZE</a>
<dt>rational expression: <a href=r38_0325.html>RATPRI</a>
<dt>rational expression: <a href=r38_0328.html>ROUNDALL</a>
<dt>RATIONALIZE switch: <a href=r38_0324.html>RATIONALIZE</a>
<dt>rational numbers: <a href=r38_0144.html>CONTINUED FRACTION</a>
<dt>RATIONAL switch: <a href=r38_0323.html>RATIONAL</a>
<dt>Ratjordan operator: <a href=r38_0628.html>Ratjordan</a>
<dt>RATPRI switch: <a href=r38_0325.html>RATPRI</a>
<dt>RAT switch: <a href=r38_0321.html>RAT</a>
<dt>REACTEQN package: <a href=r38_0664.html>REACTEQN</a>
<dt>REAL declaration: <a href=r38_0216.html>REAL</a>
<dt>real part: <a href=r38_0173.html>REPART</a>
<dt>REALROOTS operator: <a href=r38_0437.html>REALROOTS</a>
<dt>RECIP operator: <a href=r38_0101.html>RECIP</a>
<dt>RECLAIM operator: <a href=r38_0130.html>RECLAIM</a>
<dt>REDERR command: <a href=r38_0131.html>REDERR</a>
<dt>REDUCT operator: <a href=r38_0172.html>REDUCT</a>
<dt>reductum: <a href=r38_0172.html>REDUCT</a>
<dt>REMAINDER operator: <a href=r38_0102.html>REMAINDER</a>
<dt>REMFAC declaration: <a href=r38_0217.html>REMFAC</a>
<dt>REMIND declaration: <a href=r38_0417.html>REMIND</a>
<dt>remove columns operator: <a href=r38_0609.html>remove columns</a>
<dt>remove rows operator: <a href=r38_0610.html>remove rows</a>
<dt>REPART operator: <a href=r38_0173.html>REPART</a>
<dt>REPEAT command: <a href=r38_0056.html>REPEAT</a>
<dt>replace operator: <a href=r38_0026.html>replace</a>
<dt>requirements variable: <a href=r38_0016.html>requirements</a>
<dt>RESET package: <a href=r38_0665.html>RESET</a>
<dt>RESIDUE package: <a href=r38_0666.html>RESIDUE</a>
<dt>REST operator: <a href=r38_0057.html>REST</a>
<dt>RESULTANT operator: <a href=r38_0174.html>RESULTANT</a>
<dt>RETRY command: <a href=r38_0132.html>RETRY</a>
<dt>RETURN command: <a href=r38_0058.html>RETURN</a>
<dt>REVERSE operator: <a href=r38_0059.html>REVERSE</a>
<dt>revgradlex term order concept: <a href=r38_0358.html>revgradlex term order
</a>
<dt>REVPRI switch: <a href=r38_0326.html>REVPRI</a>
<dt>RHS operator: <a href=r38_0175.html>RHS</a>
<dt>right-hand side: <a href=r38_0175.html>RHS</a>
<dt>RLFI package: <a href=r38_0667.html>RLFI</a>
<dt>RLISP88 switch: <a href=r38_0327.html>RLISP88</a>
<dt>rlrootno: <a href=r38_0434.html>Roots Package</a>
<dt>root: <a href=r38_0179.html>SOLVE</a>
<dt>root: <a href=r38_0427.html>num solve</a>
<dt>ROOTACC operator: <a href=r38_0438.html>ROOTACC</a>
<dt>ROOT MULTIPLICITIES variable: <a href=r38_0017.html>ROOT MULTIPLICITIES</a>
<dt>ROOT OF operator: <a href=r38_0176.html>ROOT OF</a>
<dt>roots: <a href=r38_0176.html>ROOT OF</a>
<dt>roots: <a href=r38_0435.html>MKPOLY</a>
<dt>roots: <a href=r38_0436.html>NEARESTROOT</a>
<dt>roots: <a href=r38_0437.html>REALROOTS</a>
<dt>roots: <a href=r38_0438.html>ROOTACC</a>
<dt>roots: <a href=r38_0440.html>ROOT VAL</a>
<dt>rootsat-prec: <a href=r38_0434.html>Roots Package</a>
<dt>ROOTSCOMPLEX variable: <a href=r38_0441.html>ROOTSCOMPLEX</a>
<dt>ROOTS operator: <a href=r38_0439.html>ROOTS</a>
<dt>Roots Package introduction: <a href=r38_0434.html>Roots Package</a>
<dt>ROOTSREAL variable: <a href=r38_0442.html>ROOTSREAL</a>
<dt>rootval: <a href=r38_0434.html>Roots Package</a>
<dt>ROOT VAL operator: <a href=r38_0440.html>ROOT VAL</a>
<dt>ROUNDALL switch: <a href=r38_0328.html>ROUNDALL</a>
<dt>ROUNDBF switch: <a href=r38_0329.html>ROUNDBF</a>
<dt>rounded: <a href=r38_0214.html>PRECISION</a>
<dt>rounded: <a href=r38_0215.html>PRINT PRECISION</a>
<dt>rounded: <a href=r38_0219.html>SCIENTIFIC NOTATION</a>
<dt>rounded: <a href=r38_0291.html>FULLPREC</a>
<dt>rounded: <a href=r38_0313.html>NUMVAL</a>
<dt>rounded: <a href=r38_0328.html>ROUNDALL</a>
<dt>ROUNDED switch: <a href=r38_0330.html>ROUNDED</a>
<dt>ROUND operator: <a href=r38_0103.html>ROUND</a>
<dt>row dim operator: <a href=r38_0611.html>row dim</a>
<dt>rows pivot operator: <a href=r38_0612.html>rows pivot</a>
<dt>rule: <a href=r38_0067.html>WHEN</a>
<dt>rule: <a href=r38_0178.html>SHOWRULES</a>
<dt>rule: <a href=r38_0190.html>CLEARRULES</a>
<dt>rule: <a href=r38_0199.html>LET</a>
<dt>rule list: <a href=r38_0060.html>RULE</a>
<dt>RULE type: <a href=r38_0060.html>RULE</a>
<dt>Runge-Kutta: <a href=r38_0429.html>num odesolve</a>
<dt>saturation operator: <a href=r38_0389.html>saturation</a>
<dt>SAVEAS command: <a href=r38_0133.html>SAVEAS</a>
<dt>SAVESTRUCTR switch: <a href=r38_0331.html>SAVESTRUCTR</a>
<dt>SCALAR declaration: <a href=r38_0218.html>SCALAR</a>
<dt>SCIENTIFIC NOTATION declaration: <a href=r38_0219.html>SCIENTIFIC NOTATION
</a>
<dt>SCOPE package: <a href=r38_0668.html>SCOPE</a>
<dt>SECH operator: <a href=r38_0258.html>SECH</a>
<dt>SECOND operator: <a href=r38_0063.html>SECOND</a>
<dt>SEC operator: <a href=r38_0257.html>SEC</a>
<dt>SELECT operator: <a href=r38_0177.html>SELECT</a>
<dt>semicolon command: <a href=r38_0020.html>semicolon</a>
<dt>SETMOD command: <a href=r38_0104.html>SETMOD</a>
<dt>SET operator: <a href=r38_0064.html>SET</a>
<dt>SETQ operator: <a href=r38_0065.html>SETQ</a>
<dt>SETS package: <a href=r38_0669.html>SETS</a>
<dt>SHARE declaration: <a href=r38_0220.html>SHARE</a>
<dt>Shi operator: <a href=r38_0511.html>Shi</a>
<dt>SHOW GRID switch: <a href=r38_0568.html>SHOW GRID</a>
<dt>SHOWRULES operator: <a href=r38_0178.html>SHOWRULES</a>
<dt>SHOWTIME command: <a href=r38_0134.html>SHOWTIME</a>
<dt>SHUT command: <a href=r38_0234.html>SHUT</a>
<dt>SIGN operator: <a href=r38_0105.html>SIGN</a>
<dt>simplex operator: <a href=r38_0613.html>simplex</a>
<dt>simplification: <a href=r38_0284.html>EXP switch</a>
<dt>simplification: <a href=r38_0317.html>PRECISE</a>
<dt>simplification: <a href=r38_0324.html>RATIONALIZE</a>
<dt>simplification: <a href=r38_0642.html>COMPACT</a>
<dt>simplification: <a href=r38_0674.html>TRIGSIMP</a>
<dt>sine: <a href=r38_0259.html>SIN</a>
<dt>Sine integral function: <a href=r38_0510.html>Si</a>
<dt>sine integral function: <a href=r38_0512.html>s i</a>
<dt>singular value decomposition: <a href=r38_0617.html>svd</a>
<dt>SINH operator: <a href=r38_0260.html>SINH</a>
<dt>SIN operator: <a href=r38_0259.html>SIN</a>
<dt>Si operator: <a href=r38_0510.html>Si</a>
<dt>s i operator: <a href=r38_0512.html>s i</a>
<dt>SixjSymbol operator: <a href=r38_0527.html>SixjSymbol</a>
<dt>size variable: <a href=r38_0559.html>size</a>
<dt>slash operator: <a href=r38_0030.html>slash</a>
<dt>Smithex int operator: <a href=r38_0626.html>Smithex int</a>
<dt>Smithex operator: <a href=r38_0625.html>Smithex</a>
<dt>Solid harmonic polynomials: <a href=r38_0507.html>SolidHarmonicY</a>
<dt>SolidHarmonicY operator: <a href=r38_0507.html>SolidHarmonicY</a>
<dt>solve: <a href=r38_0005.html>assumptions</a>
<dt>solve: <a href=r38_0016.html>requirements</a>
<dt>solve: <a href=r38_0017.html>ROOT MULTIPLICITIES</a>
<dt>solve: <a href=r38_0149.html>EXPAND CASES</a>
<dt>solve: <a href=r38_0167.html>ODESOLVE</a>
<dt>solve: <a href=r38_0176.html>ROOT OF</a>
<dt>solve: <a href=r38_0268.html>ARBVARS</a>
<dt>solve: <a href=r38_0276.html>CRAMER</a>
<dt>solve: <a href=r38_0292.html>FULLROOTS</a>
<dt>solve: <a href=r38_0307.html>MULTIPLICITIES</a>
<dt>solve: <a href=r38_0336.html>TRIGFORM</a>
<dt>solve: <a href=r38_0338.html>TRNONLNR</a>
<dt>solve: <a href=r38_0339.html>VAROPT</a>
<dt>solve: <a href=r38_0436.html>NEARESTROOT</a>
<dt>solve: <a href=r38_0437.html>REALROOTS</a>
<dt>solve: <a href=r38_0439.html>ROOTS</a>
<dt>solve: <a href=r38_0440.html>ROOT VAL</a>
<dt>SOLVE operator: <a href=r38_0179.html>SOLVE</a>
<dt>SOLVESINGULAR switch: <a href=r38_0332.html>SOLVESINGULAR</a>
<dt>sorting: <a href=r38_0180.html>SORT</a>
<dt>SORT operator: <a href=r38_0180.html>SORT</a>
<dt>SPDE package: <a href=r38_0670.html>SPDE</a>
<dt>Special Function Package introduction: <a href=r38_0444.html>Special Functio
n Package</a>
<dt>Spence's Integral: <a href=r38_0497.html>DILOG extended</a>
<dt>Spherical harmonic polynomials: <a href=r38_0508.html>SphericalHarmonicY</a>
<dt>SphericalHarmonicY operator: <a href=r38_0508.html>SphericalHarmonicY</a>
<dt>SPUR declaration: <a href=r38_0418.html>SPUR</a>
<dt>SQRT operator: <a href=r38_0106.html>SQRT</a>
<dt>squarep operator: <a href=r38_0614.html>squarep</a>
<dt>square root: <a href=r38_0106.html>SQRT</a>
<dt>square root: <a href=r38_0317.html>PRECISE</a>
<dt>stack rows operator: <a href=r38_0615.html>stack rows</a>
<dt>steepest descent: <a href=r38_0426.html>num min</a>
<dt>STIRLING1 operator: <a href=r38_0522.html>STIRLING1</a>
<dt>STIRLING2 operator: <a href=r38_0523.html>STIRLING2</a>
<dt>STRING type: <a href=r38_0003.html>STRING</a>
<dt>STRUCTR operator: <a href=r38_0181.html>STRUCTR</a>
<dt>STRUCTR OPERATOR: <a href=r38_0331.html>SAVESTRUCTR</a>
<dt>StruveH operator: <a href=r38_0458.html>StruveH</a>
<dt>StruveL operator: <a href=r38_0459.html>StruveL</a>
<dt>sub matrix operator: <a href=r38_0616.html>sub matrix</a>
<dt>SUB operator: <a href=r38_0182.html>SUB</a>
<dt>substitution: <a href=r38_0182.html>SUB</a>
<dt>substitution: <a href=r38_0195.html>FORALL</a>
<dt>substitution: <a href=r38_0199.html>LET</a>
<dt>substitution: <a href=r38_0205.html>MATCH</a>
<dt>substitution: <a href=r38_0227.html>WHERE</a>
<dt>summation: <a href=r38_0183.html>SUM</a>
<dt>summation: <a href=r38_0678.html>ZEILBERG</a>
<dt>SUM operator: <a href=r38_0183.html>SUM</a>
<dt>surface switch: <a href=r38_0562.html>surface</a>
<dt>svd operator: <a href=r38_0617.html>svd</a>
<dt>swap columns operator: <a href=r38_0618.html>swap columns</a>
<dt>swap entries operator: <a href=r38_0619.html>swap entries</a>
<dt>swap rows operator: <a href=r38_0620.html>swap rows</a>
<dt>switch: <a href=r38_0071.html>ADJPREC</a>
<dt>switch: <a href=r38_0094.html>NOCONVERT</a>
<dt>switch: <a href=r38_0209.html>OFF</a>
<dt>switch: <a href=r38_0210.html>ON</a>
<dt>switch: <a href=r38_0265.html>ALGINT</a>
<dt>switch: <a href=r38_0266.html>ALLBRANCH</a>
<dt>switch: <a href=r38_0267.html>ALLFAC</a>
<dt>switch: <a href=r38_0268.html>ARBVARS</a>
<dt>switch: <a href=r38_0269.html>BALANCED MOD</a>
<dt>switch: <a href=r38_0270.html>BFSPACE</a>
<dt>switch: <a href=r38_0271.html>COMBINEEXPT</a>
<dt>switch: <a href=r38_0272.html>COMBINELOGS</a>
<dt>switch: <a href=r38_0273.html>COMP</a>
<dt>switch: <a href=r38_0274.html>COMPLEX</a>
<dt>switch: <a href=r38_0275.html>CREF</a>
<dt>switch: <a href=r38_0276.html>CRAMER</a>
<dt>switch: <a href=r38_0277.html>DEFN</a>
<dt>switch: <a href=r38_0278.html>DEMO</a>
<dt>switch: <a href=r38_0279.html>DFPRINT</a>
<dt>switch: <a href=r38_0280.html>DIV</a>
<dt>switch: <a href=r38_0281.html>ECHO</a>
<dt>switch: <a href=r38_0282.html>ERRCONT</a>
<dt>switch: <a href=r38_0283.html>EVALLHSEQP</a>
<dt>switch: <a href=r38_0284.html>EXP switch</a>
<dt>switch: <a href=r38_0285.html>EXPANDLOGS</a>
<dt>switch: <a href=r38_0286.html>EZGCD</a>
<dt>switch: <a href=r38_0287.html>FACTOR</a>
<dt>switch: <a href=r38_0288.html>FAILHARD</a>
<dt>switch: <a href=r38_0289.html>FORT</a>
<dt>switch: <a href=r38_0290.html>FORTUPPER</a>
<dt>switch: <a href=r38_0291.html>FULLPREC</a>
<dt>switch: <a href=r38_0292.html>FULLROOTS</a>
<dt>switch: <a href=r38_0293.html>GC</a>
<dt>switch: <a href=r38_0294.html>GCD switch</a>
<dt>switch: <a href=r38_0295.html>HORNER</a>
<dt>switch: <a href=r38_0296.html>IFACTOR</a>
<dt>switch: <a href=r38_0297.html>INT switch</a>
<dt>switch: <a href=r38_0298.html>INTSTR</a>
<dt>switch: <a href=r38_0299.html>LCM</a>
<dt>switch: <a href=r38_0300.html>LESSSPACE</a>
<dt>switch: <a href=r38_0301.html>LIMITEDFACTORS</a>
<dt>switch: <a href=r38_0302.html>LIST switch</a>
<dt>switch: <a href=r38_0303.html>LISTARGS</a>
<dt>switch: <a href=r38_0304.html>MCD</a>
<dt>switch: <a href=r38_0305.html>MODULAR</a>
<dt>switch: <a href=r38_0306.html>MSG</a>
<dt>switch: <a href=r38_0307.html>MULTIPLICITIES</a>
<dt>switch: <a href=r38_0308.html>NAT</a>
<dt>switch: <a href=r38_0309.html>NERO</a>
<dt>switch: <a href=r38_0310.html>NOARG</a>
<dt>switch: <a href=r38_0311.html>NOLNR</a>
<dt>switch: <a href=r38_0312.html>NOSPLIT</a>
<dt>switch: <a href=r38_0313.html>NUMVAL</a>
<dt>switch: <a href=r38_0314.html>OUTPUT</a>
<dt>switch: <a href=r38_0315.html>OVERVIEW</a>
<dt>switch: <a href=r38_0316.html>PERIOD</a>
<dt>switch: <a href=r38_0317.html>PRECISE</a>
<dt>switch: <a href=r38_0318.html>PRET</a>
<dt>switch: <a href=r38_0319.html>PRI</a>
<dt>switch: <a href=r38_0320.html>RAISE</a>
<dt>switch: <a href=r38_0321.html>RAT</a>
<dt>switch: <a href=r38_0322.html>RATARG</a>
<dt>switch: <a href=r38_0323.html>RATIONAL</a>
<dt>switch: <a href=r38_0324.html>RATIONALIZE</a>
<dt>switch: <a href=r38_0325.html>RATPRI</a>
<dt>switch: <a href=r38_0326.html>REVPRI</a>
<dt>switch: <a href=r38_0327.html>RLISP88</a>
<dt>switch: <a href=r38_0328.html>ROUNDALL</a>
<dt>switch: <a href=r38_0329.html>ROUNDBF</a>
<dt>switch: <a href=r38_0330.html>ROUNDED</a>
<dt>switch: <a href=r38_0331.html>SAVESTRUCTR</a>
<dt>switch: <a href=r38_0332.html>SOLVESINGULAR</a>
<dt>switch: <a href=r38_0333.html>TIME</a>
<dt>switch: <a href=r38_0334.html>TRALLFAC</a>
<dt>switch: <a href=r38_0335.html>TRFAC</a>
<dt>switch: <a href=r38_0336.html>TRIGFORM</a>
<dt>switch: <a href=r38_0337.html>TRINT</a>
<dt>switch: <a href=r38_0338.html>TRNONLNR</a>
<dt>switch: <a href=r38_0339.html>VAROPT</a>
<dt>switch: <a href=r38_0370.html>groebopt</a>
<dt>switch: <a href=r38_0372.html>groebprereduce</a>
<dt>switch: <a href=r38_0373.html>groebfullreduction</a>
<dt>switch: <a href=r38_0374.html>gltbasis</a>
<dt>switch: <a href=r38_0377.html>groebstat</a>
<dt>switch: <a href=r38_0378.html>trgroeb</a>
<dt>switch: <a href=r38_0379.html>trgroebs</a>
<dt>switch: <a href=r38_0396.html>groebprot</a>
<dt>switch: <a href=r38_0425.html>TRNUMERIC</a>
<dt>switch: <a href=r38_0537.html>taylorautocombine</a>
<dt>switch: <a href=r38_0538.html>taylorautoexpand</a>
<dt>switch: <a href=r38_0540.html>taylorkeeporiginal</a>
<dt>switch: <a href=r38_0542.html>taylorprintorder</a>
<dt>switch: <a href=r38_0561.html>contour</a>
<dt>switch: <a href=r38_0562.html>surface</a>
<dt>switch: <a href=r38_0563.html>hidden3d</a>
<dt>switch: <a href=r38_0564.html>PLOTKEEP</a>
<dt>switch: <a href=r38_0565.html>PLOTREFINE</a>
<dt>switch: <a href=r38_0568.html>SHOW GRID</a>
<dt>switch: <a href=r38_0569.html>TRPLOT</a>
<dt>switch: <a href=r38_0572.html>fast la</a>
<dt>SWITCHES introduction: <a href=r38_0264.html>SWITCHES</a>
<dt>symbolic: <a href=r38_0008.html>EVAL MODE</a>
<dt>SYMBOLIC command: <a href=r38_0221.html>SYMBOLIC</a>
<dt>SYMMETRIC declaration: <a href=r38_0222.html>SYMMETRIC</a>
<dt>symmetricp operator: <a href=r38_0621.html>symmetricp</a>
<dt>symmetries: <a href=r38_0634.html>APPLYSYM</a>
<dt>SYMMETRY package: <a href=r38_0671.html>SYMMETRY</a>
<dt>TANH operator: <a href=r38_0262.html>TANH</a>
<dt>TAN operator: <a href=r38_0261.html>TAN</a>
<dt>Taylor: <a href=r38_0660.html>ORTHOVEC</a>
<dt>taylorautocombine switch: <a href=r38_0537.html>taylorautocombine</a>
<dt>taylorautoexpand switch: <a href=r38_0538.html>taylorautoexpand</a>
<dt>taylorcombine operator: <a href=r38_0539.html>taylorcombine</a>
<dt>TAYLOR introduction: <a href=r38_0535.html>TAYLOR introduction</a>
<dt>taylorkeeporiginal switch: <a href=r38_0540.html>taylorkeeporiginal</a>
<dt>taylor operator: <a href=r38_0536.html>taylor</a>
<dt>taylororiginal operator: <a href=r38_0541.html>taylororiginal</a>
<dt>taylorprintorder switch: <a href=r38_0542.html>taylorprintorder</a>
<dt>taylorprintterms variable: <a href=r38_0543.html>taylorprintterms</a>
<dt>taylorrevert operator: <a href=r38_0544.html>taylorrevert</a>
<dt>Taylor series: <a href=r38_0672.html>TPS</a>
<dt>taylorseriesp operator: <a href=r38_0545.html>taylorseriesp</a>
<dt>taylortemplate operator: <a href=r38_0546.html>taylortemplate</a>
<dt>taylortostandard operator: <a href=r38_0547.html>taylortostandard</a>
<dt>T constant: <a href=r38_0018.html>T</a>
<dt>terminal variable: <a href=r38_0558.html>terminal</a>
<dt>term order: <a href=r38_0355.html>torder compile</a>
<dt>term order: <a href=r38_0356.html>lex term order</a>
<dt>term order: <a href=r38_0357.html>gradlex term order</a>
<dt>term order: <a href=r38_0358.html>revgradlex term order</a>
<dt>term order: <a href=r38_0359.html>gradlexgradlex term order</a>
<dt>term order: <a href=r38_0360.html>gradlexrevgradlex term order</a>
<dt>term order: <a href=r38_0361.html>lexgradlex term order</a>
<dt>term order: <a href=r38_0362.html>lexrevgradlex term order</a>
<dt>term order: <a href=r38_0363.html>weighted term order</a>
<dt>term order: <a href=r38_0364.html>graded term order</a>
<dt>term order: <a href=r38_0365.html>matrix term order</a>
<dt>term order: <a href=r38_0384.html>glexconvert</a>
<dt>Term order introduction: <a href=r38_0353.html>Term order</a>
<dt>TEX: <a href=r38_0667.html>RLFI</a>
<dt>TEX: <a href=r38_0673.html>TRI</a>
<dt>then: <a href=r38_0052.html>IF</a>
<dt>THIRD operator: <a href=r38_0066.html>THIRD</a>
<dt>ThreejSymbol operator: <a href=r38_0525.html>ThreejSymbol</a>
<dt>tilde operator: <a href=r38_0037.html>tilde</a>
<dt>time: <a href=r38_0134.html>SHOWTIME</a>
<dt>TIMES operator: <a href=r38_0107.html>TIMES</a>
<dt>TIME switch: <a href=r38_0333.html>TIME</a>
<dt>title variable: <a href=r38_0554.html>title</a>
<dt>toeplitz operator: <a href=r38_0622.html>toeplitz</a>
<dt>Top: <a href=r38_0682.html>EDITDEF</a>
<dt>torder compile operator: <a href=r38_0355.html>torder compile</a>
<dt>torder operator: <a href=r38_0354.html>torder</a>
<dt>TP operator: <a href=r38_0348.html>TP</a>
<dt>TPS package: <a href=r38_0672.html>TPS</a>
<dt>trace: <a href=r38_0223.html>TR</a>
<dt>trace: <a href=r38_0224.html>UNTR</a>
<dt>TRACE operator: <a href=r38_0349.html>TRACE</a>
<dt>TRALLFAC switch: <a href=r38_0334.html>TRALLFAC</a>
<dt>transform: <a href=r38_0656.html>LAPLACE</a>
<dt>transpose: <a href=r38_0348.html>TP</a>
<dt>TR declaration: <a href=r38_0223.html>TR</a>
<dt>TRFAC switch: <a href=r38_0335.html>TRFAC</a>
<dt>trgroebs switch: <a href=r38_0379.html>trgroebs</a>
<dt>trgroeb switch: <a href=r38_0378.html>trgroeb</a>
<dt>TRIGFORM switch: <a href=r38_0336.html>TRIGFORM</a>
<dt>TRIGSIMP package: <a href=r38_0674.html>TRIGSIMP</a>
<dt>TRINT switch: <a href=r38_0337.html>TRINT</a>
<dt>TRI package: <a href=r38_0673.html>TRI</a>
<dt>TRNONLNR switch: <a href=r38_0338.html>TRNONLNR</a>
<dt>TRNUMERIC switch: <a href=r38_0425.html>TRNUMERIC</a>
<dt>TRPLOT switch: <a href=r38_0569.html>TRPLOT</a>
<dt>TRUE concept: <a href=r38_0122.html>TRUE</a>
<dt>type: <a href=r38_0001.html>IDENTIFIER</a>
<dt>type: <a href=r38_0002.html>KERNEL</a>
<dt>type: <a href=r38_0003.html>STRING</a>
<dt>type: <a href=r38_0045.html>EQUATION</a>
<dt>type: <a href=r38_0060.html>RULE</a>
<dt>type: <a href=r38_0061.html>Free Variable</a>
<dt>type: <a href=r38_0062.html>Optional Free Variable</a>
<dt>type: <a href=r38_0168.html>ONE OF</a>
<dt>type: <a href=r38_0423.html>Interval</a>
<dt>type: <a href=r38_0551.html>Pointset</a>
<dt>ultraspherical polynomials: <a href=r38_0506.html>GegenbauerP</a>
<dt>univariate polynomial: <a href=r38_0384.html>glexconvert</a>
<dt>until: <a href=r38_0056.html>REPEAT</a>
<dt>UNTR declaration: <a href=r38_0224.html>UNTR</a>
<dt>utilities: <a href=r38_0636.html>ASSIST</a>
<dt>vandermonde operator: <a href=r38_0623.html>vandermonde</a>
<dt>variable: <a href=r38_0005.html>assumptions</a>
<dt>variable: <a href=r38_0006.html>CARD NO</a>
<dt>variable: <a href=r38_0008.html>EVAL MODE</a>
<dt>variable: <a href=r38_0009.html>FORT WIDTH</a>
<dt>variable: <a href=r38_0010.html>HIGH POW</a>
<dt>variable: <a href=r38_0013.html>LOW POW</a>
<dt>variable: <a href=r38_0016.html>requirements</a>
<dt>variable: <a href=r38_0017.html>ROOT MULTIPLICITIES</a>
<dt>variable: <a href=r38_0061.html>Free Variable</a>
<dt>variable: <a href=r38_0062.html>Optional Free Variable</a>
<dt>variable: <a href=r38_0371.html>gvarslast</a>
<dt>variable: <a href=r38_0375.html>gltb</a>
<dt>variable: <a href=r38_0376.html>glterms</a>
<dt>variable: <a href=r38_0392.html>groebmonfac</a>
<dt>variable: <a href=r38_0393.html>groebresmax</a>
<dt>variable: <a href=r38_0394.html>groebrestriction</a>
<dt>variable: <a href=r38_0397.html>groebprotfile</a>
<dt>variable: <a href=r38_0402.html>gmodule</a>
<dt>variable: <a href=r38_0441.html>ROOTSCOMPLEX</a>
<dt>variable: <a href=r38_0442.html>ROOTSREAL</a>
<dt>variable: <a href=r38_0543.html>taylorprintterms</a>
<dt>variable: <a href=r38_0554.html>title</a>
<dt>variable: <a href=r38_0555.html>xlabel</a>
<dt>variable: <a href=r38_0556.html>ylabel</a>
<dt>variable: <a href=r38_0557.html>zlabel</a>
<dt>variable: <a href=r38_0558.html>terminal</a>
<dt>variable: <a href=r38_0559.html>size</a>
<dt>variable: <a href=r38_0560.html>view</a>
<dt>variable: <a href=r38_0566.html>plot xmesh</a>
<dt>variable: <a href=r38_0567.html>plot ymesh</a>
<dt>variable elimination: <a href=r38_0356.html>lex term order</a>
<dt>variable order: <a href=r38_0198.html>KORDER</a>
<dt>variable order: <a href=r38_0212.html>ORDER</a>
<dt>VARNAME declaration: <a href=r38_0225.html>VARNAME</a>
<dt>VAROPT switch: <a href=r38_0339.html>VAROPT</a>
<dt>VECDIM command: <a href=r38_0419.html>VECDIM</a>
<dt>vector algebra: <a href=r38_0637.html>AVECTOR</a>
<dt>vector algebra: <a href=r38_0660.html>ORTHOVEC</a>
<dt>vector calculus: <a href=r38_0660.html>ORTHOVEC</a>
<dt>VECTOR declaration: <a href=r38_0420.html>VECTOR</a>
<dt>view variable: <a href=r38_0560.html>view</a>
<dt>Weber's function: <a href=r38_0453.html>BESSELY</a>
<dt>WEIGHT command: <a href=r38_0226.html>WEIGHT</a>
<dt>weighted term order concept: <a href=r38_0363.html>weighted term order</a>
<dt>WHEN operator: <a href=r38_0067.html>WHEN</a>
<dt>WHERE operator: <a href=r38_0227.html>WHERE</a>
<dt>WHILE command: <a href=r38_0228.html>WHILE</a>
<dt>WhittakerW operator: <a href=r38_0462.html>WhittakerW</a>
<dt>work space: <a href=r38_0184.html>WS</a>
<dt>WRITE command: <a href=r38_0135.html>WRITE</a>
<dt>WS operator: <a href=r38_0184.html>WS</a>
<dt>WTLEVEL command: <a href=r38_0229.html>WTLEVEL</a>
<dt>WU package: <a href=r38_0677.html>WU</a>
<dt>Wu-Wen-Tsun algorithm: <a href=r38_0677.html>WU</a>
<dt>XCOLOR package: <a href=r38_0675.html>XCOLOR</a>
<dt>XIDEAL package: <a href=r38_0676.html>XIDEAL</a>
<dt>xlabel variable: <a href=r38_0555.html>xlabel</a>
<dt>ylabel variable: <a href=r38_0556.html>ylabel</a>
<dt>ZEILBERG package: <a href=r38_0678.html>ZEILBERG</a>
<dt>ZETA operator: <a href=r38_0450.html>ZETA</a>
<dt>zlabel variable: <a href=r38_0557.html>zlabel</a>
<dt>ZTRANS package: <a href=r38_0679.html>ZTRANS</a>
</menu>