11. Алгоритмы быстрого умножения чисел

Алгоритм Карацубы — метод быстрого умножения со сложностью вычисления n^log₂³. В то время, как наивный алгоритм, умножение в столбик, требует n² операций. Следует заметить, что при длине чисел короче нескольких десятков знаков (точнее определяется экспериментально), быстрее работает обычное умножение. Представим, что есть два числа A и B длиной n в какой-то системе счисления BASE: A = a_n-1a_n-2...a₀ B = b_n-1a_n-2...a₀, где a_?, b_? — значение в соотв. разряде числа. Каждое из них можно представить в виде суммы их двух частей, половинок длиной m = n / 2 (если n нечетное, то одна часть короче другой на один разряд: A₀ = a_m-1a_m-2...a₀ A₁ = a_n-1a_n-2...a_m A = A₀ + A₁ * BASE^m B₀ = b_m-1b_m-2...b₀ B₁ = b_n-1b_n-2...b_m B = B₀ + B₁ * BASE^m Тогда: A * B = ( A₀ + A₁ * BASE^m ) * ( B₀ + B₁ * BASE^m ) = A₀ * B₀ + A₀ * B₁ * BASE^m + A₁ * B₀ * BASE^m + A₁ * B₁ * BASE^{2 * m} = A₀ * B₀ + ( A₀ * B₁ + A₁ * B₀ ) * BASE^m + A₁ * B₁ * BASE^{2 * m} Здесь нужно 4 операции умножения (части формулы * BASE^{? * m} не являются умножением, фактически указывая место записи результата, разряд). Но с другой стороны: ( A₀ + A₁ ) * ( B₀ + B₁ ) = A₀ * B₀ + A₀ * B₁ + A₁ * B₀ + A₁ * B₁ Посмотрев на выделенные части в обоих формулах. После несложных преобразований количество операций умножения можно свести к 3-м, заменив два умножения на одно и несколько операций сложения и вычитания, время выполнения которых на порядок меньше: A₀ * B₁ + A₁ * B₀ = ( A₀ + A₁ ) * ( B₀ + B₁ ) — A₀ * B₀ — A₁ * B₁ Окончательный вид выражения: A * B = A₀ * B₀ + (( A₀ + A₁ ) * ( B₀ + B₁ ) — A₀ * B₀ — A₁ * B₁ ) * BASE^m + A₁ * B₁ * BASE^{2 * m} Графическое представление:

Пример Для примера умножим два восьмизначных числа в десятичной системе 12345 и 98765: Из изображении явно видна рекурсивная природа алгоритма. Для числа длиной менее четырех разрядов применялось наивное умножение.

Быстрое преобразование Фурье

Будем считать, что наш многочлен имеет степень n=2^k. Если нет, дополним старшие коэффициенты нулями до ближайшей степени двойки. Основная идея БПФ: Пусть: A(x)=a₀+xa₂+x²a₄+...+x^n/2-1a_n-2 (четные коэффициэнты P) B(x)=a₁+xa₃+x²a₅+...+x^n/2-1a_n-1 (нечётные коэффициенты P). Тогда P(x)=A(x²)+x⋅B(x²). Теперь применим принцип «разделяй и властвуй»: чтобы посчитать значения P в n точках (ω₀,ω₁,...), посчитаем значения A и B рекурсивно в n/2 точках (ω₀,ω₂,...). Теперь значение P(ω_i) восстановить достаточно просто: P(ω_i)=A(ω_2i)+ω_i⋅B(ω_2i) Если обозначить за ξ_i=ω_2i точки, в которых мы считаем значения многочлена степени n/2, формула преобразится: P(ω_i)=A(ξ_i)+ω_i⋅B(ξ_i) Её уже можно загонять в программу, не забыв что i принимает значения от 0 до n-1, а ξ_i определено лишь от 0 до n/2-1. Вывод — надо будет взять i по модулю n/2. Время работы выражается рекуррентной формулой T(n)=O(n)+2T(n/2). Это довольно известное соотношение и оно раскрывается в O(n⋅log₂n) (грубо говоря, глубина рекурсии — log₂n уровней, на каждом уровне суммарно по всем вызовам выполняется O(n) операций).

12. Алгоритм Тоома Кука

Исходными данными служат два положительных длинных числа [n, u] и [n, v]; результатом - их произведение [2n, uv]. Используются четыре стека U, V, W и C, в которых при выполнении алгоритма будут храниться длинные числа, и пятый стек, содержащий коды временно приостановленных операций (имеется всего три кода, и для их представления можно воспользоваться малыми целыми числами). Массивы q и г целых чисел имеют индексы от 0 до 10; необходимо выделить память для этих двух массивов и для еще нескольких временных переменных, упомянутых в алгоритме.

1. (Начальная установка.) Сделать все стеки пустыми. Присвоить K значение 1, q₀ и q₁ - значение 16, r₀ и r₁ - значение 4, Q - значение 4 и R - значение 2.

2. (Построение таблицы размеров). Пока K < 10 и q_K-1 + q_K ≥ n, выполнять следующие вычисления. Изменить К на К+1, Q - на Q + R; если (R+1)₂ ≤ Q, то изменить R на R+1; установить q_K равным 2^Q и r_k равным 2^R. Если цикл оканчивается из-за K = 10, то остановиться, выдав сообщение об ошибке - число битов n слишком велико, массивы q и г переполнились. В противном случае присвоить k значение K. Поместить [q_K + q_K-1, v] и за ним [q_K + q_K-1, n] в стек C (вероятно, потребуется добавить к [n, u] и [n, v] слева нули). Поместить в управляющий стек код стоп.

3. (Главный внешний цикл.) Пока управляющий стек не пуст, выполнять шаги с 4-го по 18-й. Если на этом шаге управляющий стек окажется пустым, то остановиться с сообщением об ошибке; в управляющем стеке должен быть по крайней мере один элемент.

4. (Внутренний цикл разбиения u и v.) Пока k > 1, выполнять шаги с 5-го по 8-й,

5. (Установка параметров разбиения.) Установить k равным k - 1, s равным q_k, t равным r_k и p равным q_k-1 + q_k.

6. (Разбиение верхнего элемента стека C.) Длинное число [q_k + q_k+1, u] на вершине C следует рассматривать как t + 1 чисел длиной s битов каждое. Разбить [q_k + q_k+1, u] на длинные числа [s, U_t], [s, U_t-1], ..., [s, U₁], [s, U₀]. Эти t + 1 чисел являются коэффициентами многочлена степени t, который следует вычислить в точках 0, 1, ..., 2t - l, 2t no правилу Горнера. Для i = 0, 1, ..., 2t - l, 2t вычислить [p, X_i] по формуле (...([s, U_t]·i + ... + [s, U₁]·i + [s, U₀] и сразу поместить [p, X_i] в стек U. Для выполнения умножений можно использовать подпрограмму умножения длинных чисел на короткие; никакой промежуточный или окончательный результат не потребует более p битов. Удалить [q_k+q_k-1, u] из стека C.

7. (Продолжение разбиения.) Выполнить над числом [m, v], находящимся сейчас на вершине стека C, ту же последовательность действий, что на шаге 6; полученные числа [p, Y₀], ...,[p, Y_2t] поместить в стек V в порядке получения. Не забудьте удалить вершину стека C.

8. (Заполнение заново стека C.) Попеременно удалять 2t раз) вершины стеков V и U и помещать эти значения в стек C. В результате значения, вычисленные на шагах 6 и 7, будут помещены, чередуясь, в стек C в обратном порядке. После выполнения этого перемешивания верхняя часть стека C, рассматриваемая снизу вверх, будет иметь вид [p, Y_2t], [p, X_2t], ..., [p, Y₀], [p, X₀], на вершине будет [p, X₀]. Поместить в управляющий стек один код операции интерполировать и 2t кодов операции сохранять и вернуться к шагу 4.

9. (Подготовка к интерполяции.) Присвоить k значение 0. Выбрать два верхних элемента стека C и поместить их в обычные переменные u и v. Оба числа u и v будут состоять из 32 битов. Используя некоторую другую подпрограмму умножения, вычислить [64, w] = [64, uv]. Это умножение можно выполнить аппаратно или с помощью подпрограммы, как вы найдете нужным.

10. (Интерполяция при необходимости.) Выбрать вершину управляющего стека в переменную A. Если значение A есть интерполировать, то выполнить шаги с 11-го по 16-й, в противном случае перейти к шагу 17.

11. (Организация интерполяции.) Поместить [m, w] в стек W (это может быть значение, полученное на шаге 9 или 16). Присвоить s значение q_k, t - значение r_k, р - значение q_k-i + q_k. Обозначим верхнюю часть стека W, рассматриваемую снизу вверх, как [2р, Z₀], [2p, Z₁], ..., [2р, Z_2t-1], [2p, Z_2t], последнее из этих значений - на вершине стека.

12. (Внешний цикл деления Z.) Выполнять шаг 13 для i = 1, 2, 2t.

13. (Внутренний цикл деления Z.) Присвоить [2p, Z_j] значение ([2p, Z_j] - [2p, Z_j-1])/i для j =2t, 2t - 1, ..., i + 1, i. Все разности будут положительными, а все деления выполняются нацело, т. е. без остатка.

14. (Внешний цикл умножения Z.) Выполнять шаг 15 для i = 2t-1, 2t-2, ..., 2, 1.

15. (Внутренний цикл умножения Z.) Заменить [2р, Z_j] на [2р, Z_j] - i·[2р, Zj+1] для j = i, i+1, ..., 2t-2, 2t-1. Все разности будут положительными, и все результаты поместятся в 2p битов.

16. (Образование нового w и начало нового цикла.) Присвоить значение многочлена (... ([2р, Z_2t]·2^s + [2р, Z_2t-1])·2^s + ... + [2р, Z₁])·2^s + [2р, Z₀] переменной [2(q_k + q_k+1), w]. Этот шаг можно выполнять, используя только сдвиги и сложения длинных чисел. Заметьте, что используется та же переменная [m, w], что и на шаге 9. Удалить [2p, Z_2t], ..., [2p, Z₀] из стека W. Присвоить k значение k + 1 и вернуться к шагу 10.

17. (Проверка окончания.) Если A имеет значение стоп, то в переменной [m, w], уже вычисленной на шаге 9 или 16, находится результат алгоритма. В этом случае окончить работу.

18. (Сохранение значения.) Значением A должен быть код сохранить (если это не так, завершить алгоритм по ошибке). Присвоить k значение k + 1 и поместить [q_k + q_k-1, w] в стек W. Это значение w, только что вычисленное на шаге 9 или 16. Теперь вернуться к шагу 3.