3.2.1 Number Types

3

3.2

3.2.1	Number Types
3.2.2	Generic Numerics
3.2.3	Flonums
3.2.4	Fixnums

top← prev up next →

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
> (rational? "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.

Note: the result of this function is platform-dependent, so using it in syntax transformers can lead to platform-dependent bytecode files.

(flonum? v) → boolean?
v : any/c

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

(double-flonum? v) → boolean?
v : any/c

Identical to flonum?.

(single-flonum? v) → boolean?
v : any/c

Return #t if v is a single-precision floating-point number, #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

(real->single-flonum x) → single-flonum?
x : real?

Coerces x to a single-precision floating-point number. If x is already a single-precision floating-point number, it is returned.

(real->double-flonum x) → flonum?
x : real?

Coerces x to a double-precision floating-point number. If x is already a double-precision floating-point number, it is returned.

top← prev up next →