# Challenge: optimizing isqrt

Christian Gollwitzer auriocus at gmx.de
Sat Nov 1 09:02:12 CET 2014

```Hi Steven,

let me start by answering from reverse:
> Q3: What is the largest value of n beyond which you can never use the
float
> optimization?
>

A3: There is no such value, besides the upper limit of floats (DBL_MAX~
10^308)

P3: If you feed a perfect square into the floating point square root
algorithm, with a mantissa of the root of length smaller than the
bitwidth of your float, it will always come out perfectly. I.e.,
computing sqrt(25) in FP math is no different from sqrt(25*2**200):

>>> 25*2**200
40173451106474756888549052308529065063055074844569820882534400L
>>> x=int(math.sqrt(25*2**200))
>>> x
6338253001141147007483516026880L
>>> x*x
40173451106474756888549052308529065063055074844569820882534400L
>>>

Am 01.11.14 02:29, schrieb Steven D'Aprano:
> There is an algorithm for calculating the integer square root of any
> positive integer using only integer operations:
>
> def isqrt(n):
>      if n < 0: raise ValueError
>      if n == 0:
>          return 0
>      bits = n.bit_length()
>      a, b = divmod(bits, 2)
>      x = 2**(a+b)
>      while True:
>          y = (x + n//x)//2
>          if y >= x:
>              return x
>          x = y

> Q2: For values above M, is there a way of identifying which values of n are
> okay to use the optimized version?

A2: Do it in a different way.

Your above algorithm is obviously doing Heron- or Newton-Raphson
iterations, so the same as with floating point math. The first line
before the while loop computes some approximation to sqrt(n). Instead of
doing bit shuffling, you could compute this by FP math and get closer to
the desired result, unless the integer is too large to be represented by
FP. Now, the terminating condition seems to rely on the fact that the
initial estimate x>=sqrt(n), but I don't really understand it. My guess
is that if you do x=int(sqrt(n)), then do the first iteration, then swap
x and y such that x>y, then enter the loop, you would simply start with
a better estimate in case that the significant bits can be represented
by the float.

So this is my try, but not thoroughly tested:

def isqrt(n):
if n < 0: raise ValueError
if n == 0:
return 0
bits = n.bit_length()
# the highest exponent in 64bit IEEE is 1023
if n>2**1022:
a, b = divmod(bits, 2)
x = 2**(a+b)
else:
x=int(math.sqrt(n))
y=n//x
if x<y:
x,y = (y,x)

while True:
y = (x + n//x)//2
if y >= x:
return x
x = y

Christian

```

More information about the Python-list mailing list