Next: Numeric Conversions, Previous: Predicates on Numbers, Up: Numbers [Contents][Index]

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

, not `eq`

. There can be many distinct floating-point
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 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 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)))

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 integers.

- Function:
`=`

*number-or-marker &rest number-or-markers* This function tests whether all 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-marker &rest number-or-markers* This function tests whether each argument is strictly less than the following argument. It returns

`t`if so,`nil`

otherwise.

- Function:
`<=`

*number-or-marker &rest number-or-markers* This function tests whether each argument is less than or equal to the following argument. It returns

`t`if so,`nil`

otherwise.

- Function:
`>`

*number-or-marker &rest number-or-markers* This function tests whether each argument is strictly greater than the following argument. It returns

`t`if so,`nil`

otherwise.

- Function:
`>=`

*number-or-marker &rest number-or-markers* This function tests whether each argument is greater than or equal to the following 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

- Function:
`min`

*number-or-marker &rest numbers-or-markers* This function returns the smallest 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.

(min -4 1) ⇒ -4

- Function:
`abs`

*number* This function returns the absolute value of

`number`.

Next: Numeric Conversions, Previous: Predicates on Numbers, Up: Numbers [Contents][Index]