Pourquoi pow (a, d, n) est-il tellement plus rapide que a ** d% n?

J'essayais de mettre en œuvre un test de primalité de Miller-Rabin et j'étais perplexe sur la raison pour laquelle cela prenait si longtemps (> 20 secondes) pour les nombres de taille moyenne (~ 7 chiffres). J'ai finalement trouvé que la ligne de code suivante était la source du problème:

x = a**d % n

(où a, det nsont tous similaires, mais inégaux, des nombres de taille moyenne, **est l'opérateur d'exponentiation et %est l'opérateur modulo)

J'ai ensuite essayé de le remplacer par ce qui suit:

x = pow(a, d, n)

et c'est par comparaison presque instantané.

Pour le contexte, voici la fonction d'origine:

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

Un exemple de calcul chronométré:

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

Sortie (exécutée avec PyPy 1.9.0):

2642565
time: 23.785543s
2642565
time: 0.000030s

Sortie (exécutée avec Python 3.3.0, 2.7.2 renvoie des temps très similaires):

2642565
time: 14.426975s
2642565
time: 0.000021s

Et une question connexe, pourquoi ce calcul est-il presque deux fois plus rapide lorsqu'il est exécuté avec Python 2 ou 3 qu'avec PyPy, alors que PyPy est généralement beaucoup plus rapide ?

Voir l'article de Wikipedia sur l'exponentiation modulaire . Fondamentalement, lorsque vous le faites a**d % n, vous devez en fait calculer a**d, ce qui peut être assez important. Mais il existe des moyens de calculer a**d % nsans avoir à se calculer a**dlui-même, et c'est ce qui powfait. L' **opérateur ne peut pas faire cela car il ne peut pas "voir dans le futur" pour savoir que vous allez immédiatement prendre le module.

BrenBarn a répondu à votre question principale. Pour votre côté:

pourquoi est-il presque deux fois plus rapide lorsqu'il est exécuté avec Python 2 ou 3 que PyPy, alors que PyPy est généralement beaucoup plus rapide?

Si vous lisez la page de performances de PyPy , c'est exactement le genre de chose pour laquelle PyPy n'est pas bon - en fait, le tout premier exemple qu'ils donnent:

Les mauvais exemples incluent les calculs avec des longs longs - qui sont effectués par un code de support non optimisable.

Théoriquement, transformer une énorme exponentiation suivie d'un mod en une exponentiation modulaire (au moins après la première passe) est une transformation qu'un JIT pourrait être capable de faire… mais pas le JIT de PyPy.

En remarque, si vous avez besoin de faire des calculs avec d'énormes entiers, vous voudrez peut-être regarder des modules tiers comme gmpy, qui peuvent parfois être beaucoup plus rapides que l'implémentation native de CPython dans certains cas en dehors des utilisations traditionnelles, et qui en ont également beaucoup de fonctionnalités supplémentaires que vous auriez autrement à écrire vous-même, au prix d'être moins pratique.

Il existe des raccourcis pour faire l'exponentiation modulaire: par exemple, vous pouvez trouver a**(2i) mod npour chaque ide 1à log(d)et multiplier ensemble (mod n) les résultats intermédiaires dont vous avez besoin. Une fonction d'exponentiation modulaire dédiée telle que 3 arguments pow()peut tirer parti de ces astuces car elle sait que vous faites de l'arithmétique modulaire. L'analyseur Python ne peut pas reconnaître cela étant donné l'expression nue a**d % n, il effectuera donc le calcul complet (ce qui prendra beaucoup plus de temps).

Le moyen de x = a**d % ncalculer est de monter aà la dpuissance, puis modulo cela avec n. Premièrement, si aest grand, cela crée un nombre énorme qui est ensuite tronqué. Cependant, x = pow(a, d, n)est très probablement optimisé pour que seuls les derniers nchiffres soient suivis, qui sont tout ce qui est nécessaire pour calculer la multiplication modulo un nombre.