To test numbers for numerical equality, you should normally use
=
instead of non-numeric comparison predicates like eq
,
eql
and equal
. Distinct floating-point and large
integer objects can be numerically equal. If you use eq
to
compare them, you test whether they are the same object; if you
use eql
or equal
, you test whether their values are
indistinguishable. In contrast, =
uses numeric
comparison, and sometimes returns t
when a non-numeric
comparison would return nil
and vice versa. See Floating-Point Basics.
In Emacs Lisp, if two fixnums are numerically equal, they are the
same Lisp object. That is, eq
is equivalent to =
on
fixnums. It is sometimes convenient to use eq
for comparing
an unknown value with a fixnum, because eq
does not report an
error if the unknown value is not a number—it accepts arguments of
any type. By contrast, =
signals an error if the arguments are
not numbers or markers. However, it is better programming practice to
use =
if you can, even for comparing integers.
Sometimes it is useful to compare numbers with eql
or equal
,
which treat two numbers as equal if they have the same data type (both
integers, or both floating point) and the same value. By contrast,
=
can treat an integer and a floating-point number as equal.
See Equality Predicates.
There is another wrinkle: because floating-point arithmetic is not exact, it is often a bad idea to check for equality of floating-point values. Usually it is better to test for approximate equality. Here’s a function to do this:
(defvar fuzz-factor 1.0e-6) (defun approx-equal (x y) (or (= x y) (< (/ (abs (- x y)) (max (abs x) (abs y))) fuzz-factor)))
This function tests whether all its arguments are numerically equal,
and returns t
if so, nil
otherwise.
eql
value1 value2 ¶This function acts like eq
except when both arguments are
numbers. It compares numbers by type and numeric value, so that
(eql 1.0 1)
returns nil
, but (eql 1.0 1.0)
and
(eql 1 1)
both return t
. This can be used to compare
large integers as well as small ones.
Floating-point values with the same sign, exponent and fraction are eql
.
This differs from numeric comparison: (eql 0.0 -0.0)
returns
nil
and (eql 0.0e+NaN 0.0e+NaN)
returns t
,
whereas =
does the opposite.
This function tests whether its arguments are numerically equal, and
returns t
if they are not, and nil
if they are.
This function tests whether each argument is strictly less than the
following argument. It returns t
if so, nil
otherwise.
This function tests whether each argument is less than or equal to
the following argument. It returns t
if so, nil
otherwise.
This function tests whether each argument is strictly greater than
the following argument. It returns t
if so, nil
otherwise.
This function tests whether each argument is greater than or equal to
the following argument. It returns t
if so, nil
otherwise.
max
number-or-marker &rest numbers-or-markers ¶This function returns the largest of its arguments.
(max 20) ⇒ 20 (max 1 2.5) ⇒ 2.5 (max 1 3 2.5) ⇒ 3
min
number-or-marker &rest numbers-or-markers ¶This function returns the smallest of its arguments.
(min -4 1) ⇒ -4
abs
number ¶This function returns the absolute value of number.