The following commands and algebraic functions return true/false values,
where 1 represents "true" and 0 represents "false." In cases where
a truth value is required (such as for the condition part of a rewrite
rule, or as the condition for a `Z [ Z ]` control structure), any
nonzero value is accepted to mean "true." (Specifically, anything
for which `dnonzero`

returns 1 is "true," and anything for
which `dnonzero`

returns 0 or cannot decide is assumed "false."
Note that this means that `Z [ Z ]` will execute the "then"
portion if its condition is provably true, but it will execute the
"else" portion for any condition like a = b that is not
provably true, even if it might be true. Algebraic functions that
have conditions as arguments, like `? :`

and `&&`

, remain
unevaluated if the condition is neither provably true nor provably
false. See section Declarations.)

The `a =` (`calc-equal-to`

) command, or ``eq(a,b)'` function
(which can also be written ``a = b'` or ``a == b'` in an algebraic
formula) is true if a and b are equal, either because they
are identical expressions, or because they are numbers which are
numerically equal. (Thus the integer 1 is considered equal to the float
1.0.) If the equality of a and b cannot be determined,
the comparison is left in symbolic form. Note that as a command, this
operation pops two values from the stack and pushes back either a 1 or
a 0, or a formula ``a = b'` if the values' equality cannot be determined.

Many Calc commands use ``='` formulas to represent **equations**.
For example, the `a S` (`calc-solve-for`

) command rearranges
an equation to solve for a given variable. The `a M`
(`calc-map-equation`

) command can be used to apply any
function to both sides of an equation; for example, `2 a M *`
multiplies both sides of the equation by two. Note that just
`2 *` would not do the same thing; it would produce the formula
``2 (a = b)'` which represents 2 if the equality is true or
zero if not.

The `eq`

function with more than two arguments (e.g., `C-u 3 a =`
or ``a = b = c'`) tests if all of its arguments are equal. In
algebraic notation, the ``='` operator is unusual in that it is
neither left- nor right-associative: ``a = b = c'` is not the
same as ``(a = b) = c'` or ``a = (b = c)'` (which each compare
one variable with the 1 or 0 that results from comparing two other
variables).

The `a #` (`calc-not-equal-to`

) command, or ``neq(a,b)'` or
``a != b'` function, is true if a and b are not equal.
This also works with more than two arguments; ``a != b != c != d'`
tests that all four of a, b, c, and d are
distinct numbers.

The `a <` (`calc-less-than`

) [``lt(a,b)'` or ``a < b'`]
operation is true if a is less than b. Similar functions
are `a >` (`calc-greater-than`

) [``gt(a,b)'` or ``a > b'`],
`a [` (`calc-less-equal`

) [``leq(a,b)'` or ``a <= b'`], and
`a ]` (`calc-greater-equal`

) [``geq(a,b)'` or ``a >= b'`].

While the inequality functions like `lt`

do not accept more
than two arguments, the syntax ``a <= b < c'` is translated to an
equivalent expression involving intervals: ``b in [a .. c)'`.
(See the description of `in`

below.) All four combinations
of ``<'` and ``<='` are allowed, or any of the four combinations
of ``>'` and ``>='`. Four-argument constructions like
``a < b < c < d'`, and mixtures like ``a < b = c'` that
involve both equalities and inequalities, are not allowed.

The `a .` (`calc-remove-equal`

) [`rmeq`

] command extracts
the righthand side of the equation or inequality on the top of the
stack. It also works elementwise on vectors. For example, if
``[x = 2.34, y = z / 2]'` is on the stack, then `a .` produces
``[2.34, z / 2]'`. As a special case, if the righthand side is a
variable and the lefthand side is a number (as in ``2.34 = x'`), then
Calc keeps the lefthand side instead. Finally, this command works with
assignments ``x := 2.34'` as well as equations, always taking the
the righthand side, and for ``=>'` (evaluates-to) operators, always
taking the lefthand side.

The `a &` (`calc-logical-and`

) [``land(a,b)'` or ``a && b'`]
function is true if both of its arguments are true, i.e., are
non-zero numbers. In this case, the result will be either a or
b, chosen arbitrarily. If either argument is zero, the result is
zero. Otherwise, the formula is left in symbolic form.

The `a |` (`calc-logical-or`

) [``lor(a,b)'` or ``a || b'`]
function is true if either or both of its arguments are true (nonzero).
The result is whichever argument was nonzero, choosing arbitrarily if both
are nonzero. If both a and b are zero, the result is
zero.

The `a !` (`calc-logical-not`

) [``lnot(a)'` or ``! a'`]
function is true if a is false (zero), or false if a is
true (nonzero). It is left in symbolic form if a is not a
number.

The `a :` (`calc-logical-if`

) [``if(a,b,c)'` or ``a ? b : c'`]
function is equal to either b or c if a is a nonzero
number or zero, respectively. If a is not a number, the test is
left in symbolic form and neither b nor c is evaluated in
any way. In algebraic formulas, this is one of the few Calc functions
whose arguments are not automatically evaluated when the function itself
is evaluated. The others are `lambda`

, `quote`

, and
`condition`

.

One minor surprise to watch out for is that the formula ``a?3:4'`
will not work because the ``3:4'` is parsed as a fraction instead of
as three separate symbols. Type something like ``a ? 3 : 4'` or
``a?(3):4'` instead.

As a special case, if a evaluates to a vector, then both b and c are evaluated; the result is a vector of the same length as a whose elements are chosen from corresponding elements of b and c according to whether each element of a is zero or nonzero. Each of b and c must be either a vector of the same length as a, or a non-vector which is matched with all elements of a.

The `a {` (`calc-in-set`

) [``in(a,b)'`] function is true if
the number a is in the set of numbers represented by b.
If b is an interval form, a must be one of the values
encompassed by the interval. If b is a vector, a must be
equal to one of the elements of the vector. (If any vector elements are
intervals, a must be in any of the intervals.) If b is a
plain number, a must be numerically equal to b.
See section Set Operations using Vectors, for a group of commands that manipulate sets
of this sort.

The ``typeof(a)'` function produces an integer or variable which
characterizes a. If a is a number, vector, or variable,
the result will be one of the following numbers:

1 Integer 2 Fraction 3 Floating-point number 4 HMS form 5 Rectangular complex number 6 Polar complex number 7 Error form 8 Interval form 9 Modulo form 10 Date-only form 11 Date/time form 12 Infinity (inf, uinf, or nan) 100 Variable 101 Vector (but not a matrix) 102 Matrix

Otherwise, a is a formula, and the result is a variable which represents the name of the top-level function call.

The ``integer(a)'` function returns true if a is an integer.
The ``real(a)'` function
is true if a is a real number, either integer, fraction, or
float. The ``constant(a)'` function returns true if a is
any of the objects for which `typeof`

would produce an integer
code result except for variables, and provided that the components of
an object like a vector or error form are themselves constant.
Note that infinities do not satisfy any of these tests, nor do
special constants like `pi`

and `e`

.

See section Declarations, for a set of similar functions that recognize
formulas as well as actual numbers. For example, ``dint(floor(x))'`
is true because ``floor(x)'` is provably integer-valued, but
``integer(floor(x))'` does not because ``floor(x)'` is not
literally an integer constant.

The ``refers(a,b)'` function is true if the variable (or sub-expression)
b appears in a, or false otherwise. Unlike the other
tests described here, this function returns a definite "no" answer
even if its arguments are still in symbolic form. The only case where
`refers`

will be left unevaluated is if a is a plain
variable (different from b).

The ``negative(a)'` function returns true if a "looks" negative,
because it is a negative number, because it is of the form -x,
or because it is a product or quotient with a term that looks negative.
This is most useful in rewrite rules. Beware that ``negative(a)'`
evaluates to 1 or 0 for *any* argument a, so it can only
be stored in a formula if the default simplifications are turned off
first with `m O` (or if it appears in an unevaluated context such
as a rewrite rule condition).

The ``variable(a)'` function is true if a is a variable,
or false if not. If a is a function call, this test is left
in symbolic form. Built-in variables like `pi`

and `inf`

are considered variables like any others by this test.

The ``nonvar(a)'` function is true if a is a non-variable.
If its argument is a variable it is left unsimplified; it never
actually returns zero. However, since Calc's condition-testing
commands consider "false" anything not provably true, this is
often good enough.

The functions `lin`

, `linnt`

, `islin`

, and `islinnt`

check if an expression is "linear," i.e., can be written in the form
a + b x for some constants a and b, and some
variable or subformula x. The function ``islin(f,x)'` checks
if formula f is linear in x, returning 1 if so. For
example, ``islin(x,x)'`, ``islin(-x,x)'`, ``islin(3,x)'`, and
``islin(x y / 3 - 2, x)'` all return 1. The ``lin(f,x)'` function
is similar, except that instead of returning 1 it returns the vector
[a, b, x]. For the above examples, this vector would be
[0, 1, x], [0, -1, x], [3, 0, x], and
[-2, y/3, x], respectively. Both `lin`

and `islin`

generally remain unevaluated for expressions which are not linear,
e.g., ``lin(2 x^2, x)'` and ``lin(sin(x), x)'`. The second
argument can also be a formula; ``islin(2 + 3 sin(x), sin(x))'`
returns true.

The `linnt`

and `islinnt`

functions perform a similar check,
but require a "non-trivial" linear form, which means that the
b coefficient must be non-zero. For example, ``lin(2,x)'`
returns [2, 0, x] and ``lin(y,x)'` returns [y, 0, x],
but ``linnt(2,x)'` and ``linnt(y,x)'` are left unevaluated
(in other words, these formulas are considered to be only "trivially"
linear in x).

All four linearity-testing functions allow you to omit the second
argument, in which case the input may be linear in any non-constant
formula. Here, the a=0, b=1 case is also considered
trivial, and only constant values for a and b are
recognized. Thus, ``lin(2 x y)'` returns [0, 2, x y],
``lin(2 - x y)'` returns [2, -1, x y], and ``lin(x y)'`
returns [0, 1, x y]. The `linnt`

function would allow the
first two cases but not the third. Also, neither `lin`

nor
`linnt`

accept plain constants as linear in the one-argument
case: ``islin(2,x)'` is true, but ``islin(2)'` is false.

The ``istrue(a)'` function returns 1 if a is a nonzero
number or provably nonzero formula, or 0 if a is anything else.
Calls to `istrue`

can only be manipulated if `m O` mode is
used to make sure they are not evaluated prematurely. (Note that
declarations are used when deciding whether a formula is true;
`istrue`

returns 1 when `dnonzero`

would return 1, and
it returns 0 when `dnonzero`

would return 0 or leave itself
in symbolic form.)

Go to the first, previous, next, last section, table of contents.