calc: Basic Arithmetic
8.1 Basic Arithmetic
====================
The ‘+’ (‘calc-plus’) command adds two numbers. The numbers may be any
of the standard Calc data types. The resulting sum is pushed back onto
the stack.
If both arguments of ‘+’ are vectors or matrices (of matching
dimensions), the result is a vector or matrix sum. If one argument is a
vector and the other a scalar (i.e., a non-vector), the scalar is added
to each of the elements of the vector to form a new vector. If the
scalar is not a number, the operation is left in symbolic form: Suppose
you added ‘x’ to the vector ‘[1,2]’. You may want the result
‘[1+x,2+x]’, or you may plan to substitute a 2-vector for ‘x’ in the
future. Since the Calculator can’t tell which interpretation you want,
it makes the safest assumption. 
Reducing and Mapping, for a way
to add ‘x’ to every element of a vector.
If either argument of ‘+’ is a complex number, the result will in
general be complex. If one argument is in rectangular form and the
other polar, the current Polar mode determines the form of the result.
If Symbolic mode is enabled, the sum may be left as a formula if the
necessary conversions for polar addition are non-trivial.
If both arguments of ‘+’ are HMS forms, the forms are added according
to the usual conventions of hours-minutes-seconds notation. If one
argument is an HMS form and the other is a number, that number is
converted from degrees or radians (depending on the current Angular
mode) to HMS format and then the two HMS forms are added.
If one argument of ‘+’ is a date form, the other can be either a real
number, which advances the date by a certain number of days, or an HMS
form, which advances the date by a certain amount of time. Subtracting
two date forms yields the number of days between them. Adding two date
forms is meaningless, but Calc interprets it as the subtraction of one
date form and the negative of the other. (The negative of a date form
can be understood by remembering that dates are stored as the number of
days before or after Jan 1, 1 AD.)
If both arguments of ‘+’ are error forms, the result is an error form
with an appropriately computed standard deviation. If one argument is
an error form and the other is a number, the number is taken to have
zero error. Error forms may have symbolic formulas as their mean and/or
error parts; adding these will produce a symbolic error form result.
However, adding an error form to a plain symbolic formula (as in ‘(a +/-
b) + c’) will not work, for the same reasons just mentioned for vectors.
Instead you must write ‘(a +/- b) + (c +/- 0)’.
If both arguments of ‘+’ are modulo forms with equal values of ‘M’,
or if one argument is a modulo form and the other a plain number, the
result is a modulo form which represents the sum, modulo ‘M’, of the two
values.
If both arguments of ‘+’ are intervals, the result is an interval
which describes all possible sums of the possible input values. If one
argument is a plain number, it is treated as the interval ‘[x .. x]’.
If one argument of ‘+’ is an infinity and the other is not, the
result is that same infinity. If both arguments are infinite and in the
same direction, the result is the same infinity, but if they are
infinite in different directions the result is ‘nan’.
The ‘-’ (‘calc-minus’) command subtracts two values. The top number
on the stack is subtracted from the one behind it, so that the
computation ‘5 <RET> 2 -’ produces 3, not -3. All options available for
‘+’ are available for ‘-’ as well.
The ‘*’ (‘calc-times’) command multiplies two numbers. If one
argument is a vector and the other a scalar, the scalar is multiplied by
the elements of the vector to produce a new vector. If both arguments
are vectors, the interpretation depends on the dimensions of the
vectors: If both arguments are matrices, a matrix multiplication is
done. If one argument is a matrix and the other a plain vector, the
vector is interpreted as a row vector or column vector, whichever is
dimensionally correct. If both arguments are plain vectors, the result
is a single scalar number which is the dot product of the two vectors.
If one argument of ‘*’ is an HMS form and the other a number, the HMS
form is multiplied by that amount. It is an error to multiply two HMS
forms together, or to attempt any multiplication involving date forms.
Error forms, modulo forms, and intervals can be multiplied; see the
comments for addition of those forms. When two error forms or intervals
are multiplied they are considered to be statistically independent;
thus, ‘[-2 .. 3] * [-2 .. 3]’ is ‘[-6 .. 9]’, whereas ‘[-2 .. 3] ^ 2’ is
‘[0 .. 9]’.
The ‘/’ (‘calc-divide’) command divides two numbers.
When combining multiplication and division in an algebraic formula,
it is good style to use parentheses to distinguish between possible
interpretations; the expression ‘a/b*c’ should be written ‘(a/b)*c’ or
‘a/(b*c)’, as appropriate. Without the parentheses, Calc will interpret
‘a/b*c’ as ‘a/(b*c)’, since in algebraic entry Calc gives division a
lower precedence than multiplication. (This is not standard across all
computer languages, and Calc may change the precedence depending on the
language mode being used. Language Modes.) This default
ordering can be changed by setting the customizable variable
‘calc-multiplication-has-precedence’ to ‘nil’ (Customizing
Calc); this will give multiplication and division equal precedences.
Note that Calc’s default choice of precedence allows ‘a b / c d’ to be
used as a shortcut for
a b
---.
c d
When dividing a scalar ‘B’ by a square matrix ‘A’, the computation
performed is ‘B’ times the inverse of ‘A’. This also occurs if ‘B’ is
itself a vector or matrix, in which case the effect is to solve the set
of linear equations represented by ‘B’. If ‘B’ is a matrix with the
same number of rows as ‘A’, or a plain vector (which is interpreted here
as a column vector), then the equation ‘A X = B’ is solved for the
vector or matrix ‘X’. Otherwise, if ‘B’ is a non-square matrix with the
same number of _columns_ as ‘A’, the equation ‘X A = B’ is solved. If
you wish a vector ‘B’ to be interpreted as a row vector to be solved as
‘X A = B’, make it into a one-row matrix with ‘C-u 1 v p’ first. To
force a left-handed solution with a square matrix ‘B’, transpose ‘A’ and
‘B’ before dividing, then transpose the result.
HMS forms can be divided by real numbers or by other HMS forms.
Error forms can be divided in any combination of ways. Modulo forms
where both values and the modulo are integers can be divided to get an
integer modulo form result. Intervals can be divided; dividing by an
interval that encompasses zero or has zero as a limit will result in an
infinite interval.
The ‘^’ (‘calc-power’) command raises a number to a power. If the
power is an integer, an exact result is computed using repeated
multiplications. For non-integer powers, Calc uses Newton’s method or
logarithms and exponentials. Square matrices can be raised to integer
powers. If either argument is an error (or interval or modulo) form,
the result is also an error (or interval or modulo) form.
If you press the ‘I’ (inverse) key first, the ‘I ^’ command computes
an Nth root: ‘125 <RET> 3 I ^’ computes the number 5. (This is entirely
equivalent to ‘125 <RET> 1:3 ^’.)
The ‘\’ (‘calc-idiv’) command divides two numbers on the stack to
produce an integer result. It is equivalent to dividing with </>, then
rounding down with ‘F’ (‘calc-floor’), only a bit more convenient and
efficient. Also, since it is an all-integer operation when the
arguments are integers, it avoids problems that ‘/ F’ would have with
floating-point roundoff.
The ‘%’ (‘calc-mod’) command performs a “modulo” (or “remainder”)
operation. Mathematically, ‘a%b = a - (a\b)*b’, and is defined for all
real numbers ‘a’ and ‘b’ (except ‘b=0’). For positive ‘b’, the result
will always be between 0 (inclusive) and ‘b’ (exclusive). Modulo does
not work for HMS forms and error forms. If ‘a’ is a modulo form, its
modulo is changed to ‘b’, which must be positive real number.
The ‘:’ (‘calc-fdiv’) [‘fdiv’] command divides the two integers on
the top of the stack to produce a fractional result. This is a
convenient shorthand for enabling Fraction mode (with ‘m f’) temporarily
and using ‘/’. Note that during numeric entry the ‘:’ key is
interpreted as a fraction separator, so to divide 8 by 6 you would have
to type ‘8 <RET> 6 <RET> :’. (Of course, in this case, it would be much
easier simply to enter the fraction directly as ‘8:6 <RET>’!)
The ‘n’ (‘calc-change-sign’) command negates the number on the top of
the stack. It works on numbers, vectors and matrices, HMS forms, date
forms, error forms, intervals, and modulo forms.
The ‘A’ (‘calc-abs’) [‘abs’] command computes the absolute value of a
number. The result of ‘abs’ is always a nonnegative real number: With a
complex argument, it computes the complex magnitude. With a vector or
matrix argument, it computes the Frobenius norm, i.e., the square root
of the sum of the squares of the absolute values of the elements. The
absolute value of an error form is defined by replacing the mean part
with its absolute value and leaving the error part the same. The
absolute value of a modulo form is undefined. The absolute value of an
interval is defined in the obvious way.
The ‘f A’ (‘calc-abssqr’) [‘abssqr’] command computes the absolute
value squared of a number, vector or matrix, or error form.
The ‘f s’ (‘calc-sign’) [‘sign’] command returns 1 if its argument is
positive, -1 if its argument is negative, or 0 if its argument is zero.
In algebraic form, you can also write ‘sign(a,x)’ which evaluates to ‘x
* sign(a)’, i.e., either ‘x’, ‘-x’, or zero depending on the sign of
‘a’.
The ‘&’ (‘calc-inv’) [‘inv’] command computes the reciprocal of a
number, i.e., ‘1 / x’. Operating on a square matrix, it computes the
inverse of that matrix.
The ‘Q’ (‘calc-sqrt’) [‘sqrt’] command computes the square root of a
number. For a negative real argument, the result will be a complex
number whose form is determined by the current Polar mode.
The ‘f h’ (‘calc-hypot’) [‘hypot’] command computes the square root
of the sum of the squares of two numbers. That is, ‘hypot(a,b)’ is the
length of the hypotenuse of a right triangle with sides ‘a’ and ‘b’. If
the arguments are complex numbers, their squared magnitudes are used.
The ‘f Q’ (‘calc-isqrt’) [‘isqrt’] command computes the integer
square root of an integer. This is the true square root of the number,
rounded down to an integer. For example, ‘isqrt(10)’ produces 3. Note
that, like ‘\’ [‘idiv’], this uses exact integer arithmetic throughout
to avoid roundoff problems. If the input is a floating-point number or
other non-integer value, this is exactly the same as ‘floor(sqrt(x))’.
The ‘f n’ (‘calc-min’) [‘min’] and ‘f x’ (‘calc-max’) [‘max’]
commands take the minimum or maximum of two real numbers, respectively.
These commands also work on HMS forms, date forms, intervals, and
infinities. (In algebraic expressions, these functions take any number
of arguments and return the maximum or minimum among all the arguments.)
The ‘f M’ (‘calc-mant-part’) [‘mant’] function extracts the
“mantissa” part ‘m’ of its floating-point argument; ‘f X’
(‘calc-xpon-part’) [‘xpon’] extracts the “exponent” part ‘e’. The
original number is equal to ‘m * 10^e’, where ‘m’ is in the interval
‘[1.0 .. 10.0)’ except that ‘m=e=0’ if the original number is zero. For
integers and fractions, ‘mant’ returns the number unchanged and ‘xpon’
returns zero. The ‘v u’ (‘calc-unpack’) command can also be used to
“unpack” a floating-point number; this produces an integer mantissa and
exponent, with the constraint that the mantissa is not a multiple of ten
(again except for the ‘m=e=0’ case).
The ‘f S’ (‘calc-scale-float’) [‘scf’] function scales a number by a
given power of ten. Thus, ‘scf(mant(x), xpon(x)) = x’ for any real ‘x’.
The second argument must be an integer, but the first may actually be
any numeric value. For example, ‘scf(5,-2) = 0.05’ or ‘1:20’ depending
on the current Fraction mode.
The ‘f [’ (‘calc-decrement’) [‘decr’] and ‘f ]’ (‘calc-increment’)
[‘incr’] functions decrease or increase a number by one unit. For
integers, the effect is obvious. For floating-point numbers, the change
is by one unit in the last place. For example, incrementing ‘12.3456’
when the current precision is 6 digits yields ‘12.3457’. If the current
precision had been 8 digits, the result would have been ‘12.345601’.
Incrementing ‘0.0’ produces ‘10^-p’, where ‘p’ is the current precision.
These operations are defined only on integers and floats. With numeric
prefix arguments, they change the number by ‘n’ units.
Note that incrementing followed by decrementing, or vice-versa, will
almost but not quite always cancel out. Suppose the precision is 6
digits and the number ‘9.99999’ is on the stack. Incrementing will
produce ‘10.0000’; decrementing will produce ‘9.9999’. One digit has
been dropped. This is an unavoidable consequence of the way
floating-point numbers work.
Incrementing a date/time form adjusts it by a certain number of
seconds. Incrementing a pure date form adjusts it by a certain number
of days.
Info Catalog
calc: Arithmetic
calc: Arithmetic
calc: Integer Truncation