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

### 3.4 Comparison of Numbers

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.

```          (max 20)
⇒ 20
(max 1 2.5)
⇒ 2.5
(max 1 3 2.5)
⇒ 3
```
— Function: min number-or-marker &rest numbers-or-markers

This function returns the smallest of its arguments.

```          (min -4 1)
⇒ -4
```
— Function: abs number

This function returns the absolute value of number.