python 黄金分割

转载

mob64ca13fb6939 2024-10-29 17:14:58

文章标签 python 黄金分割 python java 最优解迭代 文章分类 Python 后端开发

文章目录

切线法原理
代码实现

Python代码
Java代码

求解实例

切线法原理

在上一篇文章中，我们使用黄金分割法求解了一维最优化问题。

本文介绍另一种求解该问题的算法：切线法。

该方法的逻辑是：首先在 $python 黄金分割_python 黄金分割$ 内随机选择一点 $python 黄金分割_java_02$ ，沿着该点做一条切线，切线和 $python 黄金分割_迭代_03$ 轴的交点被选择为下一个点 $python 黄金分割_迭代_04$ ，如此反复直至 $python 黄金分割_java_05$ 小于给定阈值，即得到最优解。

python 黄金分割_最优解_06

接下来，我们看一下该方法的数学原理。
针对点 $python 黄金分割_java_02$ ，切线方程为
$python 黄金分割_迭代_08$
令 $python 黄金分割_迭代_09$ ，得到对应的 $python 黄金分割_迭代_04$ 为
$python 黄金分割_迭代_11$

随着 $python 黄金分割_迭代_12$ 的增大， $python 黄金分割_最优解_13$ 如果能趋向于0， $python 黄金分割_java_05$ 就能小于任意给定阈值，最终得到最优解。
当然，如果待优化函数一阶或者二阶不可导，那么切线法就无法使用了。

代码实现

Python代码

以下的tangent_method函数为切线法的Python代码。
除待优化函数 $python 黄金分割_python_15$ 外，代码中还定义了对应的一阶导数 $python 黄金分割_最优解_16$ 和二阶导数 $python 黄金分割_java_17$ 。

# 待优化函数
def f(t):
    return t ** 2 - t * 5 + 8


# 待优化函数一阶导数
def d_f(t):
    return 2 * t - 5


# 待优化函数二阶导数
def d_2_f(t):
    return 2


# 切线法
def tangent_method(x, eps):

    cnt = 0
    while abs(-d_f(x) / d_2_f(x)) > eps:
        # 更新x，并增加迭代次数
        x += -d_f(x) / d_2_f(x)
        cnt += 1

    return x, f(x), cnt


if __name__ == '__main__':
    # 参数设置
    left_point = 1
    right_point = 7
    min_interval_value = 0.1

    # 选取初始点
    x0 = 6
    # 调用切线法求解最小值
    best_x, best_y, iter_cnt = tangent_method(x0, min_interval_value)
    # 输出最优解
    print('best_x: {}, best_y: {}, iter_cnt: {}.'.format(best_x, best_y, iter_cnt))

Java代码

以下的tangentMethod函数为切线法的Java代码。

public class TangentMethod {

    public static void main(String[] args) {
        // 参数设置
        int leftPoint = 1;
        int rightPoint = 7;
        double minIntervalValue = 0.1;

        double x0 = 6.0;
        Solution best_solution = tangentMethod(x0, minIntervalValue);
        System.out.println("best_x: " + best_solution.best_x);
        System.out.println("best_y: " + best_solution.best_y);
        System.out.println("cnt: " + best_solution.cnt);
    }

    // 切线法
    private static Solution tangentMethod(double x, double eps) {
        // 统计迭代次数
        int cnt = 0;

        while (Math.abs(df(x) / d2f(x)) > eps) {
            // 更新x，并增加迭代次数
            x -= df(x) / d2f(x);
            cnt ++;
        }

        // 构造最优解对象
        Solution best_solution = new Solution();
        best_solution.best_x = x;
        best_solution.best_y = f(x);
        best_solution.cnt = cnt;

        return best_solution;
    }

    // 待优化函数
    private static double f(double t) {
        return t * t - t * 5 + 8;
    }

    // 待优化函数一阶导数
    private static double df(double t) {
        return t * 2 - 5;
    }

    // 待优化函数二阶导数
    private static double d2f(double t) {
        return 2;
    }

    // 解对象
    private static class Solution {
        double best_x;
        double best_y;
        int cnt;
    }
}