最近写作业，遇到计算量很大的一道数学题，感觉还是喜欢go的所以第一个想到的是用go实现一下，省的手算了。

题目大概是 用bisection的方法find root of f(x)=x^(1/3)+3，需要几步？ 把题目说清楚还有一个目的是，代码里有一句是注释掉的，root那句，需要注意，现在是要推算x^{(1/3)的，所以得假设你现在是得不到x}(1/3)的。
代码如下：
目前代码有个问题，答案是14，通过一个公式得到，但运行代码得到的是15，目前想到的原因是，第一个error是直接就在的，不该count的，但是是强行解释，所以也可能是其他原因，先放这儿，有大牛欢迎来讲讲。
还有一点是代码里也包含了一点regula-Falsi方法的实现，因为并不需要得到迭代次数，所以就只是在main里做了一点计算
（另外，代码调试是在goplayground中进行的，非常方便）

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println("Hello, playground")
    times := biSection(-2.0, -1.0)
    fmt.Println(times)

    rfP0 := regulaFalsi(-2.0, -1.0)
    fmt.Println("rfP0", rfP0,f(rfP0))
    rfP1 := regulaFalsi(-2.0,rfP0)
    fmt.Println("rfP1", rfP1,f(rfP1))
    rfP2 := regulaFalsi(-2.0,rfP1)
    fmt.Println("rfP2", rfP2,f(rfP2))
    Q0:=rfP2-(((rfP2-rfP1)*(rfP2-rfP1))/(rfP2-2*rfP1+rfP0))
    fmt.Println("Q0", Q0)
    
    rfP3 := regulaFalsi(-2.0,rfP2)
    fmt.Println("rfP3", rfP3,f(rfP3))
    Q1:=rfP3-(((rfP3-rfP2)*(rfP3-rfP2))/(rfP3-2*rfP2+rfP1))
    fmt.Println("Q1", Q1)

}

func regulaFalsi(u, v float64) float64 {
    var result float64 = ((u)*f(v) - (v)*f(u)) / (f(v) - f(u))
    return result
}

func biSection(i, j float64) int {
    var err float64 = 1.0
    count := 0
    var root float64 = math.Cbrt(-3)
    fmt.Println("rooot", root)
    for err >= 0.00005 {
        //if f(i)*f(j) < 0 {
        //err = math.Abs((midP(i, j) - root)) / math.Abs(root)
        err = math.Abs(j-i)/2
        fmt.Println("err", err)
        count++
        var p float64 = midP(i, j)
        if f(p) == 0 {
            return count
        }
        if f(p)*f(i) < 0 {
            j = p
        }
        if f(p)*f(j) < 0 {
            i = p
        }
        //}
    }
    return count
}

func midP(i, j float64) float64 {
    var midP float64 = (j-i)/2 + i
    return midP
}

func f(x float64) float64 {
    var y float64 = x*x*x + 3
    return y
}