How to take a cube root in Go?

I'm writing a cube root function in Google Go using Newton's method. I want to check the results using math/cmplx.Pow(), but for the life of me, I can't figure out how. How do I do this?

Have you tried myCubicRootOfx = Pow(x, 1.0/3) ?

edited: thanks to Jason McCreary comment:<br>
We cannot use 1/3 as the 2nd parameter to Pow as this is a integer division and hence doesn't produce the expected 1/3 value. By using 1.0/3 or 1/3.0 etc. we effectively produce a float with the 0.333333... value.

I wrote the cube root function using Newton's method as part of the Go Tour Exercise 47. Perhaps the two functions below (Cbrt1 and Cbrt) are helpful.

package main

import (
    "fmt"
    "math/cmplx"
)

// Newton's method cube root function that hopes for
//   convergence within 20 iterations
func Cbrt1(x complex128) complex128 {
    var z complex128 = x
    for i:= 0; i < 20; i++ {
    	z = z - ((z*z*z - x) / (3.0*z*z))
    }
    return z
}

// Newton's method cube root function that runs until stable
func Cbrt(x complex128) complex128 {
    var z, z0 complex128 = x, x
    for {
	    z = z - ((z*z*z - x) / (3.0*z*z))
        if cmplx.Abs(z - z0) < 1e-10 {
            break
        }
        z0 = z
    }
    return z
}

func main() {
    fmt.Println(Cbrt(2.0) , "should match" , cmplx.Pow(2, 1.0/3.0))
}

As you're using Newton's method, I suppose you're starting with a positive real number.

So you don't need complex numbers.

You may simply do

package main

import (
    "fmt"
    "math"
)

func main() {
    x := 100.0
    root := math.Pow(x, 1.0/3.0)
    fmt.Println(root)
}

Looks like go has changed more recently than some of the other answers, so I figured I would update - they built cuberoot right into math as Cbrt. It takes, and returns, a float64. A quick reference is at godoc math | grep Cbrt (if you've got godoc installed, which I highly recommend)

import "math"

func main() {
    var x float64 = math.Cbrt(8)
    fmt.Println(x) // prints 2
}

For example,

package main

import (
	"fmt"
	"math/cmplx"
)

func main() {
	var x complex128
	x = -8
	y := cmplx.Pow(x, 1.0/3.0)
	fmt.Println(y)
	x = -27i
	y = cmplx.Pow(x, 1.0/3.0)
	fmt.Println(y)
	x = -8 - 27i
	y = cmplx.Pow(x, 1.0/3.0)
	fmt.Println(y)
	x = complex(-8, -27)
	y = cmplx.Pow(x, 1.0/3.0)
	fmt.Println(y)
}

Output:

(1+1.732050807568877i)
(2.5980762113533156-1.4999999999999996i)
(2.4767967587776756-1.7667767800295509i)
(2.4767967587776756-1.7667767800295509i)

The Go Programming Language Specification

Package cmplx

try something like this

package main

import(
    	"fmt"
        "math/cmplx"
    )


func Cbrt(x complex128) complex128 {
    z := complex128(1)
 
   
    for i:=0;i<100;i++ {  // OR JUST for{ since you will outrun complex128 in worth case
      last_z := z
        
      z = z - ((z*z*z - x)/(3 *z*z))    
      if last_z == z{
        return z
      }
    }
    return z
}

func main() {
    fmt.Println("good enough", Cbrt(9))
    fmt.Println("builtin", cmplx.Pow(9, 1.0/3.0))
}