View source for Shifting nth root algorithm

{{Proposed deletion/dated
  |concern = Has never been sourced since its creation over 20 years ago. Appears to be original research. Better (but still not great) coverage of computation of roots is at our main article [[nth root]].
  |timestamp = 20240609020345
  |nom = David Eppstein
  |help = 
}}
{{DISPLAYTITLE:Shifting ''n''th root algorithm}}
{{unreferenced|date=May 2010}}
The '''shifting ''n''th root algorithm''' is an [[algorithm]] for extracting the [[nth root|''n''th root]] of a positive [[real number]] which proceeds iteratively by shifting in ''n'' [[numerical digit|digits]] of the radicand, starting with the most significant, and produces one digit of the root on each iteration, in a manner similar to [[long division]].

== Algorithm ==

=== Notation ===

Let <math>B</math> be the [[radix|base]] of the number system you are using, and <math>n</math> be the degree of the root to be extracted.  Let <math>x</math> be the radicand processed thus far, <math>y</math> be the root extracted thus far, and <math>r</math> be the remainder.  Let <math>\alpha</math> be the next <math>n</math> digits of the radicand, and <math>\beta</math> be the next digit of the root.  Let <math>x'</math> be the new value of <math>x</math> for the next iteration, <math>y'</math> be the new value of <math>y</math> for the next iteration, and <math>r'</math> be the new value of <math>r</math> for the next iteration.  These are all [[integer]]s.

=== Invariants ===
At each iteration, the [[Invariant (computer science)|invariant]] <math>y^n + r = x</math> will hold.  The invariant <math>(y+1)^n>x</math> will hold.  Thus <math>y</math> is the largest integer less than or equal to the <math>n</math>th root of <math>x</math>, and <math>r</math> is the remainder.

=== Initialization ===
The initial values of <math>x, y</math>, and <math>r</math> should be 0.  The value of <math>\alpha</math> for the first iteration should be the most significant aligned block of <math>n</math> digits of the radicand.  An aligned block of <math>n</math> digits means a block of digits aligned so that the decimal point falls between blocks.  For example, in 123.4 the most significant aligned block of two digits is 01, the next most significant is 23, and the third most significant is 40.

=== Main loop ===
On each iteration we shift in <math>n</math> digits of the radicand, so we have <math>x' = B^n x + \alpha</math> and we produce one digit of the root, so we have <math>y' = B y + \beta </math>. The first invariant implies that <math>r' = x' - y'^n</math>. We want to choose <math>\beta</math> so that the invariants described above hold. It turns out that there is always exactly one such choice, as will be proved below.

{{Math proof|title=Proof of existence and uniqueness of <math>\beta</math>|drop=hidden|proof=
By definition of a digit, <math>0 \leq \beta < B</math>, and by definition of a block of digits, <math>0 \leq \alpha < B^n</math>

The first invariant says that:
: <math>x' = y'^n + r'</math>
or
: <math>B^n x + \alpha = (B y + \beta)^n + r'.</math>

So, pick the largest integer <math>\beta</math> such that
: <math>(B y + \beta)^n \le B^n x + \alpha.</math>

Such a <math>\beta</math> always exists, since <math>0 \leq \beta < B</math> and if <math>\beta = 0</math> then <math>B^n y^n \le B^n x + \alpha</math>, but since <math>y^n \le x</math>, this is always true for <math>\beta = 0</math>. Thus, there will always be a <math>\beta</math> that satisfies the first invariant

Now consider the second invariant.  It says:
: <math>(y'+1)^n > x'</math>
or
: <math>(B y + \beta + 1)^n>B^n x + \alpha.</math>

Now, if <math>\beta</math> is not the largest admissible <math>\beta</math> for the first invariant as described above, then <math>\beta + 1</math> is also admissible, and we have
:<math>(B y + \beta + 1)^n \le B^n x + \alpha.</math>

This violates the second invariant, so to satisfy both invariants we must pick the largest <math>\beta</math> allowed by the first invariant.  Thus we have proven the existence and uniqueness of <math>\beta</math>.
}}
To summarize, on each iteration:
# Let <math>\alpha</math> be the next aligned block of digits from the radicand
# Let <math>x' = B^n x + \alpha</math>
# Let <math>\beta</math> be the largest <math>\beta</math> such that <math>(B y + \beta)^n \le B^n x + \alpha</math>
# Let <math>y' = B y + \beta</math>
# Let <math>r' = x' - y'^n</math>

Now, note that <math>x = y^n + r</math>, so the condition
: <math>(B y + \beta)^n \le B^n x + \alpha</math>
is equivalent to
: <math>(B y + \beta)^n - B^n y^n \le B^n r + \alpha</math>
and
: <math>r' = x' - y'^n = B^n x + \alpha - (B y + \beta)^n</math>
is equivalent to
: <math>r' = B^n r + \alpha - ((B y + \beta)^n - B^n y ^n).</math>

Thus, we do not actually need <math>x</math>, and since <math>r = x - y^n</math> and <math>x<(y+1)^n</math>, <math>r<(y+1)^n-y^n</math> or <math>r<n y^{n-1}+O(y^{n-2})</math>, or <math>r<n x^{{n-1}\over n} + O(x^{{n-2}\over n})</math>, so by using <math>r</math> instead of <math>x</math> we save time and space by a factor of 1/<math>n</math>.  Also, the <math>B^n y^n</math> we subtract in the new test cancels the one in <math>(B y + \beta)^n</math>, so now the highest power of <math>y</math> we have to evaluate is <math>y^{n-1}</math> rather than <math>y^n</math>.

=== Summary ===
# Initialize <math>r</math> and <math>y</math> to 0.
# Repeat until desired [[decimal precision|precision]] is obtained:
## Let <math>\alpha</math> be the next aligned block of digits from the radicand.
## Let <math>\beta</math> be the largest <math>\beta</math> such that <math>(B y + \beta)^n - B^n y^n \le B^n r + \alpha.</math>
## Let <math>y' = B y + \beta</math>.
## Let <math>r' = B^n r + \alpha - ((B y + \beta)^n - B^n y^n).</math>
## Assign <math>y \leftarrow y'</math> and <math>r \leftarrow r'.</math>
# <math>y</math> is the largest integer such that <math>y^n<x B^k</math>, and <math>y^n+r=x B^k</math>, where <math>k</math> is the number of digits of the radicand after the decimal point that have been consumed (a negative number if the algorithm has not reached the decimal point yet).

== Paper-and-pencil ''n''th roots ==
As noted above, this algorithm is similar to long division, and it lends itself to the same notation:

      {{Font color|red||1}}.  {{Font color|green||4}}   {{Font color|blue||4}}   {{Font color|magenta||2}}   {{Font color|gold||2}}   {{Font color|cyan||4}}
     ——————————————————————
 _ {{Font color|#444444||3}}/ 3.{{Font color|darkred||000}} {{Font color|darkgreen||000}} {{Font color|darkblue||000}} {{Font color|darkmagenta||000}} {{Font color|darkcyan||000}}
  \/  {{Font color|red||1}}                        = {{Font color|#444444||3}}(10×{{Font color|gray||0}})<sup>2</sup>×{{Font color|red||1}}     +{{Font color|#444444||3}}(10×{{Font color|gray||0}})×{{Font color|red||1}}<sup>2</sup>     +{{Font color|red||1}}<sup>3</sup>
      —
      2 {{Font color|darkred||000}}
      1 744                    = {{Font color|#444444||3}}(10×{{Font color|red||1}})<sup>2</sup>×{{Font color|green||4}}     +{{Font color|#444444||3}}(10×{{Font color|red||1}})×{{Font color|green||4}}<sup>2</sup>     +{{Font color|green||4}}<sup>3</sup>
      —————
        256 {{Font color|darkgreen||000}}
        241 984                = {{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}})<sup>2</sup>×{{Font color|blue||4}}    +{{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}})×{{Font color|blue||4}}<sup>2</sup>    +{{Font color|blue||4}}<sup>3</sup>
        ———————
         14 016 {{Font color|darkblue||000}}
         12 458 888            = {{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}})<sup>2</sup>×{{Font color|magenta||2}}   +{{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}})×{{Font color|magenta||2}}<sup>2</sup>   +{{Font color|magenta||2}}<sup>3</sup>
         ——————————
          1 557 112 {{Font color|darkmagenta||000}}
          1 247 791 448        = {{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}}{{Font color|magenta||2}})<sup>2</sup>×{{Font color|gold||2}}  +{{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}}{{Font color|magenta||2}})×{{Font color|gold||2}}<sup>2</sup>  +{{Font color|gold||2}}<sup>3</sup>
          —————————————
            309 320 552 {{Font color|darkcyan||000}}
            249 599 823 424    = {{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}}{{Font color|magenta||2}}{{Font color|gold||2}})<sup>2</sup>×{{Font color|cyan||4}} +{{Font color|#444444||3}}(10×{{Font color|red||1}}{{Font color|green||4}}{{Font color|blue||4}}{{Font color|magenta||2}}{{Font color|gold||2}})×{{Font color|cyan||4}}<sup>2</sup> +{{Font color|cyan||4}}<sup>3</sup>
            ———————————————
             59 720 728 576

Note that after the first iteration or two the leading term dominates the
<math>(B y + \beta)^n - B^n y^n</math>, so we can get an often correct first guess at <math>\beta</math> by dividing <math>B^n r + \alpha</math> by <math>n B^{n-1} y^{n-1}</math>.

== Performance ==
On each iteration, the most time-consuming task is to select <math>\beta</math>.  We know that there are <math>B</math> possible values, so we can find <math>\beta</math> using <math>O(\log(B))</math> comparisons.  Each comparison will require evaluating <math>(B y +\beta)^n - B^n y^n</math>.  In the ''k''th iteration, <math>y</math> has <math>k</math> digits, and the polynomial can be evaluated with <math>2 n - 4</math> multiplications of up to <math>k(n-1)</math> digits and <math>n - 2</math> additions of up to <math>k(n-1)</math> digits, once we know the powers of <math>y</math> and <math>\beta</math> up through <math>n-1</math> for <math>y</math> and <math>n</math> for <math>\beta</math>.  <math>\beta</math> has a restricted range, so we can get the powers of <math>\beta</math> in constant time.  We can get the powers of <math>y</math> with <math>n-2</math> multiplications of up to <math>k(n-1)</math> digits.  Assuming <math>n</math>-digit multiplication takes time <math>O(n^2)</math> and addition takes time <math>O(n)</math>, we take time
<math>O(k^2 n^2)</math> for each comparison, or time <math>O(k^2 n^2 \log(B))</math> to pick <math>\beta</math>.  The remainder of the algorithm is addition and subtraction that takes time <math>O(k)</math>, so each iteration takes <math>O(k^2 n^2 \log(B))</math>.  For all <math>k</math> digits, we need time <math>O(k^3 n^2 \log(B))</math>.

The only internal storage needed is <math>r</math>, which is <math>O(k)</math> digits on the ''k''th iteration.  That this algorithm does not have bounded memory usage puts an upper bound on the number of digits which can be computed mentally, unlike the more elementary algorithms of arithmetic.  Unfortunately, any bounded memory state machine with periodic inputs can only produce periodic outputs, so there are no such algorithms which can compute irrational numbers from rational ones, and thus no bounded memory root extraction algorithms.

Note that increasing the base increases the time needed to pick <math>\beta</math> by a factor of <math>O(\log{B})</math>, but decreases the number of digits needed to achieve a given precision by the same factor, and since the algorithm is cubic time in the number of digits, increasing the base gives an overall speedup of <math>O(\log^2{B})</math>.  When the base is larger than the radicand, the algorithm degenerates to [[binary search]], so it follows that this algorithm is not useful for computing roots with a computer, as it is always outperformed by much simpler binary search, and has the same memory complexity.

== Examples ==

=== Square root of 2 in binary ===

       1. 0  1  1  0  1
     ------------------
 _  / 10.00 00 00 00 00     1
  \/   1                  + 1
      -----               ----
       1 00                100
          0               +  0
      --------            -----
       1 00 00             1001
         10 01            +   1
      -----------         ------
          1 11 00          10101
          1 01 01         +    1
          ----------      -------
             1 11 00       101100
                   0      +     0
             ----------   --------
             1 11 00 00    1011001
             1 01 10 01          1
             ----------
                1 01 11 remainder

=== Square root of 3 ===
      1. 7  3  2  0  5
     ----------------------
 _  / 3.00 00 00 00 00
  \/  1 = 20×0×1+1^2
      -
      2 00
      1 89 = 20×1×7+7^2 (27 x 7)
      ----
        11 00
        10 29 = 20×17×3+3^2  (343 x 3)
        -----
           71 00
           69 24 = 20×173×2+2^2 (3462 x 2)
           -----
            1 76 00
                  0 = 20×1732×0+0^2 (34640 x 0)
            -------
            1 76 00 00
            1 73 20 25 = 20×17320×5+5^2 (346405 x 5)
            ----------
               2 79 75

=== Cube root of 5 ===
      1.  7   0   9   9   7
     ----------------------
 _ 3/ 5. 000 000 000 000 000
  \/  1 = 300×(0^2)×1+30×0×(1^2)+1^3
      -
      4 000
      3 913 = 300×(1^2)×7+30×1×(7^2)+7^3
      -----
         87 000
              0 = 300×(17^2)×0+30×17×(0^2)+0^3
        -------
         87 000 000
         78 443 829 = 300×(170^2)×9+30×170×(9^2)+9^3
         ----------
          8 556 171 000
          7 889 992 299 = 300×(1709^2)×9+30×1709×(9^2)+9^3
          -------------
            666 178 701 000
            614 014 317 973 = 300×(17099^2)×7+30×17099×(7^2)+7^3
            ---------------
             52 164 383 027

=== Fourth root of 7 ===
      1.   6    2    6    5    7
     ---------------------------
 _ 4/ 7.0000 0000 0000 0000 0000
  \/  1 = 4000×(0^3)×1+600×(0^2)×(1^2)+40×0×(1^3)+1^4
      -
      6 0000
      5 5536 = 4000×(1^3)×6+600×(1^2)×(6^2)+40×1×(6^3)+6^4
      ------
        4464 0000
        3338 7536 = 4000×(16^3)×2+600×(16^2)×(2^2)+40×16×(2^3)+2^4
        ---------
        1125 2464 0000
        1026 0494 3376 = 4000×(162^3)×6+600×(162^2)×(6^2)+40×162×(6^3)+6^4
        --------------
          99 1969 6624 0000
          86 0185 1379 0625 = 4000×(1626^3)×5+600×(1626^2)×(5^2)+
          -----------------   40×1626×(5^3)+5^4
          13 1784 5244 9375 0000
          12 0489 2414 6927 3201 = 4000×(16265^3)×7+600×(16265^2)×(7^2)+
          ----------------------   40×16265×(7^3)+7^4
           1 1295 2830 2447 6799

== See also ==
* [[Methods of computing square roots]]
* [[nth root algorithm|''n''th root algorithm]]

== External links ==
* [http://www.homeschoolmath.net/teaching/sqr-algorithm-why-works.php Why the square root algorithm works] "Home School Math". Also related pages giving examples of the long-division-like pencil and paper method for square roots.
* [https://q12.medium.com/reflections-on-the-square-root-of-two-ae792db4c7e Reflections on The Square Root of Two] "Medium". With an example of a C++ implementation.

[[Category:Operations on numbers]]
[[Category:Root-finding algorithms]]
[[Category:Computer arithmetic algorithms]]
[[Category:Digit-by-digit algorithms]]
{{⚠️🚨COPIED from EverybodyWiki ❗❕⚠️😡😤Please respect Licence CC-BY-SA ❗}}
{{Source Wikipedia}}