Is There a Short-Hand for Nth Root of X in Python

Is there a short-hand for nth root of x in Python?

nth root of x is x^(1/n), so you can do 9**(1/2) to find the 2nd root of 9, for example. In general, you can compute the nth root of x as:

x**(1/n)

Note: In Python 2, you had to do 1/float(n) or 1.0/n so that the result would be a float rather than an int. For more details, see Why does Python give the "wrong" answer for square root?

How do I calculate square root in Python?

Option 1: `math.sqrt()`

The math module from the standard library has a sqrt function to calculate the square root of a number. It takes any type that can be converted to float (which includes int) as an argument and returns a float.

>>> import math
>>> math.sqrt(9)
3.0

Option 2: Fractional exponent

The power operator (**) or the built-in pow() function can also be used to calculate a square root. Mathematically speaking, the square root of a equals a to the power of 1/2.

The power operator requires numeric types and matches the conversion rules for binary arithmetic operators, so in this case it will return either a float or a complex number.

>>> 9 ** (1/2)
3.0
>>> 9 ** .5  # Same thing
3.0
>>> 2 ** .5
1.4142135623730951

(Note: in Python 2, 1/2 is truncated to 0, so you have to force floating point arithmetic with 1.0/2 or similar. See Why does Python give the "wrong" answer for square root?)

This method can be generalized to nth root, though fractions that can't be exactly represented as a float (like 1/3 or any denominator that's not a power of 2) may cause some inaccuracy:

>>> 8 ** (1/3)
2.0
>>> 125 ** (1/3)
4.999999999999999

Edge cases

Negative and complex

Exponentiation works with negative numbers and complex numbers, though the results have some slight inaccuracy:

>>> (-25) ** .5  # Should be 5j
(3.061616997868383e-16+5j)
>>> 8j ** .5  # Should be 2+2j
(2.0000000000000004+2j)

Note the parentheses on -25! Otherwise it's parsed as -(25**.5) because exponentiation is more tightly binding than unary negation.

Meanwhile, math is only built for floats, so for x<0, math.sqrt(x) will raise ValueError: math domain error and for complex x, it'll raise TypeError: can't convert complex to float. Instead, you can use cmath.sqrt(x), which is more more accurate than exponentiation (and will likely be faster too):

>>> import cmath
>>> cmath.sqrt(-25)
5j
>>> cmath.sqrt(8j)
(2+2j)

Precision

Both options involve an implicit conversion to float, so floating point precision is a factor. For example:

>>> n = 10**30
>>> x = n**2
>>> root = x**.5
>>> n == root
False
>>> n - root  # how far off are they?
0.0
>>> int(root) - n  # how far off is the float from the int?
19884624838656

Very large numbers might not even fit in a float and you'll get OverflowError: int too large to convert to float. See Python sqrt limit for very large numbers?

Other types

Let's look at Decimal for example:

Exponentiation fails unless the exponent is also Decimal:

>>> decimal.Decimal('9') ** .5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for ** or pow(): 'decimal.Decimal' and 'float'
>>> decimal.Decimal('9') ** decimal.Decimal('.5')
Decimal('3.000000000000000000000000000')

Meanwhile, math and cmath will silently convert their arguments to float and complex respectively, which could mean loss of precision.

decimal also has its own .sqrt(). See also calculating n-th roots using Python 3's decimal module

How to inverse taking the n-th root

You would want to find the xth root of the value. To do that you raise the result to the inverse of the power. So, the answer to your question is:

a = 2 ** x
b = a ** (1/x) # Code to reverse the process done for a.
print(a) # Prints 1024
print(b) # Should print 2

How to compute the nth root of a very big integer

You can make it run slightly faster by avoiding the while loops in favor of setting low to 10 ** (len(str(x)) / n) and high to low * 10. Probably better is to replace the len(str(x)) with the bitwise length and using a bit shift. Based on my tests, I estimate a 5% speedup from the first and a 25% speedup from the second. If the ints are big enough, this might matter (and the speedups may vary). Don't trust my code without testing it carefully. I did some basic testing but may have missed an edge case. Also, these speedups vary with the number chosen.

If the actual data you're using is much bigger than what you posted here, this change may be worthwhile.

from timeit import Timer

def find_invpow(x,n):
    """Finds the integer component of the n'th root of x,
    an integer such that y ** n <= x < (y + 1) ** n.
    """
    high = 1
    while high ** n < x:
        high *= 2
    low = high/2
    while low < high:
        mid = (low + high) // 2
        if low < mid and mid**n < x:
            low = mid
        elif high > mid and mid**n > x:
            high = mid
        else:
            return mid
    return mid + 1

def find_invpowAlt(x,n):
    """Finds the integer component of the n'th root of x,
    an integer such that y ** n <= x < (y + 1) ** n.
    """
    low = 10 ** (len(str(x)) / n)
    high = low * 10

    while low < high:
        mid = (low + high) // 2
        if low < mid and mid**n < x:
            low = mid
        elif high > mid and mid**n > x:
            high = mid
        else:
            return mid
    return mid + 1

x = 237734537465873465
n = 5
tests = 10000

print "Norm", Timer('find_invpow(x,n)', 'from __main__ import find_invpow, x,n').timeit(number=tests)
print "Alt", Timer('find_invpowAlt(x,n)', 'from __main__ import find_invpowAlt, x,n').timeit(number=tests)

Norm 0.626754999161

Alt 0.566340923309

calculating n-th roots using Python 3's decimal module

According to the documentation, there is a function power(x,y) :

With two arguments, compute x**y. If x is negative then y must be
integral. The result will be inexact unless y is integral and the
result is finite and can be expressed exactly in ‘precision’ digits.
The result should always be correctly rounded, using the rounding mode
of the current thread’s context

This implies that power(x, 1.0/n) should give you what you want.

You can also take the nth root with

nthRoot = Decimal(x) ** (Decimal(1.0) / Decimal(n) )

Not sure if you consider either of these "built in" as you have to compute the reciprocal of n explicitly to get the nth root.

Is there short Pandas method chain for assigning grouped nth value?

Here is an updated solution, using Pandas, which is still longer than what you will get with dplyr:

import seaborn as sns
import pandas as pd

iris = sns.load_dataset('iris')

iris['cs'] = (iris
              .sort_values(['species','sepal_length'])
              .groupby('species')['sepal_length']
              .transform('cumsum'))

M = (iris
     .sort_values(['species','cs'])
     .groupby('species')['cs'])

groupby has a nth function that gets you a row per group : https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.core.groupby.GroupBy.nth.html

iris = (iris
        .sort_values(['species','cs'])
        .reset_index(drop=True)
        .merge(M.nth(3), how='left', on='species')
        .rename(columns={'cs_x':'cs',
                         'cs_y':'cs4th'})
        )

iris.head()
    sepal_length    sepal_width     petal_length    petal_width  species         cs     cs4th
0       4.3             3.0             1.1             0.1       setosa        4.3      17.5
1       4.4             2.9             1.4             0.2       setosa        8.7      17.5
2       4.4             3.0             1.3             0.2       setosa       13.1      17.5
3      4.4              3.2             1.3             0.2       setosa       17.5      17.5 
4      4.5              2.3             1.3             0.3       setosa       22.0      17.5

Update: 16/04/2021 ... Below is a better way to achieve the OP's goal:

(iris
.sort_values(['species', 'sepal_length'])
.assign(cs = lambda df: df.groupby('species')
                          .sepal_length
                          .transform('cumsum'), 
        cs4th = lambda df: df.groupby('species')
                             .cs
                             .transform('nth', 3)
        )
.groupby('species')
.head(4)
)

     sepal_length  sepal_width  petal_length  petal_width     species    cs  cs4th
13            4.3          3.0           1.1          0.1      setosa   4.3   17.5
8             4.4          2.9           1.4          0.2      setosa   8.7   17.5
38            4.4          3.0           1.3          0.2      setosa  13.1   17.5
42            4.4          3.2           1.3          0.2      setosa  17.5   17.5
57            4.9          2.4           3.3          1.0  versicolor   4.9   20.0
60            5.0          2.0           3.5          1.0  versicolor   9.9   20.0
93            5.0          2.3           3.3          1.0  versicolor  14.9   20.0
98            5.1          2.5           3.0          1.1  versicolor  20.0   20.0
106           4.9          2.5           4.5          1.7   virginica   4.9   22.0
121           5.6          2.8           4.9          2.0   virginica  10.5   22.0
113           5.7          2.5           5.0          2.0   virginica  16.2   22.0
101           5.8          2.7           5.1          1.9   virginica  22.0   22.0

Why does Python give the wrong answer for square root? What is integer division in Python 2?

In Python 2, sqrt=x**(1/2) does integer division. 1/2 == 0.

So x^(1/2) equals x⁽⁰⁾, which is 1.

It's not wrong, it's the right answer to a different question.

If you want to calculate the square root without an import of the math module, you'll need to use x**(1.0/2) or x**(1/2.). One of the integers needs to be a floating number.

Note: this is not the case in Python 3, where 1/2 would be 0.5 and 1//2 would instead be integer division.

Is There a Short-Hand for Nth Root of X in Python