MATLAB:把函数当参数传：fzero(@myfun,x0)、integral(f,0,1) 的通用套路

1. 为什么求解器都爱收函数句柄：接口契约的由来

打开 MATLAB 帮助文档，你会发现一个耐人寻味的现象：fzero、integral、ode45、fsolve、fminbnd、quadgk 这些函数，尽管解决的数学问题千差万别——求根、积分、解微分方程、非线性方程组、极值优化——它们的第一个参数却高度一致：一个函数句柄。这不是巧合，而是 MathWorks 在 R14 前后逐步确立的一套接口设计哲学。

要理解这套哲学，得先回到一个更朴素的问题：如果不用函数句柄，我们怎么把"一个函数"交给另一个函数？在 MATLAB 早期版本里，答案是把函数名写成字符串，比如 fzero('myfun', x0)。这种写法今天仍能运行，但已被官方标记为不推荐（legacy）。字符串的问题在于：它只是"名字"，求解器拿到名字后还得回头去查这个函数在不在路径上、有几个输入输出、是不是被同名文件遮蔽。这层间接性既慢又脆弱。

函数句柄则不同。当你在 MATLAB 里写下 h = @myfun，MATLAB 在那一刻就把函数与它的解析路径"绑定"成了一个对象。这个对象可以被赋值、被复制、被存进 cell 数组、被传进另一个函数，甚至在原函数文件被重命名之后仍能通过已绑定的路径继续工作（直到会话结束）。本文评述：句柄的本质是把"函数"从静态的代码文本提升为运行时可传递的一等公民，这正是求解器接口能够统一的前提。

契约的核心只有一句话：求解器只关心"你给我一个东西，我喂它一个（或一组）数，它吐出一个（或一组）数"。至于这个东西背后是脚本、是匿名表达式、是嵌套函数还是 MEX 编译产物，求解器一概不问。

这种"只问形状、不问出身"的设计，在软件工程里对应的是依赖倒置原则（Dependency Inversion Principle）的一个具体形态：高层模块（求解算法）不依赖低层模块（用户函数）的具体实现，二者都依赖抽象接口（句柄调用约定）。MathWorks 官方文档在 "Function Handles" 一节中明确把句柄描述为"a data type that stores an association to a function"，并强调它支持"passing functions as arguments to other functions"。这一表述与学术界对高阶函数（higher-order function）的定义一脉相承——函数可以作为参数、可以作为返回值。

从计算数学的角度看，这种接口统一还有更深一层的好处。数值算法（如 Brent 法求根、自适应 Gauss-Kronrod 积分、Runge-Kutta 步进）在教科书里都是按"给定 f，执行迭代"来描述的，算法本身与 f 的具体形式无关。MATLAB 把这一抽象直接落到了语言层面，使得同一段算法代码可以服务于任意用户函数。笔者认为，这是 MATLAB 相比许多"把算法写死在脚本里"的工程语言更接近数学表达的地方。

值得补充的是，这一设计并非 MATLAB 独有。Python 的 scipy.optimize.brentq(f, a, b)、Julia 的 Roots.find_zero(f, x0)、C++ 的 std::function 模板参数，走的都是同一条路。差异在于 MATLAB 把句柄做成了语言内建类型，而 C++ 依赖模板与可调用对象、Python 依赖鸭子类型。理解这一点，有助于我们在跨语言迁移时快速抓住共性。

2. @ 语法全解：命名句柄、匿名句柄与字符串的边界

2.1 命名函数句柄：@ 加函数名

最基本的形式是 @functionName。它把已存在的函数（无论是内置函数、工具箱函数还是你自己写的 M 文件函数）包装成句柄。例如：

h = @sin;          % 内置函数
y = h(pi/2);       % 等价于 sin(pi/2)，返回 1
g = @myLocalFun;   % 用户自定义函数
class(h)           % 返回 'function_handle'

这里有个容易被忽略的细节：@sin 与直接写 sin 在语义上不同。后者在表达式里会被立即求值（如果带参数），而前者是一个"待调用"的对象。你可以用 functions(h) 查看句柄内部信息，它会返回一个结构体，包含 function（函数名）、type（'simple'、'scoped'、'anonymous' 等）、file（所在文件路径）等字段。这是调试句柄问题的第一把钥匙。

2.2 匿名函数句柄：@(x) 表达式

第二种形式是 @(arglist) expression，即匿名函数。它不需要单独写一个 M 文件，直接在表达式里就地定义：

f = @(x) x.^2 - 4;
fzero(f, 1)        % 求 x^2-4=0 在 1 附近的正根，得 2

g = @(x,y) x.^2 + y.^2;   % 多输入
integral(@(x) exp(-x.^2), 0, Inf)   % 高斯积分，得 sqrt(pi)/2

匿名函数的强大之处在于它可以"就地捕获"当前工作区的变量，形成闭包。但这也正是陷阱所在，下一节详述。本文评述：匿名函数让"临时定义一个小函数"变得像写一行算式一样自然，这是 MATLAB 相比需要显式 def 或 function 关键字的语言在交互式数值计算上的显著优势。

2.3 字符串形式：为什么还在，为什么不推荐

字符串形式 fzero('myfun', x0) 至今仍能运行，是因为 MATLAB 保留了向后兼容。但它有几个硬伤：一是无法表达匿名函数（你没法把 @(x) x.^2-4 写成字符串而不借助 eval）；二是每次调用都要做名称解析，性能略差；三是在并行、GPU、代码生成等场景下支持不完整。MathWorks 在多个函数的文档中已明确建议改用句柄。

形式	示例	能否捕获变量	推荐度
命名句柄	@myfun	否	推荐
匿名句柄	@(x) x.^2-4	是	推荐
字符串	'myfun'	否	不推荐
内联对象	inline('x^2-4')	否	已废弃

3. 匿名函数与闭包：捕获变量的时间冻结陷阱

匿名函数捕获外部变量时，捕获的是"定义那一刻的值"，而不是"调用那一刻的值"。这个规则听起来简单，但在循环里构造一组句柄时，几乎每个 MATLAB 用户都踩过坑。经典案例如下：

% 错误示范：所有句柄都捕获了循环结束后的 a
fns = cell(1,3);
for a = 1:3
    fns{a} = @(x) x + a;
end
fns{1}(0)   % 期望 1，实际返回 4（a 已变成 3）
fns{2}(0)   % 期望 2，实际返回 4
fns{3}(0)   % 期望 3，实际返回 4

原因是 MATLAB 的匿名函数按"引用"捕获变量，循环变量 a 在循环结束后停留在终值 3，三个句柄共享同一个 a。正确做法是在循环体内引入一个临时变量做"值快照"：

% 正确示范：用临时变量冻结当前值
fns = cell(1,3);
for a = 1:3
    a_fixed = a;              % 关键：每次迭代新建变量
    fns{a} = @(x) x + a_fixed;
end
fns{1}(0)   % 返回 1
fns{2}(0)   % 返回 2
fns{3}(0)   % 返回 3

本文评述：这个陷阱的根源在于 MATLAB 的闭包语义与 JavaScript 的 var 声明、Python 的 late-binding closure 高度相似，都是"捕获变量而非值"。理解这一点后，跨语言迁移时就能举一反三。值得注意的是，Python 里常用 lambda x, a=a: x+a 的默认参数技巧来冻结值，MATLAB 没有默认参数机制，只能用临时变量或嵌套函数。

3.1 嵌套函数 vs 匿名函数：作用域差异

嵌套函数（nested function）与匿名函数在捕获行为上有关键差异。嵌套函数共享父函数的工作区，父函数变量变化时嵌套函数能看到最新值；而匿名函数在定义时就固定了捕获关系。下面的例子展示了嵌套函数的"实时可见"特性：

function f = makeAdder()
    n = 0;
    f = @addOne;          % 返回嵌套函数句柄
    function y = addOne(x)
        n = n + 1;        % 修改父工作区的 n
        y = x + n;
    end
end

g = makeAdder();
g(10)   % 返回 11（n 从 0 变 1）
g(10)   % 返回 12（n 从 1 变 2）

这种"带状态"的句柄在需要计数器、缓存、迭代器时非常有用。MathWorks 文档在 "Nested Functions" 一节中专门讨论了这种共享工作区的机制。笔者认为，这是 MATLAB 在函数式与命令式之间取得的一个实用平衡：既保留了闭包的表达力，又允许副作用。

4. fzero 实战：从单变量求根到参数化扫描

4.1 fzero 的算法基础

fzero 求解的是单变量标量函数的零点，即找 x 使 f(x)=0。它默认使用 Brent 法——一种结合了二分法、割线法和逆二次插值的混合算法。Brent 法要求初始区间两端函数值异号（即存在符号变化），因此 fzero(f, x0) 中的 x0 若为标量，MATLAB 会先自动扩张出一个包含符号变化的区间；若 x0 为二元向量 [a b]，则直接在该区间内搜索。

Brent 法的收敛性在数值分析经典教材中有严格证明（可参考 R. P. Brent 1973 年著作《Algorithms for Minimization without Derivatives》）。MATLAB 的实现细节未完全公开，但从行为上看，它遵循了标准的 Brent 流程。本文评述：理解底层算法不是为了重写它，而是为了知道什么时候它会失败——比如函数在该区间内不连续、有多个零点、或函数值始终同号时，fzero 会报错或返回非预期结果。

4.2 基础用法与常见报错

% 基础：求 cos(x) = x 的根
f = @(x) cos(x) - x;
x_root = fzero(f, 0.5);        % 约 0.739085

% 指定区间
x_root2 = fzero(f, [0 1]);     % 同样结果

% 带选项：显示迭代过程
opts = optimset('Display','iter');
x_root3 = fzero(f, 0.5, opts);

% 常见报错：区间端点同号
try
    fzero(f, [2 3]);           % cos(2)-2 与 cos(3)-3 同号
catch ME
    disp(ME.message);          % 提示函数值必须异号
end

4.3 参数化扫描：把参数"喂"进句柄

工程中更常见的是"带参数的方程"，比如求 x^2 - k = 0 中随 k 变化的根。这时需要把 k 传进句柄。最直接的方式是匿名函数包装：

k_list = 1:5;
roots_k = zeros(size(k_list));
for i = 1:numel(k_list)
    k = k_list(i);
    f = @(x) x.^2 - k;         % 捕获当前 k
    roots_k(i) = fzero(f, 1);
end
disp(roots_k)   % 1.0000 1.4142 1.7321 2.0000 2.2361

注意这里同样要注意闭包捕获问题：如果把 f = @(x) x.^2 - k 写在循环外，所有迭代都会用同一个 k。写成循环内定义是安全的，因为每次迭代都新建了句柄。

4.4 多根问题的处理策略

fzero 一次只返回一个根，且返回哪个根取决于初值。对于多根函数，工程上常用"扫描 + 去重"策略：在区间上密集采样，找出符号变化点，再对每个变化点调用 fzero。下面是一个可复用的工具函数：

function roots = find_all_roots(f, a, b, N)
% FIND_ALL_ROOTS 在 [a,b] 上扫描并求所有单根
% f: 函数句柄; N: 扫描点数
    xs = linspace(a, b, N);
    ys = f(xs);
    roots = [];
    for i = 1:N-1
        if sign(ys(i)) ~= sign(ys(i+1))
            r = fzero(f, [xs(i) xs(i+1)]);
            if isempty(roots) || all(abs(roots - r) > 1e-8)
                roots(end+1) = r; %#ok<AGROW>
            end
        end
    end
end

这个函数体现了"句柄契约"的复用价值：find_all_roots 本身接收一个句柄，内部再把它交给 fzero，形成句柄的"二次传递"。这种模式在工具箱开发中非常常见。笔者认为，能否自然地写出这种"接收句柄、传递句柄"的代码，是区分 MATLAB 中级与高级使用者的一个实用标志。

5. integral 实战：向量化要求与 ArrayValued 开关

5.1 integral 的自适应算法

integral 是 R2012a 引入的现代积分函数，取代了旧的 quad 和 quadl。它默认采用全局自适应求积（global adaptive quadrature），底层基于 Gauss-Kronrod 求积规则，并支持无限区间、端点奇异性处理。MathWorks 文档指出，integral 在大多数情况下比 quad 更快、更稳健，且支持复数被积函数。

Gauss-Kronrod 规则的核心思想是：在区间内选取一组节点，同时用低阶和高阶两组权重计算积分，两者之差作为误差估计。若误差超过容差，则细分区间递归处理。这套机制要求被积函数在被调用时能"一次接收一组点、返回一组值"，这就是向量化要求的来源。

5.2 向量化：integral 的硬性要求

% 正确：使用点运算，支持向量输入
f = @(x) exp(-x.^2);
I = integral(f, 0, 1);        % 约 0.7468

% 错误：使用矩阵运算，标量输入才成立
g = @(x) exp(-x^2);
% integral(g, 0, 1) 会报错：矩阵维度不一致

这是初学者最常见的坑。integral 会一次性把多个节点打包成向量传给 f，如果 f 内部用的是 ^ 而不是 .^，就会触发矩阵乘法语义，维度对不上直接报错。本文评述：向量化要求本质上是把"逐点求值"的循环从求解器内部转移到了用户函数内部，用内存换速度。这与 NumPy 的 ufunc 思想一致。

5.3 ArrayValued 开关：当函数无法向量化时

有些函数天生无法向量化，比如内部含 if-else 分支、调用外部求解器、或返回非标量。这时可以用 'ArrayValued', true 选项，让 integral 逐点调用：

% 无法向量化的函数：含分支
h = @(x) (x > 0.5) * 1 + (x <= 0.5) * 0;   % 阶跃，可向量化
% 但下面这种就难向量化：
k = @(x) arrayfun(@(t) myScalarFun(t), x);

% 用 ArrayValued 逐点求值
I2 = integral(k, 0, 1, 'ArrayValued', true);

ArrayValued 会显著降低性能，因为它放弃了批量求值的优势。工程上的建议是：优先改写为向量化形式，实在不行再用 ArrayValued。MathWorks 文档也明确提示该选项会"slow down the integration"。

选项	作用	典型场景
ArrayValued	逐点求值	函数含分支、返回非标量
AbsTol	绝对误差容限	被积函数量级很小
RelTol	相对误差容限	默认 1e-6
Waypoints	指定积分路径点	处理内部奇点
Method	选择算法	'auto'/'tiled'

5.4 二重三重积分：integral2 / integral3

% 二重积分：f(x,y) = x.*y 在 [0,1]x[0,1]
f2 = @(x,y) x.*y;
I2 = integral2(f2, 0, 1, 0, 1);   % 0.25

% 三重积分
f3 = @(x,y,z) x.*y.*z;
I3 = integral3(f3, 0, 1, 0, 1, 0, 1);  % 0.125

% 非矩形区域：内层上下限是外层变量的函数
I4 = integral2(@(x,y) x+y, 0, 1, @(x) 0, @(x) x);

注意 integral2 和 integral3 对向量化的要求更高：被积函数需要支持网格化输入（integral2 默认传矩阵，integral3 传三维数组）。这要求函数内部使用点运算，且能处理矩阵输入。MathWorks 文档建议用 'ArrayValued' 或 'Method','iterated' 来简化。

6. 参数化传参四种套路：匿名包装、嵌套、结构体与 varargin

求解器只接受"单输入单输出"或"多输入多输出"的标准签名，但工程函数往往需要额外参数（材料常数、几何尺寸、控制增益）。如何把这些参数"塞"进句柄，是 MATLAB 工程实践的核心技能。下面系统梳理四种套路。

6.1 套路一：匿名函数包装（最常用）

function y = model(x, p)
    y = p.a * exp(-p.b * x) + p.c;
end

% 包装：把 p 冻结进句柄
p = struct('a',2,'b',0.5,'c',1);
f = @(x) model(x, p);
x_root = fzero(f, 0);

这是最直观的方式，适合参数少、调用次数不多的场景。缺点是每次包装都新建一个句柄，若在循环里大量创建会有轻微开销。

6.2 套路二：嵌套函数共享工作区

function x_root = solve_with_params(p, x0)
    x_root = fzero(@residual, x0);
    function r = residual(x)
        r = p.a * exp(-p.b * x) + p.c;   % 直接访问 p
    end
end

嵌套函数的好处是参数"天然可见"，不需要显式包装。而且如果求解过程中需要更新参数（比如迭代重加权），嵌套函数能实时看到变化。本文评述：嵌套函数适合"参数在求解过程中可能变化"的场景，匿名包装适合"参数固定"的场景，二者不是替代关系而是互补。

6.3 套路三：结构体 + 匿名函数

% 把参数打包成结构体，便于批量传递
params = struct('a',2,'b',0.5,'c',1,'tol',1e-8);
f = @(x) params.a * exp(-params.b * x) + params.c;
opts = optimset('TolX', params.tol);
x_root = fzero(f, 0, opts);

结构体的优势是参数组织清晰，便于在多个函数间共享，也便于保存到 .mat 文件。缺点是访问字段比访问局部变量略慢（约 10-20% 开销，视版本而定），在极端性能敏感场景需注意。

6.4 套路四：varargin 可变参数

function y = model_var(x, varargin)
    p = parse_params(varargin{:});
    y = p.a * exp(-p.b * x) + p.c;
end

% 调用时直接传参
f = @(x) model_var(x, 'a', 2, 'b', 0.5, 'c', 1);
x_root = fzero(f, 0);

varargin 适合参数数量可变、需要向后兼容的库函数。缺点是类型检查弱、性能略差，且匿名包装时仍需把参数写死。

套路	适用场景	性能	可读性
匿名包装	参数固定、快速原型	高	高
嵌套函数	参数动态变化	高	中
结构体	参数多、需共享	中	高
varargin	参数可变、库函数	中低	中

7. 句柄家族全景：str2func、functions、feval 与性能对比

7.1 str2func：从字符串构造句柄

name = 'sin';
h = str2func(name);
h(0)   % 返回 0

% 批量构造
names = {'sin','cos','tan'};
hs = cellfun(@str2func, names, 'UniformOutput', false);
vals = cellfun(@(f) f(0), hs);   % [0 1 0]

str2func 适合"函数名来自配置文件或用户输入"的场景。但要注意：它不会检查函数是否存在，构造成功但调用时才报错。安全做法是配合 exist(name,'file') 做前置检查。

7.2 functions：句柄内省

h = @(x) x.^2;
info = functions(h);
disp(info)
% 输出包含：
%   function: '@(x) x.^2'
%   type: 'anonymous'
%   file: ''
%   workspace: {2x1 cell}   % 捕获的变量

h2 = @sin;
info2 = functions(h2);
%   function: 'sin'
%   type: 'simple'
%   file: '...\matlab\...\sin.m'

functions 是调试句柄问题的利器。当你不确定一个句柄到底绑定了什么、捕获了哪些变量时，它能给出完整答案。特别是 workspace 字段，能揭示闭包捕获了哪些变量及其值。

7.3 feval：老式调用接口

% feval 可以接受句柄或字符串
y1 = feval(@sin, 0);
y2 = feval('sin', 0);   % 仍可用，但不推荐

% 与直接调用的性能差异
h = @sin;
tic; for i=1:1e6, h(0); end; t1 = toc;
tic; for i=1e6, feval(h, 0); end; t2 = toc;
fprintf('直接调用 %.3f s, feval %.3f s\n', t1, t2);

在现代 MATLAB（R2015b 引入的新执行引擎）中，直接调用句柄与 feval 的性能差异已经很小，但在循环内仍能测出 feval 略慢。工程建议：除非需要兼容旧代码，否则优先用 h(args) 形式。

7.4 性能实测：句柄 vs 字符串 vs 内联

下面是一组在 R2023b、Windows 11、i7-12700H 上运行的模拟基准（模拟数据，仅用于说明相对趋势，不代表绝对性能）：

调用方式	1e6 次调用耗时（模拟）	相对开销
直接调用 sin(0)	0.08 s	1.0x
句柄 h(0)	0.09 s	1.1x
feval(h,0)	0.11 s	1.4x
feval('sin',0)	0.35 s	4.4x

本文评述：句柄的调用开销在现代引擎下已接近直接调用，字符串形式则明显落后。这从性能角度也印证了"用句柄替代字符串"的官方建议。需要说明的是，上述数据为模拟基准，实际数值随硬件、MATLAB 版本、函数复杂度变化，读者应以自己环境实测为准。

8. 从 ode45 到 fsolve：同一契约的横向迁移

理解了 fzero 和 integral 的句柄契约后，你会发现 MATLAB 整个数值求解器家族都在遵循同一套约定。下面横向对比几个常用求解器，展示契约的一致性。

8.1 ode45：微分方程右端函数

% dy/dt = -2y + sin(t)
odefun = @(t,y) -2*y + sin(t);
[t,y] = ode45(odefun, [0 10], 1);

% 带参数：阻尼系数 c
c = 0.5;
odefun2 = @(t,y) -c*y + sin(t);
[t2,y2] = ode45(odefun2, [0 10], 1);

ode45 的句柄签名是 @(t,y)，返回列向量 dy/dt。注意 y 可以是向量（方程组），此时 odefun 必须返回同维列向量。这与 integral 的向量化要求类似，但方向不同：integral 要求"输入向量、输出向量"，ode45 要求"输入向量、输出向量"但语义是状态导数。

8.2 fsolve：非线性方程组

% 求解方程组：
% x^2 + y^2 = 4
% x*y = 1
fun = @(v) [v(1)^2 + v(2)^2 - 4;
            v(1)*v(2) - 1];
x0 = [1.5, 0.5];
sol = fsolve(fun, x0);

fsolve 的句柄接收向量、返回向量，与 fzero 的标量版本形成"向量化升级"。这种"标量→向量"的推广在 MATLAB 中反复出现：fzero→fsolve、fminbnd→fminsearch、quad→integral（支持数组值）。笔者认为，掌握这种"标量版理解原理、向量版处理工程"的对应关系，是高效使用 MATLAB 优化工具箱的关键。

8.3 契约一致性总结

求解器	句柄签名	输入形状	输出形状
fzero	@(x)	标量	标量
integral	@(x)	向量	向量
ode45	@(t,y)	标量+向量	向量
fsolve	@(v)	向量	向量
fminsearch	@(v)	向量	标量

9. 前沿延伸：GPU、自动微分与 Python 互操作中的句柄

9.1 GPU 数组与句柄

自 R2010b 引入 Parallel Computing Toolbox 的 gpuArray 以来，MATLAB 逐步把句柄契约延伸到了 GPU 场景。许多支持 GPU 的函数（如 arrayfun、pagefun）接受句柄作为参数：

if canUseGPU
    G = gpuArray.rand(1000, 1000);
    f = @(x) x.^2 + 2*x + 1;
    R = arrayfun(f, G);   % 在 GPU 上逐元素执行
end

注意 GPU 上的 arrayfun 对句柄有限制：函数必须是"可元素化"的，不能包含动态内存分配、不能调用 CPU-only 函数。MathWorks 文档在 "Run MATLAB Functions on a GPU" 一节中列出了支持列表。本文评述：GPU 场景下句柄契约的"形状要求"变得更严格，因为 GPU 内核需要静态确定的内存布局。理解这一点能避免"CPU 能跑、GPU 报错"的困惑。

9.2 自动微分与 dlarray

深度学习工具箱（Deep Learning Toolbox）引入的 dlarray 和 dlgradient 把自动微分带进了 MATLAB。其核心模式是：定义一个函数句柄，用 dlfeval 在自动微分上下文中执行：

% 定义损失函数句柄
lossFun = @(w) sum((w - target).^2);

% 在自动微分上下文中求梯度
w = dlarray(randn(3,1));
grad = dlfeval(@(w) dlgradient(lossFun(w), w), w);

这里句柄的作用是"延迟执行"：dlfeval 需要在追踪计算图的环境中调用函数，而句柄正好提供了这种延迟。这与 JAX 的 jax.grad(f)、PyTorch 的 torch.autograd.grad(f, x) 在设计哲学上高度一致。笔者认为，自动微分是句柄契约在机器学习时代最重要的新应用场景，它把"函数作为参数"从数值算法扩展到了梯度计算。

9.3 Python 互操作：py.* 与句柄桥接

自 R2014b 起，MATLAB 支持直接调用 Python。反过来，Python 也可以通过 matlab.engine 调用 MATLAB 函数。在互操作场景下，句柄的传递需要特别注意：

% MATLAB 调用 Python 函数
pyFun = py.scipy.optimize.brentq;
% 注意：Python 函数不能直接接收 MATLAB 句柄
% 需要包装为 Python 可调用对象，或改用 MATLAB 原生求解器

% 推荐做法：在 MATLAB 侧用 integral，避免跨语言传句柄
I = integral(@(x) exp(-x.^2), 0, 1);

跨语言句柄传递目前仍是痛点：MATLAB 句柄无法直接作为 Python callable 传入 scipy，反之 Python 函数包装成 MATLAB 句柄也需要 🔒 复制本站文章内容需登录并达到 L3。当前：未登录