(defn sum-recur [term next a b]
  (if (> a b)
    0
    (+ (term a)
       (sum-recur term next (next a) b))))

(defn sum-iter [term next a b]
  (defn iter [a result]
    (if (> a b)
      result
      (iter (next a) (+ result (term a)))))
  (iter a 0))

(defn cube [n]
  (* n n n))
(defn inc [n]
  (+ n 1))

(defn simpsons-recur [f a b n]
  (def h (/ (- b a) n))
  (defn fapply [k]
    (f (+ a (* k h))))
  (defn add-two [k]
    (+ k 2))
  (* (/ h 3)
     (+
      (f a)
      (f b)
      (* 4 (sum-recur fapply add-two 1 n))
      (* 2 (sum-recur fapply add-two 2 (- n 1))))))

(defn simpsons-iter [f a b n]
  (def h (/ (- b a) n))
  (defn fapply [k]
    (f (+ a (* k h))))
  (defn add-two [k]
    (+ k 2))
  (* (/ h 3)
     (+
      (f a)
      (f b)
      (* 4 (sum-iter fapply add-two 1 n))
      (* 2 (sum-iter fapply add-two 2 (- n 1))))))

(print (sum-recur cube inc 1 10))
(print (sum-iter cube inc 1 10))

(print (simpsons-recur cube 0 1 100))
(print (simpsons-iter cube 0 1 100))