r5rs-z-h-9.html

scheme 标准（r5rs）。Scheme是MIT发布的基于Lambda运算的语言

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 flonums to represent all its
inexact real numbers may
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 flonum 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.<p>

An implementation of Scheme must support exact integers
throughout the range of numbers that may be used for indexes of
lists, vectors, and strings or that may result from computing the length of a
list, vector, or string.  The <tt>length</tt>, <tt>vector-length</tt>,
and <tt>string-length</tt> 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, will indeed be read as an exact
integer, regardless of any implementation restrictions that may apply
outside this range.  Finally, the procedures listed below will always
return an exact integer result provided all their arguments are exact integers
and the mathematically expected result is representable as an exact integer
within the implementation:<p>

<tt><p>+&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;-&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;*<br>
quotient&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;remainder&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;modulo<br>
max&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;min&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;abs<br>
numerator&nbsp;&nbsp;&nbsp;&nbsp;denominator&nbsp;&nbsp;&nbsp;gcd<br>
lcm&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;floor&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;ceiling<br>
truncate&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;round&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;rationalize<br>
expt<p></tt><p>

Implementations are encouraged, but not required, to support
exact integers and exact rationals of
practically unlimited size and precision, and to implement the
above procedures and the <tt>/</tt> 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 may cause an error later.<p>


An implementation may use floating point and other approximate 
representation strategies for inexact numbers.
This report recommends, but does not require, that the IEEE 32-bit
and 64-bit floating point standards be followed by implementations that use
flonum representations, and that implementations using
other representations should match or exceed the precision achievable
using these floating point standards&nbsp;[<a href="r5rs-Z-H-14.html#%_sec_7.3">12</a>].<p>

In particular, implementations that use flonum representations
must follow these rules: A flonum result
must be represented with at least as much precision as is used to express any of
the inexact arguments to that operation.  It is desirable (but not required) for
potentially inexact operations such as <tt>sqrt</tt>, when applied to exact
arguments, to produce exact answers whenever possible (for example the
square root of an exact 4 ought to be an exact 2).
If, however, an
exact number is operated upon so as to produce an inexact result
(as by <tt>sqrt</tt>), and if the result is represented as a flonum, then
the most precise flonum format available must be used; but if the result
is represented in some other way then the representation must have at least as
much precision as the most precise flonum format available.<p>

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

<a name="%_sec_6.2.4"></a>
<h3><a href="r5rs-Z-H-2.html#%_toc_%_sec_6.2.4">6.2.4&nbsp;&nbsp;Syntax of numerical constants</a></h3><p>

<p>



The syntax of the written representations for numbers is described formally in
section&nbsp;<a href="r5rs-Z-H-10.html#%_sec_7.1.1">7.1.1</a>.  Note that case is not significant in numerical
constants.<p>


A number may be written in binary, octal, decimal, or
hexadecimal by the use of a radix prefix.  The radix prefixes are <tt>#b</tt><a name="%_idx_228"></a> (binary), <tt>#o</tt><a name="%_idx_230"></a> (octal), <tt>#d</tt><a name="%_idx_232"></a> (decimal), and <tt>#x</tt><a name="%_idx_234"></a> (hexadecimal).  With
no radix prefix, a number is assumed to be expressed in decimal.<p>

A
numerical constant may be specified to be either exact or
inexact by a prefix.  The prefixes are <tt>#e</tt><a name="%_idx_236"></a>
for exact, and <tt>#i</tt><a name="%_idx_238"></a> for inexact.  An exactness
prefix may appear before or after any radix prefix that is used.  If
the written representation of a number has no exactness prefix, the
constant may be either inexact or exact.  It is
inexact if it contains a decimal point, an
exponent, or a ``<tt>#</tt>'' character in the place of a digit,
otherwise it is exact.

In systems with inexact numbers
of varying precisions it may be useful to specify
the precision of a constant.  For this purpose, numerical constants
may be written with an exponent marker that indicates the
desired precision of the inexact
representation.  The letters <tt>s</tt>, <tt>f</tt>,
<tt>d</tt>, and <tt>l</tt> specify the use of <i>short</i>, <i>single</i>,
<i>double</i>, and <i>long</i> precision, respectively.  (When fewer
than four internal
inexact
representations exist, the four size
specifications are mapped onto those available.  For example, an
implementation with two internal representations may map short and
single together and long and double together.)  In addition, the
exponent marker <tt>e</tt> specifies the default precision for the
implementation.  The default precision has at least as much precision
as <i>double</i>, but
implementations may wish to allow this default to be set by the user.<p>

<tt><p>3.14159265358979F0<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Round&nbsp;to&nbsp;single&nbsp;---&nbsp;3.141593<br>
0.6L0<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;Extend&nbsp;to&nbsp;long&nbsp;---&nbsp;.600000000000000<p></tt><p>

<a name="%_sec_6.2.5"></a>
<h3><a href="r5rs-Z-H-2.html#%_toc_%_sec_6.2.5">6.2.5&nbsp;&nbsp;Numerical operations</a></h3><p>

The reader is referred to section&nbsp;<a href="r5rs-Z-H-4.html#%_sec_1.3.3">1.3.3</a> 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.<p>

<p>

<p><div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_240"></a>number?<i> obj</i>)</tt>&nbsp;</div>

<div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_242"></a>complex?<i> obj</i>)</tt>&nbsp;</div>

<div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_244"></a>real?<i> obj</i>)</tt>&nbsp;</div>

<div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_246"></a>rational?<i> obj</i>)</tt>&nbsp;</div>

<div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_248"></a>integer?<i> obj</i>)</tt>&nbsp;</div>
<p>

These numerical type predicates can be applied to any kind of
argument, including non-numbers.  They return <tt>#t</tt> if the object is
of the named type, and otherwise they return <tt>#f</tt>.
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 <em>z</em> is an inexact complex number, then <tt>(real? <em>z</em>)</tt> is true if
and only if <tt>(zero? (imag-part <em>z</em>))</tt> is true.  If <em>x</em> is an inexact
real number, then <tt>(integer? <em>x</em>)</tt> is true if and only if
<tt>(= <em>x</em> (round <em>x</em>))</tt>.<p>

<tt><p>(complex?&nbsp;3+4i)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(complex?&nbsp;3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(real?&nbsp;3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(real?&nbsp;-2.5+0.0i)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(real?&nbsp;#e1e10)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(rational?&nbsp;6/10)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(rational?&nbsp;6/3)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(integer?&nbsp;3+0i)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(integer?&nbsp;3.0)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(integer?&nbsp;8/4)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><p></tt><p>

<blockquote><em>Note:&nbsp;&nbsp;</em>
The behavior of these type predicates on inexact numbers
is unreliable, since any inaccuracy may affect the result.
</blockquote><p>

<blockquote><em>Note:&nbsp;&nbsp;</em>
In many implementations the <tt>rational?</tt> procedure will be the same
as <tt>real?</tt>, and the <tt>complex?</tt> procedure will be the same as
<tt>number?</tt>, 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.
</blockquote><p>

<p><p>

<p><div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_250"></a>exact?<i> <em>z</em></i>)</tt>&nbsp;</div>

<div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_252"></a>inexact?<i> <em>z</em></i>)</tt>&nbsp;</div>
<p>

These numerical predicates provide tests for the exactness of a