3.4 Comparison of Numbers

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 Float 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)))``

`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`eqlvalue1 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.

`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`maxnumber-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`minnumber-or-marker \&rest numbers-or-markersâ€‹

This function returns the smallest of its arguments.

``(min -4 1)     â‡’ -4``

`function`absnumberâ€‹

This function returns the absolute value of `number`.