Computer Science Fundamentals (CS153 2004S)
[Skip to Body]
Primary:
[Front Door]
[Current]
[Glance]

[Honesty]
[Instructions]
[Links]
[Search]
Groupings:
[EBoards]
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Readings]
[Reference]
Misc:
[Experiments in Java]
[Java API]
[Scheme Reference]
[Scheme Report]
[CS153 2003S]
[CS151 2003F]
[CS152 2000F]
[SamR]
In previous labs, you've seen that it's possible to define complex
expressions from simpler expressions. For example, we might write the
following for
express
.
val
explicitly as a rational number
(/ (inexact>exact (numerator val)) (inexact>exact (denominator val)))
What happens when we want to try this expression using different values? One possibility is to redefine val and then reexecute the expression.
> (define val (sqrt 2)) > (/ (inexact>exact (numerator val)) (inexact>exact (denominator val))) 1592262918131443/1125899906842624 > (define val 5) > (/ (inexact>exact (numerator val)) (inexact>exact (denominator val))) 5 > (define val (exp 1)) 765128314358509/281474976710656
But this seems cumbersome. It would be nice to simply give a name to this expression and use that name. Unfortunately, our current way of naming doesn't quite work.
> (define val (sqrt 2)) > (define frac (/ (inexact>exact (numerator val)) (inexact>exact (denominator val))) > frac 1592262918131443/1125899906842624 > (define val 5) > frac 1592262918131443/1125899906842624
What's going on? Scheme evaluated the expression that accompnaies
frac
once, when it was first defined. Hence,
since the expression had a particular value once, it retains that
value forever.
What we'd really like to do is to say that
. You know that Scheme has procedures, since
you've used lots of builtin procedures, including frac
is a procedure that takes a value as an input and returns
an appropriate fractionsqrt
,
*
, cons
, and list
. But can you
define your own procedures? Yes.
You use define
to give names to procedures, just as you use it
to give names for values. The values just look different. The general
form of a procedure is
(lambda (formalparameters) expression)
For example, we might write our frac
procedure as
(define frac (lambda (val) (/ (inexact>exact (numerator val)) (inexact>exact (denominator val)))))
Our frac
procedure can now be called as if it were a builtin
procedure.
> (frac (sqrt 2)) 1592262918131443/1125899906842624 > (frac 5) 5 > (frac 22/7) 22/7
We can define procedures for anything we already know how to do in Scheme.
For example, here is a simple square
procedure.
(define square (lambda (n) (* n n)))
We can test it.
> (square 2) 4 > (square 4) 16 > (square square) *: expects type <number> as 1st argument, given: #<procedure:square>; other arguments were: #<procedure:square> > (square 'a) *: expects type <number> as 1st argument, given: a; other arguments were: a
Convention in Scheme (and all programming languages) is that we carefully document what our procedures do, including input values, output values, and assumptions. We use comments provide information to the reader of our program (that is, to people instead of the computer). In Scheme, comments begin with a semicolon and end with the end of the line.
;;; Samuel A. Rebelsky ;;; Department of Mathematics and Computer Science ;;; Grinnell College ;;; rebelsky@cs.grinnell.edu ;;; Procedue: ;;; square ;;; Parameters: ;;; val, a number ;;; Purpose: ;;; Compute val*val ;;; Produces: ;;; The result of the computation ;;; Preconditions: ;;; val must be a number ;;; Postconditions: ;;; The result is the same "type" of number as val (e.g., if ;;; val is an integer, so is the result; if val is exact, ;;; so is the result). ;;; Citations: ;;; Based on code created by John David Stone dated March 17, 2000 ;;; and contained in the Web page ;;; http://www.math.grin.edu/~stone/courses/scheme/proceduredefinitions.xhtml ;;; Changes to ;;; Parameter names ;;; Formatting ;;; Comments (define square (lambda (value) (* value value)))
Yes, that's a lot of documentation for very little code. However, it is better to err on the side of too much documentation than too little documentation. More importantly, as you start writing more procedures, their purpose and details will be much less obvious. Finally, when you carefully document procedures, you begin to think more carefully about what they really need to do and how you ensure that they do so for all cases.
Here's another set of documentation, this time for the frac
procedure that we wrote earlier.
When documenting frac
, we are forced to think about (1) what
kinds of numbers it works on (in this case, it doesn't work on complex
numbers); (2) what, precisely, the relationship of the result to the
input is; and (3) what type the result has.
;;; Procedure: ;;; frac ;;; Parameters: ;;; val, a number ;;; Purpose: ;;; Express val as a fraction. ;;; Procedues: ;;; rat, a rational number. ;;; Preconditions: ;;; val cannot be complex. ;;; Postconditions: ;;; rat is exact. ;;; rat is approximately equal to val (within some unknown level ;;; of accuracy). ;;; rat is the ratio of two integers. (define frac (lambda (val) (/ (inexact>exact (numerator val)) (inexact>exact (denominator val)))))
At times, we will want to write procedures that take more than one parameter. Such procedures look just like procedures with one parameter, except that you can list more parameters between the parentheses.
(lambda (param_{1}, param_{2} ... param_{n}) expression )
For example, here is a simple procedure that finds the average of two nubmers
;;; Samuel A. Rebelsky ;;; Department of Mathematics and Computer Science ;;; Grinnell College ;;; rebelsky@cs.grinnell.edu ;;; Procedure: ;;; pairave ;;; Parameters: ;;; val1, an exact number ;;; val2, an exact number ;;; Purpose: ;;; Compute the average of two numbers. ;;; Produces: ;;; ave, The average of those two numbers. ;;; Preconditions: ;;; Both val1 and val2 are exact numbers. ;;; Postconditions: ;;; ave is an exact number. ;;; ave is equidistant from val1 and val2. That is ;;; (abs ( val1 ave)) equals (abs ( val2 ave)) (define pairave (lambda (val1 val2) (/ (+ val1 val2) 2)))
As this example may suggest, in your documentation it is particularly important to think about what you can guarantee about the results of your procedure. In this case, what does it mean to be the average of two values.
Scheme provides many other ways to define procedures. As you saw in our
discussion in class, you can build procedures by applying procedures to
other procedures (e.g., you can compose square
and
increment
). In addition, there is a different syntax for
defining simple procedures. Instead of using the lambda notation, you
can put the procedure name and its parameters in parentheses, as in
(define (pairave val1 val2) (/ (+ val1 val2) 2))
If you see a procedure defined in this way, you can think to yourself that it's just an alternate representation of the lambdastyle definition. We prefer that you use the lambdastyle definitions at this point in your career, because you will find some experience with lambdas useful later.
Monday, 4 September 2000 [Samuel A. Rebelsky]
http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2000F/Readings/proceduredefinitions.html
.
Wednesday, 31 January 2001 [Samuel A. Rebelsky]
Six P'sstyle.
http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2001S/Readings/procedures.html
.
Monday, 9 September 2002 [Samuel A. Rebelsky]
http://www.cs.grinnell.edu/~rebelsky/Courses/CS151/2002F/Readings/procedures.html
.
Wednesday, 22 January 2003 [Samuel A. Rebelsky]
Friday, 24 January 2003 [Samuel A. Rebelsky]
frac
.
http://www.cs.grinnell.edu/~rebelsky/Courses/CS153/2003S/Readings/procedures.html
.
Thursday, 22 January 2004 [Samuel A. Rebelsky]
[Skip to Body]
Primary:
[Front Door]
[Current]
[Glance]

[Honesty]
[Instructions]
[Links]
[Search]
Groupings:
[EBoards]
[Examples]
[Exams]
[Handouts]
[Homework]
[Labs]
[Outlines]
[Readings]
[Reference]
Misc:
[Experiments in Java]
[Java API]
[Scheme Reference]
[Scheme Report]
[CS153 2003S]
[CS151 2003F]
[CS152 2000F]
[SamR]
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 Fri May 7 09:44:37 2004.
The source to the document was last modified on Thu Jan 22 22:26:28 2004.
This document may be found at http://www.cs.grinnell.edu/~rebelsky/Courses/CS153/2004S/Readings/procedures.html
.
You may wish to validate this document's HTML ; ; Check with Bobby
Samuel A. Rebelsky, rebelsky@grinnell.edu