---
title: Eboard 26  Vectors
number: 26
section: eboards
held: 2017-10-30
---
CSC 151.01, Class 26:  Vectors
==============================

_Overview_

* Preliminaries
    * Notes and news
    * Upcoming work
    * Extra credit
    * Notes on Quiz 9
    * Questions
* Lab
* Debrief

### News / Etc.

* Welcome to any prospective students here for Discover Grinnell!
* Grading still isn't done.  I need less paperwork.
* Congratulations to Singers for an excellent and moving concert.
* Congratulations to Volleyball for making the Midwest Conference
  Tournament.
* Congratulations to Men's and Women's Soccer for making the Midwest
  Conference Tournament.

### Upcoming Work

* [Writeup for class 25](../writeups/writeup25) due Monday at 10:30 p.m.
    * Exercises 1 and 3.
    * Hand to: Sam (or under Sam's door)
* [Writeup for class 26](../writeups/writeup26) due Wednesday at 10:30 p.m.
    * Exercise 5.  No documentation necessary.  (But it would be nice and
      good practice.)
    * To: <csc151-01-grader@grinnell.edu>
    * Subject: CSC 151.01 Writeup 26 (YOUR NAMES)
* [Assignment 6](../assignments/assignment06) due TOMORROW.
* Read [Binary trees](../readings/binary-trees) for Wednesday's class.
    * Yes, it's ready!

### Extra credit (Academic/Artistic)

* CS Table, Tuesday at noon: TBD
* Halloween Organ Thing, Tuesday evening in Herrick Chapel.
* Rebirth Brass Band, Wednesday at 7:30 p.m. in Herrick.
* CS Extras, Thursday at 4:15 p.m.: "Building your own programming language and other reasons to go to graduate school"

### Extra credit (Peer)

### Extra credit (Misc)

### Other good things

### Notes on Quiz 9

Two common problems: Named let and tail-recursive tally.

#### Named let

Original:

```
(define factorial
  (lambda (n)
    (fact-helper 1 n)))

(define fact-helper
  (lambda (ans-so-far k)
    (if (zero? k)
        ans-so-far
        (fact-helper (* k ans-so-far)
                     (- k 1)))))
```

Ideas of named let

* Put the helper inside the primary procedure; others don't need it.
* Put the parameters and the initial values together.
* (Strange syntax)
* The body of the helper should not change, except that you may change
  the name of the helper.

Form

```
(let NAME ([PARAM-1 INITIAL-1]
           [PARAM-2 INITIAL-2])
  BODY)
```

Revised

```
(define factorial
  (lambda (n)
    (let kernel ([ans-so-far 1]
                 [k n])
      (if (zero? k)
          ans-so-far
          (kernel (* k ans-so-far)
                  (- k 1))))))
```

* (Eventually, you will just write the helpers within the procedure,
  rather than write them separately and move them within the procedure.)

#### Tail-recursive list tally

* Idea: We use a helper to keep track of both the tally and what
  we have left to explore.
* When we're done, the tally should be done; no need to backtrack.

Chart

```
tally   remaining
-----   ---------
0       '(5 -2 1 4 3 -7)
1       '(-2 1 4 3 -7)
1       '(1 4 3 -7)
2       '(4 3 -7)
3       '(3 -7)
4       '(-7)
4       '()
```

Code

```
(define tally-positive
  (lambda (lst)
    (let kernel ([tally 0]
                 [remaining lst])
      (cond
        [(null? remaining)
         tally]
        [(positive? (car remaining))
         (kernel (increment tally) (cdr remaining))]
        [else
         (kernel tally (cdr remaining))]))))
```

### Questions

Why do you tell us not to use quote to create lists?
  : If you haven't thought deeply enough about it, you don't get the
    results you expect. `'(5 (sqrt 4))`
  : For really simple lists, it's fine.  For other things, it can make
    your brain hurt.

Why is it that grabbing the ith element of a vector is faster than
grabbing the ith element of a list?

On problem 2, can we use reverse?
  : No

Can we use `equal?`
  : I suppose, but char=? is better.

Lab
---

The correct path is "/home/rebelsky/Desktop/pg1260.txt"

Writeup: Exercise 5.  Call it `my-vector-fill!`.  Do not use the existing
`vector-fill!`

Debrief
-------

Why did we see inconsistent times to build a list of random elements from a vector?
  : Four key operations: Find the length.  Choose a random number.  Get
    that element from the vector.  Add that element to a new list.
  : The first three should be consistent.  It turns out that adding an
    element to a list is less consistent than you might expect.  You won't
    notice it for a few elements, but you may notice it for a lot.
  : I expect that the timer is also not perfect.

Why are the cpu times all multiples of four?
  : Perhaps the granularity of the timer is 1/250 of a second.

Why doesn't my `my-vector-fill!` work?  (What are your common "helpful" 
comments.)
  : Remember that `vector-set!` does not return anything.  If you want to 
    recurse with the vector, you'll need to do a sequence of statements.
  : Remember that if you use `cond` or `when` you can have multiple
    consequents.
  : Don't create a new vector.
  : Reindent.

