Go forward to Vector/Matrix Tutorial.
Go backward to Basic Tutorial.
Go up to Tutorial.
Arithmetic Tutorial
===================
In this section, we explore the arithmetic and scientific functions
available in the Calculator.
The standard arithmetic commands are `+', `-', `*', `/', and `^'.
Each normally takes two numbers from the top of the stack and pushes
back a result. The `n' and `&' keys perform change-sign and
reciprocal operations, respectively.
1: 5 1: 0.2 1: 5. 1: -5. 1: 5.
. . . . .
5 & & n n
You can apply a "binary operator" like `+' across any number of stack
entries by giving it a numeric prefix. You can also apply it pairwise
to several stack elements along with the top one if you use a negative
prefix.
3: 2 1: 9 3: 2 4: 2 3: 12
2: 3 . 2: 3 3: 3 2: 13
1: 4 1: 4 2: 4 1: 14
. . 1: 10 .
.
2 RET 3 RET 4 M-3 + U 10 M-- M-3 +
You can apply a "unary operator" like `&' to the top N stack entries
with a numeric prefix, too.
3: 2 3: 0.5 3: 0.5
2: 3 2: 0.333333333333 2: 3.
1: 4 1: 0.25 1: 4.
. . .
2 RET 3 RET 4 M-3 & M-2 &
Notice that the results here are left in floating-point form. We can
convert them back to integers by pressing `F', the "floor" function.
This function rounds down to the next lower integer. There is also
`R', which rounds to the nearest integer.
7: 2. 7: 2 7: 2
6: 2.4 6: 2 6: 2
5: 2.5 5: 2 5: 3
4: 2.6 4: 2 4: 3
3: -2. 3: -2 3: -2
2: -2.4 2: -3 2: -2
1: -2.6 1: -3 1: -3
. . .
M-7 F U M-7 R
Since dividing-and-flooring (i.e., "integer quotient") is such a
common operation, Calc provides a special command for that purpose,
the backslash `\'. Another common arithmetic operator is `%', which
computes the remainder that would arise from a `\' operation, i.e.,
the "modulo" of two numbers. For example,
2: 1234 1: 12 2: 1234 1: 34
1: 100 . 1: 100 .
. .
1234 RET 100 \ U %
These commands actually work for any real numbers, not just integers.
2: 3.1415 1: 3 2: 3.1415 1: 0.1415
1: 1 . 1: 1 .
. .
3.1415 RET 1 \ U %
(*) *Exercise 1.* The `\' command would appear to be a frill, since
you could always do the same thing with `/ F'. Think of a situation
where this is not true---`/ F' would be inadequate. Now think of a
way you could get around the problem if Calc didn't provide a `\'
command. See 1: Arithmetic Answer 1. (*)
We've already seen the `Q' (square root) and `S' (sine) commands.
Other commands along those lines are `C' (cosine), `T' (tangent), `E'
(`e^x') and `L' (natural logarithm). These can be modified by the `I'
(inverse) and `H' (hyperbolic) prefix keys.
Let's compute the sine and cosine of an angle, and verify the
identity `sin(x)^2 + cos(x)^2 = 1'. We'll
arbitrarily pick -64 degrees as a good value for `x'. With
the angular mode set to degrees (type `m d'), do:
2: -64 2: -64 2: -0.89879 2: -0.89879 1: 1.
1: -64 1: -0.89879 1: -64 1: 0.43837 .
. . . .
64 n RET RET S TAB C f h
(For brevity, we're showing only five digits of the results here. You
can of course do these calculations to any precision you like.)
Remember, `f h' is the `calc-hypot', or square-root of sum of squares,
command.
Another identity is `tan(x) = sin(x) / cos(x)'.
2: -0.89879 1: -2.0503 1: -64.
1: 0.43837 . .
.
U / I T
A physical interpretation of this calculation is that if you move
`0.89879' units downward and `0.43837' units to the right, your
direction of motion is -64 degrees from horizontal. Suppose we move
in the opposite direction, up and to the left:
2: -0.89879 2: 0.89879 1: -2.0503 1: -64.
1: 0.43837 1: -0.43837 . .
. .
U U M-2 n / I T
How can the angle be the same? The answer is that the `/' operation
loses information about the signs of its inputs. Because the quotient
is negative, we know exactly one of the inputs was negative, but we
can't tell which one. There is an `f T' [`arctan2'] function which
computes the inverse tangent of the quotient of a pair of numbers.
Since you feed it the two original numbers, it has enough information
to give you a full 360-degree answer.
2: 0.89879 1: 116. 3: 116. 2: 116. 1: 180.
1: -0.43837 . 2: -0.89879 1: -64. .
. 1: 0.43837 .
.
U U f T M-RET M-2 n f T -
The resulting angles differ by 180 degrees; in other words, they point
in opposite directions, just as we would expect.
The META-RET we used in the third step is the "last-arguments"
command. It is sort of like Undo, except that it restores the
arguments of the last command to the stack without removing the
command's result. It is useful in situations like this one, where we
need to do several operations on the same inputs. We could have
accomplished the same thing by using `M-2 RET' to duplicate the top
two stack elements right after the `U U', then a pair of `M-TAB'
commands to cycle the 116 up around the duplicates.
A similar identity is supposed to hold for hyperbolic sines and
cosines, except that it is the *difference* `cosh(x)^2 - sinh(x)^2'
that always equals one. Let's try to verify this identity.
2: -64 2: -64 2: -64 2: 9.7192e54 2: 9.7192e54
1: -64 1: -3.1175e27 1: 9.7192e54 1: -64 1: 9.7192e54
. . . . .
64 n RET RET H C 2 ^ TAB H S 2 ^
Something's obviously wrong, because when we subtract these numbers
the answer will clearly be zero! But if you think about it, if these
numbers *did* differ by one, it would be in the 55th decimal place.
The difference we seek has been lost entirely to roundoff error.
We could verify this hypothesis by doing the actual calculation with,
say, 60 decimal places of precision. This will be slow, but not
enormously so. Try it if you wish; sure enough, the answer is
0.99999, reasonably close to 1.
Of course, a more reasonable way to verify the identity is to use a
more reasonable value for `x'!
Some Calculator commands use the Hyperbolic prefix for other purposes.
The logarithm and exponential functions, for example, work to the base
`e' normally but use base-10 instead if you use the Hyperbolic prefix.
1: 1000 1: 6.9077 1: 1000 1: 3
. . . .
1000 L U H L
First, we mistakenly compute a natural logarithm. Then we undo and
compute a common logarithm instead.
The `B' key computes a general base-B logarithm for any value of B.
2: 1000 1: 3 1: 1000. 2: 1000. 1: 6.9077
1: 10 . . 1: 2.71828 .
. .
1000 RET 10 B H E H P B
Here we first use `B' to compute the base-10 logarithm, then use the
"hyperbolic" exponential as a cheap hack to recover the number 1000,
then use `B' again to compute the natural logarithm. Note that `P'
with the hyperbolic prefix pushes the constant `e' onto the stack.
You may have noticed that both times we took the base-10 logarithm of
1000, we got an exact integer result. Calc always tries to give an
exact rational result for calculations involving rational numbers
where possible. But when we used `H E', the result was a
floating-point number for no apparent reason. In fact, if we had
computed `10 RET 3 ^' we *would* have gotten an exact integer 1000.
But the `H E' command is rigged to generate a floating-point result
all of the time so that `1000 H E' will not waste time computing a
thousand-digit integer when all you probably wanted was `1e1000'.
(*) *Exercise 2.* Find a pair of integer inputs to the `B' command for
which Calc could find an exact rational result but doesn't. See 2:
Arithmetic Answer 2. (*)
The Calculator also has a set of functions relating to combinatorics
and statistics. You may be familiar with the "factorial" function,
which computes the product of all the integers up to a given number.
1: 100 1: 93326215443... 1: 100. 1: 9.3326e157
. . . .
100 ! U c f !
Recall, the `c f' command converts the integer or fraction at the top
of the stack to floating-point format. If you take the factorial of a
floating-point number, you get a floating-point result accurate to the
current precision. But if you give `!' an exact integer, you get an
exact integer result (158 digits long in this case).
If you take the factorial of a non-integer, Calc uses a generalized
factorial function defined in terms of Euler's Gamma function
`gamma(n)' (which is itself available as the `f g' command).
3: 4. 3: 24. 1: 5.5 1: 52.342777847
2: 4.5 2: 52.3427777847 . .
1: 5. 1: 120.
. .
M-3 ! M-0 DEL 5.5 f g
Here we verify the identity `N! = gamma(N+1)'.
The binomial coefficient N-choose-M is defined by `n! / m! (n-m)!' for
all reals `n' and `m'. The intermediate results in this formula can
become quite large even if the final result is small; the `k c'
command computes a binomial coefficient in a way that avoids large
intermediate values.
The `k' prefix key defines several common functions out of
combinatorics and number theory. Here we compute the binomial
coefficient 30-choose-20, then determine its prime factorization.
2: 30 1: 30045015 1: [3, 3, 5, 7, 11, 13, 23, 29]
1: 20 . .
.
30 RET 20 k c k f
You can verify these prime factors by using `v u' to "unpack" this
vector into 8 separate stack entries, then `M-8 *' to multiply them
back together. The result is the original number, 30045015.
Suppose a program you are writing needs a hash table with at least
10000 entries. It's best to use a prime number as the actual size of
a hash table. Calc can compute the next prime number after 10000:
1: 10000 1: 10007 1: 9973
. . .
10000 k n I k n
Just for kicks we've also computed the next prime *less* than 10000.
See Financial Functions, for a description of the Calculator
commands that deal with business and financial calculations (functions
like `pv', `rate', and `sln').
See Binary Functions, to read about the commands for operating
on binary numbers (like `and', `xor', and `lsh').