Pow (a, d, n) neden a ** d% n'den çok daha hızlı?

Miller-Rabin asallık testini uygulamaya çalışıyordum ve orta büyüklükteki sayılar (~ 7 basamak) için neden bu kadar uzun (> 20 saniye) sürdüğünü şaşırdım. Sonunda aşağıdaki kod satırını sorunun kaynağı olarak buldum:

x = a**d % n

(burada a, dve nhepsi benzer, ancak eşit olmayan, orta büyüklükteki sayılar **üs alma operatörü ve %modulo operatörüdür)

Daha sonra bunu aşağıdakilerle değiştirmeyi denedim:

x = pow(a, d, n)

ve kıyaslandığında neredeyse anlık.

Bağlam için, işte orijinal işlev:

from random import randint

def primalityTest(n, k):
    if n < 2:
        return False
    if n % 2 == 0:
        return False
    s = 0
    d = n - 1
    while d % 2 == 0:
        s += 1
        d >>= 1
    for i in range(k):
        rand = randint(2, n - 2)
        x = rand**d % n         # offending line
        if x == 1 or x == n - 1:
            continue
        for r in range(s):
            toReturn = True
            x = pow(x, 2, n)
            if x == 1:
                return False
            if x == n - 1:
                toReturn = False
                break
        if toReturn:
            return False
    return True

print(primalityTest(2700643,1))

Örnek zamanlı bir hesaplama:

from timeit import timeit

a = 2505626
d = 1520321
n = 2700643

def testA():
    print(a**d % n)

def testB():
    print(pow(a, d, n))

print("time: %(time)fs" % {"time":timeit("testA()", setup="from __main__ import testA", number=1)})
print("time: %(time)fs" % {"time":timeit("testB()", setup="from __main__ import testB", number=1)})

Çıktı (PyPy 1.9.0 ile çalıştırın):

2642565
time: 23.785543s
2642565
time: 0.000030s

Çıktı (Python 3.3.0 ile çalıştırın, 2.7.2 çok benzer zamanlar döndürür):

2642565
time: 14.426975s
2642565
time: 0.000021s

Ve ilgili bir soru, PyPy genellikle çok daha hızlıyken, neden bu hesaplama Python 2 veya 3 ile çalıştırıldığında PyPy'den neredeyse iki kat daha hızlıdır ?

Modüler üs alma hakkındaki Wikipedia makalesine bakın . Temel olarak, yaptığınızda a**d % n, aslında hesaplamanız gerekir a**dki bu oldukça büyük olabilir. Ancak kendi kendini hesaplamak a**d % nzorunda kalmadan bilgi işlem yapmanın yolları vardır a**dve işte budur pow. **O hemen modülünü alacak olduğumuzu bilmenizi "geleceğe bakın" olamaz çünkü operatör bunu yapamaz.

BrenBarn ana sorunuzu yanıtladı. Kenara çekilmek için:

PyPy çok daha hızlıyken, neden Python 2 veya 3 ile çalıştırıldığında PyPy'den neredeyse iki kat daha hızlıdır?

PyPy'nin performans sayfasını okursanız , bu tam olarak PyPy'nin iyi olmadığı türden bir şeydir - aslında, verdikleri ilk örnek:

Kötü örnekler, optimize edilemeyen destek koduyla gerçekleştirilen büyük uzunlarla hesaplamalar yapmayı içerir.

Teorik olarak, büyük bir üs alma ve ardından bir modu modüler bir üslemeye dönüştürmek (en azından ilk geçişten sonra) bir JIT'in yapabileceği bir dönüşümdür… ama PyPy'nin JIT'i değil.

Bir yan not olarak, büyük tamsayılarla hesaplamalar yapmanız gerekiyorsa gmpy, ana akım kullanımların dışında bazı durumlarda CPython'un yerel uygulamasından çok daha hızlı olabilen ve aynı zamanda çok şey içeren üçüncü taraf modüllere bakmak isteyebilirsiniz. daha az kullanışlı olma pahasına kendi kendinize yazmak zorunda kalacağınız ek işlevler.

Modüler üs yapmak için kısayollar vardır: Örneğin, bulabilirsiniz a**(2i) mod nher için igelen 1için log(d)çarpın birlikte (mod ve n) ihtiyacınız ara sonuçları. 3 bağımsız değişken gibi özel bir modüler üs alma işlevi pow()bu tür hilelerden yararlanabilir çünkü modüler aritmetik yaptığınızı bilir. Python ayrıştırıcısı, çıplak ifade verildiğinde bunu tanıyamaz a**d % n, bu nedenle tam hesaplamayı gerçekleştirecektir (bu çok daha uzun sürecektir).

Yolu x = a**d % nhesaplanır zam etmektir aiçin dgüç, daha sonra o modulo n. İlk olarak, eğer abüyükse, bu daha sonra kesilen çok büyük bir sayı oluşturur. Bununla birlikte, x = pow(a, d, n)büyük olasılıkla n, bir sayının çarpım modülünü hesaplamak için gerekli olan yalnızca son basamaklar izlenecek şekilde optimize edilmiştir .