Working With Simple Numbers

; checks is factor are factor of number
(defn is-factor? [factor number]
  (= 0 (rem number factor)))

; optimized function to find all factor of number
(defn factors [number]
  (def l (filter #(is-factor? % number)
    (range 1 (inc (Math/floor (Math/sqrt number))))))
  (concat l (reverse (map #(/ number %) l))))

; get sum of all factors of number
(defn sum-factors [number]
  (apply + (factors number)))

; is number simple?
(defn is-simple? [number]
  (= number (- (sum-factors number) 1)))

; finds all simple numbers up to limit
(defn simple [limit]
  (filter is-simple? (range 1 (+ 1 limit))))

; finds next simple number after number
(defn next-simple [number]
  (loop [start (inc number)]
    (if (is-simple? start) start
      (recur (inc start)))))

(def start (System/currentTimeMillis))
(doseq [a (simple 10000000)] (println a))
(println (- (System/currentTimeMillis) start))