Prime Numbers

472 Chapter 9 FAST ALGORITHMS FOR LARGE-INTEGER ARITHMETIC
}
q =0;
while(v2(r) ≤ v2(y)) {
q = q − 2 v2(r)−v2(x) ;
r = r − 2 v2(r)−v2(y) y;
}
q = q cmod 2 v2(y)−v2(x)+1 ;
r = x + qy/2 v2(y)−v2(x) ;
return (q, r);
5. [Half-binary gcd function (recursive)]
hbingcd(k, x, y) {
// Matrix returned; G, u, v, k1,k2,k3,q,r are local.
1 0
G = ;
0 1
if(v2(y) >k) return G;
k1 = ⌊k/2⌋;
k3 =22k1+1 ;
u = x mod k3;
v = y mod k3;
G = hbingcd(k1,u,v); // Recurse.
(u, v) T = G(x, y) T ;
k2 = k − v2(v);
if(k2 < 0) return G;
(q, r) =divbin(u, v);
k3 =2v2(v)−v2(u) ;
0 k3
G =
G;
k3 q
k3 =22k2+1 ;
u = v2−v2(v) mod k3;
v = r2−v2(v) mod k3;
G = hbingcd(k2,u,v)G;
return G;
}
See the last part of Exercise 9.20 for some implicit advice on what operations
in Algorithm 9.4.7 are relevant to good performance. In addition, note that
to achieve the remarkably low complexity of either of these recursive gcds,
the implementor should make sure to have an efficient large-integer multiply.
Whether the multiply occurs in a matrix multiplication, or anywhere else, the
use of breakover techniques should be in force. That is, for small operands
one uses grammar-school multiply, then for larger operands one may employ
a Karatsuba or Toom–Cook approach, but use one of the optimal, FFT-based
options for very large operands. In other words, the multiplication complexity
M(N) appearing in the complexity formula atop the present section needs
be taken seriously upon implementation. These various fast multiplication
algorithms are discussed later in the chapter (Sections 9.5.1 and 9.5.2).