The reader is referred to section Entry format for a summary of the naming conventions used to specify restrictions on the types of arguments to numerical routines.

The examples used in this section assume that any numerical constant written using an exact notation is indeed represented as an exact number. Some examples also assume that certain numerical constants written using an inexact notation can be represented without loss of accuracy; the inexact constants were chosen so that this is likely to be true in implementations that use flonums to represent inexact numbers.

— procedure: **number?**` obj`

— procedure:**complex?**` obj`

— procedure:**real?**` obj`

— procedure:**rational?**` obj`

— procedure:**integer?**` obj`

— procedure:

— procedure:

— procedure:

— procedure:

These numerical type predicates can be applied to any kind of argument, including non-numbers. They return

#tif the object is of the named type, and otherwise they return#f. In general, if a type predicate is true of a number then all higher type predicates are also true of that number. Consequently, if a type predicate is false of a number, then all lower type predicates are also false of that number.If

zis an inexact complex number, then (real?z) is true if and only if (zero? (imag-partz)) is true. Ifxis an inexact real number, then (integer?x) is true if and only if (=x(roundx)).(complex? 3+4i) ==> #t (complex? 3) ==> #t (real? 3) ==> #t (real? -2.5+0.0i) ==> #t (real? #e1e10) ==> #t (rational? 6/10) ==> #t (rational? 6/3) ==> #t (integer? 3+0i) ==> #t (integer? 3.0) ==> #t (integer? 8/4) ==> #tNote:The behavior of these type predicates on inexact numbers is unreliable, since any inaccuracy may affect the result.Note:In many implementations the`rational?`

procedure will be the same as`real?`

, and the`complex?`

procedure will be the same as`number?`

, but unusual implementations may be able to represent some irrational numbers exactly or may extend the number system to support some kind of non-complex numbers.

— procedure: **exact?**` z`

— procedure:**inexact?**` z`

— procedure:

These numerical predicates provide tests for the exactness of a quantity. For any Scheme number, precisely one of these predicates is true.

— procedure: **=**` z1 z2 z3 ...`

— procedure:**<**` x1 x2 x3 ...`

— procedure:**>**` x1 x2 x3 ...`

— procedure:**<=**` x1 x2 x3 ...`

— procedure:**>=**` x1 x2 x3 ...`

— procedure:

— procedure:

— procedure:

— procedure:

These procedures return

#tif their arguments are (respectively): equal, monotonically increasing, monotonically decreasing, monotonically nondecreasing, or monotonically nonincreasing.These predicates are required to be transitive.

Note:The traditional implementations of these predicates in Lisp-like languages are not transitive.Note:While it is not an error to compare inexact numbers using these predicates, the results may be unreliable because a small inaccuracy may affect the result; this is especially true of`=`

and`zero?`

. When in doubt, consult a numerical analyst.

— library procedure: **zero?**` z`

— library procedure:**positive?**` x`

— library procedure:**negative?**` x`

— library procedure:**odd?**` n`

— library procedure:**even?**` n`

— library procedure:

— library procedure:

— library procedure:

— library procedure:

These numerical predicates test a number for a particular property, returning

#tor#f. See note above.

— library procedure: **max**` x1 x2 ...`

— library procedure:**min**` x1 x2 ...`

— library procedure:

These procedures return the maximum or minimum of their arguments.

(max 3 4) ==> 4 ; exact (max 3.9 4) ==> 4.0 ; inexactNote:If any argument is inexact, then the result will also be inexact (unless the procedure can prove that the inaccuracy is not large enough to affect the result, which is possible only in unusual implementations). If min or max is used to compare numbers of mixed exactness, and the numerical value of the result cannot be represented as an inexact number without loss of accuracy, then the procedure may report a violation of an implementation restriction.

— procedure: **+**` z1 ...`

— procedure:*****` z1 ...`

— procedure:

These procedures return the sum or product of their arguments.

(+ 3 4) ==> 7 (+ 3) ==> 3 (+) ==> 0 (* 4) ==> 4 (*) ==> 1

— procedure: **-**` z1 z2`

— procedure:**-**` z`

— optional procedure:**-**` z1 z2 ...`

— procedure:**/**` z1 z2`

— procedure:**/**` z`

— optional procedure:**/**` z1 z2 ...`

— procedure:

— optional procedure:

— procedure:

— procedure:

— optional procedure:

With two or more arguments, these procedures return the difference or quotient of their arguments, associating to the left. With one argument, however, they return the additive or multiplicative inverse of their argument.

(- 3 4) ==> -1 (- 3 4 5) ==> -6 (- 3) ==> -3 (/ 3 4 5) ==> 3/20 (/ 3) ==> 1/3

— procedure: **quotient**` n1 n2`

— procedure:**remainder**` n1 n2`

— procedure:**modulo**` n1 n2`

— procedure:

— procedure:

These procedures implement number-theoretic (integer) division.

n2should be non-zero. All three procedures return integers. Ifn1/n2is an integer:(quotientn1n2) ==>n1/n2(remaindern1n2) ==> 0 (modulon1n2) ==> 0If

n1/n2is not an integer:(quotientn1n2) ==>n_q(remaindern1n2) ==>n_r(modulon1n2) ==>n_mwhere

n_qisn1/n2rounded towards zero, 0 < |n_r| < |n2|, 0 < |n_m| < |n2|,n_randn_mdiffer fromn1by a multiple ofn2,n_rhas the same sign asn1, andn_mhas the same sign asn2.From this we can conclude that for integers

n1andn2withn2not equal to 0,(=n1(+ (*n2(quotientn1n2)) (remaindern1n2))) ==> #tprovided all numbers involved in that computation are exact.

(modulo 13 4) ==> 1 (remainder 13 4) ==> 1 (modulo -13 4) ==> 3 (remainder -13 4) ==> -1 (modulo 13 -4) ==> -3 (remainder 13 -4) ==> 1 (modulo -13 -4) ==> -1 (remainder -13 -4) ==> -1 (remainder -13 -4.0) ==> -1.0 ; inexact

— library procedure: **gcd**` n1 ...`

— library procedure:**lcm**` n1 ...`

— library procedure:

These procedures return the greatest common divisor or least common multiple of their arguments. The result is always non-negative.

(gcd 32 -36) ==> 4 (gcd) ==> 0 (lcm 32 -36) ==> 288 (lcm 32.0 -36) ==> 288.0 ; inexact (lcm) ==> 1

— procedure: **numerator**` q`

— procedure:**denominator**` q`

— procedure:

These procedures return the numerator or denominator of their argument; the result is computed as if the argument was represented as a fraction in lowest terms. The denominator is always positive. The denominator of 0 is defined to be 1.

(numerator (/ 6 4)) ==> 3 (denominator (/ 6 4)) ==> 2 (denominator (exact->inexact (/ 6 4))) ==> 2.0

— procedure: **floor**` x`

— procedure:**ceiling**` x`

— procedure:**truncate**` x`

— procedure:**round**` x`

— procedure:

— procedure:

— procedure:

These procedures return integers. Floor returns the largest integer not larger than

x. Ceiling returns the smallest integer not smaller thanx. Truncate returns the integer closest toxwhose absolute value is not larger than the absolute value ofx. Round returns the closest integer tox, rounding to even whenxis halfway between two integers.Rationale:Round rounds to even for consistency with the default rounding mode specified by the IEEE floating point standard.Note:If the argument to one of these procedures is inexact, then the result will also be inexact. If an exact value is needed, the result should be passed to the inexact->exact procedure.(floor -4.3) ==> -5.0 (ceiling -4.3) ==> -4.0 (truncate -4.3) ==> -4.0 (round -4.3) ==> -4.0 (floor 3.5) ==> 3.0 (ceiling 3.5) ==> 4.0 (truncate 3.5) ==> 3.0 (round 3.5) ==> 4.0 ; inexact (round 7/2) ==> 4 ; exact (round 7) ==> 7

— library procedure: **rationalize**` x y`

Rationalize returns the

simplestrational number differing fromxby no more thany. A rational number r_1 issimplerthan another rational number r_2 if r_1 = p_1/q_1 and r_2 = p_2/q_2 (in lowest terms) and |p_1|<= |p_2| and |q_1| <= |q_2|. Thus 3/5 is simpler than 4/7. Although not all rationals are comparable in this ordering (consider 2/7 and 3/5) any interval contains a rational number that is simpler than every other rational number in that interval (the simpler 2/5 lies between 2/7 and 3/5). Note that 0 = 0/1 is the simplest rational of all.(rationalize (inexact->exact .3) 1/10) ==> 1/3 ; exact (rationalize .3 1/10) ==> #i1/3 ; inexact

— procedure: **exp**` z`

— procedure:**log**` z`

— procedure:**sin**` z`

— procedure:**cos**` z`

— procedure:**tan**` z`

— procedure:**asin**` z`

— procedure:**acos**` z`

— procedure:**atan**` z`

— procedure:**atan**` y x`

— procedure:

— procedure:

— procedure:

— procedure:

— procedure:

— procedure:

— procedure:

— procedure:

These procedures are part of every implementation that supports general real numbers; they compute the usual transcendental functions. Log computes the natural logarithm of

z(not the base ten logarithm). Asin, acos, and atan compute arcsine (sin^-1), arccosine (cos^-1), and arctangent (tan^-1), respectively. The two-argument variant of atan computes(angle (make-rectangularxy))(see below), even in implementations that don't support general complex numbers.In general, the mathematical functions log, arcsine, arccosine, and arctangent are multiply defined. The value of log z is defined to be the one whose imaginary part lies in the range from -pi (exclusive) to pi (inclusive). log 0 is undefined. With log defined this way, the values of sin^-1 z, cos^-1 z, and tan^-1 z are according to the following formulae:

sin^-1 z = -i log (i z + sqrt1 - z^2)cos^-1 z = pi / 2 - sin^-1 ztan^-1 z = (log (1 + i z) - log (1 - i z)) / (2 i)The above specification follows [CLtL], which in turn cites [Penfield81]; refer to these sources for more detailed discussion of branch cuts, boundary conditions, and implementation of these functions. When it is possible these procedures produce a real result from a real argument.

— procedure: **sqrt**` z`

Returns the principal square root of

z. The result will have either positive real part, or zero real part and non-negative imaginary part.

— procedure: **expt**` z1 z2`

Returns

z1raised to the powerz2. For z_1 ~= 0z_1^z_2 = e^z_2 log z_10^z is 1 if z = 0 and 0 otherwise.

— procedure: **make-rectangular**` x1 x2`

— procedure:**make-polar**` x3 x4`

— procedure:**real-part**` z`

— procedure:**imag-part**` z`

— procedure:**magnitude**` z`

— procedure:**angle**` z`

— procedure:

— procedure:

— procedure:

— procedure:

— procedure:

These procedures are part of every implementation that supports general complex numbers. Suppose

x1,x2,x3, andx4are real numbers andzis a complex number such thatz=x1+x2i =x3. e^ix4Then

(make-rectangularx1x2) ==>z(make-polarx3x4) ==>z(real-partz) ==>x1(imag-partz) ==>x2(magnitudez) ==> |x3| (anglez) ==> x_anglewhere -pi < x_angle <= pi with x_angle =

x4+ 2pi n for some integer n.Rationale:Magnitude is the same as`abs`

for a real argument, but abs must be present in all implementations, whereas magnitude need only be present in implementations that support general complex numbers.

— procedure: **exact->inexact**` z`

— procedure:**inexact->exact**` z`

— procedure:

Exact->inexact returns an inexact representation of

z. The value returned is the inexact number that is numerically closest to the argument. If an exact argument has no reasonably close inexact equivalent, then a violation of an implementation restriction may be reported.Inexact->exact returns an exact representation of

z. The value returned is the exact number that is numerically closest to the argument. If an inexact argument has no reasonably close exact equivalent, then a violation of an implementation restriction may be reported.These procedures implement the natural one-to-one correspondence between exact and inexact integers throughout an implementation-dependent range. See section Implementation restrictions.