Introduction

**Diagram of cube (in solid black lines.)**
The diagram shows the relationship of width, depth or height to surface area and volume.

A cube is a regular solid in three dimensions with depth, width and height all equal.

In the diagram the figure defined by solid black lines is a cube. Width = depth = height = 2.

The length of one side is 2 units.

The surface area of one side $=\ height*depth$ or $height*width$ or $width*depth=2*2$ or $2^{2}$ square units. There are 4 square units in each side.

The volume of the cube $=\ width*depth*height\ =\ 2*2*2=2^{3}=8$ cubic units.

In this case you can see that 8 cubes of 1 unit each, when properly stacked together, form a cube with length of each side equal to 2 units and volume equal to 8 cubic units.

In mathematical terms $V=s^{3}=2^{3}=8.$

We can say that $V=s$ raised to the power of 3. Usually we say that $V=s$ cubed.

The calculation of cube root is the process reversed. Given $V$ or volume, what is the length of each side?

$s=V^{\frac {1}{3}}$ read as $s=V$ raised to the power ${\frac {1}{3}}.$ Usually we say that $s={\sqrt[{3}]{V}}$ or $s=$ cube root of $V.$

In this case $s={\sqrt[{3}]{8}}=2.$

When $s={\sqrt[{3}]{V}}$ then $s^{3}=({\sqrt[{3}]{V}})^{3}=(V^{1/3})^{3}=V^{\frac {3}{3}}=V^{1}=V.$

If $s$ is negative, then $(-s)^{3}=(-s)*(-s)*(-s)=-(s*s*s)=-V$ and ${\sqrt[{3}]{-V}}=-s.$

In theoretical math the cube root of any real number has 3 values, 1 real and 2 complex.

On this page, we'll refer to the one real value noting that the cube root of a negative real number is also a negative real number.

Calculation

Preparation

It is desired to calculate the cube root of real number $N.$

To simplify the process, and to make the implementation of the process predictable, reformat $N:$

$N=n(10^{3p})$ where:

$1<=n<1000$

$p$ is integer.

Then: ${\sqrt[{3}]{N}}={\sqrt[{3}]{n(10^{3p})}}={\sqrt[{3}]{n}}(10^{p}).$

To simplify the process further, we calculate cube root of abs(n) and restore negative sign to result, if necessary.

# python code.

NormalizeNumberDebug = 0

def NormalizeNumber (number) :
  '''
sign, newNumber, exponent = NormalizeNumber (number)
sign & exponent are both ints.
newNumber is Decimal object.
1000 > newNumber >= 1 and
exponent % 3 = 0.
This prepares number for cube root of number.
eg, 1234.56e-2 becomes 12.3456
    123.456e7 becomes 1.23456e9
'''

  number = D(str(number))+0
  if number == 0 : return (0, D(0), 0)

  sign, digits, exponent = tuple(number.as_tuple())

  digits = list(digits)

  # Remove leading zeroes.
  while (digits[0] == 0) : digits[:1] = []

  # Remove trailing zeroes.
  while (digits[-1] == 0) :
    digits[-1:] = [] ; exponent += 1

  # Ensure that there are at least 3 digits.
  while ( len(digits) < 3 ) :
    digits += [0];  exponent -= 1

  # Ensure that exponent is exactly divisible by 3.
  while exponent % 3 :
    digits += [0] ; exponent -= 1

  # Insert the decimal point so that there are exactly 1 or 2 or 3
  # digits to left of decimal point.
  len1 = len(digits) % 3
  if len1 == 0 : len1 = 3
  len2 = len(digits) - len1

  digits[len1:len1] = '.' ; exponent += len2

  # Produce number reformatted.
  str1 = ''.join( [ str(v) for v in digits ] )
  newNumber = D(str1)

  # If necessary, check.
  if NormalizeNumberDebug :
      v1 = D( ('', '-')[sign] + str1 + 'e' + str(exponent) )
      if v1 != number :
          print ('NormalizeNumber (number) : error', v1 , '!=', number)

  return sign, newNumber, exponent

Implementation

$x={\sqrt[{3}]{n}}$

$x^{3}=n$

$x^{3}-n=0$

To calculate ${\sqrt[{3}]{n}}$ calculate the real root of:

$y=f(x)=x^{3}-n.$

$f(x)$ is well defined in the region $1\leq n<1000.$

Newton's method is used to derive the root starting with $x=5.$

# python code.
simpleCubeRootDebug = 0

def simpleCubeRoot (N) :
    if simpleCubeRootDebug :
        print ('simpleCubeRoot (N): N =',N)
    if N == 0 : return D(0)
    if abs(N) == 1 : return D(str(N))

    sign1, n, exponent = NormalizeNumber (N)

    if 1 <= n < 1000 : pass
    else :
        print ('simpleCubeRoot (N) : internal error 1.')
        return None

    x = 5         # Starting value of x.
    y = x*x*x - n # Starting value of y.
    count = 33 ; L1 = []

    while count :
        count -= 1
        if simpleCubeRootDebug :
            print ('simpleCubeRoot (N) : x,y =',x,y)
        slope = 3*x*x
        delta_x = y/slope
        x -= delta_x
        if x in L1[-1:-5:-1] :
            # This value of x has been used previously.
            break
        L1 += [x]
        y = x*x*x - n

    if count == 0 :
        print ('simpleCubeRoot (N): count expired.')

    multiplier1 = (1,-1)[bool(sign1)]
    exponent1, remainder = divmod (exponent, 3)
    if remainder :
        print ('simpleCubeRoot (N): internal error 2.')
        return None

    multiplier2 = 10**D(exponent1)
    root3 = (multiplier1 * x * multiplier2).normalize() # The cube root.
    if simpleCubeRootDebug :
        print ('simpleCubeRoot (N): root3 =',root3)
    return root3

Examples

(-27)^(⅓)

**Graph of cubic function used to calculate cube root of -27.**
$Y$ axis compressed for clarity.
Newton's method quickly finds result: $3={\sqrt[{3}]{\|-27\|}}.$

# python code.

import decimal
D = decimal.Decimal

simpleCubeRootDebug = 1

N = -27
v = simpleCubeRoot (N)
print ('cube root of',N,'=',v)

simpleCubeRoot (N): N = -27
simpleCubeRoot (N) : x,y = 5 98.000
simpleCubeRoot (N) : x,y = 3.693333333333333333333333333 23.37969303703703703703703703
simpleCubeRoot (N) : x,y = 3.122011871507368646651056170 3.43011897993565925386902153
simpleCubeRoot (N) : x,y = 3.004706248711930856949932920 0.12726815845223303319846682
simpleCubeRoot (N) : x,y = 3.000007367513256026917293862 0.00019892334643539087699845
simpleCubeRoot (N) : x,y = 3.000000000018093357946763316 4.8852066456555586E-10
simpleCubeRoot (N) : x,y = 3.000000000000000000000109123 2.94632E-21
simpleCubeRoot (N) : x,y = 3.000000000000000000000000000 0E-26
simpleCubeRoot (N): root3 = -3

cube root of -27 = -3

N small

# python code.

import decimal
D = decimal.Decimal

simpleCubeRootDebug = 1

N = (D('654.12345')**3)* D('1e-234')
v = simpleCubeRoot (N)
print ('cube root of',N,'=',v)

simpleCubeRoot (N): N = 2.79884698523170070963625E-226
simpleCubeRoot (N) : x,y = 5 -154.884698523170070963625
simpleCubeRoot (N) : x,y = 7.065129313642267612848333333 72.7786652269624099669721028
simpleCubeRoot (N) : x,y = 6.579122227796059655581363000 4.8916155561565606595741185
simpleCubeRoot (N) : x,y = 6.541452268317643764895392436 0.0279543788313674002066771
simpleCubeRoot (N) : x,y = 6.541234507249539089853395935 9.305743731604330476E-7
simpleCubeRoot (N) : x,y = 6.541234500000000008034541024 1.0313397688E-15
simpleCubeRoot (N) : x,y = 6.541234500000000000000000000 0E-25
simpleCubeRoot (N): root3 = 6.5412345E-76

cube root of 2.79884698523170070963625E-226 = 6.5412345E-76

N with 102 decimal digits

# python code.

import decimal
D = decimal.Decimal

prec = decimal.getcontext().prec = 110.   # Precision.

simpleCubeRootDebug = 0

N = D('91234567890.12345678901234567890123')**3

v = simpleCubeRoot (N)
print ('cube root of',N,'=',v)

cube root of 759413404032709802223035921205529.781633123988862756497856617560063741408069807576943069432557725290867 = 91234567890.12345678901234567890123

Result is achieved with 10 passes through loop.

In python this method is more than 3 times faster than raising a number to the power ${\frac {1}{3}}.$ As size of $N$ increases, speed advantage increases.

This method produced the cube root exactly.

Links to related topics

Cubic formula

Square Roots using Newton’s Method

Shifting nth root algorithm

Powers, roots, and exponents

Roots

Exercises