一元三次方程x^3-2x+1=0，給定誤差0.0001，迭代法求解。有3個實數解，其中一個是1。
有最大迭代次數判斷，以及判斷迭代是否收斂的演算法。

牛頓迭代法

# -*- coding= utf-8 -*-
# 一元三次方程x^3-2x+1=0，給定誤差0.0001，迭代法求解。有3個實數解，其中一個是1。
# 有最大迭代次數判斷，以及判斷迭代是否收斂的演算法。

def f(x):
    # f的方程
    return x**3.0 - 2.0*x + 1.0

def f_first_order(x):
    # f的一階導數
    return 3.0 * x ** 2 -2.0

def get_root(x0, max_iter=50, tol = 1e-7):
    # 將初始值浮點化
    p0 = x0 * 1.0
    for i in range(max_iter):

        # f的一階導數不能為0，最普遍的說法是不能非正定
        p = p0 - f(p0)/ f_first_order(p0)

        # 如果小於精度值則退出迭代
        if abs(p - p0) < tol:  # tol是判斷迭代更新的閾值

            return u'經過%s次的迭代，我們估計的引數值是%s' % (i+1, p)

        p0 = p

    print (u'已達到最大迭代次數， 但是仍然無法收斂')
    
if __name__ == '__main__':
    print (get_root(2))  # 由於牛頓迭代方法是區域性最優解，不同的初始值有不同的結果。初始值分別取2、0、-2
 

梯度下降法

# -*- coding: utf-8 -*-
# 梯度下降法
def f(x):
    # 忽略常數項
    return x**3.0 - 2.0*x + 1.0

def f_first_order(x):
    # f的方程，raw_f的一階導數
    return 3.0 * x ** 2 -2.0

def get_root(x0, max_iter=100000, tol=1e-10, step=0.001):

    # 初始引數浮點化
    p0 = x0 * 1.0

    for i in range(max_iter):

        p = p0 - step * f_first_order(p0)

        # 如果小於精度值則退出迭代
        if abs(f(p0) - f(p)) < tol:
            
            return u'經過%s次的迭代，我們估計的引數值是%s' % (i+1, p)
        
        p0 = p
        
    print (u'已達到最大迭代次數， 但是仍然無法收斂')
    
if __name__ == '__main__':
    print (get_root(2))
 

哈雷迭代法

# -*- coding: utf-8 -*-
# 哈雷迭代法
def f(x):
    # f的方程，raw_f的一階導數
    return x**3.0 - 2.0*x + 1.0

def f_first_order(x):
    # f的一階導數
    return 3.0 * x ** 2 -2.0

def f_second_order(x):
    # f的二階導數
    return 6.0 ** x

def get_root(x0, max_iter=50, tol=1e-5, step=1):
    p0 = x0 * 1.0
    for i in range(max_iter):

        # f的一階導數不能為0，最普遍的說法是不能非正定

        discr = f_first_order(p0) ** 2 - 2 * f(p0) * f_second_order(p0)

        if discr < 0:

            p = p0 - step * f(p0)/ f_first_order(p0)

        else:

            if f_first_order(p0) >= 0:

                p = p0 - step * 2 * f(p0) / (f_first_order(p0) + f_first_order(p0) * (discr ** 0.5))

            else:

                 p = p0 - step * 2 * f(p0) / (f_first_order(p0) - f_first_order(p0) * (discr ** 0.5))

        # 如果小於精度值則退出迭代
        if abs(p - p0) < tol:

            return u'經過%s次的迭代，我們估計的引數值是%s' % (i+1, p)

        p0 = p

    print (u'已達到最大迭代次數， 但是仍然無法收斂')

if __name__ == '__main__':
    print (get_root(2))