[Current] [News] [Glance] [Discussions] [Instructions] [Search] [Links] [Handouts] [Outlines] [Readings] [Labs] [Homeworks] [Quizzes] [Exams] [Examples] [Fall2000.01] [Spring2000]
A Boolean value is a datum that reflects the outcome of a single
yes-or-no test. For instance, if one were to ask Scheme to compute whether
the empty list has five elements, it would be able to determine that it
does not, and it would signal this result by displaying the Boolean value
for ``no'' or ``false,'' which is #f
. There is only one other
Boolean value, the one meaning ``yes'' or ``true,'' which is
#t
. (These are called ``Boolean values'' in honor of the
logician George
Boole, who was the first to develop a satisfactory formal theory of
them.)
A predicate is a procedure that always returns a Boolean value. A
procedure call in which the procedure is a predicate performs some
yes-or-no test on its arguments. For instance, the predicate
number?
-- the question mark is part of the name of the
procedure -- takes one argument and returns #t
if that
argument is a number, #f
if it does not. Similarly, the
predicate even?
takes one argument, which must be an integer,
and returns #t
if the integer is even and #f
if
it is odd. The names of most Scheme predicates end with question marks,
and I recommend this useful convention even though it is not required by
the rules of the programming language.
Scheme provides a few predicates that let you test the ``type'' of value you're working with.
number?
tests whether its argument is a number.
symbol?
tests whether its argument is a symbol.
string?
tests whether its argument is a string.
procedure?
tests whether its argument is a
procedure.
boolean?
tests whether its argument is a Boolean
list?
tests whether its argument is a list.
Scheme provides one basic predicate for working with lists (other
than the list?
predicate).
null?
tests whether its argument is the empty list.
value.
Scheme provides a variety of predicates for testing equality.
eq?
tests whether its two arguments are identical, in
the very narrow sense of occupying the same storage location in the
computer's memory. In practice, this is useful information only if at
least one argument is known to be a symbol or a Boolean value.
eqv?
tests whether its two arguments ``should normally be
regarded as the same object'' (as the language standard declares). Note,
however, that two lists can have the same elements without being ``regarded
as the same object.'' Also note that in Scheme's view the number 5, which
is ``exact,'' is not necessarily the same object as the number 5.0, which
might be an approximation.
equal?
tests whether its two arguments are the same or,
in the case of lists, whether they have the same contents.
Scheme also provides many numeric predicates.
=
tests whether its arguments, which must all be
numbers, are numerically equal; 5 and 5.0 are numerically equal for this
purpose.
<
tests whether its arguments, which must all be
numbers, are in strictly ascending numerical order.
>
tests whether its arguments, which must all be
numbers, are in strictly descending numerical order.
<=
tests whether its arguments, which must all be
numbers, are in ascending numerical order, allowing equality.
>=
tests whether its arguments, which must all be
numbers, are in descending numerical order, allowing equality.
even?
tests whether its argument, which must be an
integer, is even.
odd?
tests whether its argument, which must be an
integer, is odd.
zero?
tests whether its argument, which must be a
number, is equal to zero.
positive?
tests whether its argument, which must be a
real number, is positive.
negative?
tests whether its argument, which must be a
real number, is negative.
Another useful Boolean procedure is not
, which takes one
argument and returns #t
if the argument is #f
and
#f
if the argument is anything else. For example, one can
test whether the square root of 100 is unequal to the absolute value of
negative twelve by giving the command
(not (= (sqrt 100) (abs -12)))
If Scheme says that the value of this expression is #t
, then
the two numbers are indeed unequal.
Two other useful Boolean procedures are and
and or
.
Can you guess what they do?
[Current] [News] [Glance] [Discussions] [Instructions] [Search] [Links] [Handouts] [Outlines] [Readings] [Labs] [Homeworks] [Quizzes] [Exams] [Examples] [Fall2000.01] [Spring2000]
Disclaimer Often, these pages were created "on the fly" with little, if any, proofreading. Any or all of the information on the pages may be incorrect. Please contact me if you notice errors.
This page may be found at http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2000F/Readings/boolean.html
Source text last modified Wed Sep 13 10:50:38 2000.
This page generated on Wed Sep 13 10:50:40 2000 by Siteweaver. Validate this page's HTML.
Contact our webmaster at rebelsky@grinnell.edu