Почему pow (a, d, n) намного быстрее, чем a ** d% n?

Я пытался реализовать тест на простоту Миллера-Рабина и был озадачен, почему это занимает так много времени (> 20 секунд) для чисел среднего размера (~ 7 цифр). В конце концов я обнаружил, что источником проблемы является следующая строка кода:

x = a**d % n

(где a, dи n- все похожие, но неравные числа среднего размера, **- это оператор возведения в степень и %- оператор по модулю)

Затем я попытался заменить его следующим:

x = pow(a, d, n)

и это по сравнению с этим почти мгновенно.

Для контекста вот исходная функция:

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

Пример расчета по времени:

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

Вывод (запускается с PyPy 1.9.0):

2642565
time: 23.785543s
2642565
time: 0.000030s

Вывод (запуск с Python 3.3.0, 2.7.2 возвращает очень похожее время):

2642565
time: 14.426975s
2642565
time: 0.000021s

И связанный с этим вопрос, почему этот расчет почти в два раза быстрее при запуске с Python 2 или 3, чем с PyPy, когда обычно PyPy намного быстрее ?

См. Статью в Википедии о модульном возведении в степень . По сути, когда вы это делаете a**d % n, вам действительно нужно вычислять a**d, что может быть довольно большим. Но есть способы вычисления a**d % nбез необходимости вычислять a**dсамого себя, и это то, что powнужно. **Оператор не может этого сделать , потому что он не может «заглянуть в будущее» , чтобы знать , что вы собираетесь немедленно принять модуль.

БренБарн ответил на ваш главный вопрос. Для вас:

почему он почти в два раза быстрее при работе с Python 2 или 3, чем PyPy, когда обычно PyPy намного быстрее?

Если вы читаете страницу производительности PyPy , это именно то, в чем PyPy не силен - по сути, самый первый пример, который они приводят:

Плохие примеры включают выполнение вычислений с большими длинными числами, что выполняется неоптимизируемым вспомогательным кодом.

Теоретически превращение огромного возведения в степень, за которым следует мод, в модульное возведение в степень (по крайней мере, после первого прохода) - это преобразование, которое JIT могла бы выполнить ... но не JIT PyPy.

В качестве побочного примечания, если вам нужно выполнять вычисления с огромными целыми числами, вы можете посмотреть на сторонние модули, например gmpy, которые иногда могут быть намного быстрее, чем собственная реализация CPython в некоторых случаях за пределами основного использования, а также имеет много дополнительных функций, которые в противном случае вам пришлось бы писать самостоятельно, но это было бы менее удобно.

Есть ярлыки для выполнения модульного возведения в степень: например, вы можете найти a**(2i) mod nдля каждого iот 1до log(d)и умножить вместе (mod n) нужные вам промежуточные результаты. Специальная функция модульного возведения в степень, такая как 3-аргумент, pow()может использовать такие уловки, потому что знает, что вы выполняете модульную арифметику. Парсер Python не может распознать это по голому выражению a**d % n, поэтому он выполнит полное вычисление (что займет гораздо больше времени).

x = a**d % nРассчитывается способ возвести aв dстепень, а затем по модулю n. Во-первых, если aон большой, это создает огромное число, которое затем обрезается. Однако, x = pow(a, d, n)скорее всего, оптимизирован так, что nотслеживаются только последние цифры, а это все, что требуется для вычисления умножения по модулю числа.