**floor***number*→`&optional`

divisor*quotient, remainder***ffloor***number*→`&optional`

divisor*quotient, remainder***ceiling***number*→`&optional`

divisor*quotient, remainder***fceiling***number*→`&optional`

divisor*quotient, remainder***truncate***number*→`&optional`

divisor*quotient, remainder***ftruncate***number*→`&optional`

divisor*quotient, remainder***round***number*→`&optional`

divisor*quotient, remainder***fround***number*→`&optional`

divisor*quotient, remainder*

These functions divide *number* by *divisor*, returning a *quotient* and *remainder*, such that:

quotient*divisor+remainder=number

The *quotient* always represents a mathematical integer.

When more than one mathematical integer might be possible (i.e. when the remainder is not zero), the kind of rounding or truncation depends on the *operator*:

**floor** and **ffloor** produce a *quotient* that has been truncated toward negative infinity; that is, the *quotient* represents the largest mathematical integer that is not larger than the mathematical quotient.

**ceiling** and **fceiling** produce a *quotient* that has been truncated toward positive infinity; that is, the *quotient* represents the smallest mathematical integer that is not smaller than the mathematical result.

**truncate** and **ftruncate** produce a *quotient* that has been truncated towards zero; that is, the *quotient* represents the mathematical integer of the same sign as the mathematical quotient, and that has the greatest integral magnitude not greater than that of the mathematical quotient.

**round** and **fround** produce a *quotient* that has been rounded to the nearest mathematical integer; if the mathematical quotient is exactly halfway between two integers, (that is, it has the form `integer + 1/2`

), then the *quotient* has been rounded to the even (divisible by two) integer.

All of these functions perform type conversion operations on *numbers*.

The *remainder* is an *integer* if both *x* and *y* are *integers*, is a *rational* if both *x* and *y* are *rationals*, and is a *float* if either *x* or *y* is a *float*.

**ffloor**, **fceiling**, **ftruncate**, and **fround** handle arguments of different *types* in the following way: If *number* is a *float*, and *divisor* is not a *float* of longer format, then the first result is a *float* of the same *type* as *number*. Otherwise, the first result is of the *type* determined by *contagion* rules; see section {\secref\NumericContagionRules}.

(floor 3/2)

→1 1/2

(ceiling 3 2)

→2 -1

(ffloor 3 2)

→1.0 1

(ffloor -4.7)

→-5.0 0.3

(ffloor 3.5d0)

→3.0d0 0.5d0

(fceiling 3/2)

→2.0 -1/2

(truncate 1)

→1 0

(truncate .5)

→0 0.5

(round .5)

→0 0.5

(ftruncate -7 2)

→-3.0 -1

(fround -7 2)

→-4.0 1

(dolist (n '(2.6 2.5 2.4 0.7 0.3 -0.3 -0.7 -2.4 -2.5 -2.6)) (format t "~&~4,1@F ~2,' D ~2,' D ~2,' D ~2,' D" n (floor n) (ceiling n) (truncate n) (round n)))

▷+2.6 2 3 2 3 +2.5 2 3 2 2 +2.4 2 3 2 2 +0.7 0 1 0 1 +0.3 0 1 0 0 -0.3 -1 0 0 0 -0.7 -1 0 0 -1 -2.4 -3 -2 -2 -2 -2.5 -3 -2 -2 -2 -2.6 -3 -2 -2 -3

→NIL

None.

None.

None.

None.

When only *number* is given, the two results are exact; the mathematical sum of the two results is always equal to the mathematical value of *number*.

`(function `

and *number* *divisor*)`(function (/ `

(where *number* *divisor*))`function`

is any of one of **floor**, **ceiling**, **ffloor**, **fceiling**, **truncate**, **round**, **ftruncate**, and **fround**) return the same first value, but they return different remainders as the second value. For example:

(floor 5 2)

→2 1

(floor (/ 5 2))

→2 1/2

If an effect is desired that is similar to **round**, but that always rounds up or down (rather than toward the nearest even integer) if the mathematical quotient is exactly halfway between two integers, the programmer should consider a construction such as `(floor (+ x 1/2))`

or `(ceiling (- x 1/2))`

.