Calcola la radice quadrata usando (bit) aggiunte e spostamenti come primitive

Domanda: Dato un -bit numero naturale , come calcolare utilizzando solo aggiunte e turni (bit)?$n$$N$$\lceil \sqrt{N} \rceil$$O(n)$

Il consiglio è di usare la ricerca binaria. Tuttavia, non sono riuscito a raggiungere la complessità richiesta (ho ottenuto ).$O(n^2)$

Cosa significa using only $O(n)$ (bit) additions and shifts:

Questo è un esercizio in un libro sugli algoritmi.
A mio avviso, significa che aggiungere due, diciamo -bit, i numeri naturali costa e spostare a, diciamo -bit, il numero naturale costa anche . Poi ci sono solo permesso di utilizzare tale operazioni volte. Non menziona il costo del confronto. Suppongo che possiamo ignorarlo o supporre che il confronto di due, diciamo bit, numeri naturali costa anche .$n$$O(1)$$n$$O(1)$$O(1)$$O(n)$
$n$$O(1)$

Il mio algoritmo$O(n^2)$ :

1. Determina l'intervallo del numero di bit di : Pertanto, $t$$\lceil \sqrt{N} \rceil$ $$2^{\frac{n-1}{2}} \le \sqrt{N} \le 2^{\frac{n}{2}} \Rightarrow 2^{\lfloor \frac{n-1}{2} \rfloor} \le \lceil \sqrt{N} \rceil \le 2^{\lceil \frac{n}{2} \rceil}$$ $$t_1 \triangleq \lfloor \frac{n-1}{2} \rfloor + 1 \le t \le \lceil \frac{n}{2} \rceil + 1 \triangleq t_2.$$
2. Ricerca binaria: trova $\lceil \sqrt{N} \rceil$ tra $2^{t_1}$ e $2^{t_2}$ usando la ricerca binaria. Per ciascun numero $x$ , per calcolare $x^2$ con aggiunte e spostamenti come primitivi e confrontarlo con $N$ .

La complessità è quindi per tempi di ricerca binaria e calcolo , ciascuno dei quali a sua volta prende aggiunte e spostamenti.$O(n \times n) = O(n^2)$$O(n)$$x^2$$O(n)$

Un algoritmo iterativo sembra che dovrebbe funzionare.

Sia . Supponiamo di sapere che è l'approssimazione intera a , cioè , e supponiamo di conoscere il valore di (ottenuto in precedenza).$M=\lfloor N/4 \rfloor$$x$$\sqrt{M}$$x=\lceil \sqrt{M} \rceil$$x^2$

Ora vogliamo trovare . Quali sono i possibili valori di ? Sono abbastanza sicuro che gli unici valori possibili siano oppure . Ed è facile provarli entrambi e vedere quale è corretto. In particolare, per , abbiamo , che può essere ottenuto da mediante due spostamenti a sinistra ( ); per , abbiamo , che può essere ottenuto da e con quattro turni a sinistra e due aggiunte ( ). Ora confronta questi due valori con$y=\lceil \sqrt{N} \rceil$$y$$y=2x$$y=2x+1$$y=2x$$y^2=4x^2$$x^2$$O(1)$$y=2x+1$$y^2=4x^2+4x+1$$x^2$$x$$O(1)$$N$ per vedere quale è corretto.

In questo modo, otteniamo un algoritmo iterativo in cui eseguiamo iterazioni e in cui ogni iterazione richiede tempo . Il tempo di esecuzione totale è , come richiesto.$n/2$$O(1)$$O(n)$

Mi rendo conto che questo non ha usato la ricerca binaria. Oh bene.

Stiamo parlando di numeri interi qui? Dove N è lungo n bit?

A = 2(n/2), B = A  and C = A2
Step: B = B/2
     If C > N,  
         C = C - 2AB + B2    // too high - make smaller
         A = A - B
     Else 
         C = C + 2AB + B2   // keep this bit
         A = A + B                 
Repeat until B = 0                  // =1 on last loop

Il loop viene eseguito n / 2 volte, il che dovrebbe fornire prestazioni O (n)

Modifica: come funziona e perché?
Questa è una versione di Successive Approximation, utilizzata anche negli algoritmi CORDIC.
A partire dal bit singolo più grande possibile (con un quadrato inferiore a N) si imposta un bit alla volta e si calcola il nuovo quadrato.
Se il nuovo quadrato è ancora inferiore a N, mantieni il bit come impostato.
Se il nuovo quadrato è troppo grande, cancella il bit, annulla l'effetto di aggiungerlo e passa al bit successivo.

Esempio: N = 441 (1 1011 1001 binario), n = 9

Start:  A = 24 = 16 (1 0000)  B = 16 C = 256 (100 0000)

1   B = 8 (1000) C = 256 + 2(16)(8) + (8)(8) = 576 (10 0100 0000) {high}
    A = 16 + 8 = 24
2   B = 4  (100) C = 576 - 2(16)(4) + (4)(4) = 400 (1 1001 0000) {low}
    A = 24 - 4 = 20
3   B = 2   (10) C = 400 + 2(20)(2) + (2)(2) = 484  (1 1110 0100) {high}
    A = 20 + 2 = 22
4   B = 1    (1) C = 484 - 2(20)(1) + (1)(1) = 441  (1 1011 1001) {keep this}
    A = 22 - 1 = 21
5   B = 1/2 or 0 in integer math; end

Il metodo principale è quello di riempire i bit di da sinistra a destra, mantenendo la nostra stima di sotto di essa, o meglio, la piazza della nostra stima di sotto . Ogni bit una potenza di 2, quindi quadrare o moltiplicare un altro numero per è sempre un bit shift. $\sqrt{N}$$N$$b$$b$

Se la stima corrente è , e conosciamo già , otteniamo e possiamo riscrivere il secondo e il terzo termine come e . Poi aggiungiamo tutto e di prova (suppongo che si può fare ) e impostare il bit se la piazza è ancora al di sotto .$a$$b=2^i$$a^2$$(a+b)^2 = a^2 + 2ab + b^2$$a << (i+1)$$1 << (i << 1)$$<$$i$$N$

Si comincia il ciclo presso e contiamo fino a zero, mantenendo e , come andiamo. È una specie di ricerca binaria, ma quella in cui i limiti sono associati a differenze a bit singolo.$i = n/2 = n >> 1$$a$$a^2$

Mi piace la risposta di Alan Campbell : con un'attenta traccia delle ipotesi precedenti, la nuova sottrazione è facile ogni volta, e la radice quadrata binaria di spostamento e aggiunta è più veloce di una divisione binaria di spostamento e aggiunta.

Ma potrebbe essere possibile andare più veloce, invece di rendere la tua prossima ipotesi una singola cifra binaria, invece usando un algoritmo "Ab" x "Ab" e rendendo la tua prossima ipotesi la media della tua ipotesi precedente e il numero originale diviso dall'ipotesi precedente. Sembra che ci vorrebbe più tempo, non più breve. Tuttavia, la divisione non deve essere esatta. Quindi, se la divisione corre solo alla radice quadrata del numero di cifre rimanenti da trovare, allora potresti effettivamente risparmiare tempo. Inoltre, se per la tua divisione usi il metodo francese, di divisione abbreviata, potresti effettivamente rompere la velocità nel tuo calcolo per divisioni davvero grandi.

Ora, se aggiungiamo calcoli in parallelo che producono risultati correggibili preliminari prima che venga trovata la risposta ... allora potremmo essere su qualcosa.