Next: , Previous: , Up: Numbers   [Contents][Index]

### 9.4 Comparison of 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.

At present, each integer value has a unique Lisp object in SXEmacs Lisp. 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 a good idea to use `=` if you can, even for comparing integers, just in case we change the representation of integers in a future SXEmacs version.

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:

```(defconst 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. SXEmacs Lisp can have just one integer object for any given value because it has a limited range of integer values.

In addition to numbers, all of the following functions also accept characters and markers as arguments, and treat them as their number equivalents.

Function: = number &rest more-numbers

This function returns `t` if all of its arguments are numerically equal, `nil` otherwise.

```(= 5)
⇒ t
(= 5 6)
⇒ nil
(= 5 5.0)
⇒ t
(= 5 5 6)
⇒ nil
```
Function: /= number &rest more-numbers

This function returns `t` if no two arguments are numerically equal, `nil` otherwise.

```(/= 5 6)
⇒ t
(/= 5 5 6)
⇒ nil
(/= 5 6 1)
⇒ t
```
Function: < number &rest more-numbers

This function returns `t` if the sequence of its arguments is monotonically increasing, `nil` otherwise.

```(< 5 6)
⇒ t
(< 5 6 6)
⇒ nil
(< 5 6 7)
⇒ t
```
Function: <= number &rest more-numbers

This function returns `t` if the sequence of its arguments is monotonically nondecreasing, `nil` otherwise.

```(<= 5 6)
⇒ t
(<= 5 6 6)
⇒ t
(<= 5 6 5)
⇒ nil
```
Function: > number &rest more-numbers

This function returns `t` if the sequence of its arguments is monotonically decreasing, `nil` otherwise.

Function: >= number &rest more-numbers

This function returns `t` if the sequence of its arguments is monotonically nonincreasing, `nil` otherwise.

Function: max number &rest more-numbers

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 &rest more-numbers

This function returns the smallest of its arguments.

```(min -4 1)
⇒ -4
```

Next: , Previous: , Up: Numbers   [Contents][Index]