Held: Monday, 26 January 2015

Back to Outline 03 - An Introduction to Scheme. On to Outline 05 - Drawings as Values.

Summary

We explore a bit more about data in Scheme, particularly the ways in which our version of Scheme supports numbers.

Related Pages

• Reading: Symbolic Values
• Reading: Numeric Values
• Lab: Numeric Values
• Lab writeup: http://bit.ly/151-2015S-lab04
• Morning EBoard 4 (Source a.m. 4)
• Afternoon EBoard 4 (Source p.m. 4)

Overview

• Values and types.
• Kinds of numbers.
• The modulo operation.

Administrivia

• New partners! (For today and tomorrow.)
• Office Hours:
  • Normally: 10:00-11:00 MTWF, 3:15-4:00 M
  • Currently booked: 10:30-11:00 M, 10:45-11:00 Tu, 10:00-11:00 F (well, it will be).
  • Reserve a slot at https://rebelsky.youcanbook.me/.
• How many people would use lab tutors on Sundays from 3-5 pm if we added a shift then?
• Homework comments:
  • My goal is that homework should be no more than three hours. If you're finding that it's taking much more (or that you're on track to take much more), you should talk to me.
  • I hear that getting three Grinnellians together is hard. I'll shoot for partners on most remaining assingnments.

Upcoming Work

• Assignment 2.
  • Due Tuesday at 10:30 p.m.
• Lab writeup for lab 4, due Wednesday at 10:30 p.m.: Problem 2, parts d,e,f. http://bitly.com/151-2015S-lab04
• Readings for Tuesday:
  • Drawings as Values

Extra Credit Opportunities

Academic

• Friday, 12:10 p.m., JRC 224A (Day PDR), CS Table, "Redundant Arrays of Inexpensive Disks" (copies outside my office)

Peer Support (Morning Section)

• Swimming, Friday, January 30, 6:30 p.m., Osgood Natatorium
• Swimming, Saturday, January 31, noon, Osgood Natatorium
• Julia's radio show, "The Hot Box". Wednesday night/Thursday morning 1:00-2:00 a.m.

Peer Support (Afternoon Section)

• Men's Baskeball, Tuesday, 7 p.m., New Darby
• Meditation group, Saturday, 4 p.m., CRSSJ
• Meditation group, Wednesday, 9:00 p.m., CRSSJ
• Swimming, Friday, January 30, 6:30 p.m., Osgood Natatorium
• Swimming, Saturday, January 31, noon, Osgood Natatorium
• Men's Tennis, Saturday, January 31, Field House

Recommended Events (no EC unless mentioned above)

• Women's Basketball, Tuesday, 5pm, New Darby
• Belly Dance Club, to be scheduled
• Salsa Club, Tuesdays at 7pm and Saturdays at 2pm
• Meditation group, Wednesdays at 9:00 and Sundays at 4:00 in CRSSJ
• #OneGrinnell, Wednesday, February 4 at 4:15 p.m.

Types

• If you reflect on the first algorithms we wrote, you'll note that we worked with different kinds of things (e.g., knives, jars, bags).
• While there are some commonalities between what you do with things (e.g., you can drop a knife or jar or bag on the floor), different things often imply different operations (e.g., you can unscrew a jar, but not a knife).
• Computer scientists use the term type to refer to the things/values we work with.
• In order to design algorithms, we need to know what kinds of operations the computer already knows. Typically, these operations are associated with types. For example, you can multiply numbers and concatenate strings. (You can't do much at all with symbols, other than make them and compare them.)
• As you may have noted in your first experiments with Scheme, Scheme assigns types to values.
• For example, a value might be a number, or a string, or a procedure, or ....
• Computer scientists often think of types in two different ways:
  • Data-driven: A type is a set of values.
  • Purpose-driven: A type provides information on the valid operations that may be applied to a piece of data.
• We will alternate between the two definitions.
• Many languages (particularly the ones you've reported being familiar with) require you to assign a type to a variable when you declare that variable.
• Scheme does not require you to assign types ot variables; it checks the type of each operand when it executes a procedure.
  • Scheme also provides procedures that let you determine the type of a value.
• As the semester progresses, you will learn new types.
• As you learn each type, you'll learn a variety of things (that correspond, in some sense, to those two approaches):
  • How to express values in the type. For example, we express string values by surrounding them with double-quotation-marks and we express numbers in much the way we always have.
  • What operations are possible on values in the type. For example, we can use the addition operation (+) on numbers and we can use the string-append operation on strings.
• Each time we encounter a type, I'll either tell you or ask you (or both) how you might express values and what obvious operations there are.

Lab

• Do the lab on numeric values
• Be prepared to reflect.

Scheme's Numeric Types

• Instead of a general "numbers" type, Scheme provides a variety of kinds of numbers.
• Integers are numbers without a fractional component.
• Rational numbers can be expressed as the ratio of two integers.
• Real numbers appear somewhere on the number line.
  • In mathematics, real numbers can be rational or irrational.
  • In Scheme, real numbers are all rational.
• Complex numbers may include an imaginary component.
• You can (almost) always use an integer when a real is expected, but you cannot always use a real when an integer is expected.
• Scheme also represents some numbers exactly and some numbers inexactly. (That is, it approximates some numbers.)
  • It certainly has to approximate irrational numbers.
  • But it also approximates many other numbers.
  • It may surprise you to see which numbers are represented inexactly. (We'll return to this issue later.)
• Some important numeric predicates (procedures that return true or false): number?, real?, integer?, exact?, and inexact?.

Modulo

• The mod (modulo, modulus) operation is one of the trickier operations we use in this class (and we use it a lot).
• Essentially, mod is used to break up the number line into even chunks.
  • If you mod by 7, you break the number line up into chunks of size 7.
  • If you mod by 23, you break the number line up into chunks of size 23.
• For each chunk, we start counting at 0.
• For example

Number line:  -9 -8|-7 -6 -5 -4 -3 -2 -1| 0  1  2  3  4  5  6| 7  8  9 10 11 
Modulo 7:      5  6| 0  1  2  3  4  5  6| 0  1  2  3  4  5  6| 0  1  2  3  4 

• The (modulo *i* *n*) operation allows us to cycle through the numbers between 0 and *n*-1.