Efficiently Computing the Inverse Square Root

Using Integer Operations

Ben Self
May 31, 2012

Contents
1 Introduction 2

2 Background 2
2.1 Floating Point Representation . . . . . . . . . . . . . . . . . . . . 2
2.2 Integer Representation and Operations . . . . . . . . . . . . . . . 3

3 The Algorithm 3
3.1 Newton’s Method . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
3.2 Computing the Initial Guess . . . . . . . . . . . . . . . . . . . . . 5
3.2.1 Idea Behind the Initial Guess . . . . . . . . . . . . . . . . 5
3.2.2 Detailed Analysis . . . . . . . . . . . . . . . . . . . . . . . 6
3.2.3 Error of the Initial Guess . . . . . . . . . . . . . . . . . . 8
3.2.4 Finding the Optimal Magic Number . . . . . . . . . . . . 9
3.3 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Conclusion 13

1
 1 Introduction
In the field of computer science, clarity of code is usually valued over efficiency.
However, sometimes this rule is broken, such as in situations where a small
piece of code must be run millions of times per second. One famous example
of this can be found in the rendering-related source code of the game Quake III
Arena. In computer graphics, vector normalization is a heavily used operation
when computing lighting and shading. For example, a renderer will commonly
need to do a shading computation at least once for each pixel on the screen. In
the modest case where a game is running at 30 frames per second on a screen
with a resolution of 800×600 pixels and only a single vector must be normalized
for each shading computation, 14,400,000 vector normalizations will need to
be performed per second! To normalize a vector x, one must multiply each
1
component by |x| = √ 2 1 2
. Thus it is important that an inverse square
x1 +···+xn
root can be computed efficiently. In Quake III Arena, this task is performed by
the following function [2] (complete with the original comments):
1 float Q_rsqrt( float number )
2 {
3 const float threehalfs = 1.5F;
4 float x2 = number * 0.5F;
5 float y = number;
6 long i = * ( long * ) &y; // evil floating point bit level hacking
7 i = 0x5f3759df - ( i >> 1 ); // what the fuck?
8 y = * ( float * ) &i;
9 y = y * ( threehalfs - ( x2 * y * y ) );
10 return y;
11 }
Unfortunately, while the code performs well and is quite accurate, it is not
at all clear what is actually going on, and the comments don’t provide much
insight. What is the meaning of the constant 0x5f3759df, and why are integer
operations being performed on floating point numbers? This paper will provide
a detailed explanation of the operations being performed and the accuracy of
the resulting value.

2 Background
2.1 Floating Point Representation
Floating point numbers (defined by float in the code) consist of a sign bit, an
8-bit exponent, and a 23-bit mantissa.

s E M
bit 31 bits 30...23 bits 22...0

s denotes the sign bit, where 0 corresponds to positive and 1 corresponds to

negative. The exponent E is an integer biased by 127, meaning that the inter-
preted value is 127 less than the actual value stored. This is to allow for both

2
negative and positive values. The mantissa M represents a real number in the
range [0, 1); the leading 1 is implied and thus not explicitly included. The value
represented by a floating point number is thus given by

(−1)s (1 + M )2E−127 .

2.2 Integer Representation and Operations

Integers (defined by long in the code) are represented by a single 32-bit field.
Integers use the two’s complement representation to allow for both negative and
positive values, meaning that bit 31 denotes the sign of the integer; however,
for the purposes of this paper, we will only be dealing with positive integers (as
the square root is only real for positive values).
The shift right operator on line 7, >>, shifts all bits to the right by the
specified amount, duplicating bit 31 and truncating bits which are shifted past
bit 0. For a positive integer x, x >> 1 results in bx/2c, as it is equivalent to
moving the “binary point” (the equivalent of the decimal point in base 2) to the
left by 1 bit and truncating the fraction. Lines 6 and 8 are casting operations
which are used to convert between different representations of a value. Line 6
interprets the raw bits of a floating point number as an integer, allowing for
integer operations to be performed, and line 8 does the reverse.

3 The Algorithm
Given a number x > 0, the algorithm uses Newton’s method to approximate
√1 . Newton’s method is an iterative root-finding algorithm which requires an
x
initial guess y0 . Line 7 computes the initial guess y0 and line 9 performs a single
iteration of Newton’s method.
We will begin by assuming that we have a reasonable initial guess and prove
the error bounds of Newton’s method. Then we will address the details of
making the initial guess.

3.1 Newton’s Method

Our goal is to find a y which satisfies the equation √1x = y. If we square,
invert, then subtract x from each side, we see that this is equivalent to solving
1 1
y 2 − x = 0, with the restriction that y must be positive. If we let f (y) = y 2 − x,
the problem then becomes finding the positive root of f (y). We can approximate
the roots of f (y) using Newton’s method, an iterative root-finding algorithm
requiring an initial guess y0 of a root, and where

f (yn )
yn+1 = yn − .
f 0 (yn )

Geometrically, yn+1 can be interpreted as the zero of the tangent line to f (y)
at yn , as shown in Figure 1.

3
 y0 y1 y

Figure 1: Geometric interpretation of Newton’s method.

For a more detailed derivation and convergence analysis of Newton’s method,

see [3]. For our purposes, we will only examine our particular choice for f (y).
Substituting our function f (y) into the formula for yn+1 , we see that

1/yn2 − x
 
3 1 2
yn+1 = yn − = yn − xy ,
−2/yn3 2 2 n

which corresponds to the line

y = y * ( threehalfs - ( x2 * y * y ) );
meaning that after the initial guess y0 is determined, a single iteration of New-
ton’s method is performed to obtain the final result.
 Suppose
 the initial guess y0 has relative error of at most 0 > 0, so that
 y−y0 
 y  ≤ 0 . We can rewrite this as

y(1 − 0 ) ≤ y0 ≤ y(1 + 0 ).

Therefore, y0 = y(1 + δ) for some δ ∈ [−0 , 0 ]. By performing a single iteration

of Newton’s method we obtain
 
3 1 2
y1 = y(1 + δ) − x (y(1 + δ))
2 2
 2 !
1 3 1 1
= √ (1 + δ) − x √ (1 + δ)
x 2 2 x
 
1 3 1
=√ 1 − δ2 − δ3
x 2 2
 
3 2 1 3
=y 1− δ − δ .
2 2

Now let g(δ) = y1 . We can find the maximum relative error after applying
Newton’s method by minimizing and maximizing g(δ) for δ ∈ [−0 , 0 ]. The
roots of g 0 (δ) = −3yδ(1 + δ/2) occur at δ = 0 and δ = −2, meaning that these

4
are the critical points of g(δ). However, for small enough 0 (specifically, for
0 < 2), we must only consider the point δ = 0 as well as the endpoints δ = ±0
(we will later see that 0 is well below
2). Evaluating at these points,
we see that
g(0) = y, g(−0 ) = y 1 − 23 20 + 21 30 , and g(0 ) = y 1 − 32 20 − 12 30 . Thus, the
minimum occurs at δ = 0 and the maximum occurs at δ = 0, so
 
3 2 1 3
y 1 − 0 − 0 < y1 < y.
2 2

Therefore, we conclude that if our initial guess y0 has an initial relative error
of at most 0 , by performing an iteration of Newton’s method our new relative
error becomes at most 23 20 + 12 30 , or
 
 y − y1  3 2 1 3
 y  ≤ 1 = 2 0 + 2 0 .
 

3.2 Computing the Initial Guess

We now turn to the algorithm which determines the initial guess y0 . This
algorithm relies heavily on the same bit strings being interpreted as both integers
and floats. If b is a bit string, then we will denote the sign bit as bs , the bits
contained in the exponent field as bE , and the bits contained in the mantissa
field as bM . Furthermore, we will write b when we wish to interpret b as an
integer or to perform integer operations, and b when we wish to interpret it
as a float or to perform floating point operations. Similarly, this applies to the
mantissa bM : bM is the integer interpretation and bM is interpreted as a real
in the range [0, 1).
The code responsible for making the initial guess y0 is the single following
line:
i = 0x5f3759df - ( i >> 1 );

For easier analysis, we rewrite these operations in the following way. Suppose
we are trying to find the inverse square root of x. Let c be the “magic number”
(0x5f3759df in the original code), and let y0 be our initial guess. Then our
code becomes:
t = x >> 1;
y_0 = c - t;
Although c is defined as an integer, we can interpret its bits as a floating point
number, and so our notation also applies to c.

3.2.1 Idea Behind the Initial Guess

If we first look at the simpler case where we ignore some of the artifacts that
occur when performing integer operations on floating point numbers, we can get
an idea of the reasoning behind the the algorithm for computing y0 . Since x is

5
positive, xs is 0. Thus the desired value we are trying to approximate with y0
is
1 1 1
√ =p =√ 2−(xE −127)/2 .
x (1 + xM )2 xE −127 1 + xM
Recall that performing a shift right operation by 1 divides an integer by 2.
Ignoring the issue of a bit being shifted from xE into xM , we consider the
exponent and mantissa fields to be divided by 2 separately so that tE = xE /2
and tM = xM /2. If we now treat the subtraction operation c − t separately
for the exponent and mantissa fields (meaning that we ignore the possibility
that the mantissa “borrows” a bit from the exponent), y0E = cE − xE /2 and
y0M = cM − xM /2. Thus, y0 = (cM − xM /2)2cE −xE /2−127 . The value of the
exponent field in c = 0x5f3759df
√
is 0xbe = 190. Substituting this value for cE ,
we see that y0 becomes 22 (cM −xM /2)2−(xE −127)/2 . By selecting cE to be 190,
the exponent 2−(xE −127)/2 is the same in y0 as it is in √1x . Therefore, cM should
√
be picked appropriately so that 22 (cM − xM /2) is a linear approximation of
√ 1 .
1+xM
In practice it is not as straightforward, as the integer shift right and sub-
traction operations on the exponent and mantissa are not performed separately,
meaning that bits can be shifted or borrowed from one field to the other. How-
ever, the high level idea of the approximation remains the same.

3.2.2 Detailed Analysis

We proceed by analyzing the following two cases separately:
1. If xE is even (before bias), then bit 0 of xE is 0, and the shift right
operation divides both the exponent and mantissa by 2 (as the sign bit is
0, the leading bit of the resulting exponent remains 0).

2. If xE is odd, then bit 0 of xE is 1, meaning that when performing the shift

right operation, a leading 1 is shifted into the mantissa. The exponent and
mantissa are divided by 2, but the bit from the exponent bleeding over
then adds the value of 1/2 to the mantissa.
First we consider the case when xE is even. By performing t = x >> 1,
tE = xE /2 and tM = bxM /2c. For simplicity however, we will consider tM
to be xM /2, as the resulting error from dropping bit 0 is only 2−24 , which is
insignificant compared to other errors. First, we notice that cs must be 0. This
is because xs = ts is 0, meaning that if cs were 1, c − t would produce a sign
bit of 1, indicating a negative value, which we cannot have. We now consider
cE − xE /2, which has two requirements:

1. cE − xE /2 must be non-negative. If it were negative, the sign bit would be

borrowed from, and because the sign bit is 0, integer wraparound would
occur and cause the sign bit to become 1, meaning the resulting float
would be negative, which we cannot have.

6
 2. cE − xE /2 must not be zero. If cM − xM /2 is negative, a bit will be
borrowed from cE − xE /2, and if cE − xE /2 is 0, the resulting exponent
will become negative, breaking our first condition.
Thus we require that cE − xE /2 ≥ 1. Recall that xE is an 8-bit unsigned integer
(before bias), meaning that it is in the range [0..255]. The values 0 and 255 are
reserved for special cases (0, denormalization, ∞, and NaN), so a valid xE falls
into [1..254]. Recalling that we are only dealing with an even xE , we are further
restricted to even integers in [2..254]. Thus, xE /2 ∈ [1..127], meaning that cE
must be at least 128.
We now consider the result of subtracting the mantissas. If cM ≥ xM /2,
then no borrowing from the exponent field occurs, and we immediately obtain
the result
y0 = (1 + cM − xM /2)2cE −xE /2−127 .
However, if cM < xM /2, then subtracting the mantissas will cause a bit to be
borrowed from the exponent field (as shown above, at least one bit is guaranteed
to be available for this purpose as cE − xE /2 ≥ 1), reducing the resulting
exponent by 1 and thus dividing the result by 2. Because cM − cE /2 < 0
but the bits in the mantissa still represent a value in the range [0, 1), this will
cause the resulting mantissa’s value to “wrap around”, effectively adding 1 to
what would have been a negative result. The resulting mantissa is therefore
1 + cM − xM /2 and we obtain the result

y0 = (2 + cM − xM /2)2cE −xE /2−128 .

Rewriting the exponents to be the same in each case, we summarize so far with
the following:
(
(2 + 2cM − xM )2cE −xE /2−128 , if cM ≥ xM /2
y0 = cE −xE /2−128
.
(2 + cM − xM /2)2 , if cM < xM /2

Now we consider the case when xE is odd. This time, by performing

t = x >> 1, bit 0 of the exponent (which is a 1, as the exponent is odd) is
shifted into bit 22 of the mantissa, adding the value of 1/2. Therefore, again
ignoring the negligible error of 2−24 by treating bxM /2c as xM /2, we see that
tE = xE /2−1/2 = (xE −1)/2 and tM = xM /2+1/2 = (xM +1)/2. Once again,
we see that cs must be 0 in order to get a non-negative initial guess. Similarly
to the case where xE is even, we again require that cE − (xE − 1)/2 ≥ 1 so that
the sign bit does not become 1 and so that a bit is available for the mantissa
to borrow from during subtraction if necessary. Once again, as the values 0
and 255 are reserved for xE and xE is odd, its range is [1..253], meaning that
(xE − 1)/2 ∈ [0..127], so again, cE must be at least 128.
We now look at the result of subtracting the mantissas. If cM ≥ (xM + 1)/2,
then once again no borrowing from the exponent field occurs and we see that

y0 = (1 + cM − (xM + 1)/2)2cE −(xE −1)/2−127 .

7
If cM < (xM + 1)/2, we must account for the bit borrowed from the exponent
field. As before, the exponent is reduced by 1, dividing the result by 2, and
the value of the mantissa wraps around to fall in the range [0, 1), equivalent to
adding 1. Therefore in this case,
y0 = (2 + cM − (xM + 1)/2)2cE −(xE −1)/2−128 .
We again summarize our results up to this point, rewriting the exponents to
be more consistent:
(2 + 2cM − xM )2cE −xE /2−128 ,


 if xE is even, cM ≥ xM /2
(2 + c − x /2)2cE −xE /2−128 ,

if xE is even, cM < xM /2
M M
y 0 = √2 cE −xE /2−128
.
 2 (2 + 4c M − 2x M )2 , if x E is odd, c M ≥ (xM + 1)/2
 √2


cE −xE /2−128
2 (3 + 2cM − xM )2 , if xE is odd, cM < (xM + 1)/2

3.2.3 Error of the Initial Guess

We now want to find the relative error of our initial guess y0 . Let y be the
actual value of √1x . Recall that

1 1 2−(xE −127)/2
y= √ = p = √ .
x (1 + xM )2xE −127 1 + xM
 
Then the relative error of y0 to y is 0 =  y−y y . Define  to be
0 y−y0
y . As

we have not yet determined the optimal value of c,  depends on cE , cM , xE ,
and xM . We again proceed by considering the cases where xE is even and odd
separately.
First suppose xE is even. Let
(
2cM − xM , if cM ≥ xM /2
fe (xM , cM ) = .
cM − xM /2, if cM < xM /2
Then we can write y0 as
y0 = (2 + fe (xM , cM ))2cE −xE /2−128 .
In this case we see that
y − y0 y0
= =1−
y y
(2 + fe (xM , cM ))2cE −xE /2−128
=1−  −(x −127)/2 
2 √E
1+xM
√ √
=1− 2 1 + xM (2 + fe (xM , cM ))2cE −192 .
Now suppose xE is odd. Let
(
4cM − 2xM , if cM ≥ (xM + 1)/2
fo (xM , cM ) = .
1 + 2cM − xM , if cM < (xM + 1)/2

8
We can again write y0 as
√
2
y0 = (2 + fo (xM , cM ))2cE −xE /2−128 .
2
As before, we simplify to see that
√
2√
=1− 1 + xM (2 + fo (xM , cM ))2cE −192 .
2
Combining our results to cover all cases,
( √ √
1 − 2 1 + xM (2 + fe (xM , cM ))2cE −192 , if xE is even
= √ .
1 − 1 + xM (2 + fo (xM , cM ))2cE −192 , if xE is odd

3.2.4 Finding the Optimal Magic Number

 
We now wish to find a value for c which will minimize the relative error  y−y0

y .
We first decide on cE by examining the exponent of y. Once again, recall that
1 1
y= √ = √ 2−(xE −127)/2 .
x 1 + xM

This result almost looks to be in the form (1 + yM )2yE −127 . However, the
mantissa (including the implied leading 1) must lie in the range [1, 2), and since
1
xM lies [0, 1) (as it does not include the implied leading 1), √1+x lies between
√ M

2/2 and 1, and so cannot be a valid mantissa. Furthermore, the exponent

must be an integer, and since we don’t know whether xE is even or odd, the
division by 2 may cause the exponent to be non-integral. As usual, we will have
to look at the even and odd cases separately. √
First suppose xE is even. If we bring a 2 out of the exponent, we can
rewrite y as r
2
2−(xE −126)/2 .
1 + xM
q
2
Since 1+x M
is now in the proper range for a mantissa and −(xE − 126)/2 is
clearly an integer, the expression above is in the proper form and we have found
the mantissa and exponent of y. In particular, accounting for bias, yE − 127 =
−(xE − 126)/2, meaning that yE = 190 − xE /2.
Now suppose xE is odd. This time we bring a 2 out of the exponent, rewriting
y as
2
√ 2−(xE −125)/2 .
1 + xM
√ 2 is again now in the proper range for a mantissa and −(xE − 125)/2 is
1+xM
clearly an integer, so the expression above is in the proper form. Therefore,
yE − 127 = −(xE − 125)/2, meaning that yE = 189 − bxE c/2.

9
 Using right shift notation, we can rewrite these results. If xE is even, then
yE = 190 − (xE >> 1), and if xE is odd, then yE = 189 − (xE >> 1). The
expressions for yE are nearly identical to the line of code to compute y0 except
that the code works with all of y0 , c, and x, rather than just the exponent fields.
However, as we want y0E to be close to yE , we have found appropriate values for
cE : 189 or 190. We cannot use both of them, as we must use the same constant
for both even and odd cases, so we decide to let cE = 190 as in the original code
and continue. This meets our previous requirement that cE be at least 128.
Having picked cE , we can now simplify our expression for :
( √ √
1 − 42 1 + xM (2 + fe (xM , cM )), if xE is even
= √ .
1 − 14 1 + xM (2 + fo (xM , cM )), if xE is odd

Our task is now to find a value for cM ∈ [0, 1) such that maxxM ∈[0,1) {||} is
minimized. To do this, we first fix cM and determine the value (or values) of
xM which maximize || for that fixed cM . As usual, we examine the cases for
xE even and xE odd separately.
First suppose xE is even. Recall the definition of fe (xM , cM ),
(
2cM − xM , if cM ≥ xM /2
fe (xM , cM ) = .
cM − xM /2, if cM < xM /2

fe (xM , cM ) is clearly continuous and differentiable for cM > xM /2 and for

cM < xM /2. If cM = xM /2, we see that 2cM − xM = cM − xM /2, so
fe (xM , cM ) is continuous there as well. Thus, fe (xM , cM ) is continuous and
piecewise differentiable on [0, 1]. The same is true of , as it is a composition of
continuous differentiable functions and fe (xM , cM ). Therefore, its maximums
and minimums will occur at critical points or endpoints of its pieces.
First we consider the endpoints. Define g1 (cM ), g2 (cM ), and g3 (cM ) to be
 when xM is 0, 1, and 2cM , respectively. Then
√
2
g1 (cM ) = 1 − (1 + cM ),
2
(
1
− cM , if cM ≥ 1/2
g2 (cM ) = 12 ,
4 − cM /2, if cM < 1/2
√
2√
g3 (cM ) = 1 − 1 + 2cM .
2
Now we consider the critical points. We see that
 √ 
2 1+c M −xM /2
√ 
∂  − 4
√
1+xM
− 1 + x M , if cM > xM /2
= 2+c −x /2 √  .
∂xM − 1 √M M
− 1 + xM , if cM < xM /2
8 1+xM

The first case is 0 when xM = 23 cM , which also satisfies the condition that
cM > xM /2. The second case is 0 when xM = 23 (1 + cM ), and the condition

10
cM < xM /2 can only be satisfied when cM < 12 . Thus, there is a critical point
at xM = 23 cM and another at xM = 32 (1 + cM ) if cM < 12 , so we define g4 (cM )
and g5 (cM ), corresponding respectively to these critical points, as
√   32
2 2
g4 (cM ) = 1 − 1 + cM ,
2 3
(
0 if cM ≥ 12
g5 (cM ) = √ 3 .
1 − 5 3630 1 + 25 cM 2 if cM < 12

Now suppose instead xE is odd. The definition of fo (xM , cM ) is

(
4cM − 2xM , if cM ≥ (xM + 1)/2
fo (xM , cM ) = .
1 + 2cM − xM , if cM < (xM + 1)/2

fo (xM , cM ) is continuous and differentiable for cM > (xM + 1)/2 and cM <
(xM + 1)/2 and if cM = (xM + 1)/2, 4cM − 2xM = 1 + 2cM − xM . Therefore,
fo (xM , cM ) is continuous and piecewise differentiable on [0, 1], as is , so the
maximums and minimums of  will occur at critical points or endpoints of its
pieces.
We first consider the endpoints where xM is 0, 1, and 2cM − 1, and de-
fine g6 (cM ), g7 (cM ), and g8 (cM ) to be  corresponding to these values of xM ,
respectively. Then
(
1
− cM , if cM ≥ 12
g6 (cM ) = 12 1
,
4 − cM /2, if cM < 2
√
2
g7 (cM ) = 1 − (1 + cM ).
2
The point xM = 2cM − 1 can only occur if cM ≥ 12 , so we define g8 (cM ) as
( √
1 − 2cM , if cM ≥ 12
g8 (cM ) = .
0, if cM < 12

Now we again consider the critical points by finding the zeros of

 
1 1+2c M −xM
√ 
∂  − 4 
√
1+xM
− 2 1 + x M , if cM > (xM + 1)/2
= √  .
∂xM − 1 3+2c√ M −xM − 1 + x M , if c M < (x M + 1)/2
4 2 1+x M

The first case is 0 when xM = (2cM − 1)/3, which satisfies the condition cM >
(xM + 1)/2 when cM > 21 . The second case is 0 when xM = (2cM + 1)/3, which
always satisfies the condition cM < (xM + 1)/2 (when cM < 1). We define
g9 (cM ) and g10 (cM ) corresponding respectively to these critical points as
(
3
1 − 32 (1 + cM ) 2 , if cM > 12
g9 (cM ) = ,
0, if cM ≤ 21

11
   32
1 2
g10 (cM ) = 1 − (2 + cM ) .
2 3
We now have a gj (cM ) covering each possible case where  could be mini-
mized or maximized over all xM ∈ [0, 1). Let h(cM ) = max1≤j≤10 {|gj (cM )|}.
Then for fixed cM ,
max {||} = h(cM ).
xM ∈[0,1)

Our last step is to determine the value for cM ∈ [0, 1) such that h(cM ) is
minimized. Using a numerical minimizer for this task, we find the optimal
value to be
cM ≈ 0.4327448899640689,
giving a maximum error of

0 = || ≈ 0.03421281.

This choice for cM corresponds to the value 0x37642f for the right half of
the magic number. This differs from the choice of cM for the original magic
number, which was 0x3759df. However, the original choice of cM corresponds
to a mantissa field of 0.432430148124695, which is not far off from our result.

3.3 Results
We have determined that the maximum relative error of the initial guess y0 is
approximately 0 = 0.03421281 and that by applying one iteration of Newton’s
method, the maximum relative error becomes 1 = 32 20 + 12 30 . Combining these
results, we obtain the maximum relative error of our final result,

1 ≈ 0.0017758.

Figure 2 shows a plot of the initial guess compared to the actual value and
Figure 3 shows the final result after an iteration of Newton’s method.

1.25 1.25

1.0 1.0

0.75 0.75

0.5 1.0 1.5 2.0 0.5 1.0 1.5 2.0

Figure 2: The initial guess (red) Figure 3: The final result (red) com-
compared to √1x (blue). pared to √1x (blue).

12
 It is worth noting that the original magic number used differs slightly from
the value we derived. It is possible that the original value was determined using
a criterion other than the minimum of the maximum error. Eberly [1] optimized
a variety of different criteria to obtain several other choices for cM , though none
of them were exactly the same as the original. It also may be the case that
the optimization to determine the original value for cM was performed after the
iteration of Newton’s method, as the true value requiring optimization is the
final result, not the initial guess. Although in theory this should produce the
same value for cM , it is easy to overlook the details of floating point math in
hardware which may introduce small amounts of error in practice. Notably, by
testing all possible floating point values using each choice for cM , Lomont [4]
found that while the initial guess using the value for cM derived here performed
better than the original choice, the new value actually produced a slightly higher
maximum error after an iteration of Newton’s method. This indicates that
Newton’s method is in fact a source of error being overlooked. Further analysis
would need to be performed to determine why this is the case.

4 Conclusion
Although the fast inverse square root function is difficult to decode at first
glance, after a detailed analysis we have a thorough understanding of the moti-
vation behind the method and its inner workings. After analyzing the specific
case of computing x−1/2 for 32-bit floating point numbers, several questions
naturally arise. Is it possible to extend the algorithm to work using 64-bit dou-
ble precision floats? The answer, fortunately, is yes, as the algorithm is not
dependent on the length of the bit strings being manipulated. Furthermore, our
optimal value for cM remains the same as long as we have computed enough
digits. Code for a 64-bit version is provided by McEniry in [5]. Another question
that arises is whether it is possible to derive similar algorithms which approxi-
mate x to powers other than −1/2. [5] briefly discusses √ this in the conclusion,
1
providing some equations as a starting point for √ n x,
n
x, and xa . Notably, we
√ √
can easily approximate x, since x = x √1x .

References
[1] David Eberly, Fast Inverse Square Root (Revisited), 2010.
[2] id software, quake3-1. 32b/ code/ game/ q_ math. c , Quake III Arena, 1999.
[3] Lee W. Johnson and R. Dean Riess, Newton’s Method, Numerical Analysis, 1982, pp. 160–
161.
[4] Chris Lomont, Fast Inverse Square Root, 2003.
[5] Charles McEniry, The Mathematics Behind the Fast Inverse Square Root Function Code,
2007.

13