Next: Numeric Conversions, Previous: Predicates on Numbers, Up: Numbers

To test numbers for numerical equality, you should normally use
`=`

, not `eq`

. There can be many distinct floating point
number objects with the same numeric value. If you use `eq`

to
compare them, then you test whether two values are the same
*object*. By contrast, `=`

compares only the numeric values
of the objects.

In Emacs Lisp, each integer value is a unique Lisp object.
Therefore, `eq`

is equivalent to `=`

where integers are
concerned. It is sometimes convenient to use `eq`

for comparing
an unknown value with an integer, 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 `equal`

, which
treats 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 two 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 (and (= x 0) (= y 0)) (< (/ (abs (- x y)) (max (abs x) (abs y))) fuzz-factor)))

Common Lisp note:Comparing numbers in Common Lisp always requires`=`

because Common Lisp implements multi-word integers, and two distinct integer objects can have the same numeric value. Emacs Lisp can have just one integer object for any given value because it has a limited range of integer values.

— Function: **=**` number-or-marker1 number-or-marker2`

This function tests whether its arguments are numerically equal, and returns

`t`

if so,`nil`

otherwise.

— Function: **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`

.

— Function: **/=**` number-or-marker1 number-or-marker2`

This function tests whether its arguments are numerically equal, and returns

`t`

if they are not, and`nil`

if they are.

— Function: **<**` number-or-marker1 number-or-marker2`

This function tests whether its first argument is strictly less than its second argument. It returns

`t`

if so,`nil`

otherwise.

— Function: **<=**` number-or-marker1 number-or-marker2`

This function tests whether its first argument is less than or equal to its second argument. It returns

`t`

if so,`nil`

otherwise.

— Function: **>**` number-or-marker1 number-or-marker2`

This function tests whether its first argument is strictly greater than its second argument. It returns

`t`

if so,`nil`

otherwise.

— Function: **>=**` number-or-marker1 number-or-marker2`

This function tests whether its first argument is greater than or equal to its second argument. It returns

`t`

if so,`nil`

otherwise.

— Function: **max**` number-or-marker &rest numbers-or-markers`

This function returns the largest of its arguments. If any of the arguments is floating-point, the value is returned as floating point, even if it was given as an integer.

(max 20) ⇒ 20 (max 1 2.5) ⇒ 2.5 (max 1 3 2.5) ⇒ 3.0