Prime Numbers

9.5 Large-integer multiplication 495
(2) Perform length-D weighted convolution, with weight generator A a
primitive (2D)-th root of unity, do carry adjust as necessary.
(3) Create length-(D/2) “fold-over” signals, as x ′ = L(x) +iH(x) and
similarly for a y ′ , employ a weighted convolution with generator A a
primitive (4D)-th root of unity, do carry adjust.
Method (1) could, of course, involve Algorithm 9.5.12, with perhaps a
fast Fermat-mod of Section 9.2.3; but one could instead use a pureinteger
Nussbaumer convolution discussed later. Method (2) is the negacyclic
approach, in which the weighted convolution can be seen to be multiplication
(mod Fn); that is, the mod operation is “free” (see Exercises). Method (3)
is the right-angle convolution approach, which also gives the mod operation
for free (see Exercises). Note that neither method (2) nor method (3) involves
zero-padding, and that method (3) actually halves the signal lengths (at the
expense of complex arithmetic). We focus on method (3), to state the following
algorithm, which, as with Algorithm 9.5.12, is often implemented in a floatingpoint
paradigm:
Algorithm 9.5.17 (DWT multiplication modulo Fermat numbers). For a
given Fermat number Fn =22n +1, and positive integers x, y ≡ −1(modFn),
this algorithm returns (xy) modFn. We choose B,D such that Fn = BD +1,
with the inputs x, y interpreted as length-D signals of base-B digits. We assume
that there exists a primitive 4D-th root of unity, A, in the field.
1. [Initialize]
E = D/2; // Halve the signal length and “fold-over” the signals.
x = L(x)+iH(x); // Length-E signals.
y = L(y)+iH(y);
a = 1,A,A 2 ,...,A E−1 ; // Weight signal.
2. [Apply transforms]
X = DWT(x, a); // Via an efficient length-E FFT algorithm.
Y = DWT(y, a);
3. [Dyadic product]
Z = X ∗ Y ;
4. [Inverse transform]
z = DWT −1 (Z, a);
5. [Unfold signal]
z =Re(z) ∪ Im(z); // Now z will have length D.
6. [Round digits]
z = round(z); // Elementwise rounding to nearest integer.
7. [Adjust carry in base B]
carry =0;
for(0 ≤ n