Go to the previous, next section.

The functions described here perform trigonometric and other transcendental
calculations. They generally produce floating-point answers correct to the
full current precision. The `H` (Hyperbolic) and `I` (Inverse)
flag keys must be used to get some of these functions from the keyboard.

One miscellanous command is shift-`P` (`calc-pi`

), which pushes
the value of @c{$\pi$}
pi (at the current precision) onto the stack. With the
Hyperbolic flag, it pushes the value e, the base of natural logarithms.
With the Inverse flag, it pushes Euler's constant @c{$\gamma$}
gamma (about 0.5772). With both Inverse and Hyperbolic, it
pushes the "golden ratio" @c{$\phi$}
phi (about 1.618). (At present, Euler's constant is not available
to unlimited precision; Calc knows only the first 100 digits.)
In Symbolic mode, these commands push the
actual variables ``pi'`, ``e'`, ``gamma'`, and ``phi'`,
respectively, instead of their values; see section Symbolic Mode.

The `Q` (`calc-sqrt`

) [`sqrt`

] function is described elsewhere;
see section Basic Arithmetic. With the Inverse flag [`sqr`

], this command
computes the square of the argument.

See section Numeric Prefix Arguments, for a discussion of the effect of numeric prefix arguments on commands in this chapter which do not otherwise interpret a prefix argument.

The shift-`L` (`calc-ln`

) [`ln`

] command computes the natural
logarithm of the real or complex number on the top of the stack. With
the Inverse flag it computes the exponential function instead, although
this is redundant with the `E` command.

The shift-`E` (`calc-exp`

) [`exp`

] command computes the
exponential, i.e., e raised to the power of the number on the stack.
The meanings of the Inverse and Hyperbolic flags follow from those for
the `calc-ln`

command.

The `H L` (`calc-log10`

) [`log10`

] command computes the common
(base-10) logarithm of a number. (With the Inverse flag [`exp10`

],
it raises ten to a given power.) Note that the common logarithm of a
complex number is computed by taking the natural logarithm and dividing
by @c{$\ln10$}
ln(10).

The `B` (`calc-log`

) [`log`

] command computes a logarithm
to any base. For example, `1024 RET 2 B` produces 10, since
2^10 = 1024. In certain cases like

`alog`

], this command is
similar to
The `f I` (`calc-ilog`

) [`ilog`

] command computes the
integer logarithm of a number to any base. The number and the base must
themselves be positive integers. This is the true logarithm, rounded
down to an integer. Thus `ilog(x,10)` is 3 for all x in the
range from 1000 to 9999. If both arguments are positive integers, exact
integer arithmetic is used; otherwise, this is equivalent to
``floor(log(x,b))'`.

The `f E` (`calc-expm1`

) [`expm1`

] command computes
exp(x)-1, but using an algorithm that produces a more accurate
answer when the result is close to zero, i.e., when @c{$e^x$}
exp(x) is close
to one.

The `f L` (`calc-lnp1`

) [`lnp1`

] command computes
ln(x+1), producing a more accurate answer when x is close
to zero.

The shift-`S` (`calc-sin`

) [`sin`

] command computes the sine
of an angle or complex number. If the input is an HMS form, it is interpreted
as degrees-minutes-seconds; otherwise, the input is interpreted according
to the current angular mode. It is best to use Radians mode when operating
on complex numbers.

Calc's "units" mechanism includes angular units like `deg`

,
`rad`

, and `grad`

. While ``sin(45 deg)'` is not evaluated
all the time, the `u s` (`calc-simplify-units`

) command will
simplify ``sin(45 deg)'` by taking the sine of 45 degrees, regardless
of the current angular mode. See section Basic Operations on Units.

Also, the symbolic variable `pi`

is not ordinarily recognized in
arguments to trigonometric functions, as in ``sin(3 pi / 4)'`, but
the `a s` (`calc-simplify`

) command recognizes many such
formulas when the current angular mode is radians *and* symbolic
mode is enabled; this example would be replaced by ``sqrt(2) / 2'`.
See section Symbolic Mode. Beware, this simplification occurs even if you
have stored a different value in the variable ``pi'`; this is one
reason why changing built-in variables is a bad idea. Arguments of
the form x plus a multiple of @c{$\pi/2$}
pi/2 are also simplified.
Calc includes similar formulas for `cos`

and `tan`

.

The `a s` command knows all angles which are integer multiples of
pi/12, @c{$\pi/10$}
pi/10, or @c{$\pi/8$}
pi/8 radians. In degrees mode,
analogous simplifications occur for integer multiples of 15 or 18
degrees, and for arguments plus multiples of 90 degrees.

With the Inverse flag, `calc-sin`

computes an arcsine. This is also
available as the `calc-arcsin`

command or `arcsin`

algebraic
function. The returned argument is converted to degrees, radians, or HMS
notation depending on the current angular mode.

With the Hyperbolic flag, `calc-sin`

computes the hyperbolic
sine, also available as `calc-sinh`

[`sinh`

]. With the
Hyperbolic and Inverse flags, it computes the hyperbolic arcsine
(`calc-arcsinh`

) [`arcsinh`

].

The shift-`C` (`calc-cos`

) [`cos`

] command computes the cosine
of an angle or complex number, and shift-`T` (`calc-tan`

) [`tan`

]
computes the tangent, along with all the various inverse and hyperbolic
variants of these functions.

The `f T` (`calc-arctan2`

) [`arctan2`

] command takes two
numbers from the stack and computes the arc tangent of their ratio. The
result is in the full range from *-180* (exclusive) to *+180*
(inclusive) degrees, or the analogous range in radians. A similar
result would be obtained with `/` followed by `I T`, but the
value would only be in the range from *-90* to *+90* degrees
since the division loses information about the signs of the two
components, and an error might result from an explicit division by zero
which `arctan2`

would avoid. By (arbitrary) definition,
``arctan2(0,0)=0'`.

The `calc-sincos`

[`sincos`

] command computes the sine and
cosine of a number, returning them as a vector of the form
``[ cos, sin]'`.
With the Inverse flag [

`arcsincos`

], this command takes a two-element
vector as an argument and computes `arctan2`

of the elements.
(This command does not accept the Hyperbolic flag.)

Calc can compute a variety of less common functions that arise in various branches of mathematics. All of the functions described in this section allow arbitrary complex arguments and, except as noted, will work to arbitrarily large precisions. They can not at present handle error forms or intervals as arguments.

NOTE: These functions are still experimental. In particular, their accuracy is not guaranteed in all domains. It is advisable to set the current precision comfortably higher than you actually need when using these functions. Also, these functions may be impractically slow for some values of the arguments.

The `f g` (`calc-gamma`

) [`gamma`

] command computes the Euler
gamma function. For positive integer arguments, this is related to the
factorial function: ``gamma(n+1) = fact(n)'`. For general complex
arguments the gamma function can be defined by the following definite
integral: @c{$\Gamma(a) = \int_0^\infty t^{a-1} e^t dt$}
gamma(a) = integ(t^(a-1) exp(t), t, 0, inf).
(The actual implementation uses far more efficient computational methods.)

The `f G` (`calc-inc-gamma`

) [`gammaP`

] command computes
the incomplete gamma function, denoted ``P(a,x)'`. This is defined by
the integral, @c{$P(a,x) = \left( \int_0^x t^{a-1} e^t dt \right) / \Gamma(a)$}
gammaP(a,x) = integ(t^(a-1) exp(t), t, 0, x) / gamma(a).
This implies that ``gammaP(a,inf) = 1'` for any a (see the
definition of the normal gamma function).

Several other varieties of incomplete gamma function are defined.
The complement of P(a,x), called Q(a,x) = 1-P(a,x) by
some authors, is computed by the `I f G` [`gammaQ`

] command.
You can think of this as taking the other half of the integral, from
x to infinity.

The `f b` (`calc-beta`

) [`beta`

] command computes the
Euler beta function, which is defined in terms of the gamma function as
beta(a,b) = gamma(a) gamma(b) / gamma(a+b), or by
beta(a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, 1).

The `f B` (`calc-inc-beta`

) [`betaI`

] command computes
the incomplete beta function I(x,a,b). It is defined by
betaI(x,a,b) = integ(t^(a-1) (1-t)^(b-1), t, 0, x) / beta(a,b).
Once again, the `H` (hyperbolic) prefix gives the corresponding
un-normalized version [`betaB`

].

The `f e` (`calc-erf`

) [`erf`

] command computes the
error function @c{$\hbox{erf}(x) = {2 \over \sqrt{\pi}} \int_0^x e^{-t^2} dt$}
erf(x) = 2 integ(exp(-(t^2)), t, 0, x) / sqrt(pi).
The complementary error function `I f e` (`calc-erfc`

) [`erfc`

]
is the corresponding integral from ``x'` to infinity; the sum
erf(x) + erfc(x) = 1.

The `f j` (`calc-bessel-J`

) [`besJ`

] and `f y`
(`calc-bessel-Y`

) [`besY`

] commands compute the Bessel
functions of the first and second kinds, respectively.
In ``besJ(n,x)'` and ``besY(n,x)'` the "order" parameter
n is often an integer, but is not required to be one.
Calc's implementation of the Bessel functions currently limits the
precision to 8 digits, and may not be exact even to that precision.
Use with care!

All of the logarithmic, trigonometric, and other scientific functions are defined for complex numbers as well as for reals. This section describes the values returned in cases where the general result is a family of possible values. Calc follows section 12.5.3 of Steele's Common Lisp, the Language, second edition, in these matters. This section will describe each function briefly; for a more detailed discussion (including some nifty diagrams), consult Steele's book.

Note that the branch cuts for `arctan`

and `arctanh`

were
changed between the first and second editions of Steele. Versions of
Calc starting with 2.00 follow the second edition.

The new branch cuts exactly match those of the HP-28/48 calculators.
They also match those of Mathematica 1.2, except that Mathematica's
`arctan`

cut is always in the right half of the complex plane,
and its `arctanh`

cut is always in the top half of the plane.
Calc's cuts are continuous with quadrants I and III for `arctan`

,
or II and IV for `arctanh`

.

Note: The current implementations of these functions with complex arguments
are designed with proper behavior around the branch cuts in mind, *not*
efficiency or accuracy. You may need to increase the floating precision
and wait a while to get suitable answers from them.

For ``sqrt(a+bi)'`: When a<0 and b is small but positive
or zero, the result is close to the +i axis. For b small and
negative, the result is close to the -i axis. The result always lies
in the right half of the complex plane.

For ``ln(a+bi)'`: The real part is defined as ``ln(abs(a+bi))'`.
The imaginary part is defined as ``arg(a+bi) = arctan2(b,a)'`.
Thus the branch cuts for `sqrt`

and `ln`

both lie on the
negative real axis.

The following table describes these branch cuts in another way.
If the real and imaginary parts of z are as shown, then
the real and imaginary parts of f(z) will be as shown.
Here `eps`

stands for a small positive value; each
occurrence of `eps`

may stand for a different small value.

z sqrt(z) ln(z) ---------------------------------------- +, 0 +, 0 any, 0 -, 0 0, + any, pi -, +eps +eps, + +eps, + -, -eps +eps, - +eps, -

For ``z1^z2'`: This is defined by ``exp(ln(z1)*z2)'`.
One interesting consequence of this is that ``(-8)^1:3'` does
not evaluate to *-2* as you might expect, but to the complex
number (1., 1.732). Both of these are valid cube roots
of *-8* (as is (1., -1.732)); Calc chooses a perhaps
less-obvious root for the sake of mathematical consistency.

For ``arcsin(z)'`: This is defined by ``-i*ln(i*z + sqrt(1-z^2))'`.
The branch cuts are on the real axis, less than *-1* and greater than 1.

For ``arccos(z)'`: This is defined by ``-i*ln(z + i*sqrt(1-z^2))'`,
or equivalently by ``pi/2 - arcsin(z)'`. The branch cuts are on
the real axis, less than *-1* and greater than 1.

For ``arctan(z)'`: This is defined by
``(ln(1+i*z) - ln(1-i*z)) / (2*i)'`. The branch cuts are on the
imaginary axis, below -i and above i.

For ``arcsinh(z)'`: This is defined by ``ln(z + sqrt(1+z^2))'`.
The branch cuts are on the imaginary axis, below -i and
above i.

For ``arccosh(z)'`: This is defined by
``ln(z + (z+1)*sqrt((z-1)/(z+1)))'`. The branch cut is on the
real axis less than 1.

For ``arctanh(z)'`: This is defined by ``(ln(1+z) - ln(1-z)) / 2'`.
The branch cuts are on the real axis, less than *-1* and greater than 1.

The following tables for `arcsin`

, `arccos`

, and
`arctan`

assume the current angular mode is radians. The
hyperbolic functions operate independently of the angular mode.

z arcsin(z) arccos(z) ------------------------------------------------------- (-1..1), 0 (-pi/2..pi/2), 0 (0..pi), 0 (-1..1), +eps (-pi/2..pi/2), +eps (0..pi), -eps (-1..1), -eps (-pi/2..pi/2), -eps (0..pi), +eps <-1, 0 -pi/2, + pi, - <-1, +eps -pi/2 + eps, + pi - eps, - <-1, -eps -pi/2 + eps, - pi - eps, + >1, 0 pi/2, - 0, + >1, +eps pi/2 - eps, + +eps, - >1, -eps pi/2 - eps, - +eps, +

z arccosh(z) arctanh(z) ----------------------------------------------------- (-1..1), 0 0, (0..pi) any, 0 (-1..1), +eps +eps, (0..pi) any, +eps (-1..1), -eps +eps, (-pi..0) any, -eps <-1, 0 +, pi -, pi/2 <-1, +eps +, pi - eps -, pi/2 - eps <-1, -eps +, -pi + eps -, -pi/2 + eps >1, 0 +, 0 +, -pi/2 >1, +eps +, +eps +, pi/2 - eps >1, -eps +, -eps +, -pi/2 + eps

z arcsinh(z) arctan(z) ----------------------------------------------------- 0, (-1..1) 0, (-pi/2..pi/2) 0, any 0, <-1 -, -pi/2 -pi/2, - +eps, <-1 +, -pi/2 + eps pi/2 - eps, - -eps, <-1 -, -pi/2 + eps -pi/2 + eps, - 0, >1 +, pi/2 pi/2, + +eps, >1 +, pi/2 - eps pi/2 - eps, + -eps, >1 -, pi/2 - eps -pi/2 + eps, +

Finally, the following identities help to illustrate the relationship between the complex trigonometric and hyperbolic functions. They are valid everywhere, including on the branch cuts.

sin(i*z) = i*sinh(z) arcsin(i*z) = i*arcsinh(z) cos(i*z) = cosh(z) arcsinh(i*z) = i*arcsin(z) tan(i*z) = i*tanh(z) arctan(i*z) = i*arctanh(z) sinh(i*z) = i*sin(z) cosh(i*z) = cos(z)

The "advanced math" functions (gamma, Bessel, etc.) are also defined for general complex arguments, but their branch cuts and principal values are not rigorously specified at present.

The `k r` (`calc-random`

) [`random`

] command produces
random numbers of various sorts.

Given a positive numeric prefix argument M, it produces a random integer N in the range @c{$0 \le N < M$} 0 <= N < M. Each of the M values appears with equal probability.

With no numeric prefix argument, the `k r` command takes its argument
from the stack instead. Once again, if this is a positive integer M
the result is a random integer less than M. However, note that
while numeric prefix arguments are limited to six digits or so, an M
taken from the stack can be arbitrarily large. If M is negative,
the result is a random integer in the range @c{$M < N \le 0$}
M < N <= 0.

If the value on the stack is a floating-point number M, the result is a random floating-point number N in the range @c{$0 \le N < M$} 0 <= N < M or @c{$M < N \le 0$} M < N <= 0, according to the sign of M.

If M is zero, the result is a Gaussian-distributed random real number; the distribution has a mean of zero and a standard deviation of one. The algorithm used generates random numbers in pairs; thus, every other call to this function will be especially fast.

If M is an error form @c{$m$ `+/-`

$\sigma$}
``m +/- s'` where *m*
and @c{$\sigma$}
*s* are both real numbers, the result uses a Gaussian
distribution with mean *m* and standard deviation @c{$\sigma$}
*s*.

If M is an interval form, the lower and upper bounds specify the
acceptable limits of the random numbers. If both bounds are integers,
the result is a random integer in the specified range. If either bound
is floating-point, the result is a random real number in the specified
range. If the interval is open at either end, the result will be sure
not to equal that end value. (This makes a big difference for integer
intervals, but for floating-point intervals it's relatively minor:
with a precision of 6, ``random([1.0..2.0))'` will return any of one
million numbers from 1.00000 to 1.99999; ``random([1.0..2.0])'` may
additionally return 2.00000, but the probability of this happening is
extremely small.)

If M is a vector, the result is one element taken at random from the vector. All elements of the vector are given equal probabilities.

The sequence of numbers produced by `k r` is completely random by
default, i.e., the sequence is seeded each time you start Calc using
the current time and other information. You can get a reproducible
sequence by storing a particular "seed value" in the Calc variable
`RandSeed`

. Any integer will do for a seed; integers of from 1
to 12 digits are good. If you later store a different integer into
`RandSeed`

, Calc will switch to a different pseudo-random
sequence. If you "unstore" `RandSeed`

, Calc will re-seed itself
from the current time. If you store the same integer that you used
before back into `RandSeed`

, you will get the exact same sequence
of random numbers as before.

The `calc-rrandom`

command (not on any key) produces a random real
number between zero and one. It is equivalent to ``random(1.0)'`.

The `k a` (`calc-random-again`

) command produces another random
number, re-using the most recent value of M. With a numeric
prefix argument `n`, it produces `n` more random numbers using
that value of M.

The `k h` (`calc-shuffle`

) command produces a vector of several
random values with no duplicates. The value on the top of the stack
specifies the set from which the random values are drawn, and may be any
of the M formats described above. The numeric prefix argument
gives the length of the desired list. (If you do not provide a numeric
prefix argument, the length of the list is taken from the top of the
stack, and M from second-to-top.)

If M is a floating-point number, zero, or an error form (so
that the random values are being drawn from the set of real numbers)
there is little practical difference between using `k h` and using
`k r` several times. But if the set of possible values consists
of just a few integers, or the elements of a vector, then there is
a very real chance that multiple `k r`'s will produce the same
number more than once. The `k h` command produces a vector whose
elements are always distinct. (Actually, there is a slight exception:
If M is a vector, no given vector element will be drawn more
than once, but if several elements of M are equal, they may
each make it into the result vector.)

One use of `k h` is to rearrange a list at random. This happens
if the prefix argument is equal to the number of values in the list:
`[1, 1.5, 2, 2.5, 3] 5 k h` might produce the permuted list
``[2.5, 1, 1.5, 3, 2]'`. As a convenient feature, if the argument
`n` is negative it is replaced by the size of the set represented
by M. Naturally, this is allowed only when M specifies
a small discrete set of possibilities.

To do the equivalent of `k h` but with duplications allowed,
given M on the stack and with `n` just entered as a numeric
prefix, use `v b` to build a vector of copies of M, then use
`V M k r` to "map" the normal `k r` function over the
elements of this vector. See section Vector/Matrix Functions.

Calc's random number generator uses several methods to ensure that
the numbers it produces are highly random. Knuth's *Art of
Computer Programming*, Volume II, contains a thorough description
of the theory of random number generators and their measurement and
characterization.

If `RandSeed`

has no stored value, Calc calls Emacs' built-in
`random`

function to get a stream of random numbers, which it
then treats in various ways to avoid problems inherent in the simple
random number generators that many systems use to implement `random`

.

When Calc's random number generator is first invoked, it "seeds" the low-level random sequence using the time of day, so that the random number sequence will be different every time you use Calc.

Since Emacs Lisp doesn't specify the range of values that will be
returned by its `random`

function, Calc exercises the function
several times to estimate the range. When Calc subsequently uses
the `random`

function, it takes only 10 bits of the result
near the most-significant end. (It avoids at least the bottom
four bits, preferably more, and also tries to avoid the top two
bits.) This strategy works well with the linear congruential
generators that are typically used to implement `random`

.

If `RandSeed`

contains an integer, Calc uses this integer to
seed an "additive congruential" method (Knuth's algorithm 3.2.2A,
computing @c{$X_{n-55} - X_{n-24}$}
X_n-55 - X_n-24). This method expands the seed
value into a large table which is maintained internally; the variable
`RandSeed`

is changed from, e.g., 42 to the vector [42]
to indicate that the seed has been absorbed into this table. When
`RandSeed`

contains a vector, `k r` and related commands
continue to use the same internal table as last time. There is no
way to extract the complete state of the random number generator
so that you can restart it from any point; you can only restart it
from the same initial seed value. A simple way to restart from the
same seed is to type `s r RandSeed` to get the seed vector,
`v u` to unpack it back into a number, then `s t RandSeed`
to reseed the generator with that number.

Calc uses a "shuffling" method as described in algorithm 3.2.2B
of Knuth. It fills a table with 13 random 10-bit numbers. Then,
to generate a new random number, it uses the previous number to
index into the table, picks the value it finds there as the new
random number, then replaces that table entry with a new value
obtained from a call to the base random number generator (either
the additive congruential generator or the `random`

function
supplied by the system). If there are any flaws in the base
generator, shuffling will tend to even them out. But if the system
provides an excellent `random`

function, shuffling will not
damage its randomness.

To create a random integer of a certain number of digits, Calc builds the integer three decimal digits at a time. For each group of three digits, Calc calls its 10-bit shuffling random number generator (which returns a value from 0 to 1023); if the random value is 1000 or more, Calc throws it out and tries again until it gets a suitable value.

To create a random floating-point number with precision `p`, Calc
simply creates a random `p`-digit integer and multiplies by
10^-p. The resulting random numbers should be very clean, but note
that relatively small numbers will have few significant random digits.
In other words, with a precision of 12, you will occasionally get
numbers on the order of @c{$10^{-9}$}
10^-9 or @c{$10^{-10}$}
10^-10, but those numbers
will only have two or three random digits since they correspond to small
integers times @c{$10^{-12}$}
10^-12.

To create a random integer in the interval ``[0 .. m)'`, Calc
counts the digits in

The Gaussian random numbers generated by ``random(0.0)'` use the
"polar" method described in Knuth section 3.4.1C. This method
generates a pair of Gaussian random numbers at a time, so only every
other call to ``random(0.0)'` will require significant calculations.

Commands relating to combinatorics and number theory begin with the
`k` key prefix.

The `k g` (`calc-gcd`

) [`gcd`

] command computes the
Greatest Common Divisor of two integers. It also accepts fractions;
the GCD of two fractions is defined by taking the GCD of the
numerators, and the LCM of the denominators. This definition is
consistent with the idea that ``a / gcd(a,x)'` should yield an
integer for any ``a'` and ``x'`. For other types of arguments,
the operation is left in symbolic form.

The `k l` (`calc-lcm`

) [`lcm`

] command computes the
Least Common Multiple of two integers or fractions. The product of
the LCM and GCD of two numbers is equal to the product of the
numbers.

The `k E` (`calc-extended-gcd`

) [`egcd`

] command computes
the GCD of two integers x and y and returns a vector
[g, a, b] where @c{$g = \gcd(x,y) = a x + b y$}
g = gcd(x,y) = a x + b y.

The `!` (`calc-factorial`

) [`fact`

] command computes the
factorial of the number at the top of the stack. If the number is an
integer, the result is an exact integer. If the number is an
integer-valued float, the result is a floating-point approximation. If
the number is a non-integral real number, the generalized factorial is used,
as defined by the Euler Gamma function. Please note that computation of
large factorials can be slow; using floating-point format will help
since fewer digits must be maintained. The same is true of many of
the commands in this section.

The `k d` (`calc-double-factorial`

) [`dfact`

] command
computes the "double factorial" of an integer. For an even integer,
this is the product of even integers from 2 to N. For an odd
integer, this is the product of odd integers from 3 to N. If
the argument is an integer-valued float, the result is a floating-point
approximation. This function is undefined for negative even integers.
The notation N!! is also recognized for double factorials.

The `k c` (`calc-choose`

) [`choose`

] command computes the
binomial coefficient N-choose-M, where M is the number
on the top of the stack and N is second-to-top. If both arguments
are integers, the result is an exact integer. Otherwise, the result is a
floating-point approximation. The binomial coefficient is defined for all
real numbers by @c{$N! \over M! (N-M)!\,$}
N! / M! (N-M)!.

The `k b` (`calc-bernoulli-number`

) [`bern`

] command
computes a given Bernoulli number. The value at the top of the stack
is a nonnegative integer n that specifies which Bernoulli number
is desired. The `H k b` command computes a Bernoulli polynomial,
taking n from the second-to-top position and x from the
top of the stack. If x is a variable or formula the result is
a polynomial in x; if x is a number the result is a number.

The `k e` (`calc-euler-number`

) [`euler`

] command similarly
computes an Euler number, and `H k e` computes an Euler polynomial.
Bernoulli and Euler numbers occur in the Taylor expansions of several
functions.

The `k s` (`calc-stirling-number`

) [`stir1`

] command
computes a Stirling number of the first kind@c{ $n \brack m$}
, given two integers
n and m on the stack. The `H k s` [`stir2`

]
command computes a Stirling number of the second kind@c{ $n \brace m$}
. These are
the number of m-cycle permutations of n objects, and
the number of ways to partition n objects into m
non-empty sets, respectively.

The `k p` (`calc-prime-test`

) command checks if the integer on
the top of the stack is prime. For integers less than eight million, the
answer is always exact and reasonably fast. For larger integers, a
probabilistic method is used (see Knuth vol. II, section 4.5.4, algorithm P).
The number is first checked against small prime factors (up to 13). Then,
any number of iterations of the algorithm are performed. Each step either
discovers that the number is non-prime, or substantially increases the
certainty that the number is prime. After a few steps, the chance that
a number was mistakenly described as prime will be less than one percent.
(Indeed, this is a worst-case estimate of the probability; in practice
even a single iteration is quite reliable.) After the `k p` command,
the number will be reported as definitely prime or non-prime if possible,
or otherwise "probably" prime with a certain probability of error.

The normal `k p` command performs one iteration of the primality
test. Pressing `k p` repeatedly for the same integer will perform
additional iterations. Also, `k p` with a numeric prefix performs
the specified number of iterations. There is also an algebraic function
``prime(n)'` or ``prime(n,iters)'` which returns 1 if n
is (probably) prime and 0 if not.

The `k f` (`calc-prime-factors`

) [`prfac`

] command
attempts to decompose an integer into its prime factors. For numbers up
to 25 million, the answer is exact although it may take some time. The
result is a vector of the prime factors in increasing order. For larger
inputs, prime factors above 5000 may not be found, in which case the
last number in the vector will be an unfactored integer greater than 25
million (with a warning message). For negative integers, the first
element of the list will be *-1*. For inputs *-1*, *0*, and
*1*, the result is a list of the same number.

The `k n` (`calc-next-prime`

) [`nextprime`

] command finds
the next prime above a given number. Essentially, it searches by calling
`calc-prime-test`

on successive integers until it finds one that
passes the test. This is quite fast for integers less than eight million,
but once the probabilistic test comes into play the search may be rather
slow. Ordinarily this command stops for any prime that passes one iteration
of the primality test. With a numeric prefix argument, a number must pass
the specified number of iterations before the search stops. (This only
matters when searching above eight million.) You can always use additional
`k p` commands to increase your certainty that the number is indeed
prime.

The `I k n` (`calc-prev-prime`

) [`prevprime`

] command
analogously finds the next prime less than a given number.

The `k t` (`calc-totient`

) [`totient`

] command computes the
Euler "totient" function@c{ $\phi(n)$}
, the number of integers less than n which
are relatively prime to n.

The `k m` (`calc-moebius`

) [`moebius`

] command computes the
Moebius "mu" function. If the input number is a product of k
distinct factors, this is (-1)^k. If the input number has any
duplicate factors (i.e., can be divided by the same prime more than once),
the result is zero.

The functions in this section compute various probability distributions. For continuous distributions, this is the integral of the probability density function from x to infinity. (These are the "upper tail" distribution functions; there are also corresponding "lower tail" functions which integrate from minus infinity to x.) For discrete distributions, the upper tail function gives the sum from x to infinity; the lower tail function gives the sum from minus infinity up to, but not including, x.

To integrate from x to y, just use the distribution
function twice and subtract. For example, the probability that a
Gaussian random variable with mean 2 and standard deviation 1 will
lie in the range from 2.5 to 2.8 is ``utpn(2.5,2,1) - utpn(2.8,2,1)'`
("the probability that it is greater than 2.5, but not greater than 2.8"),
or equivalently ``ltpn(2.8,2,1) - ltpn(2.5,2,1)'`.

The `k B` (`calc-utpb`

) [`utpb`

] function uses the
binomial distribution. Push the parameters `n`, `p`, and
then `x` onto the stack; the result (``utpb(x,n,p)'`) is the
probability that an event will occur `x` or more times out
of `n` trials, if its probability of occurring in any given
trial is `p`. The `I k B` [`ltpb`

] function is
the probability that the event will occur fewer than `x` times.

The other probability distribution functions similarly take the
form `k X` (

`calc-utp``x`

) [`utp``x`

]
and `ltp``x`

], for various letters
The ``utpc(x,v)'` function uses the chi-square distribution with
v degrees of freedom. It is the probability that a model is
correct if its chi-square statistic is x.

The ``utpf(F,v1,v2)'` function uses the F distribution, used in
various statistical tests. The parameters @c{$\nu_1$}
v1 and @c{$\nu_2$}
v2
are the degrees of freedom in the numerator and denominator,
respectively, used in computing the statistic F.

The ``utpn(x,m,s)'` function uses a normal (Gaussian) distribution
with mean m and standard deviation @c{$\sigma$}
s. It is the
probability that such a normal-distributed random variable would
exceed x.

The ``utpp(n,x)'` function uses a Poisson distribution with
mean x. It is the probability that n or more such
Poisson random events will occur.

The ``utpt(t,v)'` function uses the Student's "t" distribution
with @c{$\nu$}
v degrees of freedom. It is the probability that a
t-distributed random variable will be greater than t.
(Note: This computes the distribution function @c{$A(t|\nu)$}
A(t|v)
where @c{$A(0|\nu) = 1$}
A(0|v) = 1 and @c{$A(\infty|\nu) \to 0$}
A(inf|v) -> 0. The
`UTPT`

operation on the HP-48 uses a different definition
which returns half of Calc's value: ``UTPT(t,v) = .5*utpt(t,v)'`.)

While Calc does not provide inverses of the probability distribution
functions, the `a R` command can be used to solve for the inverse.
Since the distribution functions are monotonic, `a R` is guaranteed
to be able to find a solution given any initial guess.
See section Numerical Solutions.

Go to the previous, next section.