##### 4.2.1Number Types

 procedure(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 > (number? +nan.0) #t

 procedure(complex? v) → boolean? v : any/c
Returns (number? v), because all numbers are complex numbers.

 procedure(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

 procedure v : any/c
Returns #t if v is a rational number, #f otherwise.

Examples:
 > (rational? 1) #t > (rational? +inf.0) #f > (rational? "hello") #f

 procedure(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

 procedure v : any/c
Returns (and (integer? v) (exact? v)).

Examples:
 > (exact-integer? 1) #t > (exact-integer? 4.0) #f

 procedure v : any/c
Returns (and (exact-integer? v) (not (negative? v))).

Examples:
 > (exact-nonnegative-integer? 0) #t > (exact-nonnegative-integer? -1) #f

 procedure v : any/c
Returns (and (exact-integer? v) (positive? v)).

Examples:
 > (exact-positive-integer? 1) #t > (exact-positive-integer? 0) #f

 procedure v : any/c
Returns (and (real? v) (inexact? v)).

 procedure(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.

 procedure(flonum? v) → boolean? v : any/c
Return #t if v is a flonum, #f otherwise.

 procedure v : any/c
Identical to flonum?.

 procedure v : any/c
Return #t if v is a single-precision floating-point number, #f otherwise.

 procedure(zero? z) → boolean? z : number?
Returns (= 0 z).

Examples:
 > (zero? 0) #t > (zero? -0.0) #t

 procedure x : real?
Returns (> x 0).

Examples:
 > (positive? 10) #t > (positive? -10) #f > (positive? 0.0) #f

 procedure x : real?
Returns (< x 0).

Examples:
 > (negative? 10) #f > (negative? -10) #t > (negative? -0.0) #f

 procedure(even? n) → boolean? n : integer?
Returns (zero? (modulo n 2)).

Examples:
 > (even? 10.0) #t > (even? 11) #f > (even? +inf.0) even?: contract violation expected: integer given: +inf.0

 procedure(odd? n) → boolean? n : integer?
Returns (not (even? n)).

Examples:
 > (odd? 10.0) #f > (odd? 11) #t > (odd? +inf.0) odd?: contract violation expected: integer given: +inf.0

 procedure(exact? z) → boolean? z : number?
Returns #t if z is an exact number, #f otherwise.

Examples:
 > (exact? 1) #t > (exact? 1.0) #f

 procedure(inexact? z) → boolean? z : number?
Returns #t if z is an inexact number, #f otherwise.

Examples:
 > (inexact? 1) #f > (inexact? 1.0) #t

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

Examples:
 > (inexact->exact 1) 1 > (inexact->exact 1.0) 1

 procedure 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

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

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