web-dev-qa-db-ja.com

高速素因数分解モジュール

私は[implementationまたはclear algorithmのいずれかのpythonで[〜＃〜] n [〜＃〜]の素因数分解を取得するために探しています、擬似コードまたはその他の読みやすいもの。いくつかの要求/事実があります：

  • [〜＃〜] n [〜＃〜]は1〜20桁です
  • 事前に計算されたルックアップテーブルはありませんが、メモ化は問題ありません。
  • 数学的に証明される必要はありません（たとえば、必要に応じてGoldbachの推測に頼ることができます）
  • 正確である必要はなく、必要に応じて確率的/決定的であることが許可されます

高速素因数分解アルゴリズムが必要です。それだけでなく、オイラーphi（n）の計算など、他の多くのアルゴリズムで使用するためにも必要です。

ウィキペディアなどから他のアルゴリズムを試しましたが、それらを理解できなかった（ECM）か、アルゴリズムから実用的な実装を作成できませんでした（Pollard-Brent）。

Pollard-Brentアルゴリズムに本当に興味があるので、それに関する情報/実装は本当に素晴らしいでしょう。

ありがとう！

[〜＃〜] edit [〜＃〜]

少しいじってから、非常に高速な素数/因数分解モジュールを作成しました。最適化された試行分割アルゴリズム、Pollard-Brentアルゴリズム、miller-rabin primality test、およびインターネットで見つけた最速のプライムシーブを組み合わせています。 gcdは通常のユークリッドのGCD実装です（バイナリユークリッドのGCDはmuchよりも低速です）。

バウンティ

ああ、賞金を獲得できます！しかし、どうすれば勝ちますか？

  • モジュールの最適化またはバグを見つけます。
  • 代替/より優れたアルゴリズム/実装を提供します。

最も完全/建設的な答えが報奨金を受け取ります。

そして最後に、モジュール自体：

import random

def primesbelow(N):
    # http://stackoverflow.com/questions/2068372/fastest-way-to-list-all-primes-below-n-in-python/3035188#3035188
    #""" Input N>=6, Returns a list of primes, 2 <= p < N """
    correction = N % 6 > 1
    N = {0:N, 1:N-1, 2:N+4, 3:N+3, 4:N+2, 5:N+1}[N%6]
    sieve = [True] * (N // 3)
    sieve[0] = False
    for i in range(int(N ** .5) // 3 + 1):
        if sieve[i]:
            k = (3 * i + 1) | 1
            sieve[k*k // 3::2*k] = [False] * ((N//6 - (k*k)//6 - 1)//k + 1)
            sieve[(k*k + 4*k - 2*k*(i%2)) // 3::2*k] = [False] * ((N // 6 - (k*k + 4*k - 2*k*(i%2))//6 - 1) // k + 1)
    return [2, 3] + [(3 * i + 1) | 1 for i in range(1, N//3 - correction) if sieve[i]]

smallprimeset = set(primesbelow(100000))
_smallprimeset = 100000
def isprime(n, precision=7):
    # http://en.wikipedia.org/wiki/Miller-Rabin_primality_test#Algorithm_and_running_time
    if n < 1:
        raise ValueError("Out of bounds, first argument must be > 0")
    Elif n <= 3:
        return n >= 2
    Elif n % 2 == 0:
        return False
    Elif n < _smallprimeset:
        return n in smallprimeset


    d = n - 1
    s = 0
    while d % 2 == 0:
        d //= 2
        s += 1

    for repeat in range(precision):
        a = random.randrange(2, n - 2)
        x = pow(a, d, n)

        if x == 1 or x == n - 1: continue

        for r in range(s - 1):
            x = pow(x, 2, n)
            if x == 1: return False
            if x == n - 1: break
        else: return False

    return True

# https://comeoncodeon.wordpress.com/2010/09/18/pollard-rho-brent-integer-factorization/
def pollard_brent(n):
    if n % 2 == 0: return 2
    if n % 3 == 0: return 3

    y, c, m = random.randint(1, n-1), random.randint(1, n-1), random.randint(1, n-1)
    g, r, q = 1, 1, 1
    while g == 1:
        x = y
        for i in range(r):
            y = (pow(y, 2, n) + c) % n

        k = 0
        while k < r and g==1:
            ys = y
            for i in range(min(m, r-k)):
                y = (pow(y, 2, n) + c) % n
                q = q * abs(x-y) % n
            g = gcd(q, n)
            k += m
        r *= 2
    if g == n:
        while True:
            ys = (pow(ys, 2, n) + c) % n
            g = gcd(abs(x - ys), n)
            if g > 1:
                break

    return g

smallprimes = primesbelow(1000) # might seem low, but 1000*1000 = 1000000, so this will fully factor every composite < 1000000
def primefactors(n, sort=False):
    factors = []

    for checker in smallprimes:
        while n % checker == 0:
            factors.append(checker)
            n //= checker
        if checker > n: break

    if n < 2: return factors

    while n > 1:
        if isprime(n):
            factors.append(n)
            break
        factor = pollard_brent(n) # trial division did not fully factor, switch to pollard-brent
        factors.extend(primefactors(factor)) # recurse to factor the not necessarily prime factor returned by pollard-brent
        n //= factor

    if sort: factors.sort()

    return factors

def factorization(n):
    factors = {}
    for p1 in primefactors(n):
        try:
            factors[p1] += 1
        except KeyError:
            factors[p1] = 1
    return factors

totients = {}
def totient(n):
    if n == 0: return 1

    try: return totients[n]
    except KeyError: pass

    tot = 1
    for p, exp in factorization(n).items():
        tot *= (p - 1)  *  p ** (exp - 1)

    totients[n] = tot
    return tot

def gcd(a, b):
    if a == b: return a
    while b > 0: a, b = b, a % b
    return a

def lcm(a, b):
    return abs((a // gcd(a, b)) * b)
pythonalgorithmprime-factoring
67
orlp

Pythonで実装されたPollard-Brent：

https://comeoncodeon.wordpress.com/2010/09/18/pollard-rho-brent-integer-factorization/

13
Amber

車輪を再発明したくない場合は、ライブラリを使用してください sympy

pip install sympy

関数 sympy.ntheory.factorint

>>> from sympy.ntheory import factorint
>>> factorint(10**20+1)
{73: 1, 5964848081: 1, 1676321: 1, 137: 1}

いくつかの非常に大きな数を因数分解できます。

>>> factorint(10**100+1)
{401: 1, 5964848081: 1, 1676321: 1, 1601: 1, 1201: 1, 137: 1, 73: 1, 129694419029057750551385771184564274499075700947656757821537291527196801: 1}
45
Colonel Panic

smallprimesを使用してprimesbelowを計算する必要はありません。そのためにsmallprimesetを使用してください。

smallprimes = (2,) + Tuple(n for n in xrange(3,1000,2) if n in smallprimeset)

primefactorsをsmallprimesとpollard_brentのその他を処理するための2つの関数に分割します。これにより、smallprimesのすべてのべき乗がnから分割されるため、反復の数を節約できます。

def primefactors(n, sort=False):
    factors = []

    limit = int(n ** .5) + 1
    for checker in smallprimes:
        print smallprimes[-1]
        if checker > limit: break
        while n % checker == 0:
            factors.append(checker)
            n //= checker


    if n < 2: return factors
    else : 
        factors.extend(bigfactors(n,sort))
        return factors

def bigfactors(n, sort = False):
    factors = []
    while n > 1:
        if isprime(n):
            factors.append(n)
            break
        factor = pollard_brent(n) 
        factors.extend(bigfactors(factor,sort)) # recurse to factor the not necessarily prime factor returned by pollard-brent
        n //= factor

    if sort: factors.sort()    
    return factors

Pomerance、Selfridge、Wagstaff、およびJaeschkeの検証結果を検討することにより、Miller-Rabin素数検定を使用するisprimeの繰り返しを減らすことができます。 Wiki から。

  • n <1,373,653の場合、a = 2および3をテストするだけで十分です。
  • n <9,080,191の場合、a = 31および73をテストするだけで十分です。
  • n <4,759,123,141の場合、a = 2、7、および61をテストするだけで十分です。
  • n <2,152,302,898,747の場合、a = 2、3、5、7、11をテストするだけで十分です。
  • n <3,474,749,660,383の場合、a = 2、3、5、7、11、13をテストするだけで十分です。
  • n <341,550,071,728,321の場合、a = 2、3、5、7、11、13、および17をテストするだけで十分です。

編集1：if-elseのリターンコールを修正し、primefactorsの因子に大きな因子を追加しました。

14
Rozuur

現在でも、注意すべき点がいくつかあります。

  1. すべてのループを_checker*checker_しないでください。s=ceil(sqrt(num))と_checher < s_を使用してください
  2. checherは毎回2を足すべきで、2を除くすべての偶数を無視します
  3. _%_および_//_の代わりにdivmodを使用します
4
Kabie

python素数性テストのコレクションを含むライブラリ（実行してはいけないことのための誤ったものを含む）。これは pyprimes と呼ばれます。あなたが言及したアルゴリズムが含まれているとは思わないでください。

3
Ehtesh Choudhury

おそらくここで見られるような素数検出を行うべきです 素数を見つけるための高速アルゴリズム？

ただし、そのブログ全体を読む必要があります。彼は素数性をテストするためにいくつかのアルゴリズムをリストしています。

3
milkypostman

限界まで因数分解してから、ブレントを使用してより高い因子を取得できます

from fractions import gcd
from random import randint

def brent(N):
   if N%2==0: return 2
   y,c,m = randint(1, N-1),randint(1, N-1),randint(1, N-1)
   g,r,q = 1,1,1
   while g==1:             
       x = y
       for i in range(r):
          y = ((y*y)%N+c)%N
       k = 0
       while (k<r and g==1):
          ys = y
          for i in range(min(m,r-k)):
             y = ((y*y)%N+c)%N
             q = q*(abs(x-y))%N
          g = gcd(q,N)
          k = k + m
       r = r*2
   if g==N:
       while True:
          ys = ((ys*ys)%N+c)%N
          g = gcd(abs(x-ys),N)
          if g>1:  break
   return g

def factorize(n1):
    if n1==0: return []
    if n1==1: return [1]
    n=n1
    b=[]
    p=0
    mx=1000000
    while n % 2 ==0 : b.append(2);n//=2
    while n % 3 ==0 : b.append(3);n//=3
    i=5
    inc=2
    while i <=mx:
       while n % i ==0 : b.append(i); n//=i
       i+=inc
       inc=6-inc
    while n>mx:
      p1=n
      while p1!=p:
          p=p1
          p1=brent(p)
      b.append(p1);n//=p1 
    if n!=1:b.append(n)   
    return sorted(b)

from functools import reduce
#n= 2**1427 * 31 #
n= 67898771  * 492574361 * 10000223 *305175781* 722222227*880949 *908909
li=factorize(n)
print (li)
print (n - reduce(lambda x,y :x*y ,li))
1
Antoni Gual Via

数値_2**1427 * 31_を因数分解すると、このコードでバグに遭遇しました。

_  File "buckets.py", line 48, in prettyprime
    factors = primefactors.primefactors(n, sort=True)
  File "/private/tmp/primefactors.py", line 83, in primefactors
    limit = int(n ** .5) + 1
OverflowError: long int too large to convert to float
_

このコードスニペット：

_limit = int(n ** .5) + 1
for checker in smallprimes:
    if checker > limit: break
    while n % checker == 0:
        factors.append(checker)
        n //= checker
        limit = int(n ** .5) + 1
        if checker > limit: break
_

に書き換える必要があります

_for checker in smallprimes:
    while n % checker == 0:
        factors.append(checker)
        n //= checker
    if checker > n: break
_

とにかく、現実的な入力でより高速に実行される可能性があります。平方根は遅い-基本的に多くの乗算と同等-smallprimesは数ダースのメンバーしか持たないため、この方法で_n ** .5_の計算をタイトな内側のループから削除します。 _2**1427_のような数値の因数分解。 sqrt(2**1427)、sqrt(2**1426)、sqrt(2**1425)などを計算する理由はまったくありません。 n "を超えています。

書き換えられたコードは、大きな数で表示されても例外をスローしません。andは、timeit（サンプル入力_2_および_2**718 * 31_によると、およそ2倍の速さです。 ）。

isprime(2)が間違った結果を返すことにも注意してください。しかし、これに依存しない限りこれは問題ありません。私見では、その機能のイントロを次のように書き直す必要があります

_if n <= 3:
    return n >= 2
...
_
0
Quuxplusone