r5rs-z-h-9.html

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

<blockquote><em>Rationale:&nbsp;&nbsp;</em> 
The above definition of <tt>eqv?</tt> allows implementations latitude in
their treatment of procedures and literals:  implementations are free
either to detect or to fail to detect that two procedures or two literals
are equivalent to each other, and can decide whether or not to
merge representations of equivalent objects by using the same pointer or
bit pattern to represent both.
</blockquote><p>

<p><p>

<p><div align=left><u>procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_216"></a>eq?<i> <i>obj<sub>1</sub></i> <i>obj<sub>2</sub></i></i>)</tt>&nbsp;</div>
<p>

<tt>Eq?</tt> is similar to <tt>eqv?</tt> except that in some cases it is
capable of discerning distinctions finer than those detectable by
<tt>eqv?</tt>.<p>

<tt>Eq?</tt> and <tt>eqv?</tt> are guaranteed to have the same
behavior on symbols, booleans, the empty list, pairs, procedures,
and non-empty
strings and vectors.  <tt>Eq?</tt>'s behavior on numbers and characters is
implementation-dependent, but it will always return either true or
false, and will return true only when <tt>eqv?</tt> would also return
true.  <tt>Eq?</tt> may also behave differently from <tt>eqv?</tt> on empty
vectors and empty strings.<p>

<tt><p>(eq?&nbsp;'a&nbsp;'a)&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;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(eq?&nbsp;'(a)&nbsp;'(a))&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;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(eq?&nbsp;(list&nbsp;'a)&nbsp;(list&nbsp;'a))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#f</tt><br>
(eq?&nbsp;&quot;a&quot;&nbsp;&quot;a&quot;)&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;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(eq?&nbsp;&quot;&quot;&nbsp;&quot;&quot;)&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;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(eq?&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;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(eq?&nbsp;2&nbsp;2)&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;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(eq?&nbsp;#<tt>\</tt>A&nbsp;#<tt>\</tt>A)&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(eq?&nbsp;car&nbsp;car)&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;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(let&nbsp;((n&nbsp;(+&nbsp;2&nbsp;3)))<br>
&nbsp;&nbsp;(eq?&nbsp;n&nbsp;n))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><br>
(let&nbsp;((x&nbsp;'(a)))<br>
&nbsp;&nbsp;(eq?&nbsp;x&nbsp;x))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(let&nbsp;((x&nbsp;'#()))<br>
&nbsp;&nbsp;(eq?&nbsp;x&nbsp;x))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(let&nbsp;((p&nbsp;(lambda&nbsp;(x)&nbsp;x)))<br>
&nbsp;&nbsp;(eq?&nbsp;p&nbsp;p))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><p></tt><p>

<p>

<blockquote><em>Rationale:&nbsp;&nbsp;</em> It will usually be possible to implement <tt>eq?</tt> much
more efficiently than <tt>eqv?</tt>, for example, as a simple pointer
comparison instead of as some more complicated operation.  One reason is
that it may not be possible to compute <tt>eqv?</tt> of two numbers in
constant time, whereas <tt>eq?</tt> implemented as pointer comparison will
always finish in constant time.  <tt>Eq?</tt> may be used like <tt>eqv?</tt>
in applications using procedures to implement objects with state since
it obeys the same constraints as <tt>eqv?</tt>.
</blockquote><p>

<p><p>

<p><div align=left><u>library procedure:</u>&nbsp;&nbsp;<tt>(<a name="%_idx_218"></a>equal?<i> <i>obj<sub>1</sub></i> <i>obj<sub>2</sub></i></i>)</tt>&nbsp;</div>
<p>

<tt>Equal?</tt> recursively compares the contents of pairs, vectors, and
strings, applying <tt>eqv?</tt> on other objects such as numbers and symbols.
A rule of thumb is that objects are generally <tt>equal?</tt> if they print
the same.  <tt>Equal?</tt> may fail to terminate if its arguments are
circular data structures.<p>

<tt><p>(equal?&nbsp;'a&nbsp;'a)&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;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(equal?&nbsp;'(a)&nbsp;'(a))&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>
(equal?&nbsp;'(a&nbsp;(b)&nbsp;c)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;'(a&nbsp;(b)&nbsp;c))&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>
(equal?&nbsp;&quot;abc&quot;&nbsp;&quot;abc&quot;)&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>
(equal?&nbsp;2&nbsp;2)&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;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(equal?&nbsp;(make-vector&nbsp;5&nbsp;'a)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(make-vector&nbsp;5&nbsp;'a))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<tt>#t</tt><br>
(equal?&nbsp;(lambda&nbsp;(x)&nbsp;x)<br>
&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;(lambda&nbsp;(y)&nbsp;y))&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;&nbsp;===&gt;&nbsp;&nbsp;<i>unspecified</i><p></tt><p>

<p><p>

<a name="%_sec_6.2"></a>
<h2><a href="r5rs-Z-H-2.html#%_toc_%_sec_6.2">6.2&nbsp;&nbsp;Numbers</a></h2><p>


<a name="%_idx_220"></a><p>



<p>

Numerical computation has traditionally been neglected by the Lisp
community.  Until Common Lisp there was no carefully thought out
strategy for organizing numerical computation, and with the exception of
the MacLisp system [<a href="r5rs-Z-H-14.html#%_sec_7.3">20</a>] little effort was made to
execute numerical code efficiently.  This report recognizes the excellent work
of the Common Lisp committee and accepts many of their recommendations.
In some ways this report simplifies and generalizes their proposals in a manner
consistent with the purposes of Scheme.<p>

It is important to distinguish between the 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 <i>number</i>, <i>complex</i>, <i>real</i>,
<i>rational</i>, and <i>integer</i> to refer to both mathematical numbers
and Scheme numbers.  Machine representations such as fixed point and
floating point are referred to by names such as <i>fixnum</i> and
<i>flonum</i>.<p>


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


<a name="%_idx_222"></a><p>



Mathematically, numbers may be arranged into a tower of subtypes
in which each level is a subset of the level above it:
<p>
         number <br>
&nbsp;&nbsp;&nbsp; complex <br>
&nbsp;&nbsp;&nbsp; real <br>
&nbsp;&nbsp;&nbsp; rational <br>
&nbsp;&nbsp;&nbsp; integer 
<p><p>

For example, 3 is an integer.  Therefore 3 is also a rational,
a real, and a complex.  The same is true of the Scheme numbers
that model 3.  For Scheme numbers, these types are defined by the
predicates <tt>number?</tt>, <tt>complex?</tt>, <tt>real?</tt>, <tt>rational?</tt>,
and <tt>integer?</tt>.<p>

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


Scheme's numerical operations treat numbers as abstract data, as
independent of their representation as possible.  Although an implementation
of Scheme may use fixnum, flonum, and perhaps other representations for
numbers, this should not be apparent to a casual programmer writing
simple programs.<p>

It is necessary, however, to distinguish between numbers that are
represented exactly and those that may 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.<p>

<a name="%_sec_6.2.2"></a>
<h3><a href="r5rs-Z-H-2.html#%_toc_%_sec_6.2.2">6.2.2&nbsp;&nbsp;Exactness</a></h3><p>


<a name="%_idx_224"></a> 
Scheme numbers are either <i>exact</i> or <i>inexact</i>.  A number is
exact if it was written as an exact constant or was derived from
exact numbers using only exact operations.  A number is
inexact if it was written as an inexact constant,
if it was
derived using inexact ingredients, or if it was derived using
inexact operations. Thus inexactness is a contagious
property of a number.

If two implementations produce exact results for a
computation that did not involve inexact intermediate results,
the two ultimate results will be mathematically equivalent.  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.<p>

Rational operations such as <tt>+</tt> 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.
See section&nbsp;<a href="#%_sec_6.2.3">6.2.3</a>.<p>

With the exception of <tt>inexact-&gt;exact</tt>, 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.<p>

<a name="%_sec_6.2.3"></a>
<h3><a href="r5rs-Z-H-2.html#%_toc_%_sec_6.2.3">6.2.3&nbsp;&nbsp;Implementation restrictions</a></h3><p>

<a name="%_idx_226"></a><p>

Implementations of Scheme are not required to implement the whole
tower of subtypes given in section&nbsp;<a href="#%_sec_6.2.1">6.2.1</a>,
but they must implement a coherent subset consistent with both the
purposes of the implementation and the spirit of the Scheme language.
For example, an implementation in which all numbers are real
may still be quite useful.<p>