3.2 Numbers

Numbers in Guide: PLT Scheme introduces numbers.

All numbers are complex numbers. Some of them are real numbers, and all of the real numbers that can be represented are also rational numbers, except for +inf.0 (positive infinity), -inf.0 (negative infinity), and +nan.0 (not-a-number). Among the rational numbers, some are integers, because round applied to the number produces the same number.

Orthogonal to those categories, each number is also either an exact number or an inexact number. Unless otherwise specified, computations that involve an inexact number produce inexact results. Certain operations on inexact numbers, however, produce an exact number, such as multiplying an inexact number with an exact 0. Some operations, which can produce an irrational number for rational arguments (e.g., sqrt), may produce inexact results even for exact arguments.

In the case of complex numbers, either the real and imaginary parts are both exact or inexact, or the number has an exact zero real part and an inexact imaginary part; a complex number with an exact zero imaginary part is a real number.

Inexact real numbers are implemented as either single- or double-precision IEEE floating-point numbers – the latter by default, and the former only when support for 32-bit inexact numbers is specifically enabled when the run-time system is built, and when computation starts with numerical constants specified as single-precision numbers.

The precision and size of exact numbers is limited only by available memory (and the precision of operations that can produce irrational numbers). In particular, adding, multiplying, subtracting, and dividing exact numbers always produces an exact result.

Inexact numbers can be coerced to exact form, except for the inexact numbers +inf.0, -inf.0, and +nan.0, which have no exact form. Dividing a number by exact zero raises an exception; dividing a non-zero number other than +nan.0 by an inexact zero returns +inf.0 or -inf.0, depending on the sign of the dividend. The +nan.0 value is not = to itself, but +nan.0 is eqv? to itself. Conversely, (= 0.0 -0.0) is #t, but (eqv? 0.0 -0.0) is #f. The datum -nan.0 refers to the same constant as +nan.0.

Calculations with infinites produce results consistent with IEEE double-precision floating point where IEEE specifies the result; in cases where IEEE provides no specification (e.g., (angle +inf.0+inf.0i)), the result corresponds to the limit approaching infinity, or +nan.0 if no such limit exists.

A fixnum is an exact integer whose two’s complement representation fit into 31 bits on a 32-bit platform or 63 bits on a 64-bit platform. Two fixnums that are = are also the same according to eq?. Otherwise, the result of eq? applied to two numbers is undefined.

Two numbers are eqv? when they are both inexact or both exact, and when they are = (except for +nan.0, as noted above). Two numbers are equal? when they are eqv?.

3.2.1 Number Types

(number? v) → boolean?

v : any/c

Returns #t if v is a number, #f otherwise.

Examples:

> (number? 1)

#t

> (number? 2+3i)

#t

> (number? "hello")

#f

(complex? v) → boolean?

v : any/c

Returns (number? v), because all numbers are complex numbers.

(real? v) → boolean?

v : any/c

Returns #t if v is a real number, #f otherwise.

Examples:

> (real? 1)

#t

> (real? +inf.0)

#t

> (real? 2+3i)

#f

> (real? 2.0+0.0i)

#f

> (real? "hello")

#f

(rational? v) → boolean?

v : any/c

Returns #t if v is a rational number, #f otherwise.

Examples:

> (rational? 1)

#t

> (rational? +inf.0)

#f

> (real? "hello")

#f

(integer? v) → boolean?

v : any/c

Returns #t if v is a number that is an integer, #f otherwise.

Examples:

> (integer? 1)

#t

> (integer? 2.3)

#f

> (integer? 4.0)

#t

> (integer? +inf.0)

#f

> (integer? 2+3i)

#f

> (integer? "hello")

#f

(exact-integer? v) → boolean?

v : any/c

Returns (and (integer? v) (exact? v)).

Examples:

> (exact-integer? 1)

#t

> (exact-integer? 4.0)

#f

(exact-nonnegative-integer? v) → boolean?

v : any/c

Returns (and (exact-integer? v) (not (negative? v))).

Examples:

> (exact-nonnegative-integer? 0)

#t

> (exact-nonnegative-integer? -1)

#f

(exact-positive-integer? v) → boolean?

v : any/c

Returns (and (exact-integer? v) (positive? v)).

Examples:

> (exact-positive-integer? 1)

#t

> (exact-positive-integer? 0)

#f

(inexact-real? v) → boolean?

v : any/c

Returns (and (real? v) (inexact? v)).

(fixnum? v) → boolean?

v : any/c

Return #t if v is a fixnum, #f otherwise.

(zero? z) → boolean?

z : number?

Returns (= 0 z).

Examples:

> (zero? 0)

#t

> (zero? -0.0)

#t

(positive? x) → boolean?

x : real?

Returns (> x 0).

Examples:

> (positive? 10)

#t

> (positive? -10)

#f

> (positive? 0.0)

#f

(negative? x) → boolean?

x : real?

Returns (< x 0).

Examples:

> (negative? 10)

#f

> (negative? -10)

#t

> (negative? -0.0)

#f

(even? n) → boolean?

n : integer?

Returns (zero? (modulo n 2)).

Examples:

> (even? 10.0)

#t

> (even? 11)

#f

> (even? +inf.0)

even?: expects argument of type <integer>; given +inf.0

(odd? n) → boolean?

n : integer?

Returns (not (even? n)).

Examples:

> (odd? 10.0)

#f

> (odd? 11)

#t

> (odd? +inf.0)

odd?: expects argument of type <integer>; given +inf.0

(exact? z) → boolean?

z : number?

Returns #t if z is an exact number, #f otherwise.

Examples:

> (exact? 1)

#t

> (exact? 1.0)

#f

(inexact? z) → boolean?

z : number?

Returns #t if z is an inexact number, #f otherwise.

Examples:

> (inexact? 1)

#f

> (inexact? 1.0)

#t

(inexact->exact z) → exact?

z : number?

Coerces z to an exact number. If z is already exact, it is returned. If z is +inf.0, -inf.0, or +nan.0, then the exn:fail:contract exception is raised.

Examples:

> (inexact->exact 1)

1

> (inexact->exact 1.0)

1

(exact->inexact z) → inexact?

z : number?

Coerces z to an inexact number. If z is already inexact, it is returned.

Examples:

> (exact->inexact 1)

1.0

> (exact->inexact 1.0)

1.0

3.2.2 Arithmetic

(+ z ...) → number?

z : number?

Returns the sum of the zs, adding pairwise from left to right. If no arguments are provided, the result is 0.

Examples:

> (+ 1 2)

3

> (+ 1.0 2+3i 5)

8.0+3.0i

> (+)

0

(- z) → number?

z : number?

(- z w ...+) → number?

z : number?

w : number?

When no ws are supplied, returns (- 0 z). Otherwise, returns the subtraction of the ws from z working pairwise from left to right.

Examples:

> (- 5 3.0)

2.0

> (- 1)

-1

> (- 2+7i 1 3)

-2+7i

(* z ...) → number?

z : number?

Returns the product of the zs, multiplying pairwise from left to right. If no arguments are provided, the result is 1.

Examples:

> (* 2 3)

6

> (* 8.0 9)

72.0

> (* 1+2i 3+4i)

-5+10i

(/ z) → number?

z : number?

(/ z w ...+) → number?

z : number?

w : number?

When no ws are supplied, returns (/ 1 z). Otherwise, returns the division z by the var[w]s working pairwise from left to right.

Examples:

> (/ 3 4)

3/4

> (/ 81 3 3)

9

> (/ 10.0)

0.1

> (/ 1+2i 3+4i)

11/25+2/25i

(quotient n m) → integer?

n : integer?

m : integer?

Returns (truncate (/ n m)).

Examples:

> (quotient 10 3)

3

> (quotient -10.0 3)

-3.0

> (quotient +inf.0 3)

quotient: expects type <integer> as 1st argument, given:

+inf.0; other arguments were: 3

(remainder n m) → integer?

n : integer?

m : integer?

Returns q with the same sign as n such that

• (abs q) is between 0 (inclusive) and (abs m) (exclusive), and

• (+ q (* m (quotient n m))) equals n.

Examples:

> (remainder 10 3)

1

> (remainder -10.0 3)

-1.0

> (remainder 10.0 -3)

1.0

> (remainder -10 -3)

-1

> (remainder +inf.0 3)

remainder: expects type <integer> as 1st argument, given:

+inf.0; other arguments were: 3

(quotient/remainder n m)   →   number?   number?

n : integer?

m : integer?

Returns (values (quotient n m) (remainder n m)), but the combination is computed more efficiently than separate calls to quotient and remainder.

Examples:

> (quotient/remainder 10 3)

3

1

(modulo n m) → number?

n : integer?

m : integer?

Returns q with the same sign as m where

• (abs q) is between 0 (inclusive) and (abs m) (exclusive), and

• the difference between q and (- n (* m (quotient n m))) is a multiple of m.

Examples:

> (modulo 10 3)

1

> (modulo -10.0 3)

2.0

> (modulo 10.0 -3)

-2.0

> (modulo -10 -3)

-1

> (modulo +inf.0 3)

modulo: expects type <integer> as 1st argument, given:

+inf.0; other arguments were: 3

(add1 z) → number?

z : number?

Returns (+ z 1).

(sub1 z) → number?

z : number?

Returns (- z 1).

(abs x) → number?

x : real?

Returns the absolute value of x.

Examples:

> (abs 1.0)

1.0

> (abs -1)

1

(max x ...+) → boolean?

x : real?

Returns the largest of the xs, or +nan.0 if any x is +nan.0. If any x is inexact, the result is coerced to inexact.

Examples:

> (max 1 3 2)

3

> (max 1 3 2.0)

3.0

(min x ...+) → boolean?

x : real?

Returns the smallest of the xs, or +nan.0 if any x is +nan.0. If any x is inexact, the result is coerced to inexact.

Examples:

> (min 1 3 2)

1

> (min 1 3 2.0)

1.0

(gcd n ...) → integer?

n : integer?

Returns the greatest common divisor of the ns. If no arguments are provided, the result is 0.

Examples:

> (gcd 10)

10

> (gcd 12 81.0)

3.0

(lcm n ...) → integer?

n : integer?

Returns the least common multiple of the ns. If no arguments are provided, the result is 1.

Examples:

> (lcm 10)

10

> (lcm 3 4.0)

12.0

(round x) → integer?

x : real?

Returns the integer closest to x, resolving ties in favor of an even number.

Examples:
> (round 17/4)
4
> (round -17/4)
-4
> (round 2.5)
2.0
> (round -2.5)
-2.0

(floor x) → integer?

x : real?

Returns the largest integer is that is no more than x.

Examples:
> (floor 17/4)
4
> (floor -17/4)
-5
> (floor 2.5)
2.0
> (floor -2.5)
-3.0

(ceiling x) → integer?

x : real?

Returns the smallest integer is that is at least as large as x.

Examples:
> (ceiling 17/4)
5
> (ceiling -17/4)
-4
> (ceiling 2.5)
3.0
> (ceiling -2.5)
-2.0

(truncate x) → integer?

x : real?

Returns the integer farthest from 0 that is no closer to 0 than x.

Examples:
> (truncate 17/4)
4
> (truncate -17/4)
-4
> (truncate 2.5)
2.0
> (truncate -2.5)
-2.0

(numerator q) → integer?

q : rational?

Coreces q to an exact number, finds the numerator of the number expressed in its simplest fractional form, and returns this number coerced to the exactness of q.

Examples:

> (numerator 5)

5

> (numerator 17/4)

17

> (numerator 2.3)

2589569785738035.0

(denominator q) → integer?

q : rational?

Coreces q to an exact number, finds the numerator of the number expressed in its simplest fractional form, and returns this number coerced to the exactness of q.

Examples:

> (denominator 5)

1

> (denominator 17/4)

4

> (denominator 2.3)

1125899906842624.0

(rationalize x tolerance) → real?

x : real?

tolerance : real?

Among the real numbers within (abs tolerance) of x, returns the one corresponding to an exact number whose denominator is smallest. If multiple integers are within tolerance of x, the one closest to 0 is used.

Examples:

> (rationalize 1/4 1/10)

1/3

> (rationalize -1/4 1/10)

-1/3

> (rationalize 1/4 1/4)

0

> (rationalize 11/40 1/4)

1/2

3.2.3 Number Comparison

(= z w ...+) → boolean?

z : number?

w : number?

Returns #t if all of the arguments are numerically equal, #f otherwise. An inexact number is numerically equal to an exact number when the exact coercion of the inexact number is the exact number. Also, 0.0 and -0.0 are numerically equal, but +nan.0 is not numerically equal to itself.

Examples:

> (= 1 1.0)

#t

> (= 1 2)

#f

> (= 2+3i 2+3i 2+3i)

#t

(< x y ...+) → boolean?

x : real?

y : real?

Returns #t if the arguments in the given order are in strictly increasing, #f otherwise.

Examples:

> (< 1 1)

#f

> (< 1 2 3)

#t

> (< 1 +inf.0)

#t

> (< 1 +nan.0)

#f

(<= x y ...+) → boolean?

x : real?

y : real?

Returns #t if the arguments in the given order are in non-decreasing, #f otherwise.

Examples:

> (<= 1 1)

#t

> (<= 1 2 1)

#f

(> x y ...+) → boolean?

x : real?

y : real?

Returns #t if the arguments in the given order are in strictly decreasing, #f otherwise.

Examples:

> (> 1 1)

#f

> (> 3 2 1)

#t

> (> +inf.0 1)

#t

> (< +nan.0 1)

#f

(>= x y ...+) → boolean?

x : real?

y : real?

Returns #t if the arguments in the given order are in non-increasing, #f otherwise.

Examples:

> (>= 1 1)

#t

> (>= 1 2 1)

#f

3.2.4 Powers and Roots

(sqrt z) → number?

z : number?

Returns the principal square root of z.The result is exact if z is exact and z’s square root is rational. See also integer-sqrt.

Examples:

> (sqrt 4/9)

2/3

> (sqrt 2)

1.4142135623730951

> (sqrt -1)

0+1i

(integer-sqrt n) → complex?

n : integer?

Returns (floor (sqrt n)) for positive n. For negative n, the result is (* (integer-sqrt (- n)) 0+1i).

Examples:

> (integer-sqrt 4.0)

2.0

> (integer-sqrt 5)

2

(integer-sqrt/remainder n)   →   integer?   integer?

n : integer?

Returns (integer-sqrt n) and (- n (expt (integer-sqrt n) 2)).

Examples:

> (integer-sqrt/remainder 4.0)

2.0

0.0

> (integer-sqrt/remainder 5)

2

1

(expt z w) → number?

z : number?

w : number?

Returns z raised to the power of w. If w is exact 0, the result is 1. If z is exact 0 and w is negative, the exn:fail:contract exception is raised.

Examples:

> (expt 2 3)

8

> (expt 4 0.5)

2.0

> (expt +inf.0 0)

1

(exp z) → number?

z : number?

Returns Euler’s number raised to the power of z. The result is normally inexact, but it is 1 when z is an exact 0.

Examples:

> (exp 1)

2.718281828459045

> (exp 2+3i)

-7.315110094901103+1.0427436562359045i

> (exp 0)

1

(log z) → number?

z : number?

Returns the natural logarithm of z. The result is normally inexact, but it is 0 when z is an exact 1.

Examples:

> (log (exp 1))

1.0

> (log 2+3i)

1.2824746787307684+0.982793723247329i

> (log 1)

0

3.2.5 Trignometric Functions

(sin z) → number?

z : number?

Returns the sine of z, where z is in radians.

Examples:

> (sin 3.14159)

2.65358979335273e-06

> (sin 1.0+5.0i)

62.44551846769653+40.0921657779984i

(cos z) → number?

z : number?

Returns the cosine of z, where z is in radians.

Examples:

> (cos 3.14159)

-0.9999999999964793

> (cos 1.0+5.0i)

40.095806306298826-62.43984868079963i

(tan z) → number?

z : number?

Returns the tangent of z, where z is in radians.

Examples:

> (tan 0.7854)

1.0000036732118496

> (tan 1.0+5.0i)

8.256719834227411e-05+1.0000377833796008i

(asin z) → number?

z : number?

Returns the arcsin in radians of z.

Examples:

> (asin 0.25)

0.25268025514207865

> (asin 1.0+5.0i)

0.1937931365549317+2.330974653049312i

(acos z) → number?

z : number?

Returns the arccosine in radians of z.

Examples:

> (acos 0.25)

1.318116071652818

> (acos 1.0+5.0i)

1.3770031902399644-2.3309746530493123i

(atan z) → number?

z : number?

(atan y x) → number?

y : real?

x : real?

In the one-argument case, returns the arctangent of the inexact approximation of z, except that the result is an exact 0 for an exact 0 argument.

In the two-argument case, the result is roughly the same as (/ (exact->inexact y) (exact->inexact x)), but the signs of y and x determine the quadrant of the result. Moreover, a suitable angle is returned when y divided by x produces +nan.0 in the case that neither y nor x is +nan.0.

Examples:

> (atan 0.5)

0.4636476090008061

> (atan 2 1)

1.1071487177940904

> (atan -2 -1)

-2.0344439357957027

> (atan 1.0+5.0i)

1.530881333938778+0.19442614214700213i

> (atan +inf.0 -inf.0)

2.356194490192345

3.2.6 Complex Numbers

(make-rectangular x y) → number?

x : real?

y : real?

Returns (+ x (* y 0+1i)).

Examples:

> (make-rectangular 3 4.0)

3.0+4.0i

(make-polar magnitude angle) → number?

magnitude : real?

angle : real?

Returns (+ (* magnitude (cos angle)) (* magnitude (sin angle) 0+1i)).

Examples:

> (make-polar 2 3.14159)

-1.9999999999929585+5.30717958670546e-06i

(real-part z) → real?

z : number?

Returns the real part of the complex number z in rectangle coordinates.

Examples:

> (real-part 3+4i)

3

> (real-part 5.0)

5.0

(imag-part z) → real?

z : number?

Returns the imaginary part of the complex number z in rectangle coordinates.

Examples:

> (imag-part 3+4i)

4

> (imag-part 5.0)

0

> (imag-part 5.0+0.0i)

0.0

(magnitude z) → (and/c real? (not/c negative?))

z : number?

Returns the magnitude of the complex number z in polar coordinates.

Examples:

> (magnitude -3)

3

> (magnitude 3.0)

3.0

> (magnitude 3+4i)

5

(angle z) → real?

z : number?

Returns the angle of the complex number z in polar coordinates.

Examples:
> (angle -3)
3.141592653589793
> (angle 3.0)
0
> (angle 3+4i)
0.9272952180016122
> (angle +inf.0+inf.0i)
0.7853981633974483

3.2.7 Bitwise Operations

(bitwise-ior n ...) → exact-integer?

n : exact-integer?

Returns the bitwise “inclusive or” of the ns in their (semi-infinite) two’s complement representation. If no arguments are provided, the result is 0.

Examples:

> (bitwise-ior 1 2)

3

> (bitwise-ior -32 1)

-31

(bitwise-and n ...) → exact-integer?

n : exact-integer?

Returns the bitwise “and” of the ns in their (semi-infinite) two’s complement representation. If no arguments are provided, the result is -1.

Examples:

> (bitwise-and 1 2)

0

> (bitwise-and -32 -1)

-32

(bitwise-xor n ...) → exact-integer?

n : exact-integer?

Returns the bitwise “exclusive or” of the ns in their (semi-infinite) two’s complement representation. If no arguments are provided, the result is 0.

Examples:

> (bitwise-xor 1 5)

4

> (bitwise-xor -32 -1)

31

(bitwise-not n) → exact-integer?

n : exact-integer?

Returns the bitwise “not” of n in its (semi-infinite) two’s complement representation.

Examples:

> (bitwise-not 5)

-6

> (bitwise-not -1)

0

(arithmetic-shift n m) → exact-integer?

n : exact-integer?

m : exact-integer?

Returns the bitwise “shift” of n in its (semi-infinite) two’s complement representation. If m is non-negative, the integer n is shifted left by m bits; i.e., m new zeros are introduced as rightmost digits. If m is negative, n is shifted right by (- m) bits; i.e., the rightmost m digits are dropped.

Examples:

> (arithmetic-shift 1 10)

1024

> (arithmetic-shift 255 -3)

31

(integer-length n) → exact-integer?

n : exact-integer?

Returns the number of bits in the (semi-infinite) two’s complement representation of n after removing all leading zeros (for non-negative n) or ones (for negative n).

Examples:

> (integer-length 8)

4

> (integer-length -8)

3

3.2.8 Random Numbers

(random k [generator]) → nonnegative-exact-integer?

k : (integer-in 1 4294967087)

generator   :   pseudo-random-generator?       =   (current-pseudo-random-generator)

(random [generator]) → (and/c real? inexact? (>/c 0) (</c 1))

generator   :   pseudo-random-generator?       =   (current-pseudo-random-generator)

When called with and integer argument k, returns a random exact integer in the range 0 to k-1. When called with zero arguments, returns a random inexact number between 0 and 1, exclusive.

In each case, the number is provided by the given pseudo-random number generator (which defaults to the current one, as produced by current-pseudo-random-generator). The generator maintains an internal state for generating numbers. The random number generator uses a 54-bit version of L’Ecuyer’s MRG32k3a algorithm [L'Ecuyer02].

(random-seed k) → void?

k : (integer-in 1 (sub1 (expt 2 31)))

Seeds the current pseudo-random number generator with k. Seeding a generator sets its internal state deterministically; that is, seeding a generator with a particular number forces it to produce a sequence of pseudo-random numbers that is the same across runs and across platforms.

(make-pseudo-random-generator) → pseudo-random-generator?

Returns a new pseudo-random number generator. The new generator is seeded with a number derived from (current-milliseconds).

(pseudo-random-generator? v) → boolean?

v : any/c

Returns #t if v is a pseudo-random number generator, #f otherwise.

(current-pseudo-random-generator) → pseudo-random-generator?

(current-pseudo-random-generator generator) → void?

generator : pseudo-random-generator?

A parameter that determines the pseudo-random number generator used by random.

(pseudo-random-generator->vector generator) → vector?

generator : pseudo-random-generator?

Produces a vector that represents the complete internal state of generator. The vector is suitable as an argument to vector->pseudo-random-generator to recreate the generator in its current state (across runs and across platforms).

(vector->pseudo-random-generator vec)

→ pseudo-random-generator?

vec : vector?

Produces a pseudo-random number generator whose internal state corresponds to vec. The vector vec must contain six exact integers; the first three integers must be in the range 0 to 4294967086, inclusive; the last three integers must be in the range 0 to 4294944442, inclusive; at least one of the first three integers must be non-zero; and at least one of the last three integers must be non-zero.

(vector->pseudo-random-generator!   generator             vec)   →   void?

generator : pseudo-random-generator?

vec : vector?

Like vector->pseudo-random-generator, but changes generator to the given state, instead of creating a new generator.

3.2.9 Number–String Conversions

(number->string z [radix]) → string?

z : number?

radix : (one-of/c 2 8 10 16) = 10

Returns a string that is the printed form of z in the base specific by radix. If z is inexact, radix must be 10, otherwise the exn:fail:contract exception is raised.

Examples:

> (number->string 3.0)

"3.0"

> (number->string 255 8)

"377"

(string->number s [radix]) → (or/c number? false/c)

s : string?

radix : (integer-in 2 16) = 10