# Numbers

## Categories of numbers

Scheme treats numbers slightly differently depending on whether they are integers (whole numbers), rational numbers (expressible as a ratio of integers), real numbers (corresponding to points on a number line), or complex numbers (corresponding to points on the plane determined by a real-number line and a perpendicular line for ``imaginary numbers'' -- the square roots of negative numbers). From the Scheme programmer's point of view, these categories of numbers are nested: all integers also qualify as rational numbers (5 is the same thing as 5/1); all rationals count as real numbers, and all real numbers as complex numbers. But, mathematically speaking, the converse inclusions do not generally hold: 3/4 is rational but not an integer, the square root of 2 is real but not rational, and the square root of -1 is complex but not real.

Scheme supplies a predicate for each of these categories of numbers: `integer?`, `rational?`, `real?`, and `complex?`.

Within each category, Scheme distinguishes between exact numbers, which are guaranteed to be calculated and stored internally with complete accuracy (no rounding off), and approximations, also called inexact numbers, which are stored internally in a form that conserves the computer's memory and permits faster computations, but allows small inaccuracies (and occasionally ones that are not so small) to creep in. Since there's no great advantage in obtaining an answer quickly if it may be incorrect, we shall avoid using approximations in this course, except when the data for our problems are themselves obtained by inexact processes of measurement.

To determine whether Scheme is representing a particular number exactly or inexactly, use one of the predicates `exact?` and `inexact?`.

```> (exact? 5/9)
#t
> (exact? 13.2)
#f
> (inexact? 13.2)
#t
```

DrScheme happens to store real numbers in such a way that any real number that can be named or computed also counts as rational. For instance, when DrScheme computes `(sqrt 2)`, the value it returns is an inexact approximation to the correct value, and it turns out that DrScheme uses only rational numbers as approximations, even when the actual values that it is trying to approximate are irrational.

The standard language definition for Scheme says that an implementation of the language does not have to support all these kinds of numbers; it would be legal, for instance, to leave out complex numbers or to treat all numeric values as inexact. However, most implementations, including DrScheme, support all the kinds of numbers described here.

The built-in Scheme procedure `exact->inexact` takes an exact number as its argument and returns an inexact approximation to it:

```> (exact->inexact 12/7)
1.7142857142857142
```

Since DrScheme uses fractional notation to print out exact numbers, but renders approximations as decimal numerals, invoking this procedure is a simple way to get your result printed as a decimal. As we'll see later in the semester, however, there are better ways that give the programmer finer control over the format.

The Scheme standard does not directly support the familiar category of natural numbers, but we can think of them as being just the same things as Scheme's exact non-negative integers.

## Numerals

When you write a numeral into a Scheme program or type one in as part of a definition or command to the interactive interface, the structure of the numeral you type determines the category of the number represented.

One basic rule is that a numeral that contains a decimal point normally stands for an approximation rather than an exact number. Scheme assumes that you may have rounded off the last decimal place and takes this as implicit permission to use a rounded-off representation. If you want Scheme to interpret the numeral as an exact number, you can either convert it to a fraction -- for instance, changing `1.732` to `1732/1000` -- or attach the exactness prefix `#e` at the beginning of the numeral, making it `#e1.732`.

Conversely, a number written such as a sequence of digits (possibly with a sign at the beginning) or as a fraction normally stands for an exact number. If you want an approximation instead, use an equivalent numeral with a decimal point or attach the inexactness prefix `#i`. (So `23/70` is an exact number, but `#i23/70` is an approximation.)

Scheme permits the use of a version of scientific notation, in which a real number is expressed as the product of some coefficient and some integer power of 10. For instance, the numeral `3.17e8` denotes the real number three hundred and seventeen million -- that is, 3.17 times ten to the eighth power. The part of the numeral that precedes the `e` is the coefficient; the part that follows indicates the power of ten by which the coefficient should be multiplied. A number expressed in scientific notation is inexact unless the numeral is preceded by the exactness prefix. DrScheme uses scientific notation when printing out an approximation if its absolute value is either very large or very small, but it never uses scientific notation when printing out an exact number.

## Numerical procedures

Section 6.2.5 of the Revised5 report on the algorithmic language Scheme lists Scheme's primitive procedures for numbers. Read through the list at this point to get a feel for what Scheme supports. The following notes explain some of the subtler features of commonly used numerical procedures.

The addition and multiplication procedures, `+` and `*`, accept any number of arguments. You can, for instance, ask Scheme to imitate a cash register with a command like this one:

```> (+ 1.19
.43
.43
2.59
.89
1.39
5.19
.34
)
12.45
```

You can call the `-` procedure or the `/` procedure to operate on a single argument. The `-` procedure returns the additive inverse of a single argument -- that is, its negative, the result of subtracting it from 0. The `/` procedure returns the multiplicative inverse of a single argument -- its reciprocal, the result of dividing 1 by it.

There are four procedures relating to division. The `quotient` and `remainder` procedures apply only to integers and perform the kind of division you learned in elementary school, in which the quotient and the remainder are separated: ``Four goes into thirteen three times with a remainder of one'':

```> (quotient 13 4)
3
> (remainder 13 4)
1
```

The `/` procedure, on the other hand, can be applied to numbers of any kind (except that you can't use zero as a divisor) and yields a single result:

```> (/ 13 4)
13/4
```

The `modulo` procedure is like `remainder`, except that it always yields a result that has the same sign as the divisor. In particular, this means that when the divisor is positive and the dividend is negative, `modulo` yields a positive (or zero) result.

```> (remainder -13 4)
-1
> (modulo -13 4)
3
```

You can give any of the comparison predicates `<`, `<=`, `=`, `>=`, and `>` more than two arguments. The predicate returns `#t` only if the relation holds between each pair of adjacent arguments.

The `log` procedure, despite its name, computes natural (base e) logarithms rather than common (base ten) logarithms. You can convert a natural logarithm into a common logarithm by dividing it by the natural logarithm of 10.

When using Scheme's trigonometric functions, bear in mind that all angles are measured in radians, not degrees.