อัลกอริทึมรากที่สองจำนวนเต็มความแม่นยำตามอำเภอใจ?

มีอัลกอริทึมย่อยที่รู้จักกันดีสำหรับการคำนวณพื้นของสแควร์รูทของnจำนวนเต็มบิตหรือไม่?

อัลกอริธึมไร้เดียงสานั้นจะเป็นอย่างไร

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

สิ่งนี้ต้องใช้O(n)การวนซ้ำแต่ละอันเกี่ยวข้องกับการเพิ่มที่เป็นO(n)เวลาดังนั้นจึงเป็นO(n^2)เวลาโดยรวม มีอะไรเร็วขึ้นไหม ฉันรู้ว่าในกรณีของการคูณมีอัลกอริทึมพิเศษที่ทำได้ดีกว่าเวลากำลังสอง แต่ฉันไม่สามารถหาอะไรสำหรับรากที่สอง

คุณสามารถใช้วิธีของนิวตันหรือวิธีอื่น ๆ ในการหาค่าประมาณของรากของพหุนาม$p(x) = x^2 -c$.

อัตราการบรรจบกันของวิธีการของนิวตันจะเป็นกำลังสองซึ่งหมายความว่าจำนวนบิตที่ถูกต้องเป็นสองเท่าในการทำซ้ำแต่ละครั้ง ซึ่งหมายความว่า$O(\lg n)$ วนซ้ำของวิธีของนิวตันพอเพียง

การคำนวณซ้ำแต่ละครั้งของวิธีการของนิวตัน

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

ความซับซ้อนของการคูณคือ $\stackrel{~}{O}(b \lg b)$เพื่อคูณสอง $b$จำนวนเต็มบิต (ละเว้น $\lg \lg b$ปัจจัย). ความซับซ้อนของบิตสำหรับการหาร (ถึง$b$บิตของความแม่นยำ) เหมือนกัน ดังนั้นสามารถคำนวณซ้ำแต่ละครั้งได้$\stackrel{~}{O}(n \lg n)$การดำเนินงาน คูณด้วย$O(\lg n)$ ซ้ำเราพบว่าเวลาทำงานโดยรวมในการคำนวณรากที่สองไป $n$ บิตของความแม่นยำคือ $\stackrel{~}{O}(n (\lg n)^2)$. นี่คือสมการกำลังสอง

ฉันคิดว่าการวิเคราะห์อย่างระมัดระวังยิ่งแสดงให้เห็นว่าสิ่งนี้สามารถปรับปรุงได้ $\stackrel{~}{O}(n \lg n)$ เวลาทำงาน (โดยคำนึงถึงว่าเราจำเป็นต้องรู้เท่านั้น $x_j$ ภายใน $j$ บิตของความแม่นยำมากกว่า $n$บิตของความแม่นยำ) อย่างไรก็ตามการวิเคราะห์ขั้นพื้นฐานยิ่งแสดงเวลาในการทำงานที่ชัดเจนมากขึ้นแล้ว

หนึ่งในปัญหาของวิธีการของนิวตันคือต้องใช้การดำเนินการหารในแต่ละการวนซ้ำซึ่งเป็นการดำเนินการจำนวนเต็มพื้นฐานที่ช้าที่สุด

อย่างไรก็ตามวิธีการของนิวตันสำหรับสแควร์รูทซึ่งกันและกันกลับทำไม่ได้ ถ้า$x$ คือหมายเลขที่คุณต้องการค้นหา $\frac{1}{\sqrt x}$ย้ำ:

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

สิ่งนี้มักแสดงเป็น:

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

นั่นคือการคูณสามครั้ง การหารด้วยสองสามารถนำไปใช้เป็น shift-right ได้

ตอนนี้ปัญหาคือว่า $r$ไม่ใช่จำนวนเต็ม อย่างไรก็ตามคุณสามารถจัดการมันได้โดยการใช้ floating-point ด้วยตนเองและดำเนินการ shift หลายอย่างเพื่อชดเชยเมื่อเหมาะสม

ก่อนอื่นเรามาช่วยกัน $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$ แสดงถึงความแม่นยำของคำตอบ

เรารู้ว่าวิธีการของนิวตันประมาณสองเท่าของจำนวนนัยสำคัญที่แม่นยำ ดังนั้นเราสามารถเลือก:

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

ด้วยการจัดการเล็กน้อยเราพบ:

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

ทุกครั้งที่มีการซ้ำ:

$$\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}}$.)

แล้ว:

$$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}$หมายเลขบิต

ในแต่ละกรณีจำนวนการดำเนินการต่อการทำซ้ำคือ $O(e_i \log e_i)$และมี $O(\log e)$จำเป็นต้องทำซ้ำ การคูณสุดท้ายคือตามลำดับของ$O(2e \log 2e)$การดำเนินงาน ดังนั้นความซับซ้อนโดยรวมก็คือ$O(e \log^2 e)$ การดำเนินงานซึ่งเป็นกำลังสองย่อยในจำนวนบิตใน $x$. ที่ทำเครื่องหมายในช่องทั้งหมด

อย่างไรก็ตามการวิเคราะห์นี้ซ่อนหลักการสำคัญที่ทุกคนที่ทำงานกับจำนวนเต็มขนาดใหญ่ควรทราบ: เนื่องจากการคูณเป็น superlinear ในจำนวนบิตการดำเนินการคูณใด ๆ ควรดำเนินการกับจำนวนเต็มที่มีขนาดความแม่นยำในปัจจุบันโดยประมาณ (และ ฉันอาจเพิ่มคุณควรลองคูณตัวเลขเข้าด้วยกันซึ่งมีขนาดเท่ากัน) การใช้จำนวนเต็มที่มากกว่านั้นเสียความพยายาม ปัจจัยคงที่มีความสำคัญและสำหรับจำนวนเต็มขนาดใหญ่พวกมันมีความสำคัญมาก

เป็นการสังเกตครั้งสุดท้ายการคูณสองครั้งเป็นแบบฟอร์ม $\frac{ab}{2^c}$. เห็นได้ชัดว่ามันเป็นการสิ้นเปลืองในการคำนวณบิตทั้งหมดของ$ab$ โยนเท่านั้น $c$ของพวกเขาออกไปพร้อมกับกะ - ขวา การใช้วิธีการคูณแบบชาญฉลาดซึ่งคำนึงถึงสิ่งนี้ยังถือว่าเป็นแบบฝึกหัด