A little bit of LCG analysis fun in Clojure

lcg-deadlocks.clj

(defn rng [conf]
  (let [{:keys [a b m]} conf]
    (fn [x]
      (mod (+ (* a x) b) m))))

(defn recurredly [f seed]
  (lazy-seq
   (let [res (f seed)]
     (cons res
           (recurredly f res)))))

(defn has-deadlock-at? [conf x]
  (let [rand-seq (recurredly (rng conf) x)
        max-count (:m conf)]
    (loop [n 0, prev x]
      (let [curr (nth rand-seq n)]
        (if (> n max-count)
          nil
          (if (= curr prev)
            curr
            (recur (inc n) curr)))))))

(defn- all-deadlocks [conf]
  (map #(when (has-deadlock-at? conf %) %)
       (range (:m conf))))

(defn deadlocks [conf]
  (filter identity (all-deadlocks conf)))

(defn has-any-deadlock? [conf]
  (some identity (all-deadlocks conf)))

(comment
  (deadlocks {:a 5 :b 3 :m 7})
  (has-any-deadlock? {:a 5 :b 3 :m 139})
)