(defn square [n]
  (* n n))

(defn divides? [a b]
  (= (mod b a) 0))

(defn next [n]
  (cond
    (= n 2) 3
    (+ n 2)))

(defn smallest-divisor [n]
  (defn iter [n test]
    (cond
      (> (square test) n) n
      (divides? test n) test
      (iter n (+ test 1))))
  (iter n 2))

(defn prime? [n]
  (= n (smallest-divisor n)))

(defn smallest-divisor2 [n]
  (defn iter [n test]
    (cond
      (> (square test) n) n
      (divides? test n) test
      (iter n (next test))))
  (iter n 2))

(defn prime2? [n]
  (= n (smallest-divisor2 n)))

(defn search-for-primes [start count]
  (defn report-time [n elapsed-time1 elapsed-time2]
    (printf "%d,%f,%f" n (* elapsed-time1 1000000.0) (* elapsed-time2 1000000.0)))
  (defn start-prime-test [n start-time]
    (def a (prime? n))
    (def end-time-1 (os/clock :cputime))
    (def elapsed (- end-time-1 start-time))
    (def b (prime2? n))
    (def elapsed2 (- (os/clock :cputime) end-time-1))
    (if (and a b)
      (do
        (report-time n elapsed elapsed2)
        true)
      false))
  (defn times-prime-test [n]
    (start-prime-test n (os/clock :cputime)))
  (defn iter [test n]
    (cond
      (= n 0) 0
      (times-prime-test test) (iter (+ test 2) (- n 1))
      (iter (+ test 2) n)))
  (cond
    (= 0 (mod start 2)) (iter (+ start 1) count)
    (iter start count)))

(search-for-primes 1000 100000)
#(search-for-primes 10000 3)
#(search-for-primes 100000 3)
#(search-for-primes 1000000 3)