Algoritmo radice quadrata intera precisione arbitraria?

Esistono algoritmi subquadratici noti per il calcolo del pavimento della radice quadrata di un nintero di bit?

L'algoritmo ingenuo sarebbe qualcosa di simile

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

Questo richiede O(n)iterazioni, ognuna delle quali prevede aggiunte che sono il O(n)tempo, quindi è il O(n^2)tempo complessivo. C'è qualcosa di più veloce? So che per il caso della moltiplicazione ci sono algoritmi speciali che fanno meglio del tempo quadratico, ma non riesco a trovare nulla per le radici quadrate.

È possibile utilizzare il metodo di Newton o uno qualsiasi dei numerosi altri metodi per trovare approssimazioni alle radici del polinomio .$p(x) = x^2 -c$

Il tasso di convergenza per il metodo di Newton sarà quadratico, il che significa che il numero di bit corretti raddoppia in ciascuna iterazione. Ciò significa che sono sufficienti iterazioni del metodo di Newton.$O(\lg n)$

Viene calcolata ogni iterazione del metodo di Newton

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

La complessità in bit della moltiplicazione è O ( b lg b ) , per moltiplicare due numeri interi a b b (ignorando i fattori lg lg b ). La complessità dei bit per la divisione (a b bit di precisione) è la stessa. Pertanto, ogni iterazione può essere calcolata in operazioni O ( n lg n ) . Moltiplicando per le iterazioni O ( lg n ) , troviamo che il tempo di esecuzione complessivo per calcolare la radice quadrata in n bit di precisione è O ( n ( lg n$\stackrel{~}{O}(b \lg b)$$b$$\lg \lg b$$b$$\stackrel{~}{O}(n \lg n)$$O(\lg n)$$n$ . Questo è sub-quadratico.$\stackrel{~}{O}(n (\lg n)^2)$

Penso che un'analisi più attenta mostri che questo può essere migliorato al tempo di esecuzione di O ( n lg n ) (tenendo conto del fatto che dobbiamo solo conoscere ogni x j entro circa j bit di precisione, piuttosto che n bit di precisione) . Tuttavia, anche l'analisi più basilare mostra già un tempo di esecuzione chiaramente subquadratico.$\stackrel{~}{O}(n \lg n)$$x_j$$j$$n$

Uno dei problemi con il metodo di Newton è che richiede un'operazione di divisione in ogni iterazione, che è l'operazione intera di base più lenta.

Tuttavia, il metodo di Newton per la radice quadrata reciproca no. Se è il numero per il quale si desidera trovare $x$ , iterare:$\frac{1}{\sqrt x}$

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

Questo è spesso espresso come:

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

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

Sono tre operazioni di moltiplicazione. La divisione per due può essere implementata come spostamento a destra.

Ora il problema è che non è un numero intero. Tuttavia, è possibile manipolarlo come tale implementando manualmente il virgola mobile e facendo una serie di operazioni di spostamento per compensare, se del caso.$r$

Innanzitutto, ridimensioniamo :$x$

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

dove vorremmo che fosse maggiore di, ma vicino a, 1 . Se eseguiamo l'algoritmo sopra su x ′ anziché su x , troviamo$x'$$1$$x'$$x$$r = \frac{1}{\sqrt x'}$ . Quindi, .$\sqrt{x} = 2^e r x'$

Adesso dividiamoci in una mantissa ed esponente:$r$

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

dove $r'_i$ è un numero intero. Intuitivamente, rappresento la precisione della risposta.$e_i$

Sappiamo che il metodo di Newton raddoppia approssimativamente il numero di cifre significative accurate. Quindi possiamo scegliere:

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

Con un po 'di manipolazione, troviamo:

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}}}$$ r ′ i + 1 =2eir ′ i -r ′ i $$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}}$$

Ad ogni iterazione:

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

Ad esempio, proviamo a calcolare la radice quadrata di . Ci capita di sapere che la risposta è 2 $x = 2^{63}$ . La radice quadrata reciproco è$2^{31}\sqrt{2}$, quindi imposteremoe=31(questa è la scala del problema) e per la nostra ipotesi iniziale sceglieremor′0=3ede0=2. (Cioè, scegliamo$\frac{1}{\sqrt{2}} 2^{-31}$$e = 31$$r'_0 = 3$$e_0 = 2$ per la nostra stima iniziale a$\frac{3}{4}$$\frac{1}{\sqrt{2}}$ )

Poi:

e 2 = 8 , r ′ 2 = 180 e 3 = 16 , r ′ 3 = 46338 e 4 = 32 , r ′ 4 =

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

Possiamo capire quando interrompere l'iterazione confrontando con e ; se ho calcolato correttamente, e i > 2 e dovrebbe essere abbastanza buono. Ci fermeremo qui, però, e troveremo:$e_i$$e$$e_i > 2e$

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

$3037000499$$e_i$

$b$$O(b \log b)$$r'_i < 2^{e_i}$$w_i$$e_i$$e_{i+1}$$e_{i+1}$$2e_{i+1}$-bit numero.

$O(e_i \log e_i)$$O(\log e)$$O(2e \log 2e)$$O(e \log^2 e)$$x$ . Questo spunta tutte le caselle.

Tuttavia, questa analisi nasconde un principio importante che tutti coloro che lavorano con numeri interi grandi dovrebbero tenere a mente: poiché la moltiplicazione è superlineare nel numero di bit, qualsiasi operazione di moltiplicazione dovrebbe essere eseguita solo su numeri interi che hanno all'incirca l'entità della precisione corrente (e , Potrei aggiungere, dovresti provare a moltiplicare i numeri che hanno un ordine di grandezza simile). L'uso di numeri interi più grandi di questo è uno spreco di sforzi. I fattori costanti contano e per i numeri interi grandi contano molto.

$\frac{ab}{2^c}$$ab$$c$