r7rs-small-texinfo

numbers.texinfo (41212B)

---

 @node Numbers
 @section Numbers
 
 @cindex number
 
 It is important to distinguish between mathematical numbers, the Scheme
 numbers that attempt to model them, the machine representations used to
 implement the Scheme numbers, and notations used to write numbers. This
 report uses the types number, complex, real, rational, and integer to
 refer to both mathematical numbers and Scheme numbers.
 
 @menu
 * Numerical types::
 * Exactness::
 * Implementation restrictions::
 * Implementation extensions::
 * Syntax of numerical constants::
 * Numerical operations::
 * Numerical input and output::
 @end menu
 
 @node Numerical types
 @subsection Numerical types
 
 Mathematically, numbers are arranged into a tower of subtypes in which
 each level is a subset of the level above it:
 
 @display
 number
 complex number
 real number
 rational number
 integer
 @end display
 
 For example, 3 is an integer. Therefore 3 is also a rational, a real, and
 a complex number. The same is true of the Scheme numbers that model 3. For
 Scheme numbers, these types are defined by the predicates @code{number?},
 @code{complex?}, @code{real?}, @code{rational?}, and @code{integer?}.
 
 There is no simple relationship between a number's type and its
 representation inside a computer. Although most implementations of Scheme
 will offer at least two different representations of 3, these different
 representations denote the same integer.
 
 Scheme's numerical operations treat numbers as abstract data,
 as independent of their representation as possible. Although an
 implementation of Scheme may use multiple internal representations of
 numbers, this ought not to be apparent to a casual programmer writing
 simple programs.
 
 @node Exactness
 @subsection Exactness
 
 It is useful to distinguish between numbers that are represented exactly
 and those that might not be. For example, indexes into data structures
 must be known exactly, as must some polynomial coefficients in a
 symbolic algebra system. On the other hand, the results of measurements
 are inherently inexact, and irrational numbers may be approximated by
 rational and therefore inexact approximations. In order to catch uses
 of inexact numbers where exact numbers are required, Scheme explicitly
 distinguishes exact from inexact numbers. This distinction is orthogonal
 to the dimension of type.
 
 A Scheme number is @define{exact} if it was written as an exact constant
 or was derived from exact numbers using only exact operations. A number
 is @define{inexact} if it was written as an inexact constant, if it was
 derived using @define{inexact} ingredients, or if it was derived using
 @define{inexact} operations. Thus inexactness is a contagious property of
 a number.  In particular, an @define{exact complex number} has an exact
 real part and an exact imaginary part; all other complex numbers are
 @define{inexact complex numbers}.
 
 If two implementations produce exact results for a computation that
 did not involve inexact intermediate results, the two ultimate results
 will be mathematically equal. This is generally not true of computations
 involving inexact numbers since approximate methods such as floating-point
 arithmetic may be used, but it is the duty of each implementation to
 make the result as close as practical to the mathematically ideal result.
 
 Rational operations such as @code{+} should always produce exact
 results when given exact arguments. If the operation is unable to
 produce an exact result, then it may either report the violation of an
 implementation restriction or it may silently coerce its result to an
 inexact value. However, @code{(/ 3 4)} must not return the mathematically
 incorrect value @code{0}.  @xref{Implementation restrictions}.
 
 Except for @code{exact}, the operations described in this section must
 generally return inexact results when given any inexact arguments. An
 operation may, however, return an exact result if it can prove that the
 value of the result is unaffected by the inexactness of its arguments. For
 example, multiplication of any number by an exact zero may produce an
 exact zero result, even if the other argument is inexact.
 
 Specifically, the expression @code{(* 0 +inf.0)} may return @code{0},
 or @code{+nan.0}, or report that inexact numbers are not supported,
 or report that non-rational real numbers are not supported, or fail
 silently or noisily in other implementation-specific ways.
 
 @node Implementation restrictions
 @subsection Implementation restrictions
 
 Implementations of Scheme are not required to implement the whole tower
 of subtypes given in @ref{Numerical types}, but they must implement a
 coherent subset consistent with both the purposes of the implementation
 and the spirit of the Scheme language. For example, implementations
 in which all numbers are real, or in which non-real numbers are always
 inexact, or in which exact numbers are always integer, are still quite
 useful.
 
 Implementations may also support only a limited range of numbers of any
 type, subject to the requirements of this section. The supported range
 for exact numbers of any type may be different from the supported range
 for inexact numbers of that type. For example, an implementation that uses
 IEEE binary double-precision floating-point numbers to represent all its
 inexact real numbers may also support a practically unbounded range of
 exact integers and rationals while limiting the range of inexact reals
 (and therefore the range of inexact integers and rationals) to the dynamic
 range of the IEEE binary double format. Furthermore, the gaps between the
 representable inexact integers and rationals are likely to be very large
 in such an implementation as the limits of this range are approached.
 
 An implementation of Scheme must support exact integers throughout the
 range of numbers permitted as indexes of lists, vectors, bytevectors, and
 strings or that result from computing the length of one of these. The
 @code{length}, @code{vector-length}, @code{bytevector-length}, and
 @code{string-length} procedures must return an exact integer, and it is
 an error to use anything but an exact integer as an index. Furthermore,
 any integer constant within the index range, if expressed by an exact
 integer syntax, must be read as an exact integer, regardless of any
 implementation restrictions that apply outside this range. Finally, the
 procedures listed below will always return exact integer results provided
 all their arguments are exact integers and the mathematically expected
 results are representable as exact integers within the implementation:
 
 @itemize @w{}
 @item
 @code{-}
 
 @item
 @code{*}
 
 @item
 @code{+}
 
 @item
 @code{abs}
 
 @item
 @code{ceiling}
 
 @item
 @code{denominator}
 
 @item
 @code{exact-integer-sqrt}
 
 @item
 @code{expt}
 
 @item
 @code{floor}
 
 @item
 @code{floor/}
 
 @item
 @code{floor-quotient}
 
 @item
 @code{floor-remainder}
 
 @item
 @code{gcd}
 
 @item
 @code{lcm}
 
 @item
 @code{max}
 
 @item
 @code{min}
 
 @item
 @code{modulo}
 
 @item
 @code{numerator}
 
 @item
 @code{quotient}
 
 @item
 @code{rationalize}
 
 @item
 @code{remainder}
 
 @item
 @code{round}
 
 @item
 @code{square}
 
 @item
 @code{truncate}
 
 @item
 @code{truncate/}
 
 @item
 @code{truncate-quotient}
 
 @item
 @code{truncate-remainder}
 
 @end itemize
 
 It is recommended, but not required, that implementations support
 exact integers and exact rationals of practically unlimited size and
 precision, and to implement the above procedures and the @code{/}
 procedure in such a way that they always return exact results when
 given exact arguments. If one of these procedures is unable to deliver
 an exact result when given exact arguments, then it may either report
 a violation of an implementation restriction or it may silently coerce
 its result to an inexact number; such a coercion can cause an error
 later. Nevertheless, implementations that do not provide exact rational
 numbers should return inexact rational numbers rather than reporting an
 implementation restriction.
 
 An implementation may use floating-point and other approximate
 representation strategies for inexact numbers. This report recommends,
 but does not require, that implementations that use floating-point
 representations follow the IEEE 754 standard, and that implementations
 using other representations should match or exceed the precision
 achievable using these floating-point standards [@ref{IEEE}]. In particular,
 the description of transcendental functions in IEEE 754-2008 should be
 followed by such implementations, particularly with respect to infinities
 and NaNs.
 
 Although Scheme allows a variety of written notations for numbers, any
 particular implementation may support only some of them. For example,
 an implementation in which all numbers are real need not support the
 rectangular and polar notations for complex numbers. If an implementation
 encounters an exact numerical constant that it cannot represent as an
 exact number, then it may either report a violation of an implementation
 restriction or it may silently represent the constant by an inexact
 number.
 
 @node Implementation extensions
 @subsection Implementation extensions
 
 Implementations may provide more than one representation of floating-point
 numbers with differing precisions. In an implementation which does so, an
 inexact result must be represented with at least as much precision as is
 used to express any of the inexact arguments to that operation. Although
 it is desirable for potentially inexact operations such as @code{sqrt}
 to produce exact answers when applied to exact arguments, if an exact
 number is operated upon so as to produce an inexact result, then the
 most precise representation available must be used. For example, the
 value of @code{(sqrt 4)} should be @code{2}, but in an implementation
 that provides both single and double precision floating point numbers
 it may be the latter but must not be the former.
 
 It is the programmer's responsibility to avoid using inexact number
 objects with magnitude or significand too large to be represented in
 the implementation.
 
 In addition, implementations may distinguish special numbers called
 positive infinity, negative infinity, NaN, and negative zero.
 
 Positive infinity is regarded as an inexact real (but not rational)
 number that represents an indeterminate value greater than the numbers
 represented by all rational numbers.  Negative infinity is regarded as an
 inexact real (but not rational) number that represents an indeterminate
 value less than the numbers represented by all rational numbers.
 
 Adding or multiplying an infinite value by any finite real value results
 in an appropriately signed infinity; however, the sum of positive and
 negative infinities is a NaN. Positive infinity is the reciprocal of zero,
 and negative infinity is the reciprocal of negative zero.  The behavior
 of the transcendental functions is sensitive to infinity in accordance
 with IEEE 754.
 
 A NaN is regarded as an inexact real (but not rational) number so
 indeterminate that it might represent any real value, including positive
 or negative infinity, and might even be greater than positive infinity
 or less than negative infinity. An implementation that does not support
 non-real numbers may use NaN to represent non-real values like
 @code{(sqrt -1.0)} and @code{(asin 2.0)}.
 
 A NaN always compares false to any number, including a NaN. An arithmetic
 operation where one operand is NaN returns NaN, unless the implementation
 can prove that the result would be the same if the NaN were replaced by
 any rational number. Dividing zero by zero results in NaN unless both
 zeros are exact.
 
 Negative zero is an inexact real value written @code{-0.0} and is distinct
 (in the sense of @code{eqv?}) from @code{0.0}. A Scheme implementation
 is not required to distinguish negative zero. If it does, however, the
 behavior of the transcendental functions is sensitive to the distinction
 in accordance with IEEE 754. Specifically, in a Scheme implementing
 both complex numbers and negative zero, the branch cut of the complex
 logarithm function is such that @code{(imag-part (log -1.0-0.0i))}
 is @minus{}@greekpi{} rather than @greekpi{}.
 
 Furthermore, the negation of negative zero is ordinary zero and vice
 versa. This implies that the sum of two or more negative zeros is
 negative, and the result of subtracting (positive) zero from a negative
 zero is likewise negative. However, numerical comparisons treat negative
 zero as equal to zero.
 
 Note that both the real and the imaginary parts of a complex number can
 be infinities, NaNs, or negative zero.
 
 @node Syntax of numerical constants
 @subsection Syntax of numerical constants
 
 The syntax of the written representations for numbers is described
 formally in @ref{Formal syntax}.  Note that case is not significant in
 numerical constants.
 
 @sharpindex{b}
 @sharpindex{o}
 @sharpindex{d}
 @sharpindex{x}
 
 A number can be written in binary, octal, decimal, or hexadecimal by
 the use of a radix prefix. The radix prefixes are @code{#b} (binary),
 @code{#o} (octal), @code{#d} (decimal), and @code{#x} (hexadecimal). With
 no radix prefix, a number is assumed to be expressed in decimal.
 
 @sharpindex{e}
 @sharpindex{i}
 
 A numerical constant can be specified to be either exact or inexact
 by a prefix. The prefixes are @code{#e} for exact, and @code{#i} for
 inexact. An exactness prefix can appear before or after any radix prefix
 that is used. If the written representation of a number has no exactness
 prefix, the constant is inexact if it contains a decimal point or an
 exponent. Otherwise, it is exact.
 
 In systems with inexact numbers of varying precisions it can be useful to
 specify the precision of a constant. For this purpose, implementations
 may accept numerical constants written with an exponent marker that
 indicates the desired precision of the inexact representation. If so, the
 letter @code{s}, @code{f}, @code{d}, or @code{l}, meaning @define{short},
 @define{single}, @define{double}, or @define{long} precision, respectively, can
 be used in place of @code{e}. The default precision has at least as much
 precision as double, but implementations may allow this default to be
 set by the user.
 
 @display
 @code{3.14159265358979F0}
         Round to single --- @code{3.141593}
 @code{0.6L0}
         Extend to long --- @code{.600000000000000}
 @end display
 
 The numbers positive infinity, negative infinity, and NaN are written
 @code{+inf.0}, @code{-inf.0} and @define{+nan.0} respectively. NaN may
 also be written @code{-nan.0}. The use of signs in the written
 representation does not necessarily reflect the underlying sign of the
 NaN value, if any. Implementations are not required to support these
 numbers, but if they do, they must do so in general conformance with
 IEEE 754. However, implementations are not required to support
 signaling NaNs, nor to provide a way to distinguish between different
 NaNs.
 
 There are two notations provided for non-real complex numbers: the
 @define{rectangular notation} @var{a}@code{+}@var{b}@code{i}, where
 @var{a} is the real part and @var{b} is the imaginary part; and the
 @define{polar notation} @var{r}@code{@@}@var{@greektheta{}} where @var{r}
 is the magnitude and @var{@greektheta{}} is the phase (angle) in
 radians. These are related by the equation
 @math{a + bi = r \cos\theta + (r \sin\theta)i}. All of @var{a},
 @var{b}, @var{r}, and @var{@greektheta{}} are real numbers.
 
 @node Numerical operations
 @subsection Numerical operations
 
 The reader is referred to @ref{Error situations and unspecified
 behavior} 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 IEEE binary doubles to represent
 inexact numbers.
 
 @deffn  procedure number? obj
 @deffnx procedure complex? obj
 @deffnx procedure real? obj
 @deffnx procedure rational? obj
 @deffnx procedure integer? obj
 
 These numerical type predicates can be applied to any kind of argument,
 including non-numbers. They return @code{#t} if the object is of the
 named type, and otherwise they return @code{#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 @var{z} is a complex number, then @code{(real? }@var{z}@code{)} is
 true if and only if @code{(zero? (imag-part }@var{z}@code{))} is true. If
 @var{x} is an inexact real number, then @code{(integer? }@var{x}@code{)}
 is true if and only if @code{(= }@var{x}@code{ (round }@var{x}@code{))}.
 
 The numbers @code{+inf.0}, @code{-inf.0}, and @code{+nan.0} are real
 but not rational.
 
 @lisp
 (complex? 3+4i)    @result{} #t
 (complex? 3)       @result{} #t
 (real? 3)          @result{} #t
 (real? -2.5+0i)    @result{} #t
 (real? -2.5+0.0i)  @result{} #f
 (real? #e1e10)     @result{} #t
 (real? +inf.0)     @result{} #t
 (real? +nan.0)     @result{} #t
 (rational? -inf.0) @result{} #f
 (rational? 3.5)    @result{} #t
 (rational? 6/10)   @result{} #t
 (rational? 6/3)    @result{} #t
 (integer? 3+0i)    @result{} #t
 (integer? 3.0)     @result{} #t
 (integer? 8/4)     @result{} #t
 @end lisp
 
 Note: The behavior of these type predicates on inexact numbers is
 unreliable, since any inaccuracy might affect the result.
 
 Note: In many implementations the @code{complex?} procedure will be the
 same as @code{number?}, but unusual implementations may represent some
 irrational numbers exactly or may extend the number system to support
 some kind of non-complex numbers.
 
 @end deffn
 
 @deffn  procedure exact? z
 @deffnx procedure inexact? z
 
 These numerical predicates provide tests for the exactness of a
 quantity. For any Scheme number, precisely one of these predicates is
 true.
 
 @lisp
 (exact? 3.0)   @result{} #f
 (exact? #e3.0) @result{} #t
 (inexact? 3.)  @result{} #t
 @end lisp
 @end deffn
 
 @deffn procedure exact-integer? z
 
 Returns @code{#t} if @var{z} is both exact and an integer; otherwise
 returns @code{#f}.
 
 @lisp
 (exact-integer? 32)   @result{} #t
 (exact-integer? 32.0) @result{} #f
 (exact-integer? 32/5) @result{} #f
 @end lisp
 @end deffn
 
 @deffn {inexact library procedure} finite? z
 
 The @code{finite?} procedure returns @code{#t} on all real numbers
 except @code{+inf.0}, @code{-inf.0}, and @code{+nan.0}, and on complex
 numbers if their real and imaginary parts are both finite. Otherwise it
 returns @code{#f}.
 
 @lisp
 (finite? 3)          @result{} #t
 (finite? +inf.0)     @result{} #f
 (finite? 3.0+inf.0i) @result{} #f
 @end lisp
 @end deffn
 
 @deffn {inexact library procedure} infinite? z
 
 The @code{infinite?} procedure returns @code{#t} on the real numbers
 @code{+inf.0} and @code{-inf.0}, and on complex numbers if their real
 or imaginary parts or both are infinite. Otherwise it returns
 @code{#f}.
 
 @lisp
 (infinite? 3)          @result{} #f
 (infinite? +inf.0)     @result{} #t
 (infinite? +nan.0)     @result{} #f
 (infinite? 3.0+inf.0i) @result{} #t
 @end lisp
 @end deffn
 
 @deffn {inexact library procedure} nan? z
 
 The @code{nan?} procedure returns @code{#t} on @code{+nan.0}, and on
 complex numbers if their real or imaginary parts or both are
 @code{+nan.0}. Otherwise it returns @code{#f}.
 
 @lisp
 (nan? +nan.0)      @result{} #t
 (nan? 32)          @result{} #f
 (nan? +nan.0+5.0i) @result{} #t
 (nan? 1+2i)        @result{} #f
 @end lisp
 @end deffn
 
 @deffn  procedure = z@sub{1} z@sub{2} z@sub{3}@dots{}
 @deffnx procedure < x@sub{1} x@sub{2} x@sub{3}@dots{}
 @deffnx procedure > x@sub{1} x@sub{2} x@sub{3}@dots{}
 @deffnx procedure <= x@sub{1} x@sub{2} x@sub{3}@dots{}
 @deffnx procedure >= x@sub{1} x@sub{2} x@sub{3}@dots{}
 
 These procedures return @code{#t} if their arguments are (respectively):
 equal, monotonically increasing, monotonically decreasing, monotonically
 non-decreasing, or monotonically non-increasing, and @code{#f} otherwise.
 If any of the arguments are @code{+nan.0}, all the predicates return
 @code{#f}.  They do not distinguish between inexact zero and inexact
 negative zero.
 
 These predicates are required to be transitive.
 
 Note: The implementation approach of converting all arguments to inexact
 numbers if any argument is inexact is not transitive.  For example, let
 @code{big} be @code{(expt 2 1000)}, and assume that @code{big} is exact
 and that inexact numbers are represented by 64-bit IEEE binary floating
 point numbers.  Then @code{(= (- big 1) (inexact big))} and @code{(=
 (inexact big) (+ big 1))} would both be true with this approach, because
 of the limitations of IEEE representations of large integers, whereas
 @code{(= (- big 1) (+ big 1))} is false.  Converting inexact values to
 exact numbers that are the same (in the sense of @code{=}) to them will
 avoid this problem, though special care must be taken with infinities.
 
 Note: While it is not an error to compare inexact numbers using these
 predicates, the results are unreliable because a small inaccuracy can
 affect the result; this is especially true of @code{=} and @code{zero?}.
 When in doubt, consult a numerical analyst.
 
 @end deffn
 
 @deffn  procedure zero? z
 @deffnx procedure positive? x
 @deffnx procedure negative? x
 @deffnx procedure odd? n
 @deffnx procedure even? n
 
 These numerical predicates test a number for a particular property,
 returning @code{#t} or @code{#f}. See note above.
 
 @end deffn
 
 @deffn  procedure max x@sub{1} x@sub{2}@dots{}
 @deffnx procedure min x@sub{1} x@sub{2}@dots{}
 
 These procedures return the maximum or minimum of their arguments.
 
 @lisp
 (max 3 4)   @result{} 4    ; exact
 (max 3.9 4) @result{} 4.0  ; inexact
 @end lisp
 
 Note: 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
 @code{min} or @code{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.
 
 @end deffn
 
 @deffn  procedure + z@sub{1}@dots{}
 @deffnx procedure * z@sub{1}@dots{}
 
 These procedures return the sum or product of their arguments.
 
 @lisp
 (+ 3 4) @result{} 7
 (+ 3)   @result{} 3
 (+)     @result{} 0
 (* 4)   @result{} 4
 (*)     @result{} 1
 @end lisp
 @end deffn
 
 @deffn  procedure - z
 @deffnx procedure - z@sub{1} z@sub{2}@dots{}
 @deffnx procedure / z
 @deffnx procedure / z@sub{1} z@sub{2}@dots{}
 
 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.
 
 It is an error if any argument of @code{/} other than the first is an
 exact zero. If the first argument is an exact zero, an implementation
 may return an exact zero unless one of the other arguments is a NaN.
 
 @lisp
 (- 3 4)   @result{} -1
 (- 3 4 5) @result{} -6
 (- 3)     @result{} -3
 (/ 3 4 5) @result{} 3/20
 (/ 3)     @result{} 1/3
 @end lisp
 
 @end deffn
 
 @deffn procedure abs x
 
 The abs procedure returns the absolute value of its argument.
 
 @lisp
 (abs -7) @result{} 7
 @end lisp
 
 @end deffn
 
 @deffn  procedure floor/ n@sub{1} n@sub{2}
 @deffnx procedure floor-quotient n@sub{1} n@sub{2}
 @deffnx procedure floor-remainder n@sub{1} n@sub{2}
 @deffnx procedure truncate/ n@sub{1} n@sub{2}
 @deffnx procedure truncate-quotient n@sub{1} n@sub{2}
 @deffnx procedure truncate-remainder n@sub{1} n@sub{2}
 
 These procedures implement number-theoretic (integer) division. It is
 an error if @var{n} is zero.  The procedures ending in @code{/} return
 two integers; the other procedures return an integer. All the procedures
 compute a quotient @var{n@sub{q}} and remainder @var{n@sub{r}} such that
 @var{n@sub{1}} = @var{n@sub{2}}@var{n@sub{q}} + @var{n@sub{r}}. For each
 of the division operators, there are three procedures defined as follows:
 
 @c This is hideous. Can we do any better?
 @lisp
 (@r{@svar{operator}}/ @r{@var{n@sub{1}} @var{n@sub{2}}}) @result{} @r{@var{n@sub{q}} @var{n@sub{r}}}
 (@r{@svar{operator}}-quotient @r{@var{n@sub{1}} @var{n@sub{2}}}) @result{} @r{@var{n@sub{q}}}
 (@r{@svar{operator}}-remainder @r{@var{n@sub{1}} @var{n@sub{2}}}) @result{} @r{@var{n@sub{r}}}
 @end lisp
 
 The remainder @var{n@sub{r}} is determined by the choice of integer
 @var{n@sub{q}}: @var{n@sub{r}} = @var{n@sub{1}} @minus{}
 @var{n@sub{2}}@var{n@sub{q}}. Each set of operators uses a different
 choice of @var{n@sub{q}}:
 
 @table @code
 
 @item floor
 @math{n_q = \lfloor n_1 / n_2 \rfloor}
 
 @item truncate
 @math{n_q =} truncate@math{(n_1 / n_2)}
 
 @end table
 
 For any of the operators, and for integers @var{n@sub{1}} and
 @var{n@sub{2}} with @var{n@sub{2}} not equal to 0,
 
 @lisp
 (= @r{@var{n@sub{1}}}
    (+ (* @r{@var{n@sub{2}}} (@r{@svar{operator}}-quotient @r{@var{n@sub{1}} @var{n@sub{2}}}))
       (@r{@svar{operator}}-remainder @r{@var{n@sub{1}} @var{n@sub{2}}})))
         @result{} #t
 @end lisp
 
 provided all numbers involved in that computation are exact.
 
 Examples:
 
 @lisp
 (floor/ 5 2)        @result{}  2    1
 (floor/ -5 2)       @result{} -3    1
 (floor/ 5 -2)       @result{} -3   -1
 (floor/ -5 -2)      @result{}  2   -1
 (truncate/ 5 2)     @result{}  2    1
 (truncate/ -5 2)    @result{} -2   -1
 (truncate/ 5 -2)    @result{} -2    1
 (truncate/ -5 -2)   @result{}  2   -1
 (truncate/ -5.0 -2) @result{}  2.0 -1.0
 @end lisp
 
 @end deffn
 
 @deffn  procedure quotient n@sub{1} n@sub{2}
 @deffnx procedure remainder n@sub{1} n@sub{2}
 @deffnx procedure modulo n@sub{1} n@sub{2}
 
 The @code{quotient} and @code{remainder} procedures are equivalent to
 @code{truncate-quotient} and @code{truncate-remainder}, respectively,
 and @code{modulo} is equivalent to @code{floor-remainder}.
 
 Note: These procedures are provided for backward compatibility with
 earlier versions of this report.
 
 @end deffn
 
 @deffn  procedure gcd n@sub{1}@dots{}
 @deffnx procedure lcm n@sub{1}@dots{}
 
 These procedures return the greatest common divisor or least common
 multiple of their arguments. The result is always non-negative.
 
 @lisp
 (gcd 32 -36)   @result{} 4
 (gcd)          @result{} 0
 (lcm 32 -36)   @result{} 288
 (lcm 32.0 -36) @result{} 288.0  ; inexact
 (lcm)          @result{} 1
 @end lisp
 
 @end deffn
 
 @deffn  procedure numerator q
 @deffnx procedure denominator q
 
 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.
 
 @lisp
 (numerator (/ 6 4))   @result{} 3
 (denominator (/ 6 4)) @result{} 2
 (denominator
   (inexact (/ 6 4)))  @result{} 2.0
 @end lisp
 
 @end deffn
 
 @deffn  procedure floor x
 @deffnx procedure ceiling x
 @deffnx procedure truncate x
 @deffnx procedure round x
 
 These procedures return integers.  The @code{floor} procedure returns the
 largest integer not larger than @var{x}.  The @code{ceiling} procedure
 returns the smallest integer not smaller than @var{x}, @code{truncate}
 returns the integer closest to @var{x} whose absolute value is not larger
 than the absolute value of @var{x}, and @code{round} returns the closest
 integer to @var{x}, rounding to even when @var{x} is halfway between
 two integers.
 
 @rationale{}
 
 The @code{round} procedure rounds to even for consistency with
 the default rounding mode specified by the IEEE 754 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 can
 be passed to the @code{exact} procedure. If the argument is infinite or
 a NaN, then it is returned.
 
 @lisp
 (floor -4.3)          @result{} -5.0
 (ceiling -4.3)        @result{} -4.0
 (truncate -4.3)       @result{} -4.0
 (round -4.3)          @result{} -4.0
 
 (floor 3.5)           @result{} 3.0
 (ceiling 3.5)         @result{} 4.0
 (truncate 3.5)        @result{} 3.0
 (round 3.5)           @result{} 4.0  ; inexact
 
 (round 7/2)           @result{} 4    ; exact
 (round 7)             @result{} 7
 @end lisp
 
 @end deffn
 
 @deffn procedure rationalize x y
 
 @cindex simplest rational
 
 @c TODO: Math mode is probably overkill here. Use normal insertions?
 The @code{rationalize} procedure returns the @emph{simplest} rational
 number differing from @var{x} by no more than @var{y}. A rational
 number @var{r@sub{1}} is @emph{simpler} than another rational number
 @var{r@sub{2}} if @math{r_1 = p_1/q_1} and @math{r_2 = p_2/q_2} (in
 lowest terms) and @math{|p_1| \leq |p_2|} and @math{|q_1| \leq |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.
 
 @lisp
 (rationalize (exact .3) 1/10) @result{} 1/3    ; exact
 (rationalize .3 1/10)         @result{} #i1/3  ; inexact
 @end lisp
 
 @end deffn
 
 @deffn  {inexact library procedure} exp z
 @deffnx {inexact library procedure} log z
 @deffnx {inexact library procedure} log z@sub{1} z@sub{2}
 @deffnx {inexact library procedure} sin z
 @deffnx {inexact library procedure} cos z
 @deffnx {inexact library procedure} tan z
 @deffnx {inexact library procedure} asin z
 @deffnx {inexact library procedure} acos z
 @deffnx {inexact library procedure} atan z
 @deffnx {inexact library procedure} atan y x
 
 These procedures compute the usual transcendental functions. The
 @code{log} procedure computes the natural logarithm of @var{z} (not the
 base ten logarithm) if a single argument is given, or the
 base-@var{z@sub{2}} logarithm of @var{z@sub{1}} if two arguments are
 given. The @code{asin}, @code{acos}, and @code{atan} procedures compute
 arcsine (sin@sup{@minus{}1}), arc-cosine (cos@sup{@minus{}1}), and
 arctangent (tan@sup{@minus{}1}), respectively. The two-argument variant
 of @code{atan} computes @code{(angle (make-rectangular @var{x}
 @var{y}))} (see below), even in implementations that don't support
 complex numbers.
 
 In general, the mathematical functions log, arcsine, arc-cosine, and
 arctangent are multiply defined. The value of log @var{z} is defined to
 be the one whose imaginary part lies in the range from @minus{}@greekpi
 (inclusive if @code{-0.0} is distinguished, exclusive otherwise) to
 @greekpi (inclusive). The value of log 0 is mathematically undefined.
 With log defined this way, the values of sin@sup{@minus{}1} @var{z},
 cos@sup{@minus{}1} @var{z}, and tan@sup{@minus{}1} @var{z} are
 according to the following formul@ae{}:
 
 @displaymath
 \sin^{-1} z = -i \log (i z + \sqrt{1 - z^2})
 @end displaymath
 
 @displaymath
 \cos^{-1} z = \pi / 2 - \sin^{-1} z
 @end displaymath
 
 @displaymath
 \tan^{-1} z = (\log (1 + i z) - \log (1 - i z)) / (2 i)
 @end displaymath
 
 However, @code{(log 0.0)} returns @code{-inf.0} (and @code{(log -0.0)}
 returns @code{-inf.0+@greekpi{}i}) if the implementation supports
 infinities (and @code{-0.0}).
 
 The range of @code{(atan }@var{y} @var{x}@code{)} is as in the
 following table. The asterisk (*) indicates that the entry applies to
 implementations that distinguish minus zero.
 
 @multitable @columnfractions .16 .24 .24 .36
 @headitem @tab @var{y} condition @tab @var{x} condition @tab
   range of result @var{r}
 @item @tab @var{y} = 0.0 @tab @var{x} > 0.0 @tab 0.0
 @item * @tab @var{y} = +0.0 @tab @var{x} > 0.0 @tab +0.0
 @item * @tab @var{y} = @minus{}0.0 @tab @var{x} > 0.0 @tab @minus{}0.0
 @item @tab @var{y} > 0.0 @tab @var{x} > 0.0 @tab
   0.0 < @var{r} < @greekpi/2
 @item @tab @var{y} > 0.0 @tab @var{x} = 0.0 @tab @greekpi/2
 @item @tab @var{y} > 0.0 @tab @var{x} < 0.0 @tab
   @greekpi/2 < @var{r} < @greekpi
 @item @tab @var{y} = 0.0 @tab @var{x} < 0 @tab @greekpi
 @item * @tab @var{y} = +0.0 @tab @var{x} < 0.0 @tab @greekpi
 @item * @tab @var{y} = @minus{}0.0 @tab @var{x} < 0.0 @tab
   @minus{}@greekpi
 @item @tab @var{y} < 0.0 @tab @var{x} < 0.0 @tab
   @minus{}@greekpi < @var{r} < @minus{}@greekpi/2
 @item @tab @var{y} < 0.0 @tab @var{x} = 0.0 @tab @minus{}@greekpi/2
 @item @tab @var{y} < 0.0 @tab @var{x} > 0.0 @tab
   @minus{}@greekpi/2 < @var{r}< 0.0
 @item @tab @var{y} = 0.0 @tab @var{x} = 0.0 @tab undefined
 @item * @tab @var{y} = +0.0 @tab @var{x} = +0.0 @tab +0.0
 @item * @tab @var{y} = @minus{}0.0 @tab @var{x} = +0.0 @tab @minus{}0.0
 @item * @tab @var{y} = +0.0 @tab @var{x} = @minus{}0.0 @tab @greekpi
 @item * @tab @var{y} = @minus{}0.0 @tab @var{x} = @minus{}0.0 @tab
   @minus{}@greekpi
 @item * @tab @var{y} = +0.0 @tab @var{x} = 0 @tab
   @greekpi/2
 @item * @tab @var{y} = @minus{}0.0 @tab @var{x} = 0 @tab
   @minus{}@greekpi/2
 @end multitable
 
 The above specification follows [@ref{CLtL}], which in turn cites [@ref{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.
 
 @end deffn
 
 @deffn procedure square z
 
 Returns the square of z. This is equivalent to
 @code{(* }@var{z} @var{z}@code{)}.
 
 @lisp
 (square 42)  @result{} 1764
 (square 2.0) @result{} 4.0
 @end lisp
 
 @end deffn
 
 @deffn {inexact library procedure} sqrt z
 
 Returns the principal square root of @var{z}. The result will have
 either a positive real part, or a zero real part and a non-negative
 imaginary part.
 
 @lisp
 (sqrt 9)  @result{} 3
 (sqrt -1) @result{} +i
 @end lisp
 
 @end deffn
 
 @deffn procedure exact-integer-sqrt k
 
 Returns two non-negative exact integers @var{s} and @var{r} where
 @var{k} = @var{s}@sup{2} + @var{r} and @var{k} < (@var{s} + 1)@sup{2}.
 
 @lisp
 (exact-integer-sqrt 4) @result{} 2 0
 (exact-integer-sqrt 5) @result{} 2 1
 @end lisp
 
 @end deffn
 
 @deffn procedure expt z@sub{1} z@sub{2}
 
 Returns z@sub{1} raised to the power z@sub{2}. For nonzero
 z@sub{1}, this is
 
 @displaymath
 {z_1}^{z_2} = e^{z_2 \log {z_1}}
 @end displaymath
 
 The value of 0@sup{@var{z}} is 1 if @code{(zero? }@var{z}@code{)}, 0 if
 @code{(real-part }@var{z}@code{)} is positive, and an error otherwise.
 Similarly for 0.0@sup{@var{z}}, with inexact results.
 
 @end deffn
 
 @deffn  {complex library procedure} make-rectangular x@sub{1} x@sub{2}
 @deffnx {complex library procedure} make-polar x@sub{3} x@sub{4}
 @deffnx {complex library procedure} real-part z
 @deffnx {complex library procedure} imag-part z
 @deffnx {complex library procedure} magnitude z
 @deffnx {complex library procedure} angle z
 
 Let @var{x@sub{1}}, @var{x@sub{2}}, @var{x@sub{3}}, and @var{x@sub{4}}
 be real numbers and @var{z} be a complex number such that
 
 @displaymath
 z = x_1 + x_{2}i = x_3 \cdot e^{i x_4}
 @end displaymath
 
 Then all of
 
 @lisp
 (make-rectangular @r{@var{x@sub{1}} @var{x@sub{2}}}) @result{} z
 (make-polar @r{@var{x@sub{3}} @var{x@sub{4}}})       @result{} z
 (real-part @r{@var{z}})                  @result{} @r{@var{x@sub{1}}}
 (imag-part @r{@var{z}})                  @result{} @r{@var{x@sub{2}}}
 (magnitude @r{@var{z}})                  @result{} |@r{@var{x@sub{3}}}|
 (angle @r{@var{z}})                      @result{} @r{@var{x}@sub{angle}}
 @end lisp
 
 are true, where @minus{}@greekpi{} @leq{} @var{x@sub{angle}} @leq{}
 @greekpi{} with @var{x@sub{angle}} = @var{x@sub{4}} + 2@greekpi{}@var{n}
 for some integer @var{n}.
 
 The @code{make-polar} procedure may return an inexact complex
 number even if its arguments are exact. The @code{real-part} and
 @code{imag-part} procedures may return exact real numbers when applied
 to an inexact complex number if the corresponding argument passed to
 @code{make-rectangular} was exact.
 
 The @code{magnitude} procedure is the same as @code{abs} for a real
 argument, but @code{abs} is in the base library, whereas @code{magnitude}
 is in the optional complex library.
 
 @end deffn
 
 @deffn  procedure inexact z
 @deffnx procedure exact z
 
 The procedure @code{inexact} returns an inexact representation of @var{z}.
 The value returned is the inexact number that is numerically closest
 to the argument.  For inexact arguments, the result is the same as the
 argument. For exact complex numbers, the result is a complex number
 whose real and imaginary parts are the result of applying @code{inexact}
 to the real and imaginary parts of the argument, respectively.  If an
 exact argument has no reasonably close inexact equivalent (in the sense
 of @code{=}), then a violation of an implementation restriction may
 be reported.
 
 The procedure @code{exact} returns an exact representation of @var{z}. The
 value returned is the exact number that is numerically closest to
 the argument.  For exact arguments, the result is the same as the
 argument. For inexact non-integral real arguments, the implementation
 may return a rational approximation, or may report an implementation
 violation. For inexact complex arguments, the result is a complex number
 whose real and imaginary parts are the result of applying @code{exact}
 to the real and imaginary parts of the argument, respectively.  If an
 inexact argument has no reasonably close exact equivalent, (in the
 sense of @code{=}), 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. @xref{Implementation restrictions}.
 
 Note: These procedures were known in @rfivers{} as @code{exact->inexact}
 and @code{inexact->exact}, respectively, but they have always accepted
 arguments of any exactness.  The new names are clearer and shorter,
 as well as being compatible with @rsixrs{}.
 
 @end deffn
 
 @node Numerical input and output
 @subsection Numerical input and output
 
 @deffn  procedure number->string z
 @deffnx procedure number->string z radix
 
 It is an error if
 @var{radix} is not one of 2, 8, 10, or 16.
 
 The procedure @code{number->string} takes a number and a radix and
 returns as a string an external representation of the given number in
 the given radix such that
 
 @lisp
 (let ((number number)
       (radix radix))
   (eqv? number
         (string->number (number->string number
                                         radix)
                         radix)))
 @end lisp
 
 is true. It is an error if no possible result makes this expression
 true. If omitted, @var{radix} defaults to 10.
 
 If @var{z} is inexact, the radix is 10, and the above expression can be
 satisfied by a result that contains a decimal point, then the result
 contains a decimal point and is expressed using the minimum number
 of digits (exclusive of exponent and trailing zeroes) needed to make
 the above expression true [@ref{howtoprint}, @ref{howtoread}]; otherwise the format of the result
 is unspecified.
 
 The result returned by @code{number->string} never contains an explicit
 radix prefix.
 
 Note: The error case can occur only when @var{z} is not a complex number
 or is a complex number with a non-rational real or imaginary part.
 
 @rationale{}
 
 If @var{z} is an inexact number and the radix is 10, then
 the above expression is normally satisfied by a result containing a
 decimal point. The unspecified case allows for infinities, NaNs, and
 unusual representations.
 
 @end deffn
 
 @deffn  procedure string->number string
 @deffnx procedure string->number string radix
 
 Returns a number of the maximally precise representation expressed by the
 given @var{string}.  It is an error if @var{radix} is not 2, 8, 10, or 16.
 
 If supplied, @var{radix} is a default radix that will be overridden if an
 explicit radix prefix is present in string (e.g.@: @code{"#o177"}). If
 @var{radix} is not supplied, then the default radix is 10. If
 @var{string} is not a syntactically valid notation for a number, or
 would result in a number that the implementation cannot represent, then
 @code{string->number} returns @code{#f}. An error is never signaled due
 to the content of @var{string}.
 
 @lisp
 (string->number "100")    @result{} 100
 (string->number "100" 16) @result{} 256
 (string->number "1e2")    @result{} 100.0
 @end lisp
 
 Note: The domain of @code{string->number} may be restricted by
 implementations in the following ways.  If all numbers supported by an
 implementation are real, then @code{string->number} is permitted to
 return @code{#f} whenever @var{string} uses the polar or rectangular
 notations for complex numbers. If all numbers are integers, then
 @code{string->number} may return @code{#f} whenever the fractional
 notation is used. If all numbers are exact, then @code{string->number} may
 return @code{#f} whenever an exponent marker or explicit exactness prefix
 is used.  If all inexact numbers are integers, then @code{string->number}
 may return @code{#f} whenever a decimal point is used.
 
 The rules used by a particular implementation for @code{string->number}
 must also be applied to @code{read} and to the routine that reads
 programs, in order to maintain consistency between internal numeric
 processing, I/O, and the processing of programs.  As a consequence,
 the @rfivers{} permission to return @code{#f} when @var{string} has an
 explicit radix prefix has been withdrawn.
 
 @end deffn