1. The exponent written in binary

Write the exponent $n$ in binary, as a sum of powers of two. For example, $10 = 8 + 2 = 2^3 + 2^1$, which is 1010 in binary. The powers of $x$ follow the same split, because exponents add when powers multiply:

$x^{10} = x^{8 + 2} = x^{8} \cdot x^{2}$

In general, if bit $i$ of $n$ is $b_i$ (0 or 1), then

$x^n = \prod_{i\,:\, b_i = 1} x^{2^i}$

So $x^n$ is the product of the powers $x^1, x^2, x^4, x^8, \ldots$ that belong to the set bits of $n$. The code multiplies exactly these powers into result.

2. One round of the loop

Each round looks at the lowest bit of $n$ and then removes it:

At the start of round $i$ (counting from 0), curr_product holds $x^{2^i}$. It starts as $x = x^{2^0}$, and each round squares it.

3. Why the result is right, and why it is fast

After the round for bit $i$, result holds the product of $x^{2^j}$ over the set bits $j \le i$. When $n$ reaches 0, every bit has been handled, so result holds $x^n$ by the formula of part 1.

Each round uses the rule $x^n = (x^2)^{\lfloor n/2 \rfloor} \cdot x^{\,n \bmod 2}$. When the lowest bit is 1, result takes one factor of curr_product. Then curr_product is squared and n is halved. A recursive version uses $x^n = (x^{\lfloor n/2 \rfloor})^2 \cdot x^{\,n \bmod 2}$ instead, which squares the answer of the half-size problem. Both make $O(\log n)$ multiplications.

$n$ has about $\log_2 n + 1$ bits, and each round does at most two multiplications. So the code makes $O(\log n)$ multiplications instead of the $n - 1$ of multiplying $x$ by itself again and again. For $n = 2^{31} - 1$ that is 31 rounds instead of more than two billion multiplications.

4. Negative exponents

For $n < 0$, the rule is $x^{n} = \left(\frac{1}{x}\right)^{-n}$. The code replaces x with 1.0 / x and n with -n, and then runs the same loop on a positive exponent. The problem guarantees that $x$ is not zero when $n \le 0$, so 1.0 / x never divides by zero.

The smallest allowed exponent is $n = -2^{31}$. Then -n is $2^{31}$, which is one more than the largest 32-bit integer. Python integers have no fixed size, so n = -n works. In a language with 32-bit integers, this negation overflows. There the code must store $-n$ in a 64-bit integer.

For example, $x = 2$ and $n = -2$ become $x = 0.5$ and $n = 2$. The loop then computes $0.5 \cdot 0.5 = 0.25$.

5. Example 1 by hand

x = 2.0, n = 10, which is 1010 in binary.

The set bits are bits 1 and 3, so result is $x^{2} \cdot x^{8} = 4 \cdot 256 = 1024$. The code returns 1024.0, the expected output 1024.00000. The last squaring, 65536, is computed but not used.

6. Example 2 by hand

x = 2.1, n = 3, which is 11 in binary. In round 0 the lowest bit is 1, so result becomes $2.1$, and curr_product becomes $2.1^2 = 4.41$. In round 1 the lowest bit is 1 again, so result becomes $2.1 \cdot 4.41$.

The exact value is $2.1^3 = \frac{9261}{1000} = 9.261$. The number 2.1 has no exact binary form, so the float result is 9.261000000000001. It differs from the exact value 9.261 by about $1.0 \cdot 10^{-15}$. Rounded to five decimal places it is 9.26100, the expected output.

7. From the formula to the code

The loop runs once per bit of $n$, so the code takes $O(\log n)$ time and $O(1)$ space.