Next: Computational Lisp Functions, Previous: Stack Lisp Functions, Up: Internals

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: **zerop**` x`

Returns true if

xis 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: **negp**` x`

Returns true if

xis 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: **posp**` x`

Returns true if

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

— Function: **looks-negp**` x`

Returns true if

xis “negative-looking.” This returns true ifxis 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: **num-integerp**` x`

Returns true if

xis 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-integerp**` x`

Returns true if

xis 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: **looks-evenp**` x`

Returns true if

xis an even integer, or a formula with a leading multiplicative coefficient which is an even integer.

— Function: **realp**` x`

Returns true if

xis a real number, i.e., an integer, fraction, or floating-point number.

— Function: **floatp**` x`

Returns true if

xis a float, or a complex number, error form, interval, date form, or modulo form in which at least one component is a float.

— Function: **complexp**` x`

Returns true if

xis a rectangular or polar complex number (but not a real number).

— Function: **vectorp**` x`

Returns true if

xis a vector (this simply checks if its argument is a list whose first element is the symbol`vec`

).

— Function: **matrixp**` x`

Returns true if

xis a matrix, i.e., a vector of one or more vectors, all of the same size.

— Function: **objectp**` x`

Returns true if

xis 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: **objvecp**` x`

Returns true if

xis an object or a vector. This also accepts incomplete objects, but it rejects variables and formulas (except as mentioned above for`objectp`

).

— Function: **primp**` x`

Returns true if

xis 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: **constp**` x`

Returns true if

xis 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: **lessp**` x y`

Returns true if

xis numerically less thany. Returns false ifxis greater than or equal toy, or if the order is undefined or cannot be determined. Generally speaking, this works by checking whether ‘’ isx-y`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: **beforep**` x y`

Returns true if

xcomes beforeyin a canonical ordering of Calc objects. Ifxandyare 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 theV Svector-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: **equal**` x y`

This is the standard Lisp

`equal`

predicate; it returns true ifxandyare 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-equal**` x y`

Returns true if

xandyare 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-int**` x n`

Returns true if

xandnare numerically equal, wherenis 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-equal**` x y`

Returns true if

xandy, 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 ‘(~=’. Thexy)xandycan be numbers of any kind, including complex.

— Function: **nearly-zerop**` x y`

Returns true if

xis nearly zero, compared toy. This checks whetherxplusywould by be`nearly-equal`

toyitself, to within the current precision, in other words, if addingxtoywould have a negligible effect onydue to roundoff error.Xmay be a real or complex number, butymust be real.

— Function: **is-true**` x`

Return true if the formula

xrepresents a true value in Calc, not Lisp, terms. It tests ifxis a non-zero number or a provably non-zero formula.

— Function: **reject-arg**` val pred`

Abort the current function evaluation due to unacceptable argument values. This calls ‘

(calc-record-why’, then signals a Lisp error whichpredval)`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.