<a name=r38_0250>
<title>COSH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0237>acosh</a>).
A numeric value is not returned by <em>cosh</em> unless the switch
<a href=r38_0300.html#r38_0330>rounded</a> is on and its argument evaluates to a
number.
<P>
<P>
<P>
<P>
<a name=r38_0251>
<title>COT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>rounded</a>.
<P>
<P>
<P>
<P>
<a name=r38_0252>
<title>COTH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0199>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_0300.html#r38_0330>rounded</a>.
<P>
<P>
<P>
<P>
<a name=r38_0253>
<title>CSC</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0199>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_0300.html#r38_0330>rounded</a>.
<P>
<P>
<P>
<P>
<a name=r38_0254>
<title>CSCH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>rounded</a> is on and its argument evaluates to a
number.
<P>
<P>
<P>
<a name=r38_0255>
<title>ERF</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0256>
<title>EXP</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0257>
<title>SEC</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>rounded</a> is on. Then the
secant is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<a name=r38_0258>
<title>SECH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>rounded</a> is on. Then the
expression is calculated to the current degree of floating point precision.
<P>
<P>
<P>
<a name=r38_0259>
<title>SIN</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0260>
<title>SINH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0245>asinh</a>).
A numeric value is not returned by <em>sinh</em> unless the switch
<a href=r38_0300.html#r38_0330>rounded</a> is on and its argument evaluates to a
number.
<P>
<P>
<P>
<a name=r38_0261>
<title>TAN</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>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=r38_0262>
<title>TANH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0247>atanh</a>).
A numeric value is not returned by <em>tanh</em> unless the switch
<a href=r38_0300.html#r38_0330>rounded</a> is on and its argument evaluates to a
number.
<P>
<P>
<P>
<a name=r38_0263>
<title>Elementary Functions</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<b><a href=r38_idx.html>INDEX</a></b><p><p>
<b>Elementary Functions</b><menu>
<li><a href=r38_0200.html#r38_0236>ACOS operator</a><P>
<li><a href=r38_0200.html#r38_0237>ACOSH operator</a><P>
<li><a href=r38_0200.html#r38_0238>ACOT operator</a><P>
<li><a href=r38_0200.html#r38_0239>ACOTH operator</a><P>
<li><a href=r38_0200.html#r38_0240>ACSC operator</a><P>
<li><a href=r38_0200.html#r38_0241>ACSCH operator</a><P>
<li><a href=r38_0200.html#r38_0242>ASEC operator</a><P>
<li><a href=r38_0200.html#r38_0243>ASECH operator</a><P>
<li><a href=r38_0200.html#r38_0244>ASIN operator</a><P>
<li><a href=r38_0200.html#r38_0245>ASINH operator</a><P>
<li><a href=r38_0200.html#r38_0246>ATAN operator</a><P>
<li><a href=r38_0200.html#r38_0247>ATANH operator</a><P>
<li><a href=r38_0200.html#r38_0248>ATAN2 operator</a><P>
<li><a href=r38_0200.html#r38_0249>COS operator</a><P>
<li><a href=r38_0250.html#r38_0250>COSH operator</a><P>
<li><a href=r38_0250.html#r38_0251>COT operator</a><P>
<li><a href=r38_0250.html#r38_0252>COTH operator</a><P>
<li><a href=r38_0250.html#r38_0253>CSC operator</a><P>
<li><a href=r38_0250.html#r38_0254>CSCH operator</a><P>
<li><a href=r38_0250.html#r38_0255>ERF operator</a><P>
<li><a href=r38_0250.html#r38_0256>EXP operator</a><P>
<li><a href=r38_0250.html#r38_0257>SEC operator</a><P>
<li><a href=r38_0250.html#r38_0258>SECH operator</a><P>
<li><a href=r38_0250.html#r38_0259>SIN operator</a><P>
<li><a href=r38_0250.html#r38_0260>SINH operator</a><P>
<li><a href=r38_0250.html#r38_0261>TAN operator</a><P>
<li><a href=r38_0250.html#r38_0262>TANH operator</a><P>
</menu>
<a name=r38_0264>
<title>SWITCHES</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0210>on</a> or
<a href=r38_0200.html#r38_0209>off</a>, respectively.
The default setting of the switches described in this section is
<a href=r38_0200.html#r38_0209>off</a> unless stated otherwise.
<P>
<P>
<a name=r38_0265>
<title>ALGINT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0266>
<title>ALLBRANCH</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0179>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_0100.html#r38_0138>arbint</a>(1) indicates an arbitrary integer, whi
ch is given 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=r38_0267>
<title>ALLFAC</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0268>
<title>ARBVARS</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0100.html#r38_0139>arbcomplex</a>). Otherwise, the solution is param
etrized in
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_0150.html#r38_0179>solve</a> imply no relation among the input
variables.
<P>
<P>
<P>
<a name=r38_0269>
<title>BALANCED_MOD</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0305>modular</a>numbers are normally produced in the r
ange [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=r38_0270>
<title>BFSPACE</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0219>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=r38_0271>
<title>COMBINEEXPT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0272>
<title>COMBINELOGS</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0250.html#r38_0285>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=r38_0273>
<title>COMP</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0333>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=r38_0274>
<title>COMPLEX</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0330>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_0300.html#r38_0324>rationalize</a>.
<P>
<P>
<P>
<a name=r38_0275>
<title>CREF</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0276>
<title>CRAMER</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0345>matrix</a> inversion
and linear equation
solving (operator
<a href=r38_0150.html#r38_0179>solve</a>) is done by Cramer's rule, through exte
rior
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_0300.html#r38_0314>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=r38_0277>
<title>DEFN</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0278>
<title>DEMO</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0100.html#r38_0128>pause</a> command, <em>on demo</em> does not perm
it you to interrupt
the file for questions of your own.
<P>
<P>
<P>
<P>
<a name=r38_0279>
<title>DFPRINT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0100.html#r38_0148>df</a> are printed in a more ``natural'' notation
, with the
differentiation variables appearing as subscripts. In addition, if the
switch
<a href=r38_0300.html#r38_0310>noarg</a> is on (the default), the arguments of t
he
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=r38_0280>
<title>DIV</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0300.html#r38_0319>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=r38_0281>
<title>ECHO</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0282>
<title>ERRCONT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0283>
<title>EVALLHSEQP</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0001.html#r38_0045>equation</a>
is evaluated but not the left-hand-side. This also applies to any
substitutions made by the
<a href=r38_0150.html#r38_0182>sub</a> operator. If both sides are to be
evaluated, the switch <em>evallhseqp</em> should be turned on.
<P>
<P>
<a name=r38_0284>
<title>EXP_switch</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0157>length</a>. Be cautious about leaving <em>exp
</em> off.
<P>
<P>
<P>
<a name=r38_0285>
<title>EXPANDLOGS</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0250.html#r38_0272>combinelogs</a> to carry out these operations. Bo
th are off 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=r38_0286>
<title>EZGCD</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0050.html#r38_0086>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_0150.html#r38_0151>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_0050.html#r38_0086>gcd</a> switch must also be on for <em>ezgcd</em>
to have
effect.
<P>
<P>
<P>
<a name=r38_0287>
<title>FACTOR</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0250.html#r38_0256>exp</a> switch is
turned off, and when the <em>factor</em> switch is turned off, the
<a href=r38_0250.html#r38_0256>exp</a> switch is turned on, whether it was on pr
eviously or not.
<P>
<P>
When the switch
<a href=r38_0300.html#r38_0335>trfac</a> is on, informative messages are generat
ed at
each call to the factorizer. The
<a href=r38_0300.html#r38_0334>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_0150.html#r38_0151>factorize</a>.
<P>
<P>
<P>
<a name=r38_0288>
<title>FAILHARD</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0154>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=r38_0289>
<title>FORT</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0233>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_0650.html#r38_0652>GENTRAN</a> package offers many more possibilitie
s than the
<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=r38_0290>
<title>FORTUPPER</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0291>
<title>FULLPREC</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0200.html#r38_0219>scientific_notation</a>.
<P>
<P>
<P>
<a name=r38_0292>
<title>FULLROOTS</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0179>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_0150.html#r38_0176>root_of</a>. Default is <em>off</em>.
<P>
<P>
<a name=r38_0293>
<title>GC</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0100.html#r38_0130>reclaim</a> for an explanation of garbage collect
ion. REDUCE does
garbage collection when needed even if you have turned the notices off.
<P>
<P>
<P>
<a name=r38_0294>
<title>GCD_switch</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0250.html#r38_0256>exp</a> is off,
<em>gcd</em> has the side effect of factoring the expression.
<P>
<P>
<P>
<a name=r38_0295>
<title>HORNER</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0198>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=r38_0296>
<title>IFACTOR</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0150.html#r38_0151>factorize</a> command are factored themselves int
o 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_0150.html#r38_0151>factorize</a>, not on factoring done automaticall
y when the
<a href=r38_0250.html#r38_0287>factor</a> switch is on.
<P>
<P>
<P>
<a name=r38_0297>
<title>INT_switch</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0001.html#r38_0044>end</a><em>;</em> or
<a href=r38_0100.html#r38_0124>bye</a><em>;</em> from the keyboard;
everything else is ignored, even the command <em>on int</em>.
<P>
<P>
<P>
<a name=r38_0298>
<title>INTSTR</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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=r38_0299>
<title>LCM</title></a>
<p align="centre"><img src="redlogo.gif" width=621 height=60 border=0 alt="REDUC
E"></p>
<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_0050.html#r38_0086>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>