Shifting nth-root algorithm: Encyclopedia II - Shifting nth-root algorithm - Algorithm

Shifting nth-root algorithm - Algorithm

Shifting nth-root algorithm - Notation

Let B be the base of the number system you are using, and n be the degree of the root to be extracted. Let x be the radicand processed thus far, y be the root extracted thus far, and r be the remainder. Let α be the next n digits of the radicand, and β be the next digit of the root. Let x' be the new value of x for the next iteration, y' be the new value of y for the next iteration, and r' be the new value of r for the next iteration. These are all integers.

Shifting nth-root algorithm - Invariants

At each iteration, the invariant yⁿ + r = x will hold. The invariant (y + 1)ⁿ > x will hold. Thus y is the largest integer less than the nth root of x, and r is the remainder.

Shifting nth-root algorithm - Initialization

The initial values of x, y, and r should be 0. The value of α for the first iteration should be the most significant aligned block of n digits of the radicand. An aligned block of n 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 2 digits is 01, the next most significant is 23, and the third most significant is 40.

Shifting nth-root algorithm - Main loop

On each iteration we shift in n digits of the radicand, so we have x' = Bⁿx + α and we produce 1 digit of the root, so we have y' = By + β. We want to choose β and r' so that the invariants described above hold. It turns out that there is always exactly one such choice, as will be proved below.

The first invariant says that:

or

So, pick the largest integer β such that

and let

Such a β always exists, since if β = 0 then the condition is , but , so this is always true. Also, β must be less than B, since if β = B then we would have

but the second invariant implies that

and since Bⁿx and Bⁿ(y + 1)ⁿ are both multiples of Bⁿ the difference between them must be at least Bⁿ, and then we have

but by definition of α, so this can't be true, and (By + β)ⁿ is a monotonically increasing function of β, so it can't be true for larger β either, so we conclude that there exists an integer γ with γ < B such that an integer r' with exists such that the first invariant holds if and only if .

Now consider the second invariant. It says:

or

Now, if β is not the largest admissible β for the first invariant as described above, then β + 1 is also admissible, and we have

This violates the second invariant, so to satisfy both invariants we must pick the largest β allowed by the first invariant. Thus we have proven the existence and uniqueness of β and r'.

To summarize, on each iteration:

1. Let α be the next aligned block of digits from the radicand
2. Let x' = Bⁿx + α
3. Let β be the largest β such that
4. Let y' = By + β
5. Let r' = x' − y'ⁿ

Now, note that x = yⁿ + r, so the condition

is equivalent to

and

is equivalent to

Thus, we don't actually need x, and since r = x − yⁿ and x < (y + 1)ⁿ, r < (y + 1)ⁿ − yⁿ or r < ny^{n − 1} + O(y^{n − 2}), or , so by using r instead of x we save time and space by a factor of 1/n. Also, the Bⁿyⁿ we subtract in the new test cancels the one in (By + β)ⁿ, so now the highest power of y we have to evaluate is y^{n − 1} rather than yⁿ.

The final algorithm is:

1. Initialize r and y to 0
2. Repeat until desired precision is obtained:
   1. Let α be the next aligned block of digits from the radicand
   2. Let β be the largest β such that
   3. Let y' = By + β
   4. Let r' = Bⁿr + α − ((By + β)ⁿ − Bⁿyⁿ)
   5. Assign and
3. y is the largest integer such that yⁿ < xB^k, and yⁿ + r = xB^k, where k is the number of digits of the radicand after the decimal point that have been consumed (a negative number if the algorithm hasn't reached the decimal point yet).

Shifting nth-root algorithm - Paper and pencil nth roots

As noted above, this algorithm is similar to long division, and it lends itself to the same notation:

     1.  4   4   2   2   4
    ----------------------
  3/ 3.000 000 000 000 000
/\/  1 = 300*(0^2)*1+30*0*(1^2)+1^3
     -
     2 000
     1 744 = 300*(1^2)*4+30*1*(4^2)+4^3
     -----
       256 000
       241 984 = 300*(14^2)*4+30*14*(4^2)+4^3
       -------
        14 016 000
        12 458 888 = 300*(144^2)*2+30*144*(2^2)+2^3
        ----------
         1 557 112 000
         1 247 791 448 = 300*(1442^2)*2+30*1442*(2^2)+2^3
         -------------
           309 320 552 000
           249 599 823 424 = 300*(14422^2)*4+30*14422*(4^2)+4^3
           ---------------
            59 720 728 576

Note that after the first iteration or two the leading term dominates the (By + β)ⁿ − Bⁿyⁿ, so we can get an often correct first guess at β by dividing Br + α by nB^{n − 1}y^{n − 1}.

Shifting nth-root algorithm - Performance

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

The only internal storage needed is r, which is O(k) digits on the kth iteration. That this algorithm doesn't 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 β by a factor of O(log(B)), 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 O(log²(B)). When the base is larger than the radicand, the algorithm degenerates to binary search, so it follows that this algorithm is completely useless, as it is always outperformed by much simpler binary search, and has the same memory complexity.

Adapted from the Wikipedia article "Algorithm", under the G.N U Free Docmentation License. Please also see http://en.wikipedia.org/wiki