Warum ist pow (a, d, n) so viel schneller als a ** d% n?

Ich habe versucht, einen Miller-Rabin-Primalitätstest durchzuführen , und war verwirrt, warum es für mittelgroße Zahlen (~ 7 Stellen) so lange (> 20 Sekunden) dauerte. Ich fand schließlich die folgende Codezeile als Ursache des Problems:

x = a**d % n

(wo a, dund nsind alle ähnlich, aber ungleich, midsize Zahlen, **ist der Exponential - Operator, und %ist der Modulo - Operator)

Ich habe dann versucht, es durch Folgendes zu ersetzen:

x = pow(a, d, n)

und im Vergleich dazu ist es fast augenblicklich.

Für den Kontext ist hier die ursprüngliche Funktion:

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))

Ein Beispiel für eine zeitgesteuerte Berechnung:

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)})

Ausgabe (mit PyPy 1.9.0 ausführen):

2642565
time: 23.785543s
2642565
time: 0.000030s

Ausgabe (mit Python 3.3.0 ausgeführt, 2.7.2 liefert sehr ähnliche Zeiten):

2642565
time: 14.426975s
2642565
time: 0.000021s

Und eine verwandte Frage: Warum ist diese Berechnung mit Python 2 oder 3 fast doppelt so schnell wie mit PyPy, wenn PyPy normalerweise viel schneller ist ?

Siehe den Wikipedia-Artikel zur modularen Potenzierung . Grundsätzlich müssen a**d % nSie dann tatsächlich rechnen a**d, was ziemlich groß sein kann. Es gibt jedoch Möglichkeiten zum Rechnen, a**d % nohne sich selbst berechnen zu müssen a**d, und genau das powtut es. Der **Bediener kann dies nicht tun, weil er nicht "in die Zukunft sehen" kann, um zu wissen, dass Sie sofort den Modul nehmen werden.

BrenBarn hat Ihre Hauptfrage beantwortet. Für Ihre Seite:

Warum ist es mit Python 2 oder 3 fast doppelt so schnell wie PyPy, wenn PyPy normalerweise viel schneller ist?

Wenn Sie die Leistungsseite von PyPy lesen , ist dies genau das, was PyPy nicht kann - in der Tat das allererste Beispiel, das sie geben:

Schlechte Beispiele sind Berechnungen mit großen Longs - die von nicht optimierbarem Support-Code ausgeführt werden.

Theoretisch ist die Umwandlung einer großen Potenzierung, gefolgt von einem Mod, in eine modulare Potenzierung (zumindest nach dem ersten Durchgang) eine Transformation, die eine JIT möglicherweise durchführen kann… aber nicht die JIT von PyPy.

Nebenbei bemerkt, wenn Sie Berechnungen mit großen Ganzzahlen durchführen müssen, sollten Sie sich Module von Drittanbietern ansehen gmpy, die manchmal viel schneller als die native Implementierung von CPython sind, in einigen Fällen außerhalb der Mainstream-Anwendungen, und auch viel haben von zusätzlichen Funktionen, die Sie sonst selbst schreiben müssten, auf Kosten der Bequemlichkeit.

Es gibt Abkürzungen für die modulare Exponentiation: Sie können beispielsweise a**(2i) mod nfür jedes ivon 1bis die log(d)gewünschten nZwischenergebnisse finden und miteinander multiplizieren (mod ). Eine dedizierte modulare Exponentiationsfunktion wie 3-Argumente pow()kann solche Tricks nutzen, da sie weiß, dass Sie modulare Arithmetik ausführen. Der Python-Parser kann dies aufgrund des bloßen Ausdrucks nicht erkennen a**d % nund führt daher die vollständige Berechnung durch (was viel länger dauert).

Der Weg, der x = a**d % nberechnet wird, besteht darin, aauf die dKraft zu erhöhen und dann das mit modulo n. Erstens, wenn aes groß ist, erzeugt dies eine große Zahl, die dann abgeschnitten wird. Es wird jedoch x = pow(a, d, n)höchstwahrscheinlich so optimiert, dass nur die letzten nZiffern verfolgt werden, die alles sind, was zur Berechnung des Multiplikationsmoduls einer Zahl erforderlich ist.