Clojureでの素数の高速生成
私はClojureの問題の解決に取り組んできました Project Euler 改善するために、私はすでに数回素数の生成に遭遇しました。私の問題は、時間がかかりすぎていることです。私は誰かがClojureのような方法でこれを行う効率的な方法を見つけるのを手伝ってくれることを望んでいました。
私がこれをこぶしでしたとき、私はそれをブルートフォースしました。それは簡単でした。しかし、10001の素数を計算するには、Xeon 2.33GHzでこの方法で2分かかり、ルールには長すぎ、一般的には長すぎます。アルゴリズムは次のとおりです。
(defn next-prime-slow
"Find the next prime number, checking against our already existing list"
([sofar guess]
(if (not-any? #(zero? (mod guess %)) sofar)
guess ; Then we have a prime
(recur sofar (+ guess 2))))) ; Try again
(defn find-primes-slow
"Finds prime numbers, slowly"
([]
(find-primes-slow 10001 [2 3])) ; How many we need, initial prime seeds
([needed sofar]
(if (<= needed (count sofar))
sofar ; Found enough, we're done
(recur needed (concat sofar [(next-prime-slow sofar (last sofar))])))))
Next-prime-slowを、いくつかの追加ルール（6n +/- 1プロパティなど）を考慮した新しいルーチンに置き換えることで、最大で約70秒の速度を上げることができました。
次に、純粋なClojureでエラトステネスのふるいを作ってみました。すべてのバグを取り除いたとは思いませんが、遅すぎたために諦めました（上記よりもさらに悪いと思います）。
(defn clean-sieve
"Clean the sieve of what we know isn't prime based"
[seeds-left sieve]
(if (zero? (count seeds-left))
sieve ; Nothing left to filter the list against
(recur
(rest seeds-left) ; The numbers we haven't checked against
(filter #(> (mod % (first seeds-left)) 0) sieve)))) ; Filter out multiples
(defn self-clean-sieve ; This seems to be REALLY slow
"Remove the stuff in the sieve that isn't prime based on it's self"
([sieve]
(self-clean-sieve (rest sieve) (take 1 sieve)))
([sieve clean]
(if (zero? (count sieve))
clean
(let [cleaned (filter #(> (mod % (last clean)) 0) sieve)]
(recur (rest cleaned) (into clean [(first cleaned)]))))))
(defn find-primes
"Finds prime numbers, hopefully faster"
([]
(find-primes 10001 [2]))
([needed seeds]
(if (>= (count seeds) needed)
seeds ; We have enough
(recur ; Recalculate
needed
(into
seeds ; Stuff we've already found
(let [start (last seeds)
end-range (+ start 150000)] ; NOTE HERE
(reverse
(self-clean-sieve
(clean-sieve seeds (range (inc start) end-range))))))))))
これは悪いです。また、150000の数値が小さい場合、スタックオーバーフローが発生します。これは、recurを使用しているにもかかわらずです。それは私のせいかもしれません。
次に、Java ArrayListでJavaメソッドを使用して、ふるいを試しました。これにはかなりの時間とメモリが必要でした。
私の最近の試みは、Clojureハッシュマップを使用したふるいで、すべての数値をふるいに挿入してから、素数ではない数値を分離します。最後に、見つかった素数であるキーリストを取得します。 10000個の素数を見つけるのに約10〜12秒かかります。まだ完全にデバッグされているかどうかはわかりません。私はLispyになろうとしているので、これも再帰的です（recurとloopを使用）。
したがって、この種の問題では、問題10（2000000未満のすべての素数を合計）が私を殺しています。私の最速のコードが正しい答えを思いついたが、それを行うのに105秒かかり、かなりのメモリが必要だった（512 MBを与えたので、大騒ぎする必要はなかった）。私の他のアルゴリズムは非常に時間がかかるので、常に最初にそれらを停止することになりました。
ふるいを使用して、JavaまたはCの多くの素数を非常に高速に、それほど多くのメモリを使用せずに計算できます。問題の原因となっているClojure/LISPスタイルの何かが欠落しているに違いありません。
私が本当に間違っていることはありますか？ Clojureは、シーケンスが大きいとちょっと遅いですか？プロジェクトオイラーの議論のいくつかを読んで、人々は100ミリ秒未満で他のLispの最初の10000素数を計算しました。 JVMは速度を低下させる可能性があり、Clojureは比較的若いと思いますが、100倍の違いは期待できません。
Clojureで素数を計算するための迅速な方法について誰かが私に教えてもらえますか？
Clojure's Java interopを祝う別のアプローチがあります。これには、2.4 Ghz Core 2 Duo（シングルスレッドで実行）で374msかかります。 JavaのMiller-Rabinでの効率的なBigInteger#isProbablePrime実装に素数性チェックを処理させます。
(def certainty 5)
(defn prime? [n]
(.isProbablePrime (BigInteger/valueOf n) certainty))
(concat [2] (take 10001
(filter prime?
(take-nth 2
(range 1 Integer/MAX_VALUE)))))
Miller-Rabinの確実性5は、これよりはるかに大きい数にはおそらくあまり良くありません。その確実性は96.875%に等しいことは確かに素数です（1 - .5^certainty）
これは非常に古い質問だと思いますが、最近同じものを探すことになり、ここのリンクは私が探しているものではありませんでした（可能な限り機能タイプに制限され、必要な〜すべての〜プライムを怠惰に生成します） 。
私はニースに出くわしました F＃実装 、それですべてのクレジットは彼のものです。私はそれをClojureに移植しただけです：
(defn gen-primes "Generates an infinite, lazy sequence of prime numbers"
[]
(letfn [(reinsert [table x prime]
(update-in table [(+ prime x)] conj prime))
(primes-step [table d]
(if-let [factors (get table d)]
(recur (reduce #(reinsert %1 d %2) (dissoc table d) factors)
(inc d))
(lazy-seq (cons d (primes-step (assoc table (* d d) (list d))
(inc d))))))]
(primes-step {} 2)))
使い方は簡単です
(take 5 (gen-primes))
パーティーに非常に遅れましたが、Java BitSets：
(defn sieve [n]
"Returns a BitSet with bits set for each prime up to n"
(let [bs (new Java.util.BitSet n)]
(.flip bs 2 n)
(doseq [i (range 4 n 2)] (.clear bs i))
(doseq [p (range 3 (Math/sqrt n))]
(if (.get bs p)
(doseq [q (range (* p p) n (* 2 p))] (.clear bs q))))
bs))
これを2014Macbook Pro（2.3GHz Core i7）で実行すると、次のようになります。
user=> (time (do (sieve 1e6) nil))
"Elapsed time: 64.936 msecs"
ここで最後の例を参照してください： http://clojuredocs.org/clojure_core/clojure.core/lazy-seq
;; An example combining lazy sequences with higher order functions
;; Generate prime numbers using Eratosthenes Sieve
;; See http://en.wikipedia.org/wiki/Sieve_of_Eratosthenes
;; Note that the starting set of sieved numbers should be
;; the set of integers starting with 2 i.e., (iterate inc 2)
(defn sieve [s]
(cons (first s)
(lazy-seq (sieve (filter #(not= 0 (mod % (first s)))
(rest s))))))
user=> (take 20 (sieve (iterate inc 2)))
(2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71)
これが素晴らしくて単純な実装です：
http://clj-me.blogspot.com/2008/06/primes.html
...しかし、Clojureの1.0より前のバージョン用に書かれています。現在のバージョンの言語で動作するものについては、Clojure Contribの lazy_seqs を参照してください。
だから私はClojureを始めたばかりです、そしてええ、これはProjectEulerでたくさん出てきますね。私はかなり高速な試行除算素数アルゴリズムを作成しましたが、除算の各実行が法外に遅くなる前に、実際にはそれほど大きくスケーリングしません。
そこで、今度はふるい法を使用して、もう一度始めました。
(defn clense
"Walks through the sieve and nils out multiples of step"
[primes step i]
(if (<= i (count primes))
(recur
(assoc! primes i nil)
step
(+ i step))
primes))
(defn sieve-step
"Only works if i is >= 3"
[primes i]
(if (< i (count primes))
(recur
(if (nil? (primes i)) primes (clense primes (* 2 i) (* i i)))
(+ 2 i))
primes))
(defn prime-sieve
"Returns a lazy list of all primes smaller than x"
[x]
(drop 2
(filter (complement nil?)
(persistent! (sieve-step
(clense (transient (vec (range x))) 2 4) 3)))))
使用法と速度：
user=> (time (do (prime-sieve 1E6) nil))
"Elapsed time: 930.881 msecs
速度にはかなり満足しています。2009MBPで実行されているREPL）が不足しています。慣用的なClojureを完全に避け、代わりにサルのようにループするため、ほとんどの場合高速です。これも4Xです。完全に不変のままではなく、一時的なベクトルを使用してふるいで作業しているため、より高速です。
編集： Will Nessからのいくつかの提案/バグ修正の後、実行速度が大幅に向上しました。
(defn sieve
[[p & rst]]
;; make sure the stack size is sufficiently large!
(lazy-seq (cons p (sieve (remove #(= 0 (mod % p)) rst)))))
(def primes (sieve (iterate inc 2)))
スタックサイズが10Mの場合、2.1GzMacbookで約33秒で1001番目の素数を取得します。
これがSchemeの簡単なふるいです：
http://telegraphics.com.au/svn/puzzles/trunk/programming-in-scheme/primes-up-to.scm
10,000までの素数の実行は次のとおりです。
#;1> (include "primes-up-to.scm")
; including primes-up-to.scm ...
#;2> ,t (primes-up-to 10000)
0.238s CPU time, 0.062s GC time (major), 180013 mutations, 130/4758 GCs (major/minor)
(2 3 5 7 11 13...
ウィルのコメントに基づいて、これが私の見解です postponed-primes ：
(defn postponed-primes-recursive
([]
(concat (list 2 3 5 7)
(lazy-seq (postponed-primes-recursive
{}
3
9
(rest (rest (postponed-primes-recursive)))
9))))
([D p q ps c]
(letfn [(add-composites
[D x s]
(loop [a x]
(if (contains? D a)
(recur (+ a s))
(persistent! (assoc! (transient D) a s)))))]
(loop [D D
p p
q q
ps ps
c c]
(if (not (contains? D c))
(if (< c q)
(cons c (lazy-seq (postponed-primes-recursive D p q ps (+ 2 c))))
(recur (add-composites D
(+ c (* 2 p))
(* 2 p))
(first ps)
(* (first ps) (first ps))
(rest ps)
(+ c 2)))
(let [s (get D c)]
(recur (add-composites
(persistent! (dissoc! (transient D) c))
(+ c s)
s)
p
q
ps
(+ c 2))))))))
比較のための最初の提出：
これが私の試みです この素数ジェネレーター PythonからClojureへ。以下は無限のレイジーシーケンスを返します。
(defn primes
[]
(letfn [(prime-help
[foo bar]
(loop [D foo
q bar]
(if (nil? (get D q))
(cons q (lazy-seq
(prime-help
(persistent! (assoc! (transient D) (* q q) (list q)))
(inc q))))
(let [factors-of-q (get D q)
key-val (interleave
(map #(+ % q) factors-of-q)
(map #(cons % (get D (+ % q) (list)))
factors-of-q))]
(recur (persistent!
(dissoc!
(apply assoc! (transient D) key-val)
q))
(inc q))))))]
(prime-help {} 2)))
使用法：
user=> (first (primes))
2
user=> (second (primes))
3
user=> (nth (primes) 100)
547
user=> (take 5 (primes))
(2 3 5 7 11)
user=> (time (nth (primes) 10000))
"Elapsed time: 409.052221 msecs"
104743
編集：
パフォーマンスの比較。postponed-primesは、postponed-primesへの再帰呼び出しではなく、これまでに見られた素数のキューを使用します。
user=> (def counts (list 200000 400000 600000 800000))
#'user/counts
user=> (map #(time (nth (postponed-primes) %)) counts)
("Elapsed time: 1822.882 msecs"
"Elapsed time: 3985.299 msecs"
"Elapsed time: 6916.98 msecs"
"Elapsed time: 8710.791 msecs"
2750161 5800139 8960467 12195263)
user=> (map #(time (nth (postponed-primes-recursive) %)) counts)
("Elapsed time: 1776.843 msecs"
"Elapsed time: 3874.125 msecs"
"Elapsed time: 6092.79 msecs"
"Elapsed time: 8453.017 msecs"
2750161 5800139 8960467 12195263)
怠惰な解決策を必要とせず、特定の制限を下回る素数のシーケンスが必要な場合は、エラトステネスのふるいの簡単な実装は非常に高速です。トランジェントを使用した私のバージョンは次のとおりです。
(defn classic-sieve
"Returns sequence of primes less than N"
[n]
(loop [nums (transient (vec (range n))) i 2]
(cond
(> (* i i) n) (remove nil? (nnext (persistent! nums)))
(nums i) (recur (loop [nums nums j (* i i)]
(if (< j n)
(recur (assoc! nums j nil) (+ j i))
nums))
(inc i))
:else (recur nums (inc i)))))
慣用的で、それほど悪くはない
(def primes
(cons 1 (lazy-seq
(filter (fn [i]
(not-any? (fn [p] (zero? (rem i p)))
(take-while #(<= % (Math/sqrt i))
(rest primes))))
(drop 2 (range))))))
=> #'user/primes
(first (time (drop 10000 primes)))
"Elapsed time: 0.023135 msecs"
=> 104729
すでにたくさんの答えがありますが、私は素数の無限のシーケンスを生成する代替ソリューションを持っています。また、いくつかのソリューションのベンチマークにも興味がありました。
最初にいくつかのJava相互運用。参考のために：
(defn prime-fn-1 [accuracy]
(cons 2
(for [i (range)
:let [prime-candidate (-> i (* 2) (+ 3))]
:when (.isProbablePrime (BigInteger/valueOf prime-candidate) accuracy)]
prime-candidate)))
ベンジャミン@ https://stackoverflow.com/a/7625207/373182 is primes-fn-2
nha @ https://stackoverflow.com/a/36432061/373182 is primes-fn-3
私の実装はprimes-fn-4：
(defn primes-fn-4 []
(let [primes-with-duplicates
(->> (for [i (range)] (-> i (* 2) (+ 5))) ; 5, 7, 9, 11, ...
(reductions
(fn [known-primes candidate]
(if (->> known-primes
(take-while #(<= (* % %) candidate))
(not-any? #(-> candidate (mod %) zero?)))
(conj known-primes candidate)
known-primes))
[3]) ; Our initial list of known odd primes
(cons [2]) ; Put in the non-odd one
(map (comp first rseq)))] ; O(1) lookup of the last element of the vec "known-primes"
; Ugh, ugly de-duplication :(
(->> (map #(when (not= % %2) %) primes-with-duplicates (rest primes-with-duplicates))
(remove nil?))))
報告された数値（最初のN個の素数をカウントするミリ秒単位の時間）は、5の実行から最も速く、実験間でJVMが再起動しないため、マイレージが異なる場合があります。
1e6 3e6
(primes-fn-1 5) 808 2664
(primes-fn-1 10) 952 3198
(primes-fn-1 20) 1440 4742
(primes-fn-1 30) 1881 6030
(primes-fn-2) 1868 5922
(primes-fn-3) 489 1755 <-- WOW!
(primes-fn-4) 2024 8185
Java配列を使用
(defmacro loopwhile [init-symbol init whilep step & body]
`(loop [~init-symbol ~init]
(when ~whilep ~@body (recur (+ ~init-symbol ~step)))))
(defn primesUnderb [limit]
(let [p (boolean-array limit true)]
(loopwhile i 2 (< i (Math/sqrt limit)) 1
(when (aget p i)
(loopwhile j (* i 2) (< j limit) i (aset p j false))))
(filter #(aget p %) (range 2 limit))))
使用法と速度：
user=> (time (def p (primesUnderb 1e6)))
"Elapsed time: 104.065891 msecs"
このスレッドに来て、すでにここにあるものよりも速い代替手段を探した後、私は誰も次のリンクにリンクしていないことに驚いています クリストフグランドによる記事 ：
(defn primes3 [max]
(let [enqueue (fn [sieve n factor]
(let [m (+ n (+ factor factor))]
(if (sieve m)
(recur sieve m factor)
(assoc sieve m factor))))
next-sieve (fn [sieve candidate]
(if-let [factor (sieve candidate)]
(-> sieve
(dissoc candidate)
(enqueue candidate factor))
(enqueue sieve candidate candidate)))]
(cons 2 (vals (reduce next-sieve {} (range 3 max 2))))))
怠惰なバージョンと同様に：
(defn lazy-primes3 []
(letfn [(enqueue [sieve n step]
(let [m (+ n step)]
(if (sieve m)
(recur sieve m step)
(assoc sieve m step))))
(next-sieve [sieve candidate]
(if-let [step (sieve candidate)]
(-> sieve
(dissoc candidate)
(enqueue candidate step))
(enqueue sieve candidate (+ candidate candidate))))
(next-primes [sieve candidate]
(if (sieve candidate)
(recur (next-sieve sieve candidate) (+ candidate 2))
(cons candidate
(lazy-seq (next-primes (next-sieve sieve candidate)
(+ candidate 2))))))]
(cons 2 (lazy-seq (next-primes {} 3)))))
Clojureを使い始めたばかりなので、それが良いかどうかはわかりませんが、これが私の解決策です。
(defn divides? [x i]
(zero? (mod x i)))
(defn factors [x]
(flatten (map #(list % (/ x %)) (filter #(divides? x %) (range 1 (inc (Math/floor (Math/sqrt x))))))))
(defn prime? [x]
(empty? (filter #(and divides? (not= x %) (not= 1 %)) (factors x))))
(def primes
(filter prime? (range 2 Java.lang.Integer/MAX_VALUE)))
(defn sum-of-primes-below [n]
(reduce + (take-while #(< % n) primes)))