(define (foo f x y z) (f (f x y) z))
(define (bar x y) (+ (* 2 x) y))


(define (map f xs)
        (if (null? xs)
            xs
            (cons (f (car xs)) (map f (cdr xs)))))


(define (mathgraph g f xstep xmax ymax)
  (do ((x (- 0 xmax) (+ x xstep)))
      ((>= x xmax) #f)
    (graphics-draw-point g (/ x xmax) (/ (f x) ymax))))


(define (adder n) (lambda (m) (+ m n)))

(define (app2 f) (lambda (x) (f (f x))))

(define (scale f w h)
  (lambda (x) (/ (f (* x w)) h)))


(define (transform f dx dy)
  (lambda (x) (+ (f (- x dx)) dy))) 

(define (sigma fs)
  (if (null? fs)
      (lambda (x) 0)
    (lambda (x) (+ ((car fs) x) ((sigma (cdr fs)) x)))))


(define (make-vect x y) (cons x (cons y '())))
(define (x-cor-vect p) (car p))
(define (y-cor-vect p) (car (cdr p)))


(define (add-vect p0 p1)
  (make-vect (+ (x-cor-vect p0) (x-cor-vect p1))
             (+ (y-cor-vect p0) (y-cor-vect p1))))

(define (sub-vect p0 p1)
  (make-vect (- (x-cor-vect p0) (x-cor-vect p1))
             (- (y-cor-vect p0) (y-cor-vect p1))))

(define (scale-vect c p)
  (make-vect (* c (x-cor-vect p)) (* c (y-cor-vect p))))


(define (nth xs n)
  (if (= n 0) (car xs) (nth (cdr xs) (- n 1))))
(define (make-frame g o u v)  (cons g (cons o (cons u (cons v '())))))
(define (graphics-device-frame frame) (nth frame 0))
(define (origin-frame frame) (nth frame 1))
(define (edge1-frame frame) (nth frame 2))
(define (edge2-frame frame) (nth frame 3))

(define (frame-coord-map frame)
  (lambda (p)
    (let* ((x (x-cor-vect p)) (y (y-cor-vect p))
           (o (origin-frame frame))
           (u (edge1-frame frame))
           (v (edge2-frame frame)))
      (add-vect o (add-vect (scale-vect x u) (scale-vect y v))))))


(define (frame-draw-line x1 y1 x2 y2)
  (lambda (frame) 
    (let* ((f (frame-coord-map frame))
           (p1 (f (make-vect x1 y1)))
           (p2 (f (make-vect x2 y2)))
           (x1_ (x-cor-vect p1)) (y1_ (y-cor-vect p1))
           (x2_ (x-cor-vect p2)) (y2_ (y-cor-vect p2)))
      (graphics-draw-line (graphics-device-frame frame) x1_ y1_ x2_ y2_))))

(define PI_2 (acos 0))
(define PI (acos -1))
(define star
  (lambda (frame)
    (do ((delta (/ (* 2 PI) 5) delta)
       (i 0 (+ i 1))
       (theta PI_2 (+ theta delta)))
      ((>= i 5) #f)
      ((frame-draw-line
                (cos theta) (sin theta)
                (cos (+ theta delta delta)) (sin (+ theta delta delta)))
                frame))))


(define (default-frame g)
  (make-frame g (make-vect 0 0) (make-vect 1 0) (make-vect 0 1)))

(define (run-painter g painter)
  (painter (default-frame g)))

(define (transform-painter painter o u v)
  (lambda (frame)
    (let* ((m (frame-coord-map frame))
           (o1 (m o))
           (u1 (sub-vect (m (add-vect u o)) o1))
           (v1 (sub-vect (m (add-vect v o)) o1)))
      (painter (make-frame (graphics-device-frame frame) o1 u1 v1)))))

(define (flip-vert painter)
  (transform-painter painter (make-vect 0 0) (make-vect 1 0) (make-vect 0 -1)))
      
(define (rotate90 painter)
  (transform-painter painter (make-vect 0 0) (make-vect 0 1) (make-vect -1 0)))

(define (beside painter1 painter2)
  (let ((left  (transform-painter painter1 (make-vect -0.5 0)
                                  (make-vect 0.5 0) (make-vect 0 1)))
        (right (transform-painter painter2  (make-vect 0.5 0)
                                  (make-vect 0.5 0) (make-vect 0 1))))
    (lambda (frame)
      (left frame) (right frame))))


(define (null-painter frame) #f)     

(define (right-split painter n)
  (if (= n 0)
      null-painter
    (let ((smaller (right-split painter (- n 1))))
      (beside painter (below smaller smaller)))))

(define (filter p xs)
        (if (null? xs) 
            xs
            (if (p (car xs))
                (cons (car xs) (filter p (cdr xs)))
                (filter p (cdr xs)))))

(define (iterate a f p)
        (if (p a) 
            '()
            (cons a (iterate (f a) f p))))                

(define (2-to n)
        (iterate 2 (lambda (x) (+ x 1))
                   (lambda (x) (> x n))))

(define (non-zero? n) (not (zero? n)))
(define (sieve xs)
        (let ((p (lambda (x) (non-zero? (modulo x (car xs))))))
             (filter p xs)))

(define (prime-to n)
        (map car (iterate (2-to n) sieve null?)))