##### 3.2.1Number 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 ; 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 ; 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.