如何将C代码的二分法、牛顿迭代结果导入Matlab可视化对比

你不需要用Simulink，直接用Matlab脚本就能完成两种方法的结果对比。下面是完整的实现步骤和代码：

1. 定义目标函数与导数 #

先把你C代码里的F0（目标函数）和F1（导数）转换成Matlab匿名函数，参数和C里保持一致：

% 目标函数 F(V)
F0 = @(V) 1 - V - 100*1e-15*(exp(0.68*V/0.025) - 1);
% 导数 F'(V)
F1 = @(V) -1 - (0.68*100*1e-15/0.025)*exp(0.68*V/0.025);

2. 实现二分法（Dichotomie） #

写一个Matlab函数，返回每一步的迭代值和最终收敛的根：

function [root, iter_values] = dichotomie(F, a, b, err, maxmitr)
    iter_values = [];
    itr = 0;
    % 初始中点
    V = (a + b)/2;
    itr = itr + 1;
    iter_values = [iter_values, V];
    
    while itr < maxmitr
        if F(a)*F(V) < 0
            b = V;
        else
            a = V;
        end
        V_new = (a + b)/2;
        itr = itr + 1;
        iter_values = [iter_values, V_new];
        
        % 判断收敛
        if abs(V_new - V) < 2*err
            root = V_new;
            fprintf('二分法：经过%d次迭代，根为%.6f\n', itr, root);
            return;
        end
        V = V_new;
    end
    fprintf('二分法：未收敛或迭代次数不足\n');
    root = NaN;
end

3. 实现牛顿迭代法（Newton-Raphson） #

同样写一个Matlab函数，返回每一步的迭代值和最终根：

function [root, iter_values] = newton_raphson(F, F_prime, V0, err, maxmitr)
    iter_values = [];
    V = V0;
    iter_values = [iter_values, V];
    
    for itr = 1:maxmitr
        h = F(V)/F_prime(V);
        V_new = V - h;
        iter_values = [iter_values, V_new];
        
        fprintf('牛顿法：第%d次迭代，V=%.6f\n', itr, V_new);
        
        if abs(h) < 2*err
            root = V_new;
            fprintf('牛顿法：经过%d次迭代，根为%.6f\n', itr, root);
            return;
        end
        V = V_new;
    end
    fprintf('牛顿法：未收敛或迭代次数不足\n');
    root = NaN;
end

4. 运行两种方法并绘制对比图 #

在主脚本里调用上面的函数，获取迭代数据，然后画图对比收敛过程：

% 参数设置（和你的C代码一致）
err = 1e-6;
maxmitr = 100;
a = 0;
b = 1;
V0_newton = 0.025; % 牛顿法初始值，对应C代码里的V0

% 运行二分法
[root_dicho, iter_dicho] = dichotomie(F0, a, b, err, maxmitr);
% 运行牛顿法
[root_newton, iter_newton] = newton_raphson(F0, F1, V0_newton, err, maxmitr);

% 绘制迭代次数 vs 迭代值的对比图
figure('Name','二分法vs牛顿迭代法收敛对比');
hold on; grid on;
% 二分法的迭代点
plot(1:length(iter_dicho), iter_dicho, 'b-o', 'LineWidth',1.2, 'MarkerSize',6);
% 牛顿法的迭代点
plot(1:length(iter_newton), iter_newton, 'r-s', 'LineWidth',1.2, 'MarkerSize',6);
xlabel('迭代次数');
ylabel('迭代值V');
legend('二分法','牛顿迭代法','Location','southeast');
title('两种方法的收敛过程对比');
hold off;

% 可选：绘制误差变化图（迭代次数 vs 与最终根的误差）
figure('Name','误差变化对比');
hold on; grid on;
err_dicho = abs(iter_dicho - root_dicho);
err_newton = abs(iter_newton - root_newton);
plot(1:length(err_dicho), err_dicho, 'b-o', 'LineWidth',1.2);
plot(1:length(err_newton), err_newton, 'r-s', 'LineWidth',1.2);
xlabel('迭代次数');
ylabel('|当前值 - 最终根|');
legend('二分法','牛顿迭代法','Location','northeast');
title('误差收敛速度对比');
set(gca,'YScale','log'); % 用对数坐标更清晰
hold off;

使用说明 #

1. 把上面的代码分别保存为dichotomie.m、newton_raphson.m，再写一个主脚本（比如compare_methods.m）放入主脚本代码。
2. 运行主脚本，就能看到两种方法的迭代输出，以及两张对比图：一张是迭代值随次数的变化，另一张是误差的收敛速度（对数坐标更直观）。

通过图表你能清晰看到：牛顿法通常收敛更快，而二分法收敛稳定但速度较慢。

内容的提问来源于stack exchange，提问作者Anis Hacini