| Up | Next | Tail |
REDUCE includes a number of functions that are analogs of those found in most numerical systems. With numerical arguments, such functions return the expected result. However, they may also be called with non-numerical arguments. In such cases, except where noted, the system attempts to simplify the expression as far as it can. In such cases, a residual expression involving the original operator usually remains. These operators are as follows:
abs returns the absolute value of its single argument, if that argument has a
numerical value. A non-numerical argument is returned as an absolute value, with an
overall numerical coefficient taken outside the absolute value operator. For
example:
abs(-3/4) -> 3/4 abs(2a) -> 2*abs(a) abs(i) -> 1 abs(-x) -> abs(x)
This operator returns the ceiling (i.e., the least integer greater than the given argument) if its single argument has a numerical value. A non-numerical argument is returned as an expression in the original operator. For example:
ceiling(-5/4) -> -1 ceiling(-a) -> ceiling( - a)
This returns the complex conjugate of an expression, if that argument has a numerical
value. By default the complex conjugate of a non-numerical argument is returned as an
expression in the operators repart and impart. For example:
conj(1+i) -> - i + 1 conj(a+i*b) -> - impart(a)*i - impart(b) + repart(a) - repart(b)*i
If rules have been previously defined for the complex conjugate(s) of one or more
non-numerical terms appearing in the argument, these rules are applied and the
expansion in terms of the operators repart and impart is suppressed.
For example:
realvalued a,b; conj(a+i*b) -> a - b*i let conj z => z!*, conj c => c!*; conj(a+b*z*z!*+z*c!*) -> a + b*z*z* + c*z* conj atan z -> atan(z*)
Note that in defining the rule conj z => z!*, the rule conj z!* => z is (in
effect) automatically defined and should not be entered by the user. A more convenient
method of associating two identifiers as mutual complex-conjugates is to use the
complex_conjugates declaration as described in the section Declaring Complex
Conjugates.
The main use of rules for conj is to associate two identifiers as complex conjugates as
in the examples above. In addition rules of the form let conj(z)=>z,
conj(w)=>-w may be used. They imply that z is real-valued and w is purely
imaginary, although the effect of the first rule can also be obtained by declaring z to be
realvalued.
Rules of the form let conj z => «some-expression» may be used, but are
not recommended. More useful results will usually be obtained by defining the
equivalent rule let z => conj(«some-expression»). Rules of the form
let conj z => «some-expression» are particularly problematic if
«some-expression» involves z itself as they may be inconsistent, for example let
conj z => z+1. Even where they are consistent, better results may usually achieved
by defining alternative rules. For example, given:
realvalued a,b; let conj z => 2*a-z, conj w => w-2*b*i;
so that the real part of z is a and the imaginary part of w is b, more useful results will be
obtained by defining the mathematically equivalent rules:
realvalued a,b,x,y; let z => a +i*y, w => x + b*i;
Note also that the standard elementary functions and their inverses (where appropriate)
are automatically defined to be selfconjugate so that conj(f(z)) is simplified to
f(conj(z)). User-defined operators may be declared to be self-conjugate with the
declaration selfconjugate.
These operators convert an angle in degrees to radians and vice-versa. rad2deg
converts the radian value to an angle in degrees expressed as a single floating
point value (according to the currently specified system precision). The value to
be converted may be an integer, a rational or a floating value or indeed any
expression that simplifies to a rounded value. In particular numerical constants
such as \(\pi \) may be used in the input expression. deg2rad performs the inverse
conversion.
rad2dms converts the radian value to an angle expressed in degrees, minutes and
seconds returned as a three element list. The degree and minute values are integers the
latter in the range \(0 \ldots 59\) inclusive and the seconds value is a floating point value in the
half-open interval \([0, 60.0)\). Similarly, deg2dms converts an angle given in degrees into a such a
three element list.
The purpose of the operators dms2rad and dms2deg should also be obvious. The
degree, minute and second value to be converted is passed to the conversion function as a
three element list. There is considerable flexibility allowed in format of the list supplied
as parameter – all three values may be integers, rational numbers or rounded
values or any combination of these; the minute and second values need not
lie between zero and sixty. The list supplied is simplified with the appropriate
carrys and borrows performed (in effect at least) between the three values. For
example
{60.5, 9.2, 11.234} => {60, 39, 23.234}
{45, 0, -1} => {44, 59, 59}
If the single argument of factorial evaluates to a non-negative integer, its factorial
is returned. Otherwise an expression involving factorial is returned. For
example:
factorial(5) -> 120 factorial(a) -> factorial(a)
This operator returns the fixed value (i.e., the integer part of the given argument) if its single argument has a numerical value. A non-numerical argument is returned as an expression in the original operator. For example:
fix(-5/4) -> -1 fix(a) -> fix(a)
This operator returns the floor (i.e., the greatest integer less than the given argument) if its single argument has a numerical value. A non-numerical argument is returned as an expression in the original operator. For example:
floor(-5/4) -> -2 floor(a) -> floor(a)
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
repart and impart. For example:
impart(1+i) -> 1 impart(sin(3+4*i)) -> cos(3)*sinh(4) impart(log(2+i)) -> atan(1/2) impart(asin(1+i)) -> acosh(sqrt(5)+2)/2 impart(a+i*b) -> impart(a) + repart(b)
For the inverse trigometric and hyperbolic functions with non-numeric arguments the
output is usually more compact when the factor is on.
The operator legendre_symbol(a,p) denotes the Legendre symbol
max and min can take an arbitrary number of expressions as their arguments. If all
arguments evaluate to numerical values, the maximum or minimum of the argument list
is returned. If any argument is non-numeric, an appropriately reduced expression is
returned. For example:
max(2,-3,4,5) -> 5 min(2,-2) -> -2. max(a,2,3) -> max(A,3) min(x) -> X
max or min of an empty list returns 0.
nextprime returns the next prime greater than its integer argument, using a
probabilistic algorithm. A type error occurs if the value of the argument is not an integer.
For example:
nextprime(5) -> 7 nextprime(-2) -> 2 nextprime(-7) -> -5 nextprime 1000000 -> 1000003
whereas nextprime(a) gives a type error.
random(n) returns a random number \(r\) in the range \(0\leq r < n\). A type error occurs if the value of
the argument is not a positive integer in algebraic mode, or positive number in symbolic
mode. For example:
random(5) -> 3 random(1000) -> 191
whereas random(a) gives a type error.
random_new_seed(n) reseeds the random number generator to a sequence
determined by the integer argument \(n\). It can be used to ensure that a repeatable
pseudo-random sequence will be delivered regardless of any previous use of random, or
can be called early in a run with an argument derived from something variable (such as
the time of day) to arrange that different runs of a REDUCE program will use different
random sequences. When a fresh copy of REDUCE is first created it is as if
random_new_seed(1) has been obeyed.
A type error occurs if the value of the argument is not a positive integer.
This returns a two-element list of the real and imaginary parts of an expression, if that
argument has an numerical value. A non-numerical argument is returned as an
expression in the operators repart and impart. This is more efficient than calling
repart and impart separately particularly if its argument is complicated. For
example:
reimpart(1+i) -> {1,1}
reimpart(sin(3+4*i)) ->
{cosh(4)*sin(3),cos(3)*sinh(4)}
reimpart(log(2+i)) ->
{log(5)/2,atan(1/2)}
reimpart(asin(1+i)) ->
{acos(sqrt(5)2)/2,acosh(sqrt(5)+2)/2}
reimpart(a+i*b) ->
{ - impart(b) + repart(a),
impart(a) + repart(b)}
For the inverse trigometric and hyperbolic functions with non-numeric arguments the
output is usually more compact when the FACTOR is on.
This 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 repart and
impart. For example:
repart(1+i) -> 1 repart(sin(3+4*i)) -> cosh(4)*sin(3) repart(log(2+i)) -> log(5)/2 repart(asin(1+i)) -> acos(sqrt(5)-2)/2 repart(a+i*b) -> - impart(b) + repart(a)
For the inverse trigometric and hyperbolic functions with non-numeric arguments the
output is usually more compact when the FACTOR is on.
This operator returns the rounded value (i.e, the nearest integer) of its single argument if that argument has a numerical value. A non-numeric argument is returned as an expression in the original operator. For example:
round(-5/4) -> -1 round(a) -> round(a)
sign tries to evaluate the sign of its argument. If this is possible sign returns one of 1,
0 or -1. Otherwise, the result is the original form or a simplified variant. For
example:
sign(-5) -> -1 sign(-a^2*b) -> - sign(b)
Note that even powers of formal expressions are assumed to be positive only as long as
the switch complex is off.
| Up | Next | Front |
Hosted by