Algoritmo de precisão de raiz quadrada inteira de precisão arbitrária?

Existem algoritmos subquadráticos conhecidos para calcular o piso da raiz quadrada de um nnúmero inteiro de bit?

O algoritmo ingênuo seria algo como

def sqrt(x):
    r = 0
    i = x.bit_length() // 2
    while i >= 0:
        inc = (r << (i+1)) + (1 << (i*2))
        if inc <= x:
            x -= inc
            r += 1 << i
        i -= 1
    return r

Isso requer O(n)iterações, cada uma envolvendo adições que são de O(n)tempo, portanto é a O(n^2)hora geral. Existe algo mais rápido? Eu sei que, no caso da multiplicação, existem algoritmos especiais que se saem melhor que o tempo quadrático, mas não consigo encontrar nada para raízes quadradas.

Você pode usar o método de Newton ou qualquer outro método para encontrar aproximações às raízes do polinômio .$p(x) = x^2 -c$

A taxa de convergência para o método de Newton será quadrática, o que significa que o número de bits corretos dobra em cada iteração. Isso significa que as iterações do método de Newton são suficientes.$O(\lg n)$

Cada iteração do método de Newton calcula

$$x_{j+1} = x_j - (x_j^2 -c)/(2x_j) = 0.5 x_j + \frac{c}{2x_j}.$$

A complexidade de bits da multiplicação é O ( b lg b ) , para multiplicar dois números inteiros de b bits (ignorando os fatores lg lg b ). A complexidade de bits para divisão (para b bits de precisão) é a mesma. Portanto, cada iteração pode ser calculada em operações O ( n lg n ) . Multiplicando por O ( lg n ) iterações, descobrimos que o tempo de execução geral para calcular a raiz quadrada em n bits de precisão é O ( n ( lg n$\stackrel{~}{O}(b \lg b)$$b$$\lg \lg b$$b$$\stackrel{~}{O}(n \lg n)$$O(\lg n)$$n$ . Isso é sub-quadrático.$\stackrel{~}{O}(n (\lg n)^2)$

Penso que uma análise mais cuidadosa mostra que isso pode ser aprimorado para O ( n lg n ) tempo de execução (levando em consideração que precisamos apenas conhecer cada x j dentro de j bits de precisão, em vez de n bits de precisão) . No entanto, mesmo a análise mais básica já mostra um tempo de execução claramente subquadrático.$\stackrel{~}{O}(n \lg n)$$x_j$$j$$n$

Um dos problemas com o método de Newton é que ele requer uma operação de divisão em cada iteração, que é a operação inteira básica mais lenta.

O método de Newton para a raiz quadrada recíproca , no entanto, não. Se é o número para o qual você deseja encontrar $x$ , itere:$\frac{1}{\sqrt x}$

$$r_{i+1} = \frac{1}{2} r_i (3 - x r_i^2)$$

Isso geralmente é expresso como:

d i = 1 - w i x r i + 1 = r i + r i d

$$w_i = r_i^2$$ $$d_i = 1 - w_i x$$ $$r_{i+1} = r_i + \frac{r_i d_i}{2}$$

São três operações de multiplicação. A divisão por dois pode ser implementada como shift-right.

Agora, o problema é que não é um número inteiro. No entanto, você pode manipulá-lo dessa maneira implementando o ponto flutuante manualmente e executando várias operações de turno para compensar quando apropriado.$r$

Primeiro, vamos redimensionar :$x$

$$x' = 2^{-2e} x$$

onde gostaríamos que fosse maior que, mas próximo a 1 . Se executarmos o algoritmo acima em x ′ em vez de x , encontraremos r $x'$$1$$x'$$x$. Então,$r = \frac{1}{\sqrt x'}$$\sqrt{x} = 2^e r x'$ .

Agora vamos dividir $r$ em uma mantissa e expoente:

$$r_i = 2^{-e_i} r'_i$$

onde é um número inteiro. Intuitivamente, um e i representam a precisão da resposta.$r'_i$$e_i$

Sabemos que o método de Newton praticamente dobra o número de dígitos significativos precisos. Para que possamos escolher:

$$e_{i+1} = 2e_i$$

Com um pouco de manipulação, encontramos:

w i = r ′ i 2 x ′ i =

$$e_{i+1} = 2e_i$$ $$w_i = {r'_i}^2$$ di=2ei+1-w ′ i x ′ $$x'_i = \frac{x}{2^{2e - e_{i+1}}}$$ $$d_i = 2^{e_{i+1}} - \frac{w_i' x'_i}{2^{e_{i+1}}}$$ $$r'_{i+1} = 2^{e_i} r'_i - \frac{r'_i d_i}{2^{e_i + 1}}$$

A cada iteração:

$$\sqrt{x} \approx \frac{r'_i x}{2^{e + e_i}}$$

As an example, let's try calculating the square root of $x = 2^{63}$. We happen to know that the answer is $2^{31}\sqrt{2}$. The reciprocal square root is $\frac{1}{\sqrt{2}} 2^{-31}$, so we'll set $e = 31$ (this is the scale of the problem) and for our initial guess we'll pick $r'_0 = 3$ and $e_0 = 2$. (That is, we pick $\frac{3}{4}$ for our initial estimate to $\frac{1}{\sqrt{2}}$.)

Then:

$$e_1 = 4, r'_1 = 11$$ $$e_2 = 8, r'_2 = 180$$ $$e_3 = 16, r'_3 = 46338$$ $$e_4 = 32, r'_4 = 3037000481$$

We can work out when to stop iterating by comparing $e_i$ to $e$; if I've calculated correctly, $e_i > 2e$ should be good enough. We'll stop here, though, and find:

$$\sqrt{2^{63}} \approx \frac{3037000481 \times 2^{63}}{2^{31+32}} = 3037000481$$

The correct integer square root is $3037000499$, so we're pretty close. We could do another iteration, or do an optimised final iteration which doesn't double $e_i$. The details are left as an exercise.

To analyse the complexity of this method, note that multiplying two $b$-bit integers takes $O(b \log b)$ operations. However, we have arranged things so that $r'_i < 2^{e_i}$. So the multiplication to calculate $w_i$ multiplies two $e_i$-bit numbers to produce a $e_{i+1}$-bit number, and the other two multiplications multiply two $e_{i+1}$-bit numbers to produce a $2e_{i+1}$-bit number.

In each case, the number of operations per iteration is $O(e_i \log e_i)$, and there are $O(\log e)$ iterations required. The final multiplication is on the order of $O(2e \log 2e)$ operations. So the overall complexity is $O(e \log^2 e)$ operations, which is sub-quadratic in the number of bits in $x$. That ticks all the boxes.

However, this analysis hides an important principle which everyone working with large integers should keep in mind: because multiplication is superlinear in the number of bits, any multiplication operations should only be performed on integers which have the roughly the magnitude of the current precision (and, I might add, you should try to multiply numbers together which have a similar order of magnitude). Using integers larger than that is a waste of effort. Constant factors matter, and for large integers, they matter a lot.

As a final observation, two of the multiplications are of the form $\frac{ab}{2^c}$. Clearly it's wasteful to compute the all the bits of $ab$ only to throw $c$ of them away with a right-shift. Implementing a smart multiplication method which takes this into account is also left as an exercise.