Ganzzahliger Quadratwurzel-Algorithmus mit beliebiger Genauigkeit?

Gibt es bekannte subquadratische Algorithmen zur Berechnung des Quadratwurzelbodens einer nBit-Ganzzahl?

Der naive Algorithmus wäre so etwas wie

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

Dies erfordert O(n)Iterationen, die jeweils O(n)zeitliche Ergänzungen beinhalten , also ist es O(n^2)insgesamt Zeit. Gibt es etwas schnelleres? Ich weiß, dass es für den Fall der Multiplikation spezielle Algorithmen gibt, die besser als die quadratische Zeit sind, aber ich kann nichts für Quadratwurzeln finden.

Sie können die Newtonsche Methode oder eine Reihe anderer Methoden verwenden, um Annäherungen an Wurzeln des Polynoms .$p(x) = x^2 -c$

Die Konvergenzrate für die Newtonsche Methode ist quadratisch, was bedeutet, dass sich die Anzahl der korrekten Bits in jeder Iteration verdoppelt. Dies bedeutet, dass -Iterationen der Newtonschen Methode ausreichen.$O(\lg n)$

Jede Iteration der Newtonschen Methode wird berechnet

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

Die Bitkomplexität der Multiplikation ist O ( b lg b ) , um zwei b- Bit-Ganzzahlen zu multiplizieren (wobei lg lg b- Faktoren ignoriert werden). Die Bitkomplexität für die Division (auf b Bits der Genauigkeit) ist dieselbe. Daher kann jede Iteration in O ( n lg n ) -Operationen berechnet werden. Multipliziert man mit O ( lg n ) -Iterationen, so ergibt sich, dass die Gesamtlaufzeit zur Berechnung der Quadratwurzel mit n Genauigkeitsbits O ( n ( lg n) beträgt$\stackrel{~}{O}(b \lg b)$$b$$\lg \lg b$$b$$\stackrel{~}{O}(n \lg n)$$O(\lg n)$$n$ . Dies ist subquadratisch.$\stackrel{~}{O}(n (\lg n)^2)$

Ich denke, eine genauere Analyse zeigt, dass dies auf die Laufzeit von O ( n lg n ) verbessert werden kann (indem berücksichtigt wird, dass wir jedes x j nur mit einer Genauigkeit von etwa j und nicht mit einer Genauigkeit von n kennen müssen ). . Selbst die grundlegendere Analyse zeigt jedoch bereits eine Laufzeit, die eindeutig subquadratisch ist.$\stackrel{~}{O}(n \lg n)$$x_j$$j$$n$

Eines der Probleme bei der Newtonschen Methode besteht darin, dass in jeder Iteration eine Divisionsoperation erforderlich ist, die die langsamste grundlegende Ganzzahloperation ist.

Newtons Methode für die reziproke Quadratwurzel tut dies jedoch nicht. Wenn die Zahl ist, für die Sie 1 finden möchten$x$ , iteriere:$\frac{1}{\sqrt x}$

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

Dies wird oft ausgedrückt als:

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

Das sind drei Multiplikationsoperationen. Die Division durch zwei kann als Rechtsverschiebung implementiert werden.

$r$

$x$

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

$x'$$1$$x'$$x$$r = \frac{1}{\sqrt x'}$$\sqrt{x} = 2^e r x'$

$r$

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

$r'_i$$e_i$

Wir wissen, dass Newtons Methode die Anzahl der genauen signifikanten Stellen ungefähr verdoppelt. So können wir wählen:

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

Mit ein wenig Manipulation finden wir:

$$e_{i+1} = 2e_i$$ $$w_i = {r'_i}^2$$ $$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}}$$

Bei jeder Iteration:

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

$x = 2^{63}$$2^{31}\sqrt{2}$$\frac{1}{\sqrt{2}} 2^{-31}$$e = 31$$r'_0 = 3$$e_0 = 2$$\frac{3}{4}$$\frac{1}{\sqrt{2}}$

Dann:

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

$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 Nummer.

$O(e_i \log e_i)$$O(\log e)$$O(2e \log 2e)$$O(e \log^2 e)$$x$

Diese Analyse verbirgt jedoch ein wichtiges Prinzip, das jeder, der mit großen ganzen Zahlen arbeitet, berücksichtigen sollte: Da die Multiplikation in der Anzahl der Bits superlinear ist, sollten Multiplikationsoperationen nur mit ganzen Zahlen durchgeführt werden, die ungefähr die Größe der aktuellen Genauigkeit (und) haben Ich möchte hinzufügen, dass Sie versuchen sollten, Zahlen mit einer ähnlichen Größenordnung zu multiplizieren. Die Verwendung größerer Ganzzahlen ist eine Verschwendung von Aufwand. Konstante Faktoren sind wichtig, und für große ganze Zahlen sind sie sehr wichtig.

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