Как найти кубический корень python

Кубическим корнем числа называют такое значение, которое при возведении в куб дает исходное число. Другими словами, кубический корень — это значение, при троекратном умножении на которое мы можем получить число под корнем.

Кубический корень обозначается символом «3√». В случае с квадратным корнем мы использовали только символ ‘√’ без указания степени, который также называется радикалом.

Например, кубический корень из 125, обозначаемый как 3√125, равен 5, так как при умножении 5 на само себя три раза получается 5 x 5 x 5 = 125 = 5^3.

Чтобы вычислить кубический корень в Python, используйте простое математическое выражение x ** (1. / 3.), результатом которого является кубический корень из x в виде значения с плавающей точкой. Для проверки, корректно ли произведена операция извлечения корня, округлите полученный результат до ближайшего целого числа и возведите его в третью степень, после сравните, равен ли результат x.

x = 8

cube_root = x ** (1./3.)

print(cube_root)

Вывод

В Python для того, чтобы возвести число в степень, мы используем оператор **. Указание степени, равной 1/3, в выражении с ** позволяет получить кубический корень данного числа.

Извлечение кубического корня из отрицательного числа в Python

Мы не можем найти кубический корень из отрицательных чисел указанным выше способом. Например, кубический корень из целого числа -64 должен быть равен -4, но Python возвращает 2+3.464101615137754j.

Чтобы найти кубический корень из отрицательного числа в Python, сначала нужно применить функцию abs(), а затем можно воспользоваться представленным ранее простым выражением с ** для его вычисления.

Давайте напишем полноценную функцию, которая будет проверять, является ли входное число отрицательным, а затем вычислять его кубический корень соответствующим образом.

def get_cube_root(x):
    if x < 0:
        x = abs(x)
        cube_root = x**(1/3)*(-1)
    else:
        cube_root = x**(1/3)
    return cube_root

print(round(get_cube_root(64)))
print(get_cube_root(-64))

Вывод

Как видите, нам нужно округлить результат, чтобы получить целочисленное значение кубического корня.

Использование функции Numpy cbrt()

Библиотека numpy предлагает еще один вариант нахождения кубического корня в Python, который заключается в использовании метода cbrt(). Функция np.cbrt() вычисляет кубический корень для каждого элемента переданного ей массива.

import numpy as np 

cubes = [125, -64, 27, -8, 1] 
cube_roots = np.cbrt(cubes) 
print(cube_roots)

Вывод

Функция np.cbrt() — самый простой способ получения кубического корня числа. Она не испытывает проблем с отрицательными входными данными и возвращает целочисленное число, например, -4 для переданного в качестве аргумента числа -64, в отличие от вышеописанных подходов.

Возможно вы хотели просто решить проблему неточного извлечения корней из точных кубов, но получилось как получилось:

import struct
from fractions import Fraction


def difference(float_expected, float_root, degree):
    '''
    Возвращает разницу между степенью корня и ожидаемым значением
    '''

    fraction_expected = Fraction.from_float(float_expected)
    fraction_root = Fraction.from_float(float_root)
    return abs(fraction_expected - fraction_root ** degree)


def ternary_search(lower_bound, upper_bound, function):
    '''
    Находит целое значение x из промежутка [lower_bound, upper_bound),
    для которого значение function(x) минимально
    '''

    while lower_bound + 3 < upper_bound:
        mid1 = (lower_bound * 2 + upper_bound) // 3
        mid2 = (lower_bound + upper_bound * 2) // 3
        res1 = function(mid1)
        res2 = function(mid2)
        if res1 < res2:
            upper_bound = mid2
        else:
            lower_bound = mid1

    return min(range(lower_bound, upper_bound), key=function)


def create_float(exponent, mantissa):
    '''
    Создает число binary64 IEEE-754 по экспоненте и мантиссе
    '''
    
    number = (exponent << 52) + mantissa
    return struct.unpack('d', number.to_bytes(8, 'little'))[0]


def precise_root(float_value, degree):
    '''
    Возвращает максимально точное значение корня среди всех возможных
    значений binary64 IEEE-754 (используя только стандартный формат
    1-11-52, исключая все субнормальные и специальные значения)

    value - положительное число с плавающей запятой
    degree - положительное целое число больше единицы
    '''
    
    nearest_values = [float_value ** (1 / degree)]
    min_difference = difference(float_value, nearest_values[0], degree)
    for exponent in range(1023, 2047):
        calc_difference = lambda x: difference(float_value,
                                               create_float(exponent, x),
                                               degree)
        mantissa = ternary_search(0, 2 ** 52, calc_difference)
        diff = difference(float_value, create_float(exponent, mantissa), degree)
        if diff < min_difference:
            nearest_values = [create_float(exponent, mantissa)]
        elif diff == min_difference:
            nearest_values.append(create_float(exponent, mantissa))

    return nearest_values[0]


if __name__ == "__main__":
    value = 1000000001.0
    degree = 9
    root = precise_root(value, degree)
    diff = difference(value, root, degree)
    print(format(root, '.70f'))
    print(format(value ** (1 / degree), '.70f'))
    print(format(float(diff), '.70f'))
    print(format(float(difference(value, value ** (1 / degree), degree)), '.70f'))
    # 10.0000000011111112030448566656559705734252929687500000000000000000000000
    # 10.0000000011111094266880172654055058956146240234375000000000000000000000
    # 0.0000000831848155171970377866333596662828941958878203877247869968414307
    # 0.0000015155363413641129334422444352448167137481505051255226135253906250

Под извлечением корня из какого-либо числа чаще всего подразумевают нахождение решение уравнения x в степени n = value, соответственно для квадратного корня, число n — это два, для кубического — 3. Чаще всего под результатом и числом подразумеваются вещественные числа.

В программировании нахождение корней используется очень часто. Разберемся, как и какими методами можно эффективно извлекать корни из числа. Вначале рассмотрим, какие способы есть в Python, и определим самый эффективный. Потом более подробно разберём, как можно найти не только квадратный корень из числа, но и кубический, и потом корень n степени.

Способы извлечения корня

В языке программирования Python 3 существует три способа извлечения корней:

• Использование функции sqrt из стандартной математической библиотеки math.
• Операция возведения в степень **
• Применение функции pow(x, n)

Чтобы воспользоваться первым способом, необходимо вначале импортировать sqrt из модуля math. Это делается с помощью ключевого слова import: from math import sqrt. При помощи этой функции можно извлекать только квадратный корень из числа. Приведем пример:

from math import sqrt
x = sqrt(4)
print(x)

2.0

Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.

from math import hypot
x = hypot(4,3)
print(x)

5.0

Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:

n = 2
x = 4**(1./n)
print(x)

2.0

Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.

Последний метод использует функцию pow(value, n). Эта функция в качестве аргумента value возьмет число, которое необходимо возвести в степень, а второй аргумент будет отвечать за степень числа. Как и в предыдущем методе, необходимо использовать дробь, для того, чтобы получить корень числа.

x = pow(4, 0.5)
print(x)

2.0

Какой метод быстрее?

Для того, чтобы определить какой же метод предпочтительнее использовать, напишем программу. Замерять время выполнения будем с помощью метода monotonic библиотеки time.

from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
    x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")

sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds

Как видно, самое быстрое решение — использовать **. На втором месте метод sqrt, а pow — самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.

Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.

Квадратный корень

Для извлечения квадратного корня самым наглядным способом, правда не самым быстрым, будет использование sqrt из модуля math.

from math import sqrt
x = sqrt (value)

Но можно использовать и трюки с возведением в степень 1/2, что тоже будет приводить к нужному результату.

x = value ** (0.5) или x = pow(value, 0.5).

Кубический корень

Для извлечения кубического корня в Python 3 метод sqrt не подойдет, поэтому воспользуйтесь возведением в степень 1/3:

x = value ** (1./3) или x=pow(value, 1/3).

Корень n-степени

Корень n-степени из числа в Python извлекается можно получить двумя способами с помощью возведения в степень 1.0/n:

• С помощью оператора **.
• Используя функцию pow.

Как было проверено выше, оператор ** быстрее. Поэтому его использовать более целесообразно. Приведем пример вычисления кубических корней в Python 3 с помощью этих двух методов:

n = 4.
x = 16.0 ** (1./n)
print(x)
x = pow(16.0, 1./n)
print(x)

2.0
2.0

Корень отрицательного числа

Рассмотрим, как поведут себя функции, если будем брать корень из отрицательного числа.

from math import sqrt
x = sqrt(-4)

File "main.py", line 2, in 
    x = sqrt(-4)
ValueError: math domain error

Как видим, функция sqrt выдаёт исключение.

Теперь посмотрим, что будет при использовании других методов.

x = -4 ** 0.5
print(x)
x = pow(-4, 0.5)
print(x)

-2.0
(1.2246467991473532e-16+2j)

Как видно из результата, оператор ** не выдает исключения и возвращает некорректный результат. Функция pow работает корректно. В результате получаем комплексное число 2j, что является верным.

Вывод

В Python существуют два универсальных способа для извлечения корня из числа. Это возведение в необходимую степень 1/n. Кроме того, можно воспользоваться функцией из математического модуля языка, если необходимо извлечь квадратный корень числа.

Все эти методы имеют свои преимущества и недостатки. Самый наглядный это sqrt, но подходит только для квадратный корней из числа. Остальные методы не такие элегантные, но легко могут извлечь корень нужной степени из числа. Кроме того оператор ** оказался наиболее быстрым при тестировании.

Необходимо также помнить про целочисленное деление, неправильное использование которого может приводить к ошибке в вычислении.

Given a number n, find the cube root of n.
Examples: 

Input:  n = 3
Output: Cubic Root is 1.442250

Input: n = 8
Output: Cubic Root is 2.000000

We can use binary search. First we define error e. Let us say 0.0000001 in our case. The main steps of our algorithm for calculating the cubic root of a number n are: 

• Initialize start = 0 and end = n
• Calculate mid = (start + end)/2
• Check if the absolute value of (n – mid*mid*mid) < e. If this condition holds true then mid is our answer so return mid. 
• If (mid*mid*mid)>n then set end=mid
• If (mid*mid*mid)

Below is the implementation of above idea. 

Cubic root of 3 is 1.44225

Time Complexity: O(logn)
Auxiliary Space: O(1) Please refer complete article on Find cubic root of a number for more details!

Method #2: Using power(**) function

Cubic root of 3 is 1.44225

Method #3 : Using math.pow()

Cubic root of 3 is 1.44225

Method 4: Using the exponentiation operator in the math library

Cubic Root of 3 is 1.44225
Cubic Root of 8 is 2.0

Time complexity: O(log n) where n is the input number. 
Auxiliary space: O(1), as the algorithm only uses a few variables.

Method 5: without using the power function or the exponentiation operator in the math library:

This method uses the iterative method of computing the cubic root of a number. The idea is to start with an initial guess and improve the guess iteratively until the difference between the guess and the actual cubic root is small enough. This method is known as the Babylonian method or Heron’s method.

Cubic root of 3 is 1.44225

Time complexity: O(log(n))
Auxiliary space: O(1) since we are only using a few variables to store the intermediate values.

Method 6: Using reduce():

Algorithm:

1. Initialize x to n.
2. Compute y as (2x + n/x^2) / 3.
3. While the absolute difference between x and y is greater than or equal to 0.000001, set x to y and compute a new value of y using the same formula as step 2.
4. Return the final value of y.

Cubic root of 3 is 1.44225

Time complexity: The while loop iterates until the difference between x and y is less than 0.000001. Therefore, the number of iterations required is proportional to log(1/0.000001), which is constant. Thus, the time complexity is O(1).
Auxiliary Space: The algorithm uses only two variables, x and y, which require constant space. Therefore, the space complexity is also O(1).

Last Updated :
27 Mar, 2023

Like Article

Save Article