Быстрое возведение в степень

public class Solution {
    public static double FastPow(double x, int n) {
        // Возведении любого числа в степень 0 - всегда дает 1
        if (n == 0) {
            return 1.0;
        }
        // Возведение x в отрицательную степень n тоже самое
        // что и возведение 1/x в положительную степень n
        if (n < 0) {
            return FastPow(1.0 / x, -n);
        }
        // Накапливаем ответ
        double result = 1;
        // Алгоритм быстрого возведения в степень
        while (n != 0) {
            // Если степень, в которую возводим нечетная
            if (n % 2 != 0) {
                result *= x;
                n -= 1;
            } 
            // Если степень, в которую возводим четная
            else {
                // Именно за счет этой оптимизации получаем
                // оптимальное решение. Она заключается в том, что
                // возвести, например 2 в 100 степень тоже самое что и 
                // 4 в 50 степень - т е мы можем в 2 раза сократить степень
                // но при этом x нужно умножить на самого себя
                x *= x;
                n /= 2;
            }
        }
        return result;
    }
}

using namespace std;

double fastPow(double x, int n) {
    // Возведение любого числа в степень 0 - всегда дает 1
    if (n == 0) {
        return 1.0;
    }
    // Возведение x в отрицательную степень n тоже самое
    // что и возведение 1/x в положительную степень n
    if (n < 0) {
        return fastPow(1.0 / x, -n);
    }
    // Накапливаем ответ
    double result = 1;
    // Алгоритм быстрого возведения в степень
    while (n != 0) {
        // Если степень, в которую возводим нечетная
        if (n % 2 != 0) {
            result *= x;
            n -= 1;
        }
        // Если степень, в которую возводим четная
        else {
            // Именно за счет этой оптимизации получаем
            // оптимальное решение. Она заключается в том, что
            // возвести, например 2 в 100 степень тоже самое что и
            // 4 в 50 степень - т.е. мы можем в 2 раза сократить степень
            // но при этом x нужно умножить на самого себя
            x *= x;
            n /= 2;
        }
    }
    return result;
}

package main

func fastPow(x float64, n int) float64 {
    // Возведение любого числа в степень 0 - всегда дает 1
    if n == 0 {
        return 1.0
    }
    // Возведение x в отрицательную степень n тоже самое
    // что и возведение 1/x в положительную степень n
    if n < 0 {
        return fastPow(1.0 / x, -n)
    }
    // Накапливаем ответ
    result := 1.0
    // Алгоритм быстрого возведения в степень
    for n != 0 {
        // Если степень, в которую возводим нечетная
        if n % 2 != 0 {
            result *= x
            n -= 1
        } else { // Если степень, в которую возводим четная
            // Именно за счет этой оптимизации получаем
            // оптимальное решение. Она заключается в том, что
            // возвести, например 2 в 100 степень тоже самое что и 
            // 4 в 50 степень - т е мы можем в 2 раза сократить степень
            // но при этом x нужно умножить на самого себя
            x *= x
            n /= 2
        }
    }
    return result
}

import java.util.*;

public class Solution {
    public double fastPow(double x, int n) {
        // Возведении любого числа в степень 0 - всегда дает 1
        if (n == 0) {
            return 1.0f;
        }
        // Возведение x в отрицательную степень n тоже самое
        // что и возведение 1/x в положительную степень n
        if (n < 0) {
            return fastPow(1.0f / x, -n);
        }
        // Накапливаем ответ
        float result = 1;
        // Алгоритм быстрого возведения в степень
        while (n != 0) {
            // Если степень, в которую возводим нечетная
            if (n % 2 != 0) {
                result *= x;
                n -= 1;
            } else {
                // Если степень, в которую возводим четная
                // Именно за счет этой оптимизации получаем
                // оптимальное решение. Она заключается в том, что
                // возвести, например 2 в 100 степень тоже самое что и 
                // 4 в 50 степень - т е мы можем в 2 раза сократить степень
                // но при этом x нужно умножить на самого себя
                x *= x;
                n /= 2;
            }
        }
        return result;
    }
}

from typing import *

def fast_pow(x: float, n: int) -> float:
    # Возведении любого числа в степень 0 - всегда дает 1
    if n == 0:
        return 1.0
    # Возведение x в отрицательную степень n тоже самое
    # что и возведение 1/x в положительную степень n
    if n < 0:
        return fast_pow(1.0 / x, -n)
    # Накапливаем ответ
    result = 1
    # Алгоритм быстрого возведения в степень
    while n != 0:
        # Если степень, в которую возводим нечетная
        if n % 2 != 0:
            result *= x
            n -= 1
        # Если степень, в которую возводим четная
        else:
            # Именно за счет этой оптимизации получаем
            # оптимальное решение. Она заключается в том, что
            # возвести, например 2 в 100 степень тоже самое что и 
            # 4 в 50 степень - т е мы можем в 2 раза сократить степень
            # но при этом x нужно умножить на самого себя
            x *= x
            n //= 2
    return result

/**
* @param {number} x
* @param {number} n
* @returns {number}
*/
export function fastPow(x, n) {
    // Возведении любого числа в степень 0 - всегда дает 1
    if (n === 0) {
        return 1.0;
    }
    // Возведение x в отрицательную степень n тоже самое
    // что и возведение 1/x в положительную степень n
    if (n < 0) {
        return fastPow(1.0 / x, -n);
    }
    // Накапливаем ответ
    let result = 1;
    // Алгоритм быстрого возведения в степень
    while (n !== 0) {
        // Если степень, в которую возводим нечетная
        if (n % 2 !== 0) {
            result *= x;
            n -= 1;
        } else {
            // Если степень, в которую возводим четная
            // Именно за счет этой оптимизации получаем
            // оптимальное решение. Она заключается в том, что
            // возвести, например 2 в 100 степень тоже самое что и 
            // 4 в 50 степень - т е мы можем в 2 раза сократить степень
            // но при этом x нужно умножить на самого себя
            x *= x;
            n = Math.floor(n / 2);
        }
    }
    return result;
}