3.2 Numbers

► |  | Guide: Racket

1 | Welcome to Racket
2 | Racket Essentials
3 | Built-In Datatypes
4 | Expressions and Definitions
5 | Programmer-Defined Datatypes
6 | Modules
7 | Contracts
8 | Input and Output
9 | Regular Expressions
10 | Exceptions and Control
11 | Iterations and Comprehensions
12 | Pattern Matching
13 | Classes and Objects
14 | Units (Components)
15 | Reflection and Dynamic Evaluation
16 | Macros
17 | Creating Languages
18 | Performance
19 | Running and Creating Executables
20 | Compilation and Configuration
21 | More Libraries
22 | Dialects of Racket and Scheme
| Bibliography
| Index

▼ | 3 | Built-In Datatypes

3.1 | Booleans
3.2 | Numbers
3.3 | Characters
3.4 | Strings (Unicode)
3.5 | Bytes and Byte Strings
3.6 | Symbols
3.7 | Keywords
3.8 | Pairs and Lists
3.9 | Vectors
3.10 | Hash Tables
3.11 | Boxes
3.12 | Void and Undefined

top← prev up next →

#### 3.2`` 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.

> > > Reading Numbers in Reference: Racket documents the fine points of the syntax of numbers.

Examples:
> 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:
> (/ 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:
> ( 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.

( define (sigma f a b)
( if (= a b)
0
(+ (f a) (sigma f (+ a 1) b))))

> ( time ( round (sigma ( lambda (x) (/ 1 x)) 1 2000)))
cpu time: 357 real time: 358 gc time: 216
8
> ( time ( round (sigma ( lambda (x) (/ 1.0 x)) 1 2000)))
cpu time: 1 real time: 0 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:
> ( 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: expects argument of type <real number>; given -5+2i
> ( sin -5+2i)
3.6076607742131563+1.0288031496599335i

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:
> (= 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:
> (= 1/2 0.5)
#t
> (= 1/10 0.1)
#f
> ( inexact->exact 0.1)
3602879701896397/36028797018963968

> > > Numbers in Reference: Racket provides more on numbers and number procedures.

top← prev up next →