Rasgele hassas tamsayı karekök algoritması?

Bir nbit tamsayısının kare kökünün tabanını hesaplamak için bilinen herhangi bir alt-ikinci algoritma var mı?

Saf algoritma şöyle bir şey olurdu

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

Bu O(n), her biri O(n)zaman olan eklemeler içeren iterasyonlar gerektirir , bu yüzden O(n^2)genel olarak zaman. Daha hızlı bir şey var mı? Çarpma durumunda, ikinci dereceden daha iyi olan özel algoritmalar olduğunu biliyorum, ancak kare kökler için hiçbir şey bulamıyorum.

Polinomun köklerine yaklaşım bulmak için Newton yöntemini veya diğer yöntemlerden herhangi birini kullanabilirsiniz$p(x) = x^2 -c$.

Newton yöntemi için yakınsama oranı ikinci dereceden olacaktır, yani doğru olan bit sayısı her yinelemede iki katına çıkar. Bunun anlamı$O(\lg n)$ Newton yönteminin yinelemeleri yeterlidir.

Newton yönteminin her yinelemesi hesaplanır

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

Çarpmanın bit karmaşıklığı $\stackrel{~}{O}(b \lg b)$, iki ile çarpmak $b$bit tamsayıları (yoksayılıyor) $\lg \lg b$faktörler). Bölme için bit karmaşıklığı ($b$kesinlik) aynıdır. Bu nedenle, her bir yineleme$\stackrel{~}{O}(n \lg n)$operasyonlar. İle çarpma$O(\lg n)$ yinelemeler, karekök hesaplamak için toplam çalışma süresinin $n$ hassasiyet parçaları $\stackrel{~}{O}(n (\lg n)^2)$. Bu ikinci dereceden.

Bence daha dikkatli bir analiz bunun geliştirilebileceğini gösteriyor $\stackrel{~}{O}(n \lg n)$ çalışma süresi (yalnızca her birini bilmemiz gerektiğini dikkate alarak) $x_j$ hakkında $j$ doğruluk parçaları $n$hassasiyet bitleri). Bununla birlikte, daha temel analizler bile, açıkça subadratik olan bir çalışma süresini göstermektedir.

Newton yöntemiyle ilgili sorunlardan biri, her yinelemede en yavaş temel tamsayı işlemi olan bir bölme işlemi gerektirmesidir.

Ancak Newton'un karşılıklı karekökü yöntemi böyle değildir. Eğer$x$ bulmak istediğiniz sayıdır $\frac{1}{\sqrt x}$, yineleme:

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

Bu genellikle şu şekilde ifade edilir:

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

Bu üç çarpma işlemi. İkiye bölünme, bir vardiya hakkı olarak uygulanabilir.

Şimdi sorun şu ki $r$bir tamsayı değil. Bununla birlikte, kayan noktayı manuel olarak uygulayarak ve uygun olduğunda telafi etmek için bir sürü kaydırma işlemi yaparak bu şekilde değiştirebilirsiniz.

İlk olarak, yeniden ölçeklendirelim $x$:

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

nerede isteriz $x'$ daha büyük, ancak $1$. Yukarıdaki algoritmayı çalıştırırsak$x'$ onun yerine $x$, bulduk $r = \frac{1}{\sqrt x'}$. Sonra,$\sqrt{x} = 2^e r x'$.

Şimdi ayrılalım $r$ bir mantis ve üs içine:

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

nerede $r'_i$bir tamsayıdır. sezgisel,$e_i$ cevabın kesinliğini temsil eder.

Newton yönteminin doğru anlamlı basamak sayısını kabaca iki katına çıkardığını biliyoruz. Böylece seçebiliriz:

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

Biraz manipülasyon ile buluyoruz:

$$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}}$$

Her yinelemede:

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

Örnek olarak, kare kökünü hesaplamayı deneyelim. $x = 2^{63}$. Cevabın$2^{31}\sqrt{2}$. Karşılıklı karekök$\frac{1}{\sqrt{2}} 2^{-31}$, bu yüzden $e = 31$ (bu sorunun ölçeğidir) ve ilk tahminimiz için $r'_0 = 3$ ve $e_0 = 2$. (Yani, biz seçeriz$\frac{3}{4}$ ilk tahminimiz için $\frac{1}{\sqrt{2}}$.)

Sonra:

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

Karşılaştırma yaparak yinelemeyi ne zaman durduracağımızı hesaplayabiliriz $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.