It is useful to distinguish between numbers that are represented exactly and those that might not be. For example, indexes into data structures must be known exactly, as must some polynomial coefficients in a symbolic algebra system. On the other hand, the results of measurements are inherently inexact, and irrational numbers may be approximated by rational and therefore inexact approximations. In order to catch uses of inexact numbers where exact numbers are required, Scheme explicitly distinguishes exact from inexact numbers. This distinction is orthogonal to the dimension of type.

A Scheme number is exact if it was written as an exact constant or was derived from exact numbers using only exact operations. A number is inexact if it was written as an inexact constant, if it was derived using inexact ingredients, or if it was derived using inexact operations. Thus inexactness is a contagious property of a number. In particular, an exact complex number has an exact real part and an exact imaginary part; all other complex numbers are inexact complex numbers.

If two implementations produce exact results for a computation that did not involve inexact intermediate results, the two ultimate results will be mathematically equal. This is generally not true of computations involving inexact numbers since approximate methods such as floating-point arithmetic may be used, but it is the duty of the implementation to make the result as close as practical to the mathematically ideal result.

Rational operations such as + should always produce exact results when given exact arguments. If the operation is unable to produce an exact result, then it may either report the violation of an implementation restriction or it may silently coerce its result to an inexact value.

Except for exact, the operations described in this section must generally return inexact results when given any inexact arguments. An operation may, however, return an exact result if it can prove that the value of the result is unaffected by the inexactness of its arguments. For example, multiplication of any number by an exact zero may produce an exact zero result, even if the other argument is inexact.

Specifically, the expression (* 0 +inf.0) may return 0, or +nan.0, or report that inexact numbers are not supported, or report that non-rational real numbers are not supported, or fail silently or noisily in other implementation-specific ways.

The procedures listed below will always return exact integer results provided all their arguments are exact integers and the mathematically expected results are representable as exact integers within the implementation: -, *, +, abs, ceiling, denominator, exact-integer-sqrt, expt, floor, floor/, floor-quotient, floor-remainder, gcd, lcm, max, min, modulo, numerator, quotient, rationalize, remainder, square, truncate, truncate/, truncate-quotient, truncate-remainder.

When combining two values of different numeric types, the values are converted to the first line in the following that subsumes (follows) both types. The computation is done using values of that type, and so is the result. For example adding a long and a float converts the former to the latter, yielding a float.

Note that short, byte, ushort, ubyte are converted to int regardless, even in the case of a single-operand operation, such as unary negation. Another exception is trancendental functions (such as cos), where integer operands are converted to double.

When comparing a primitive signed integer value with a primitive unsigned integer (for example < applied to a int and a ulong) the mathemically correct result is computed, as it converting both operands to integer.