Lecture 2026-02-10

vectors

Primitive data structure: the array

• a "slice" of memory

• a sequence of consecutive memory

will dicuss at length when we return to C.

• Racket ( Schmee) : the vector

  • used much like traditional array

    • Unlike arrays- can hold items of any size ( unlimited integers, strings, whatever )

Vectors in racket.

(define x (vector `blue #t "you"))  3-item vector
 
(define y (make-vector 10))
(define y (make-vector 10 5))
(define z (build-vector 10 sqr) 

(vector-ref y 7) => 49
(vector-set! y 7 50 ) 
(vector-ref y 7 ) => 50

• Main advantage of vectors over lists:

  • vector-set! runs in O(1) time

• Main disadvantages of vectors over lists:

  • size is fixed

  • diifficult to add or remove elements

  • tends to force an imperative style

    • Imagine map, adds cons and cons until recursion bottles out,

      • Thus list is built incremently. this is exactly how lists work in racket.

        • BUT since vectors cannot grow, TO USE VECTORS, one may deduce the size of the vector BEFORE HAND

          • THEN MUTATE THE VALUES IN THE VECTOR.

            • THIS IS AN INHERENTLY NON-FUNCTIONAL WAY TO GO ABOUT IT.

lets build my-build-vector

(define (my-build-vector n f )
     ( define res ( make-vector n))
          (define (mbv-h i)
          (cond
          [(= i n) empty]
          [ (vector-set! res i (f i ))
                   (mbv-h) (+ i 1 ))]))
                   (mbv-h 0))

• Observe that it creates the result first before modifying contents.

• Vectors work well with imperative-style algorithms

  • for, for/vector in Racket helps with this.

(define (my-build-vector n f)
 (define res (make-vector n))
(for ([i n ])
      (vector-set! res ii (f i )))
      res)

• What's a macro

  • A way of building your own syntax in Racket/Scheme

  A function whose input and output are syntax !

  • for being a macro, thus translates to another scheme and racket code that actually operates as advertised !

    • Hence we can mostly use it as a function

(define (my-build-vector n f)
   (for/vector
   ;; returns a loop and runs through all the things and puts them in a vector !
   ([i n ]) (f i )))

;; sums the elements in a vector

PURELY FUNCTIONAL IMPLEMENTATION OF SUM-VECTOR

(define (sum-vector vec)
     (define (sv-h i acc)
        (cond
         [(= i (vector-length vec)) acc]
         [else 
         ( sv-h (+ i 1 ) ( + acc ( vector-ref vec i )))])
         (sv-h i 0   0)
         )
       
       ;; think how can i prove this with induction on an invariant.

• Doesn't this look like a loop? We have seen anything with tail recursion may likely be rewritten as a loop

NOT PURELY FUNCTIONAL IMPLEMENTATION OF SUM-VECTOR

(define (sum-vector vec)
   (define sum 0)
   (for [i ([vector-length vec)])
       (set! sum ( + sum (vector-ref vec i)))
       sum)

• notice how if we are only given sum-vector it would be impossible to know if its functional or not.

  • Hence:

Not pure functional— since uses mutation. But looks purely functional.

• use of mutation confined to the intervals of sum-vector

• can't be detected outside the function

• outsiders could consider it functional !

• Providees a strategy for keeping problems with mutation udner control

  • Hide it behind a pure functional interface

Recall:

• How does this work

  • Memory only holds for fixed-size data !

    • But there's still unlimited numbers?

    • strings?

Recall:

What does this output (4 )

(define (mutate-posn p)
    (set-posn-x! p ( + 1 ( posn-x p))))
    (define p (posn 3 5 ))
    (mutate-posn pP
    (posn-x  p)

vs.

What does this output ? ( 3)

void mutate (struct posN p){
p.x +=1;
}
int main(){
struct posn p = {3,5};
mutate(p);
printf("%d\n", p.x);
}

• directly translating in C we realize doesn't work!

Racket structs aren't like C structs

• the struct is copied in Racket, but change to the fields still persist.

• the fields of a struct are boxed - they're pointers.

• Similarily, the items in a Racket vector are addresses that point to the actual contents ( which can then be any size )!

Similarily, the fields of a cons are pointers:

(cons 1 (cons `blue ( cons #t empty)))

Box + pointer diagram:

• Also since Racket is dynamically typed, the values 1, `blue, #t, must include type information.

  • More later.

"Vectors" in C: Arrays

• array: sequence of conseccutive memory locations.

e.g.

int main(){
int grades[10]; //arrays of 10 ints.
  for(int i=0;i<10;++i){
  scanf("%d", &grades[i]);
  ;;note the "define then mutate" theme that arises in non-functional
  ;; languages like C.
  ;; directly putting input from input stream into location at grade[i]
  )printf("%d\n", grades[i]);
  }
  for(int i=0;i<10;++i){
  acc+=grades[i];
  }
  printf("%d\n", acc/10);
}

a[i] - access i-th item of array n

int grades[10] // valid entries are grades[0],...,grades[9]

What happens if you go out of bounds? UB

Will it stop you? No.

Program may or may not crash.

• If not, data may be corrupted; no way to detect.

• can give the bounds implicity:

size of grades array

int main(){
int grades[] ={0,0,0,0,0};
printf("%d/n", sizeof(grades)/sizeoof(int));
}

• amt of space occupied by grades ( 20 bytes )

• amt of space an int occupies ( 4 bytes )