|
|
# Numbers
|
|
|
|
|
|
A Racket _number_ is either exact or inexact:
|
|
|
|
|
|
* An _exact_ number is either
|
|
|
|
|
|
* an arbitrarily large or small integer, such as `5`,
|
|
|
`99999999999999999`, or `-17`;
|
|
|
|
|
|
* a rational that is exactly the ratio of two arbitrarily small or
|
|
|
large integers, such as `1/2`, `99999999999999999/2`, or `-3/4`; or
|
|
|
|
|
|
* a complex number with exact real and imaginary parts \(where the
|
|
|
imaginary part is not zero\), such as `1+2i` or `1/2+3/4i`.
|
|
|
|
|
|
* An _inexact_ number is either
|
|
|
|
|
|
* an IEEE floating-point representation of a number, such as `2.0` or
|
|
|
`3.14e+87`, where the IEEE infinities and not-a-number are written
|
|
|
`+inf.0`, `-inf.0`, and `+nan.0` \(or `-nan.0`\); or
|
|
|
|
|
|
* a complex number with real and imaginary parts that are IEEE
|
|
|
floating-point representations, such as `2.0+3.0i` or
|
|
|
`-inf.0+nan.0i`; as a special case, an inexact complex number can
|
|
|
have an exact zero real part with an inexact imaginary part.
|
|
|
|
|
|
Inexact numbers print with a decimal point or exponent specifier, and
|
|
|
exact numbers print as integers and fractions. The same conventions
|
|
|
apply for reading number constants, but `#e` or `#i` can prefix a number
|
|
|
to force its parsing as an exact or inexact number. The prefixes `#b`,
|
|
|
`#o`, and `#x` specify binary, octal, and hexadecimal interpretation of
|
|
|
digits.
|
|
|
|
|
|
> +\[missing\] in \[missing\] documents the fine points of the syntax of
|
|
|
> numbers.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> 0.5
|
|
|
0.5
|
|
|
> #e0.5
|
|
|
1/2
|
|
|
> #x03BB
|
|
|
955
|
|
|
```
|
|
|
|
|
|
Computations that involve an inexact number produce inexact results, so
|
|
|
that inexactness acts as a kind of taint on numbers. Beware, however,
|
|
|
that Racket offers no “inexact booleans,” so computations that branch on
|
|
|
the comparison of inexact numbers can nevertheless produce exact
|
|
|
results. The procedures `exact->inexact` and `inexact->exact` convert
|
|
|
between the two types of numbers.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (/ 1 2)
|
|
|
1/2
|
|
|
> (/ 1 2.0)
|
|
|
0.5
|
|
|
> (if (= 3.0 2.999) 1 2)
|
|
|
2
|
|
|
> (inexact->exact 0.1)
|
|
|
3602879701896397/36028797018963968
|
|
|
```
|
|
|
|
|
|
Inexact results are also produced by procedures such as `sqrt`, `log`,
|
|
|
and `sin` when an exact result would require representing real numbers
|
|
|
that are not rational. Racket can represent only rational numbers and
|
|
|
complex numbers with rational parts.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (sin 0) ; rational...
|
|
|
0
|
|
|
> (sin 1/2) ; not rational...
|
|
|
0.479425538604203
|
|
|
```
|
|
|
|
|
|
In terms of performance, computations with small integers are typically
|
|
|
the fastest, where “small” means that the number fits into one bit less
|
|
|
than the machine’s word-sized representation for signed numbers.
|
|
|
Computation with very large exact integers or with non-integer exact
|
|
|
numbers can be much more expensive than computation with inexact
|
|
|
numbers.
|
|
|
|
|
|
```racket
|
|
|
(define (sigma f a b)
|
|
|
(if (= a b)
|
|
|
0
|
|
|
(+ (f a) (sigma f (+ a 1) b))))
|
|
|
```
|
|
|
|
|
|
```racket
|
|
|
> (time (round (sigma (lambda (x) (/ 1 x)) 1 2000)))
|
|
|
cpu time: 80 real time: 80 gc time: 17
|
|
|
8
|
|
|
> (time (round (sigma (lambda (x) (/ 1.0 x)) 1 2000)))
|
|
|
cpu time: 1 real time: 1 gc time: 0
|
|
|
8.0
|
|
|
```
|
|
|
|
|
|
The number categories _integer_, _rational_, _real_ \(always rational\),
|
|
|
and _complex_ are defined in the usual way, and are recognized by the
|
|
|
procedures `integer?`, `rational?`, `real?`, and `complex?`, in addition
|
|
|
to the generic `number?`. A few mathematical procedures accept only real
|
|
|
numbers, but most implement standard extensions to complex numbers.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (integer? 5)
|
|
|
#t
|
|
|
> (complex? 5)
|
|
|
#t
|
|
|
> (integer? 5.0)
|
|
|
#t
|
|
|
> (integer? 1+2i)
|
|
|
#f
|
|
|
> (complex? 1+2i)
|
|
|
#t
|
|
|
> (complex? 1.0+2.0i)
|
|
|
#t
|
|
|
> (abs -5)
|
|
|
5
|
|
|
> (abs -5+2i)
|
|
|
abs: contract violation
|
|
|
expected: real?
|
|
|
given: -5+2i
|
|
|
> (sin -5+2i)
|
|
|
3.6076607742131563+1.0288031496599337i
|
|
|
```
|
|
|
|
|
|
The `=` procedure compares numbers for numerical equality. If it is
|
|
|
given both inexact and exact numbers to compare, it essentially converts
|
|
|
the inexact numbers to exact before comparing. The `eqv?` \(and
|
|
|
therefore `equal?`\) procedure, in contrast, compares numbers
|
|
|
considering both exactness and numerical equality.
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (= 1 1.0)
|
|
|
#t
|
|
|
> (eqv? 1 1.0)
|
|
|
#f
|
|
|
```
|
|
|
|
|
|
Beware of comparisons involving inexact numbers, which by their nature
|
|
|
can have surprising behavior. Even apparently simple inexact numbers may
|
|
|
not mean what you think they mean; for example, while a base-2 IEEE
|
|
|
floating-point number can represent `1/2` exactly, it can only
|
|
|
approximate `1/10`:
|
|
|
|
|
|
Examples:
|
|
|
|
|
|
```racket
|
|
|
> (= 1/2 0.5)
|
|
|
#t
|
|
|
> (= 1/10 0.1)
|
|
|
#f
|
|
|
> (inexact->exact 0.1)
|
|
|
3602879701896397/36028797018963968
|
|
|
```
|
|
|
|
|
|
> +\[missing\] in \[missing\] provides more on numbers and number
|
|
|
> procedures.
|