►The Racket Reference
►4 Datatypes
▼4.2 Numbers
4.2.1 Number Types
4.2.2 Generic Numerics
4.2.3 Flonums
4.2.4 Fixnums
4.2.5 Extflonums
On this page:
number?
complex?
real?
rational?
integer?
exact-integer?
exact-nonnegative-integer?
exact-positive-integer?
inexact-real?
fixnum?
flonum?
double-flonum?
single-flonum?
zero?
positive?
negative?
even?
odd?
exact?
inexact?
inexact->exact
exact->inexact
real->single-flonum
real->double-flonum
  top  ← prev  up  next → 
4.2.1 Number 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

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

(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

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

(exact-integer? v) → boolean?

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

Examples:
> (exact-integer? 1)

#t

> (exact-integer? 4.0)

#f

procedure

(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

procedure

(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

procedure

(inexact-real? v) → boolean?

  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

(double-flonum? v) → boolean?

  v : any/c
Identical to flonum?.

procedure

(single-flonum? v) → boolean?

  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

(positive? x) → boolean?

  x : real?
Returns (> x 0).

Examples:
> (positive? 10)

#t

> (positive? -10)

#f

> (positive? 0.0)

#f

procedure

(negative? x) → boolean?

  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

(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, +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

(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

procedure

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

procedure

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