Возведение в степень возведением в квадрат - Википедия - Exponentiation by squaring

Эта статья поднимает множество проблем. Пожалуйста помоги Улучши это или обсудите эти вопросы на страница обсуждения. (Узнайте, как и когда удалить эти сообщения-шаблоны) Эта статья использует Разметка HTML. Пожалуйста помощь изменив разметку HTML на Вики-разметка где это уместно. Для получения помощи в поиске или замене проблемных тегов см. инструкции. (Февраль 2019 г.) Эта статья нужны дополнительные цитаты для проверка. Пожалуйста помоги улучшить эту статью к добавление цитат в надежные источники. Материал, не полученный от источника, может быть оспорен и удален Найдите источники: «Возведение в квадрат»  – Новости  · газеты  · книги  · ученый  · JSTOR (Февраль 2018 г.) (Узнайте, как и когда удалить этот шаблон сообщения) (Узнайте, как и когда удалить этот шаблон сообщения)

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

Основной метод

Эта секция может быть сбивает с толку или неясно читателям. В частности, в примере описывается алгоритм, отличный от алгоритма оставшейся части раздела, поскольку биты показателя степени рассматриваются в противоположном порядке. Пожалуйста, помоги нам прояснить раздел. Возможно обсуждение этого вопроса на страница обсуждения. (Апрель 2019) (Узнайте, как и когда удалить этот шаблон сообщения)

Метод основан на наблюдении, что для положительного целого числа п, у нас есть

${ displaystyle x ^ {n} = { begin {case} x , (x ^ {2}) ^ { frac {n-1} {2}}, & { mbox {if}} n { mbox {нечетно}} (x ^ {2}) ^ { frac {n} {2}}, & { mbox {if}} n { mbox {четно}}. end {cases} }}$

Этот метод использует биты экспоненты для определения вычисляемых степеней.

В этом примере показано, как вычислить ${ displaystyle x ^ {13}}$ Показатель 13 в двоичном формате равен 1101. Биты используются в порядке слева направо. Показатель степени имеет 4 бита, поэтому существует 4 итерации.

Сначала инициализируйте результат равным 1: ${ Displaystyle г leftarrow 1 , (= х ^ {0})}$.

Шаг 1) ${ Displaystyle г leftarrow г ^ {2} , (= х ^ {0})}$; бит 1 = 1, поэтому вычислить ${ Displaystyle г leftarrow г CDOT х , (= х ^ {1})}$;

Шаг 2) ${ Displaystyle г leftarrow г ^ {2} , (= х ^ {2})}$; бит 2 = 1, поэтому вычислить ${ Displaystyle г leftarrow г CDOT х , (= х ^ {3})}$;

Шаг 3) ${ Displaystyle г leftarrow г ^ {2} , (= х ^ {6})}$; бит 3 = 0, поэтому мы закончили этот шаг (эквивалентно, это соответствует ${ Displaystyle г leftarrow г CDOT х ^ {0} , (= х ^ {6})}$);

Шаг 4) ${ Displaystyle г leftarrow г ^ {2} , (= х ^ {12})}$; бит 4 = 1, поэтому вычислить ${ Displaystyle г leftarrow г CDOT х , (= х ^ {13})}$.

Если мы напишем ${ displaystyle n}$ в двоичном виде как ${ displaystyle b_ {k} cdots b_ {0}}$, то это эквивалентно определению последовательности ${ displaystyle r_ {k + 1}, ldots, r_ {0}}$ позволяя ${ displaystyle r_ {k + 1} = 1}$ а затем определение ${ displaystyle r_ {i} = r_ {i + 1} ^ {2} x ^ {b_ {i}}}$ за ${ Displaystyle я = к, ldots, 0}$, куда ${ displaystyle r_ {0}}$ будет равно ${ Displaystyle х ^ {п}}$.

Это может быть реализовано следующим образом рекурсивный алгоритм:

  Функция exp_by_squaring(Икс, п)    если п < 0  тогда возвращаться exp_by_squaring(1 / Икс, -п);    еще если п = 0  тогда возвращаться  1;    еще если п = 1  тогда возвращаться  Икс ;    еще если п является четное  тогда возвращаться exp_by_squaring(Икс * Икс,  п / 2);    еще если п является странный  тогда возвращаться Икс * exp_by_squaring(Икс * Икс, (п - 1) / 2);

Хотя нет хвостовой рекурсивный, этот алгоритм можно переписать в хвостовой рекурсивный алгоритм, введя вспомогательную функцию:

  Функция exp_by_squaring(Икс, п)    возвращаться exp_by_squaring2(1, Икс, п)  Функция exp_by_squaring2(у, Икс, п)    если п < 0  тогда возвращаться exp_by_squaring2(у, 1 / Икс, - п);    еще если п = 0  тогда возвращаться  у;    еще если п = 1  тогда возвращаться  Икс * у;    еще если п является четное  тогда возвращаться exp_by_squaring2(у, Икс * Икс,  п / 2);    еще если п является странный  тогда возвращаться exp_by_squaring2(Икс * у, Икс * Икс, (п - 1) / 2).

А хвостовой рекурсивный вариант также может быть построен с использованием пары аккумуляторов вместо вспомогательной функции, как показано на F # пример ниже. Накопители a1 и a2 можно рассматривать как хранящие значения ${ Displaystyle х ^ {я}}$ и ${ displaystyle x ^ {j}}$ где i и j инициализируются значениями 1 и 0 соответственно. В четном случае i удваивается, а в нечетном случае j увеличивается на i. Конечный результат ${ Displaystyle х ^ {я + j}}$ куда ${ Displaystyle я + J = п}$.

позволять exp_by_squaring Икс п =    позволять rec _exp Икс п ' а1 а2 =        если   п ' = 0   тогда 1        Элиф п ' = 1   тогда а1*а2        Элиф п '%2 = 0 тогда _exp Икс (п '/2) (а1*а1) а2        еще               _exp Икс (п '-1) а1 (а1*а2)    _exp Икс п Икс 1

Итерационная версия алгоритма также использует ограниченное вспомогательное пространство и задается формулой

  Функция exp_by_squaring_iterative(Икс, п)    если п < 0 тогда      Икс := 1 / Икс;      п := -п;    если п = 0 тогда возвращаться 1    у := 1;    пока п > 1 делать      если п является четное тогда         Икс := Икс * Икс;        п := п / 2;      еще        у := Икс * у;        Икс := Икс * Икс;        п := (п – 1) / 2;    возвращаться Икс * у

Вычислительная сложность

Краткий анализ показывает, что такой алгоритм использует ${ Displaystyle lfloor log _ {2} п rfloor}$ квадраты и самое большее ${ Displaystyle lfloor log _ {2} п rfloor}$ умножения, где ${ Displaystyle lfloor ; rfloor}$ обозначает функция пола. Точнее, количество умножений на единицу меньше, чем количество единиц, присутствующих в двоичное расширение из п. За п больше, чем примерно 4, это в вычислительном отношении более эффективно, чем наивное многократное умножение основания на себя.

Каждое возведение в квадрат приводит примерно к удвоению количества цифр предыдущего, и поэтому, если умножение двух d-значные числа реализованы в O (d^k) операции для некоторых фиксированных k, то сложность вычисления Икс^п дан кем-то

${ displaystyle sum limits _ {i = 0} ^ {O ( log n)} { big (} 2 ^ {i} O ( log x) { big)} ^ {k} = O { big (} (n log x) ^ {k} { big)}.}$

2^k-арный метод

Этот алгоритм вычисляет значение Икс^п после раскрытия экспоненты по основанию 2^k. Впервые это было предложено Брауэр в 1939 году. В приведенном ниже алгоритме мы используем следующую функцию ж(0) = (k, 0) и ж(м) = (s, ты), куда м = ты·2^s с ты странный.

Алгоритм:

Вход

Элемент Икс из грамм, параметр k > 0, неотрицательное целое число п = (п_л−1, п_л−2, ..., п₀)_2^k и предварительно вычисленные значения ${ displaystyle x ^ {3}, x ^ {5}, ..., x ^ {2 ^ {k} -1}}$.

Выход

Элемент Икс^п в грамм

у: = 1; я: = l - 1пока i ≥ 0 do (s, u): = f (nя)    за j: = 1 к к - с делать        у: = у2     у: = у * хты    за j: = 1 к s делать        у: = у2    я: = я - 1возвращаться у

Для оптимальной эффективности k должно быть наименьшим целым числом, удовлетворяющим^{[1][требуется разъяснение ]}

${ displaystyle log n <{ frac {k (k + 1) cdot 2 ^ {2k}} {2 ^ {k + 1} -k-2}} + 1.}$

Метод раздвижного окна

Этот метод является эффективным вариантом двух^k-арный метод. Например, чтобы вычислить показатель степени 398, который имеет двоичное расширение (110 001 110)₂, возьмем окно длиной 3, используя 2^kалгоритма метода и вычислить 1, x³, Икс⁶, Икс¹², Икс²⁴, Икс⁴⁸, Икс⁴⁹, Икс⁹⁸, Икс⁹⁹, Икс¹⁹⁸, Икс¹⁹⁹, Икс³⁹⁸. Но мы также можем вычислить 1, x³, Икс⁶, Икс¹², Икс²⁴, Икс⁴⁸, Икс⁹⁶, Икс¹⁹², Икс¹⁹⁸, Икс¹⁹⁹, Икс³⁹⁸, что экономит одно умножение и сводится к вычислению (110 001 110)₂

Вот общий алгоритм:

Алгоритм:

Вход

Элемент Икс из грамм, неотрицательное целое число п=(п_л−1, п_л−2, ..., п₀)₂, параметр k > 0 и предварительно вычисленные значения ${ displaystyle x ^ {3}, x ^ {5}, ..., x ^ {2 ^ {k} -1}}$.

Выход

Элемент Икс^п ∈ грамм.

Алгоритм:

у: = 1; я: = l - 1пока я> -1 делать    если пя = 0 тогда        у: = у2'i: = i - 1 еще        s: = max {i - k + 1, 0} пока пs = 0 делать            s: = s + 1[примечания 1]        за ч: = 1 к я - с + 1 делать            у: = у2        u: = (nя, пя-1, ..., пs)2        у: = у * хты        я: = s - 1возвращаться у

Лестничная техника Монтгомери

Многие алгоритмы возведения в степень не обеспечивают защиты от атаки по побочным каналам. А именно, злоумышленник, наблюдающий за последовательностью возведения в квадрат и умножения, может (частично) восстановить показатель степени, участвующий в вычислении. Это проблема, если показатель степени должен оставаться в секрете, как со многими криптосистемы с открытым ключом. Техника под названием "Монтгомери лестница"^[2] решает эту проблему.

Учитывая двоичное расширение положительного ненулевого целого числа п = (п_k−1...п₀)₂ с п_{к − 1} = 1, мы можем вычислить Икс^п следующее:

Икс1 = х; Икс2 = х2за i = k - от 2 до 0 делать    Если пя = 0 тогда        Икс2 = х1 * Икс2; Икс1 = х12    еще        Икс1 = х1 * Икс2; Икс2 = х22возвращаться Икс1

Алгоритм выполняет фиксированную последовательность операций (вплоть до бревноп): умножение и возведение в квадрат происходят для каждого бита в экспоненте, независимо от конкретного значения бита. Аналогичный алгоритм умножения на удвоение существует.

Эта конкретная реализация лестницы Монтгомери еще не защищена от кеширования. время атаки: задержки доступа к памяти могут по-прежнему наблюдаться злоумышленником, поскольку доступ к различным переменным зависит от значения битов секретной экспоненты. Современные криптографические реализации используют метод «разброса», чтобы гарантировать, что процессор всегда пропускает более быстрый кэш.^[3]

Показатель с фиксированной базой

Есть несколько методов, которые можно использовать для расчета Икс^п когда база фиксирована, а показатель степени меняется. Как видно, предварительные вычисления играют ключевую роль в этих алгоритмах.

Метод Яо

Метод Яо ортогонален 2^k-арный метод, в котором показатель раскрывается по основанию б = 2^k и вычисления выполняются в соответствии с приведенным выше алгоритмом. Позволять п, п_я, б, и б_я быть целыми числами.

Пусть показатель п быть написано как

${ displaystyle n = sum _ {i = 0} ^ {w-1} n_ {i} b_ {i},}$

куда ${ displaystyle 0 leqslant n_ {i}$ для всех ${ displaystyle i in [0, w-1]}$.

Позволять Икс_я = Икс^б_я.

Тогда алгоритм использует равенство

${ displaystyle x ^ {n} = prod _ {i = 0} ^ {w-1} x_ {i} ^ {n_ {i}} = prod _ {j = 1} ^ {h-1} { bigg [} prod _ {n_ {i} = j} x_ {i} { bigg]} ^ {j}.}$

Учитывая элемент Икс из грамм, а показатель степени п записанные в приведенной выше форме вместе с предварительно вычисленными значениями Икс^б₀...Икс^б_ш−1, элемент Икс^п рассчитывается по следующему алгоритму:

y = 1, u = 1, j = h - 1пока j> 0 делать    за я = 0 к w - 1 делать        если пя = j тогда            и = и × хбя    y = y × u j = j - 1возвращаться у

Если мы установим час = 2^k и б_я = час^я, то п_я значения - это просто цифры п в базе час. Метод Яо собирает ты первые те Икс_я которые кажутся высшей власти ${ displaystyle h-1}$; в следующем раунде те, у кого есть власть ${ displaystyle h-2}$ собраны в ты а также и т. д. Переменная у умножается ${ displaystyle h-1}$ раз с начальным ты, ${ displaystyle h-2}$ раз со следующими наибольшими степенями и т. д. алгоритм использует ${ Displaystyle ш + ч-2}$ умножения и ${ displaystyle w + 1}$ элементы должны быть сохранены для вычисления Икс^п.^[1]

Евклидов метод

Евклидов метод впервые был введен в Эффективное возведение в степень с использованием предварительных вычислений и цепочек сложения векторов пользователя P.D. Rooij.

Этот метод вычисления ${ Displaystyle х ^ {п}}$ в группе грамм, куда п является натуральным целым числом, алгоритм которого приведен ниже, рекурсивно использует следующее равенство:

${ displaystyle x_ {0} ^ {n_ {0}} cdot x_ {1} ^ {n_ {1}} = left (x_ {0} cdot x_ {1} ^ {q} right) ^ { n_ {0}} cdot x_ {1} ^ {n_ {1} mod n_ {0}},}$

куда ${ displaystyle q = left lfloor { frac {n_ {1}} {n_ {0}}} right rfloor}$Другими словами, евклидово деление экспоненты п₁ к п₀ используется для возврата частного q и отдых п₁ мод п₀.

Учитывая базовый элемент Икс в группе грамм, а показатель степени ${ displaystyle n}$ написано, как в методе Яо, элемент ${ Displaystyle х ^ {п}}$ рассчитывается с использованием ${ displaystyle l}$ предварительно вычисленные значения ${ displaystyle x ^ {b_ {0}}, ..., x ^ {b_ {l_ {i}}}}$ а затем алгоритм ниже.

Начать цикл       Находить ${ displaystyle M  in [0, l-1]}$, такой, что ${ displaystyle  forall i  in [0, l-1], n_ {M}  geq n_ {i}}$.    Находить ${ displaystyle N  in { big (} [0, l-1] -M { big)}}$, такой, что ${ displaystyle  forall i  in { big (} [0, l-1] -M { big)}, n_ {N}  geq n_ {i}}$.    Разрыв петли если ${ displaystyle n_ {N} = 0}$.    Позволять ${ Displaystyle д =  lfloor n_ {M} / n_ {N}  rfloor}$, а потом позволять ${ displaystyle n_ {N} = (n_ {M} { bmod {n}} _ {N})}$.    Вычислить рекурсивно ${ displaystyle x_ {M} ^ {q}}$, а потом позволять ${ Displaystyle x_ {N} = x_ {N}  cdot x_ {M} ^ {q}}$.Конец цикла;Возвращаться ${ displaystyle x ^ {n} = x_ {M} ^ {n_ {M}}}$.

Сначала алгоритм находит наибольшее значение среди п_я а затем супремум в наборе { п_я \ я ≠ M }.Затем поднимается Икс_M к власти q, умножает это значение на Икс_N, а затем назначает Икс_N результат этого вычисления и п_M Значение п_M по модулю п_N.

Дальнейшие приложения

Та же идея позволяет быстро вычислять большие показатели по модулю число. Особенно в криптография, полезно вычислять мощности в звенеть из целые числа по модулю q. Его также можно использовать для вычисления целочисленных степеней в группа, используя правило

Мощность(Икс, −п) = (Мощность (Икс, п))⁻¹.

Метод работает во всех полугруппа и часто используется для вычисления степеней матрицы.

Например, оценка

13789⁷²²³⁴¹ (мод. 2345) = 2029

потребовалось бы очень много времени и много места для хранения, если бы использовался наивный метод: вычислить 13789⁷²²³⁴¹, затем возьмите остаток при делении на 2345. Даже использование более эффективного метода займет много времени: возведите в квадрат 13789, возьмите остаток при делении на 2345, умножьте результат на 13789 и так далее. Это займет меньше чем ${ Displaystyle 2 журнал _ {2} (722340) leq 40}$ модульные умножения.

Применяя выше возведение в квадрат алгоритм, где "*" интерпретируется как Икс * у = ху mod 2345 (то есть умножение с последующим делением на остаток) приводит только к 27 умножениям и делениям целых чисел, которые все могут быть сохранены в одном машинном слове.

Примеры реализации

Вычисление по степеням двойки

Это нерекурсивная реализация вышеуказанного алгоритма в Рубин.

п = п - 1 избыточно, когда п = п / 2 неявно округляется до нуля, как это сделали бы строго типизированные языки с целочисленным делением. (п = п >> 1 имеет тот же эффект.) n [0] - крайний правый бит двоичного представления п, поэтому если он равен 1, то число нечетное, а если оно равно нулю, то число четное. Это также п по модулю 2. (п & 1 имеет тот же эффект.)

def мощность(Икс, п)  результат = 1  пока п.ненулевой?    если п[0].ненулевой?      результат *= Икс      п -= 1    конец    Икс *= Икс    п /= 2  конец  возвращаться результатконец

Пример выполнения: вычисление 3¹⁰

параметр x = 3 параметр n = 10 результат: = 1Итерация 1  n = 10 -> n четно x: = x2 = 32 = 9 п: = п / 2 = 5Итерация 2  n = 5 -> n нечетно -> результат: = результат * x = 1 * x = 1 * 32 = 9 n: = n - 1 = 4 x: = x2 = 92 = 34 = 81 п: = п / 2 = 2Итерация 3  n = 2 -> n четно x: = x2 = 812 = 38 = 6561 п: = п / 2 = 1Итерация 4  n = 1 -> n нечетно -> результат: = результат * x = 32 * 38 = 310 = 9 * 6561 = 59049 n: = n - 1 = 0 вернуть результат

Пример выполнения: вычисление 3¹⁰

результат: = 3bin: = "1010"Итерация для цифры 4:  результат: = результат2 = 32 = 9  1010мусорное ведро - Цифра равна «0» Итерация для цифры 3:  результат: = результат2 = (32)2 = 34  = 81  1010мусорное ведро - Цифра равна "1" -> результат: = результат * 3 = (32)2*3 = 35  = 243Итерация для цифры 2:  результат: = результат2 = ((32)2*3)2 = 310  = 59049  1010мусорное ведро - Цифра равна "0".

Этот пример основан на алгоритме выше. При ручном расчете следует идти слева направо. Если начальный номер равен 1, просто игнорируйте его. Затем, если следующий - один, возведите в квадрат и умножьте. Если следующий - ноль, только квадрат.

Расчет произведений мощностей

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

Пример

Формула а⁷×б⁵ можно рассчитать за 3 шага:

((а)²×а)²×а (4 умножения для расчета а⁷),

((б)²)²×б (3 умножения для расчета б⁵),

(а⁷)×(б⁵) (1 умножение для вычисления произведения двух),

итого получается 8 умножений.

Более быстрое решение - вычислить обе мощности одновременно:

((а×б)²×а)²×а×б,

что требует всего 6 умножений. Обратите внимание, что а×б рассчитывается дважды; результат может быть сохранен после первого вычисления, что сокращает количество умножений до 5.

Пример с числами:

2⁷×3⁵ = ((2×3)²×2)²×2×3 = (6²×2)²×6 = 72²×6 = 31104.

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

Использование трансформации

Пример выше а⁷×б⁵ также может быть вычислено только с 5 умножениями, если выражение преобразовано перед вычислением:

а⁷×б⁵ = а²×(ab)⁵, с ab := а×б,

ab := а×б (1 умножение),

а²×(ab)⁵ = ((ab)²×а)²×ab (4 умножения).

Обобщение преобразования показывает следующую схему:

Для расчета а^А×б^B×...×м^M×п^N

1. Определять ab := а×б, abc = ab×c, ...
2. Вычислить преобразованное выражение а^А−B×ab^B−C×...×abc..м^M−N×abc..мин^N.

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

Примеры

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

Перекодирование цифр со знаком

В некоторых вычислениях может быть более эффективным разрешить отрицательные коэффициенты и, следовательно, использовать инверсию базы, при условии инверсии в грамм является «быстрым» или рассчитанным заранее. Например, при вычислении Икс^2k−1, двоичный метод требует k−1 умножения и k−1 квадраты. Однако можно было выполнить k квадраты, чтобы получить Икс^2k а затем умножить на Икс⁻¹ чтобы получить Икс^2k−1.

Для этого определим представление цифр со знаком целого числа п в корне б в качестве

${ displaystyle n = sum _ {i = 0} ^ {l-1} n_ {i} b ^ {i} { text {with}} | n_ {i} |$

Знаковое двоичное представление соответствует конкретному выбору б = 2 и ${ displaystyle n_ {i} in {- 1,0,1 }}$. Обозначается он ${ Displaystyle (п_ {l-1} точки п_ {0}) _ {s}}$. Есть несколько методов вычисления этого представления. Представление не уникальное. Например, возьмите п = 478: два различных знаково-двоичных представления задаются ${ displaystyle (10 { bar {1}} 1100 { bar {1}} 10) _ {s}}$ и ${ displaystyle (100 { bar {1}} 1000 { bar {1}} 0) _ {s}}$, куда ${ displaystyle { bar {1}}}$ используется для обозначения −1. Поскольку двоичный метод вычисляет умножение для каждой ненулевой записи в представлении с основанием 2 п, мы заинтересованы в нахождении двоичного представления со знаком с наименьшим числом ненулевых элементов, то есть с минимальный Вес Хэмминга. Один из способов сделать это - вычислить представление в несмежная форма, или сокращенно NAF, который удовлетворяет ${ displaystyle n_ {i} n_ {i + 1} = 0 { text {для всех}} i geqslant 0}$ и обозначается ${ displaystyle (n_ {l-1} dots n_ {0}) _ { text {NAF}}}$. Например, представление NAF для 478 - это ${ displaystyle (1000 { bar {1}} 000 { bar {1}} 0) _ { text {NAF}}}$. Это представление всегда имеет минимальный вес Хэмминга. Простой алгоритм вычисления представления NAF заданного целого числа ${ Displaystyle п = (п_ {l} п_ {l-1} точки n_ {0}) _ {2}}$ с ${ displaystyle n_ {l} = n_ {l-1} = 0}$ следующее:

${ displaystyle c_ {0} = 0}$за я = 0 к л − 1 делать ${ Displaystyle c_ {я + 1} =  left  lfloor { frac {1} {2}} (c_ {i} + n_ {i} + n_ {i + 1})  right  rfloor}$  ${ displaystyle n_ {i} '= c_ {i} + n_ {i} -2c_ {i + 1}}$возвращаться ${ Displaystyle (п_ {l-1} ' точки n_ {0}') _ { текст {НАФ}}}$

Другой алгоритм Коямы и Цуруока не требует условия, что ${ Displaystyle п_ {я} = п_ {я + 1} = 0}$; он по-прежнему минимизирует вес Хэмминга.

Альтернативы и обобщения

Возведение в степень возведением в квадрат можно рассматривать как неоптимальный возведение в степень алгоритм: он вычисляет показатель степени по добавочная цепочка состоящий из повторяющихся удвоений экспоненты (возведения в квадрат) и / или увеличения показателя степени на один (умножение на Икс) Только. В более общем плане, если можно любой ранее вычисленные показатели для суммирования (путем умножения этих степеней Икс), иногда можно выполнить возведение в степень, используя меньшее количество умножений (но обычно с использованием большего объема памяти). Наименьшая мощность, при которой это происходит, - для п = 15:

${ Displaystyle х ^ {15} = х раз (х раз [х раз х ^ {2}] ^ {2}) ^ {2}}$ (возведение в квадрат, 6 умножений),

${ Displaystyle х ^ {15} = х ^ {3} раз ([х ^ {3}] ^ {2}) ^ {2}}$ (оптимальная цепочка сложения, 5 умножений, если Икс³ используется повторно).

В общем, найдя оптимальный сложение цепочки для заданного показателя степени является сложной задачей, для которой не известны эффективные алгоритмы, поэтому оптимальные цепочки обычно используются только для малых показателей (например, в компиляторы где цепочки для малых мощностей предварительно сведены в таблицу). Однако есть ряд эвристический алгоритмы, которые, хотя и не являются оптимальными, имеют меньше операций умножения, чем возведение в степень путем возведения в квадрат за счет дополнительной бухгалтерской работы и использования памяти. Тем не менее, число умножений никогда не растет медленнее, чем Θ (бревно п), поэтому эти алгоритмы улучшаются асимптотически только после возведения в степень путем возведения в квадрат в лучшем случае с постоянным множителем.

Смотрите также

• Модульное возведение в степень
• Векторная цепочка сложения
• Редукция Монтгомери
• Несмежная форма
• Цепочка добавления

Примечания

Рекомендации