# Boolean Values

In this lab, you will have the opportunity to explore a number of issues relating to predicates, Boolean values, and conditional operations.

Procedures covered in this lab include:

• Type predicates: `boolean?`, `integer?`, `list?`, `null?`, `number?`, `pair?`, `procedure?`, `symbol?`
• Equality comparators: `=`, `eq?`, `eqv?`, `equal?`,
• Numeric comparators: `<` (strictly less than), `<=` (less than or equal to), `=` (equal to), `>=` (greater than or equal to), `>` (strictly greater than)
• Boolean operations: `and`, `or`, `not`

## Exercises

### Exercise 0: Preparation

Although this laboratory focuses on Boolean operations, it also uses some numeric predicates. You may therefore want to rescan the reading on numbers.

After making sure that you're prepared, start DrScheme.

### Exercise 1: Type Predicates

Fill in a few interesting entries in following table. You need not fill int the whole table; simply do as much as you think gives you a good sense of the various predicates.

 5 5.0 'five "five" list #t #f (cons 'a null) null 'null () `number?` `symbol?` `string?` `procedure?` `boolean?` `list?`

### Exercise 2: Empty lists

Which of the following does Scheme consider an empty list?

• `null`
• `'null`
• `()`
• `(list 'a)`
• `(list)`
• `'nothing`

### Exercise 3: Equality

Consider the following definitions

```(define alpha (list 'a 'b 'c))
(define beta (list 'a 'b 'c))
(define gamma alpha)
(define delta (cons (car alpha) (cdr alpha)))
```

Determine which of the lists are `eq?`, `eqv?`, or `equal?`.

### Exercise 4: Reflection

What, if anything, did you find surprising in the results of the previous exercises?

By looking at the Scheme report, see if you can find a pair of values that are equal in the sense of `=` but not in the sense of `eqv`.

### Exercise 5: What is `not`?

a. What type is `not`?

### Exercise 6: Combining Boolean Values

Fill in the following tables for each of the operations `and` and `or`.

`and`

 First argument Second argument Result `#f` `#f` `#f` `#t` `#t` `#f` `#t` `#t`

`or`

 First argument Second argument Result `#f` `#f` `#f` `#t` `#t` `#f` `#t` `#t`

### Exercise 7: Ranges

a. Write a Boolean expression that determines if the value named by `grade` is between 0 and 100, inclusive.

b. Test that expression using different values of `grade`.

### Exercise 8: Exploring `and` and `or`

a. Determine the value `and` returns when called with no parameters.

b. Explain why you think the designers of Scheme had `and` return that value.

c. Determine the value `and` returns when called with integers as parameters.

d. Explain why you think the designers of Scheme had `and` return that value.

e. Determine the value `or` returns when called with no parameters.

f. Explain why you think the designers of Scheme had `or` return that value.

g. Determine the value `or` returns when called with only integers as parameters.

h. Explain why you think the designers of Scheme had `or` return that value.

If you are puzzled by some of the answers, you may want to look at the notes on this problem, available at the end of the lab.

### Exercise 9: Primitive Values

Define and test a Scheme predicate, `(primitive? val)`, that returns `#t` if val is a symbol, number, character, or Booelan value, and `#f` otherwise.

### Exercise 10: Between, Revisited

Define and test a Scheme predicate `between?` that takes three arguments, all real numbers, and determines whether the second one lies strictly between the first and third (returning `#t` if it is, `#f` if it is not). For example, 6 lies strictly between 5 and 13, so both `(between? 5 6 13)` and `(between? 13 6 5)` should have the value `#t`.

### Exercise 11: Triangulation

Three line segments can be assembled into a triangle if, and only if, the length of each of them is less than the sum of the lengths of the other two. Define a Scheme predicate `triangle?` that takes three arguments, all positive real numbers, and determines whether line segments of those three lengths (assumed to be measured in the same units) could be assembled into a triangle.

Note that you will have to use a combination of `and`s and `or`s to solve this problem.

### Exercise 12: Safer Computation

```;;; Procedure:
;;; Parameters:
;;;   x, a number [verified]
;;;   y, a number [verified]
;;; Purpose:
;;; Produces:
;;;   sum, a number.
;;; Preconditions:
;;; Postconditions:
;;;   sum = x + y
;;; Problems:
;;;   If either x or y is not a number, sum is #f.
(lambda (x y)
(and (number? x) (number? y) (+ x y))))
```

Define similar procedures, `safe-subtract` and `safe-multiply`, that confirm that their parameters are numbers before subtracting and multiplying, respectively.

What is the advantage of defining such procedures?

### Exercise 13: Safer Division

You may note that the divide procedure, `/`, produces an error if the divisor is 0. We might, therefore, hope for a safer version that returns `#f` rather than giving up, when the divisor is 0 (or when either dividend or divisor is not a number).

Define a procedure, `safe-divide`, that does just that.

### Exercise 14: Identifying Oddness

a. Consider the expression `(and (integer? x) (odd? x) x)`. What value does it return if `x` is not an integer? If `x` is even? If `x` is odd?

b. Using what you've determined about the previous expression, write a procedure, `(first-odd i1 i2 i3)`, that takes as parameters three integers and returns the first odd value. If none of the integers is odd, `first-odd` should return `#f`.

## Notes

### Notes on Problem 8

`(and)` has value true (`#t`) because `and` has a value of true if none of the parameters have value false. Since this calls has no parameters, none are false.

`(or)` has value false (`#f`) because `or` has value false if none of the parameters is non-false. Since this call has no parameters, none are non-false.

## History

Tuesday, 5 September 2006 [Samuel A. Rebelsky]

Friday, 8 September 2006 [Samuel A. Rebelsky]

• Deleted a problem that students find both confusing and obvious. (Thanks to MP, TC, and EJ for the suggestion to delete it.)

Saturday, 9 Septemer 2006 [Samuel A. Rebelsky]

Disclaimer: I usually create these pages on the fly, which means that I rarely proofread them and they may contain bad grammar and incorrect details. It also means that I tend to update them regularly (see the history for more details). Feel free to contact me with any suggestions for changes.

This document was generated by Siteweaver on Sun Feb 4 08:24:33 2007.
The source to the document was last modified on Sun Feb 4 08:24:31 2007.
This document may be found at `http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2006F/Labs/boolean.html`.

You may wish to validate this document's HTML ; ;

Samuel A. Rebelsky, rebelsky@grinnell.edu

Copyright © 2006 Samuel A. Rebelsky. This work is licensed under a Creative Commons Attribution-NonCommercial 2.5 License. To view a copy of this license, visit `http://creativecommons.org/licenses/by-nc/2.5/` or send a letter to Creative Commons, 543 Howard Street, 5th Floor, San Francisco, California, 94105, USA.