17.5.7.4 Predicates

The functions described here are predicates, that is, they return a
true/false value where nil means false and anything else means
true. These predicates are expanded by defmath, for example,
from zerop to math-zerop. In many cases they correspond
to native Lisp functions by the same name, but are extended to cover
the full range of Calc data types.

Function: zeropx

Returns true if x is numerically zero, in any of the Calc data
types. (Note that for some types, such as error forms and intervals,
it never makes sense to return true.) In defmath, the expression
‘(= x 0)’ will automatically be converted to ‘(math-zerop x)’,
and ‘(/= x 0)’ will be converted to ‘(not (math-zerop x))’.

Function: negpx

Returns true if x is negative. This accepts negative real numbers
of various types, negative HMS and date forms, and intervals in which
all included values are negative. In defmath, the expression
‘(< x 0)’ will automatically be converted to ‘(math-negp x)’,
and ‘(>= x 0)’ will be converted to ‘(not (math-negp x))’.

Function: pospx

Returns true if x is positive (and non-zero). For complex
numbers, none of these three predicates will return true.

Function: looks-negpx

Returns true if x is “negative-looking.” This returns true if
x is a negative number, or a formula with a leading minus sign
such as ‘-a/b’. In other words, this is an object which can be
made simpler by calling (- x).

Function: integerpx

Returns true if x is an integer of any size.

Function: fixnumpx

Returns true if x is a native Lisp integer.

Function: natnumpx

Returns true if x is a nonnegative integer of any size.

Function: fixnatnumpx

Returns true if x is a nonnegative Lisp integer.

Function: num-integerpx

Returns true if x is numerically an integer, i.e., either a
true integer or a float with no significant digits to the right of
the decimal point.

Function: messy-integerpx

Returns true if x is numerically, but not literally, an integer.
A value is num-integerp if it is integerp or
messy-integerp (but it is never both at once).

Function: num-natnumpx

Returns true if x is numerically a nonnegative integer.

Function: evenpx

Returns true if x is an even integer.

Function: looks-evenpx

Returns true if x is an even integer, or a formula with a leading
multiplicative coefficient which is an even integer.

Function: oddpx

Returns true if x is an odd integer.

Function: ratpx

Returns true if x is a rational number, i.e., an integer or a
fraction.

Function: realpx

Returns true if x is a real number, i.e., an integer, fraction,
or floating-point number.

Function: anglepx

Returns true if x is a real number or HMS form.

Function: floatpx

Returns true if x is a float, or a complex number, error form,
interval, date form, or modulo form in which at least one component
is a float.

Function: complexpx

Returns true if x is a rectangular or polar complex number
(but not a real number).

Function: rect-complexpx

Returns true if x is a rectangular complex number.

Function: polar-complexpx

Returns true if x is a polar complex number.

Function: numberpx

Returns true if x is a real number or a complex number.

Function: scalarpx

Returns true if x is a real or complex number or an HMS form.

Function: vectorpx

Returns true if x is a vector (this simply checks if its argument
is a list whose first element is the symbol vec).

Function: numvecpx

Returns true if x is a number or vector.

Function: matrixpx

Returns true if x is a matrix, i.e., a vector of one or more vectors,
all of the same size.

Function: square-matrixpx

Returns true if x is a square matrix.

Function: objectpx

Returns true if x is any numeric Calc object, including real and
complex numbers, HMS forms, date forms, error forms, intervals, and
modulo forms. (Note that error forms and intervals may include formulas
as their components; see constp below.)

Function: objvecpx

Returns true if x is an object or a vector. This also accepts
incomplete objects, but it rejects variables and formulas (except as
mentioned above for objectp).

Function: primpx

Returns true if x is a “primitive” or “atomic” Calc object,
i.e., one whose components cannot be regarded as sub-formulas. This
includes variables, and all objectp types except error forms
and intervals.

Function: constpx

Returns true if x is constant, i.e., a real or complex number,
HMS form, date form, or error form, interval, or vector all of whose
components are constp.

Function: lesspx y

Returns true if x is numerically less than y. Returns false
if x is greater than or equal to y, or if the order is
undefined or cannot be determined. Generally speaking, this works
by checking whether ‘x - y’ is negp. In
defmath, the expression ‘(< x y)’ will automatically be
converted to ‘(lessp x y)’; expressions involving >, <=,
and >= are similarly converted in terms of lessp.

Function: beforepx y

Returns true if x comes before y in a canonical ordering
of Calc objects. If x and y are both real numbers, this
will be the same as lessp. But whereas lessp considers
other types of objects to be unordered, beforep puts any two
objects into a definite, consistent order. The beforep
function is used by the V S vector-sorting command, and also
by Calc’s algebraic simplifications to put the terms of a product into
canonical order: This allows ‘x y + y x’ to be simplified easily to
‘2 x y’.

Function: equalx y

This is the standard Lisp equal predicate; it returns true if
x and y are structurally identical. This is the usual way
to compare numbers for equality, but note that equal will treat
0 and 0.0 as different.

Function: math-equalx y

Returns true if x and y are numerically equal, either because
they are equal, or because their difference is zerop. In
defmath, the expression ‘(= x y)’ will automatically be
converted to ‘(math-equal x y)’.

Function: equal-intx n

Returns true if x and n are numerically equal, where n
is a fixnum which is not a multiple of 10. This will automatically be
used by defmath in place of the more general math-equal
whenever possible.

Function: nearly-equalx y

Returns true if x and y, as floating-point numbers, are
equal except possibly in the last decimal place. For example,
314.159 and 314.166 are considered nearly equal if the current
precision is 6 (since they differ by 7 units), but not if the current
precision is 7 (since they differ by 70 units). Most functions which
use series expansions use with-extra-prec to evaluate the
series with 2 extra digits of precision, then use nearly-equal
to decide when the series has converged; this guards against cumulative
error in the series evaluation without doing extra work which would be
lost when the result is rounded back down to the current precision.
In defmath, this can be written ‘(~= xy)’.
The x and y can be numbers of any kind, including complex.

Function: nearly-zeropx y

Returns true if x is nearly zero, compared to y. This
checks whether x plus y would by be nearly-equal
to y itself, to within the current precision, in other words,
if adding x to y would have a negligible effect on y
due to roundoff error. X may be a real or complex number, but
y must be real.

Function: is-truex

Return true if the formula x represents a true value in
Calc, not Lisp, terms. It tests if x is a non-zero number
or a provably non-zero formula.

Function: reject-argval pred

Abort the current function evaluation due to unacceptable argument values.
This calls ‘(calc-record-why predval)’, then signals a
Lisp error which normalize will trap. The net effect is that the
function call which led here will be left in symbolic form.

Function: inexact-value

If Symbolic mode is enabled, this will signal an error that causes
normalize to leave the formula in symbolic form, with the message
“Inexact result.” (This function has no effect when not in Symbolic mode.)
Note that if your function calls ‘(sin 5)’ in Symbolic mode, the
sin function will call inexact-value, which will cause your
function to be left unsimplified. You may instead wish to call
‘(normalize (list 'calcFunc-sin 5))’, which in Symbolic mode will
return the formula ‘sin(5)’ to your function.

Function: overflow

This signals an error that will be reported as a floating-point overflow.