Numbers

(+ n ...)

Sum of the arguments; (+) is 0.

(+ 1 2 3.5)

(- n m ...)
(- n)

Subtracts the rest from the first; negates a single argument.

(list (- 10 3 2) (- 5))

(* n ...)

Product of the arguments; (*) is 1.

(* 2 3 4)

(/ n m ...)
(/ n)

Divides the first by the rest. Integers that divide evenly stay integers; otherwise the result is a float (there are no rationals).

(list (/ 10 2) (/ 1 4) (/ 2))

(quotient n m)

Integer division, truncated toward zero.

(quotient 17 5)

(remainder n m)

Remainder with the sign of the dividend.

(remainder -17 5)

(modulo n m)

Modulo with the sign of the divisor.

(modulo -17 5)

(abs n)

Absolute value.

(abs -7)

(min n ...)

Smallest argument.

(min 3 1 2)

(max n ...)

Largest argument.

(max 3 1 2)

(expt base power)

base raised to power. Exact for an integer base and non-negative integer power, a float otherwise.

(expt 2 100)

(sqrt n)

Square root. Exact for perfect squares.

(list (sqrt 16) (sqrt 2))

(exact->inexact n)

Converts to a float.

(exact->inexact 1)

(inexact n)

Converts to a float.

(inexact 1)

(inexact->exact n)

Converts an integral float to an integer.

(inexact->exact 3.0)

(exact n)

Converts an integral float to an integer.

(exact 3.0)

(round n)

Rounds to the nearest integer, ties to even.

(list (round 2.5) (round 3.5) (round 2.6))

(floor n)

Largest integer not above the argument.

(floor 2.7)

(ceiling n)

Smallest integer not below the argument.

(ceiling 2.1)

(truncate n)

Drops the fractional part.

(truncate -2.7)

(number? x)

Is the argument a number?

(list (number? 1) (number? "1"))

(integer? x)

Is the argument an integer (including integral floats)?

(list (integer? 2) (integer? 2.0) (integer? 2.5))

(exact? n)

Is the argument an exact number (an integer)?

(list (exact? 1) (exact? 1.0))

(inexact? n)

Is the argument a float?

(inexact? 1.0)

(zero? n)

Is the argument zero?

(zero? 0)

(positive? n)

Is the argument above zero?

(positive? 5)

(negative? n)

Is the argument below zero?

(negative? 5)

(even? n)

Is the integer even?

(even? 10)

(odd? n)

Is the integer odd?

(odd? 10)

(= n m ...)

Are the arguments equal?

(= 1 1.0)

(< n m ...)

Are the arguments increasing?

(< 1 2 3)

(> n m ...)

Are the arguments decreasing?

(> 3 2 2)

(<= n m ...)

Are the arguments non-decreasing?

(<= 1 2 2)

(>= n m ...)

Are the arguments non-increasing?

(>= 3 3 1)

(number->string n)

Prints a number.

(number->string 42)

(string->number s)

Parses a number, or returns #f.

(list (string->number "42") (string->number "nope"))