link管理

链接快照平台

输入网页链接，自动生成快照
标签化管理网页链接

fmincon

寻找约束非线性多变量函数的最小值

语法


             
              x = fmincon(fun,x0,A,b)


             
              x = fmincon(fun,x0,A,b,Aeq,beq)


             
              x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub)


             
              x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)


             
              x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)


             
              x = fmincon(problem)


             
              [x,fval] = fmincon(
              
               ___
              
              )


             
              [x,fval,exitflag,output] = fmincon(
              
               ___
              
              )


             
              [x,fval,exitflag,output,lambda,grad,hessian] = fmincon(
              
               ___
              
              )

说明

非线性规划求解器。

求以下问题的最小值：

$\min_{x} f (x) such that {\begin{matrix} c (x) \leq 0 \\ c e q (x) = 0 \\ A \cdot x \leq b \\ A e q \cdot x = b e q \\ l b \leq x \leq u b, \end{matrix}$

b 和 beq 是向量，A 和 Aeq 是矩阵，c(x) 和 ceq(x) 是返回向量的函数，f(x) 是返回标量的函数。f(x)、c(x) 和 ceq(x) 可以是非线性函数。

x、lb 和 ub 可以作为向量或矩阵传递；请参阅矩阵参量。

示例

x = fmincon( fun , x0 , A , b ) 从 x0 开始，尝试在满足线性不等式 A*x ≤ b 的情况下寻找 fun 中所述的函数的最小值点 x 。 x0 可以是标量、向量或矩阵。

注意

传递额外参数说明如何将额外的参数传递给目标函数和非线性约束函数（如有必要）。

示例

x = fmincon( fun , x0 , A , b , Aeq , beq ) 在满足线性等式 Aeq*x = beq 以及不等式 A*x ≤ b 的情况下最小化 fun 。如果不存在不等式，则设置 A = [] 和 b = [] 。

示例

x = fmincon( fun , x0 , A , b , Aeq , beq , lb , ub ) 对 x 中的设计变量定义一组下界和上界，使解始终在 lb ≤ x ≤ ub 范围内。如果不存在等式，请设置 Aeq = [] 和 beq = [] 。如果 x(i) 无下界，请设置 lb(i) = -Inf ，如果 x(i) 无上界，请设置 ub(i) = Inf 。

注意

如果为问题指定的输入边界不一致， fmincon 会引发错误。这种情况下，输出 x 为 x0 ， fval 为 [] 。

对于默认的 'interior-point' 算法， fmincon 将违反边界 lb ≤ x ≤ ub 或等于某一边界的 x0 分量重置到边界区域内部。对于 'trust-region-reflective' 算法， fmincon 将违反边界的分量重置到边界区域内部。对于其他算法， fmincon 将违反边界的分量重置为最近边界的值。遵守边界的分量不会更改。请参阅迭代可能违反约束。

示例

x = fmincon( fun , x0 , A , b , Aeq , beq , lb , ub , nonlcon ) 执行最小化时，满足 nonlcon 所定义的非线性不等式 c(x) 或等式 ceq(x) 。 fmincon 进行优化，以满足 c(x) ≤ 0 和 ceq(x) = 0 。如果不存在边界，请设置 lb = [] 和/或 ub = [] 。

示例

x = fmincon( fun , x0 , A , b , Aeq , beq , lb , ub , nonlcon , options ) 使用 options 所指定的优化选项执行最小化。使用 optimoptions 可设置这些选项。如果没有非线性不等式或等式约束，请设置 nonlcon = [] 。

示例

x = fmincon( problem ) 求 problem 的最小值，它是 problem 中所述的一个结构体。

示例

[ x , fval ] = fmincon( ___ ) 对上述任何语法，返回目标函数 fun 在解 x 处的值。

示例

[ x , fval , exitflag , output ] = fmincon( ___ ) 还返回描述 fmincon 的退出条件的值 exitflag ，以及提供优化过程信息的结构体 output 。

示例

[ x , fval , exitflag , output , lambda , grad , hessian ] = fmincon( ___ ) 还返回：

lambda - 结构体，其字段包含解 x 处的拉格朗日乘数。
grad - fun 在解 x 处的梯度。
hessian - fun 在解 x 处的黑塞矩阵。请参阅 fmincon黑塞函数。

示例

全部折叠

线性不等式约束

打开实时脚本

在具有线性不等式约束的情况下求罗森布罗克函数的最小值。

将目标函数 fun 设置为罗森布罗克函数。众所周知，Rosenbrock 函数很难实现最小化。它在点 (1,1) 处的最小目标值为 0。有关详细信息，请参阅使用优化实时编辑器任务或求解器的有约束非线性问题。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

从点 [-1,2] 开始求最小值，约束为 $x (1) + 2 x (2) \leq 1$ 。以 A = [1,2] 和 b = 1 为条件，以 Ax <= b 形式表达此约束。请注意，此约束意味着解不会在无约束解 (1,1) 处，因为在此点处 $x (1) + 2 x (2) = 3 > 1$ 。

x0 = [-1,2];
A = [1,2];
b = 1;
x = fmincon(fun,x0,A,b)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x = 1×2
    0.5022    0.2489

线性不等式和等式约束

打开实时脚本

在既有线性不等式约束又有线性等式约束的情况下求罗森布罗克函数的最小值。

将目标函数 fun 设置为罗森布罗克函数。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

从点 [0.5,0] 开始求最小值，约束为 $x (1) + 2 x (2) \leq 1$ 和 $2 x (1) + x (2) = 1$ 。

以 A = [1,2] 和 b = 1 为条件，以 A*x <= b 形式表达线性不等式约束。
以 Aeq = [2,1] 和 beq = 1 为条件，以 Aeq*x = beq 形式表达线性等式约束。

x0 = [0.5,0];
A = [1,2];
b = 1;
Aeq = [2,1];
beq = 1;
x = fmincon(fun,x0,A,b,Aeq,beq)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x = 1×2
    0.4149    0.1701

具有边界约束的最小化

打开实时脚本

在存在边界约束的情况下，求目标函数的最小值。

目标函数是具有两个变量的简单代数函数。

fun = @(x)1+x(1)/(1+x(2)) - 3*x(1)*x(2) + x(2)*(1+x(1));

关注 $x$ 为正值且满足 $x (1) \leq 1$ 和 $x (2) \leq 2$ 的区域。

lb = [0,0];
ub = [1,2];

该问题没有线性约束，因此将这些参量设置为 [] 。

A = [];
b = [];
Aeq = [];
beq = [];

尝试使用一个位于区域中部的初始点。

x0 = (lb + ub)/2;

求解。

x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x = 1×2
    1.0000    2.0000

使用另一个初始点会得到不同的解。

x0 = x0/5;
x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x = 1×2
10^-6 ×
    0.4000    0.4000

要确定哪个解更好，请参阅获得目标函数值。

非线性约束

打开脚本

在非线性约束下求函数的最小值

在边界约束下求罗森布罗克函数在圆内最小的点。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;

在区域 $0 \le x(1) \le 0.5$ 、 $0.2 \le x(2) \le 0.8$ 内寻找。

lb = [0,0.2];
ub = [0.5,0.8];

同时在以 [1/3,1/3] 为圆心、半径为 1/3 的圆内寻找。将以下代码复制到您的 MATLAB® 路径上名为 circlecon.m 的文件中。

function [c,ceq] = circlecon(x)
c = (x(1)-1/3)^2 + (x(2)-1/3)^2 - (1/3)^2;
ceq = [];

没有线性约束，因此将这些参量设置为 [] 。

A = [];
b = [];
Aeq = [];
beq = [];

选择一个满足所有约束的初始点。

x0 = [1/4,1/4];

求解。

nonlcon = @circlecon;
x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)
Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
    0.5000    0.2500

非默认选项

打开实时脚本

设置选项以在迭代期间查看输出信息并使用不同算法。

要观察 fmincon 求解过程，请将 Display 选项设置为 'iter' 。此外，尝试 'sqp' 算法，该算法有时比默认的 'interior-point' 算法更快或更准确。

options = optimoptions('fmincon','Display','iter','Algorithm','sqp');

在单位圆盘 $| | x | |^{2} \leq 1$ 上求罗森布罗克函数的最小值。首先创建一个表示非线性约束的函数。将此函数保存为 MATLAB® 路径上名为 unitdisk.m 的文件。

type unitdisk.m

function [c,ceq] = unitdisk(x)
c = x(1)^2 + x(2)^2 - 1;
ceq = [];

创建其余的问题设定。然后运行 fmincon 。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
nonlcon = @unitdisk;
x0 = [0,0];
x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

 Iter  Func-count            Fval   Feasibility   Step Length       Norm of   First-order  
                                                                       step    optimality
    0           3    1.000000e+00     0.000e+00     1.000e+00     0.000e+00     2.000e+00  
    1          12    8.913011e-01     0.000e+00     1.176e-01     2.353e-01     1.107e+01  
    2          22    8.047847e-01     0.000e+00     8.235e-02     1.900e-01     1.330e+01  
    3          28    4.197517e-01     0.000e+00     3.430e-01     1.217e-01     6.172e+00  
    4          31    2.733703e-01     0.000e+00     1.000e+00     5.254e-02     5.705e-01  
    5          34    2.397111e-01     0.000e+00     1.000e+00     7.498e-02     3.164e+00  
    6          37    2.036002e-01     0.000e+00     1.000e+00     5.960e-02     3.106e+00  
    7          40    1.164353e-01     0.000e+00     1.000e+00     1.459e-01     1.059e+00  
    8          43    1.161753e-01     0.000e+00     1.000e+00     1.754e-01     7.383e+00  
    9          46    5.901602e-02     0.000e+00     1.000e+00     1.547e-02     7.278e-01  
   10          49    4.533081e-02     2.898e-03     1.000e+00     5.393e-02     1.252e-01  
   11          52    4.567454e-02     2.225e-06     1.000e+00     1.492e-03     1.679e-03  
   12          55    4.567481e-02     4.386e-12     1.000e+00     2.095e-06     1.502e-05  
   13          58    4.567481e-02     0.000e+00     1.000e+00     2.193e-12     1.406e-05  
Local minimum possible. Constraints satisfied.
fmincon stopped because the size of the current step is less than
the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2
    0.7864    0.6177

有关迭代输出的详细信息，请参阅迭代输出。

使用梯度

打开脚本

将梯度计算加入目标函数中，以实现更快或更可靠的计算。

将梯度计算作为条件化输出包含在目标函数文件中。有关详细信息，请参阅包括梯度和黑塞函数。目标函数是罗森布罗克函数，

$f(x) = 100{\left( {{x_2} - x_1^2} \right)^2} +
{(1 - {x_1})^2},$

它有梯度

$\nabla f(x) = \left[ {\begin{array}{*{20}{c}}
{ - 400\left( {{x_2} - x_1^2} \right){x_1} - 2\left( {1 - {x_1}} \right)}\\
{200\left( {{x_2} - x_1^2} \right)}
\end{array}} \right].$

function [f,g] = rosenbrockwithgrad(x)
% Calculate objective f
f = 100*(x(2) - x(1)^2)^2 + (1-x(1))^2;
if nargout > 1 % gradient required
    g = [-400*(x(2)-x(1)^2)*x(1)-2*(1-x(1));
        200*(x(2)-x(1)^2)];

将此代码保存为 MATLAB® 路径上名为 rosenbrockwithgrad.m 的文件。

创建使用目标函数梯度的选项。

options = optimoptions('fmincon','SpecifyObjectiveGradient',true);

为问题创建其他输入。然后调用 fmincon 。

fun = @rosenbrockwithgrad;
x0 = [-1,2];
A = [];
b = [];
Aeq = [];
beq = [];
lb = [-2,-2];
ub = [2,2];
nonlcon = [];
x = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)
Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
    1.0000    1.0000

使用问题结构体

打开实时脚本

使用问题结构体而不是单独的参量来求解与非默认选项中相同的问题。

创建选项以及一个问题结构体。有关字段名称和必需的字段，请参阅 problem 。

options = optimoptions('fmincon','Display','iter','Algorithm','sqp');
problem.options = options;
problem.solver = 'fmincon';
problem.objective = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
problem.x0 = [0,0];

非线性约束函数 unitdisk 出现在此示例末尾。在 problem 中包含该非线性约束函数。

problem.nonlcon = @unitdisk;

求解。

x = fmincon(problem)

 Iter  Func-count            Fval   Feasibility   Step Length       Norm of   First-order  
                                                                       step    optimality
    0           3    1.000000e+00     0.000e+00     1.000e+00     0.000e+00     2.000e+00  
    1          12    8.913011e-01     0.000e+00     1.176e-01     2.353e-01     1.107e+01  
    2          22    8.047847e-01     0.000e+00     8.235e-02     1.900e-01     1.330e+01  
    3          28    4.197517e-01     0.000e+00     3.430e-01     1.217e-01     6.172e+00  
    4          31    2.733703e-01     0.000e+00     1.000e+00     5.254e-02     5.705e-01  
    5          34    2.397111e-01     0.000e+00     1.000e+00     7.498e-02     3.164e+00  
    6          37    2.036002e-01     0.000e+00     1.000e+00     5.960e-02     3.106e+00  
    7          40    1.164353e-01     0.000e+00     1.000e+00     1.459e-01     1.059e+00  
    8          43    1.161753e-01     0.000e+00     1.000e+00     1.754e-01     7.383e+00  
    9          46    5.901602e-02     0.000e+00     1.000e+00     1.547e-02     7.278e-01  
   10          49    4.533081e-02     2.898e-03     1.000e+00     5.393e-02     1.252e-01  
   11          52    4.567454e-02     2.225e-06     1.000e+00     1.492e-03     1.679e-03  
   12          55    4.567481e-02     4.386e-12     1.000e+00     2.095e-06     1.502e-05  
   13          58    4.567481e-02     0.000e+00     1.000e+00     2.193e-12     1.406e-05  
Local minimum possible. Constraints satisfied.
fmincon stopped because the size of the current step is less than
the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2
    0.7864    0.6177

迭代输出和解与在非默认选项中的相同。

以下代码创建 unitdisk 函数。

function [c,ceq] = unitdisk(x)
c = x(1)^2 + x(2)^2 - 1;
ceq = [];
end

获得目标函数值

打开实时脚本

带 fval 输出调用 fmincon ，以获得解处的目标函数值。

具有边界约束的最小化示例给出了两个解。哪个更好？运行以下示例，它请求 fval 输出和解。

fun = @(x)1+x(1)./(1+x(2)) - 3*x(1).*x(2) + x(2).*(1+x(1));
lb = [0,0];
ub = [1,2];
A = [];
b = [];
Aeq = [];
beq = [];
x0 = (lb + ub)/2;
[x,fval] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x = 1×2
    1.0000    2.0000

fval = -0.6667

使用另一个起点 x0 运行问题。

x0 = x0/5;
[x2,fval2] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub)

Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.

x2 = 1×2
10^-6 ×
    0.4000    0.4000

fval2 = 1.0000

此解的目标函数值 fval2 = 1，高于第一个值 fval = –0.6667。第一个解 x 具有较低的目标函数局部最小值。

使用额外输出检查解

打开脚本

要轻松检查解的质量，可请求 exitflag 和 output 输出。

设立一个在单位圆盘 $||x||^2 \le 1$ 上最小化罗森布罗克函数的问题。首先创建一个表示非线性约束的函数。将此函数保存为 MATLAB® 路径上名为 unitdisk.m 的文件。

function [c,ceq] = unitdisk(x)
c = x(1)^2 + x(2)^2 - 1;
ceq = [];

创建其余的问题设定。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
nonlcon = @unitdisk;
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
x0 = [0,0];

使用 fval 、 exitflag 和 output 输出调用 fmincon 。

[x,fval,exitflag,output] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)
Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
    0.7864    0.6177
fval =
    0.0457
exitflag =
output = 
  struct with fields:
         iterations: 24
          funcCount: 84
    constrviolation: 0
           stepsize: 6.9162e-06
          algorithm: 'interior-point'
      firstorderopt: 2.4373e-08
       cgiterations: 4
            message: 'Local minimum found that satisfies the constraints....'
       bestfeasible: [1x1 struct]

exitflag 值 1 表示该解是局部最小值。
output 结构体报告有关求解过程的几个统计量。具体来说，它在 output.iterations 中给出迭代次数，在 output.funcCount 中给出函数计算次数，以及在 output.constrviolation 中给出可行性。

获取所有输出

打开脚本

fmincon 可以返回几个输出，您可以使用这些输出来分析报告的解。

设立一个在单位圆盘上最小化罗森布罗克函数的问题。首先创建一个表示非线性约束的函数。将此函数保存为 MATLAB® 路径上名为 unitdisk.m 的文件。

function [c,ceq] = unitdisk(x)
c = x(1)^2 + x(2)^2 - 1;
ceq = [];

创建其余的问题设定。

fun = @(x)100*(x(2)-x(1)^2)^2 + (1-x(1))^2;
nonlcon = @unitdisk;
A = [];
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
x0 = [0,0];

请求所有 fmincon 输出。

[x,fval,exitflag,output,lambda,grad,hessian] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)
Local minimum found that satisfies the constraints.
Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the value of the constraint tolerance.
    0.7864    0.6177
fval =
    0.0457
exitflag =
output = 
  struct with fields:
         iterations: 24
          funcCount: 84
    constrviolation: 0
           stepsize: 6.9162e-06
          algorithm: 'interior-point'
      firstorderopt: 2.4373e-08
       cgiterations: 4
            message: 'Local minimum found that satisfies the constraints....'
       bestfeasible: [1x1 struct]
lambda = 
  struct with fields:
         eqlin: [0x1 double]
      eqnonlin: [0x1 double]
       ineqlin: [0x1 double]
         lower: [2x1 double]
         upper: [2x1 double]
    ineqnonlin: 0.1215
grad =
   -0.1911
   -0.1501
hessian =
  497.2903 -314.5589
 -314.5589  200.2392

lambda.ineqnonlin 输出显示非线性约束在解处为活动状态，并给出相关联的拉格朗日乘数的值。
grad 输出给出了在解 x 处目标函数梯度的值。
fmincon黑塞函数中描述了 hessian 输出。

输入参数

全部折叠

`fun` — 要计算最小值的函数
函数句柄 | 函数名称

要计算最小值的函数，指定为函数句柄或函数名称。 fun 函数接受向量或数组 x ，并返回实数标量 f ，即在 x 处计算的目标函数值。

fmincon 以 x0 参量的形状将 x 传递给目标函数和任何非线性约束函数。例如，如果 x0 是 5×3 数组，则 fmincon 将 x 以 5×3 数组的形式传递给 fun 。但是，在将 x 转换为列向量 x(:) 后， fmincon 会将线性约束矩阵 A 或 Aeq 乘以 x 。

将 fun 指定为文件的函数句柄：

x = fmincon(@myfun,x0,A,b)

其中 myfun 是一个 MATLAB ^® 函数，例如

function f = myfun(x)
f = ...            % Compute function value at x

您还可以为匿名函数指定 fun 作为函数句柄：

x = fmincon(@(x)norm(x)^2,x0,A,b);

如果您可以计算 fun 的梯度且 SpecifyObjectiveGradient 选项设置为 true ，设置如下

options = optimoptions('fmincon','SpecifyObjectiveGradient',true)

则

fun

必须在第二个输出参量中返回梯度向量


                          g(x)

。

如果您还可以计算黑塞矩阵，并通过 optimoptions 将 HessianFcn 选项设置为 'objective' ，且将 Algorithm 选项设置为 'trust-region-reflective' ，则 fun 必须在第三个输出参量中返回黑塞函数值 H(x) ，它是一个对称矩阵。 fun 可以给出稀疏黑塞矩阵。有关详细信息，请参阅适用于 fminunc 信赖域或 fmincon 信赖域反射算法的黑塞函数。

如果您还可以计算黑塞矩阵，并且 Algorithm 选项设置为 'interior-point' ，则有另一种方法将黑塞矩阵传递给 fmincon 。有关详细信息，请参阅适用于 fmincon 内点算法的黑塞函数。有关使用 Symbolic Math Toolbox™ 计算梯度和黑塞矩阵的示例，请参阅 Calculate Gradients and Hessians Using Symbolic Math Toolbox 。

interior-point 和 trust-region-reflective 算法允许您提供黑塞矩阵乘法函数。此函数给出黑塞乘以向量的乘积结果，而不直接计算黑塞矩阵。这可以节省内存。请参阅黑塞矩阵乘法函数。

示例: fun = @(x)sin(x(1))*cos(x(2))

数据类型: char | function_handle | string

`x0` — 初始点
实数向量 | 实数数组

初始点，指定为实数向量或实数数组。求解器使用 x0 的大小以及其中的元素数量确定 fun 接受的变量数量和大小。

'interior-point' 算法 - 如果 HonorBounds 选项是 true （默认值），则 fmincon 会将处于 lb 或 ub 边界之上或之外的 x0 分量重置为严格处于边界范围内的值。
'trust-region-reflective' 算法 - fmincon 将关于边界或线性等式不可行的 x0 分量重置为可行。
'sqp' 、 'sqp-legacy' 或 'active-set' 算法 - fmincon 将超出边界的 x0 分量重置为对应边界的值。

示例: x0 = [1,2,3,4]

数据类型: double

`A` — 线性不等式约束
实矩阵

线性不等式约束，指定为实矩阵。 A 是 M × N 矩阵，其中 M 是不等式的数目，而 N 是变量的数目（ x0 中的元素数）。对于大型问题，将 A 作为稀疏矩阵传递。

A 以如下形式编写 M 个线性不等式

A*x <= b ,

其中， x 是由 N 个变量组成的列向量 x(:) ， b 是具有 M 个元素的列向量。

例如，假设有以下不等式：

x ₁ +2x ₂ ≤10
3x ₁ +4x ₂ ≤20
5x ₁ +6x ₂ ≤30，

通过输入以下约束来指定不等式。

A = [1,2;3,4;5,6];
b = [10;20;30];

示例: 要指定 x 分量总和等于或小于 1，请使用 A = ones(1,N) 和 b = 1 。

数据类型: double

`b` — 线性不等式约束
实数向量

线性不等式约束，指定为实数向量。 b 是与 A 矩阵相关的包含 M 个元素的向量。如果将 b 作为行向量传递，求解器会在内部将 b 转换为列向量 b(:) 。对于大型问题，将 b 作为稀疏向量传递。

b 以如下形式编写 M 个线性不等式

A*x <= b ,

其中， x 是由 N 个变量组成的列向量 x(:) ， A 是大小为 M × N 的矩阵。

例如，假设有以下不等式：

x ₁ + 2x ₂ ≤ 10
3x ₁ + 4x ₂ ≤ 20
5x ₁ + 6x ₂ ≤ 30。

通过输入以下约束来指定不等式。

A = [1,2;3,4;5,6];
b = [10;20;30];

示例: 要指定 x 分量总和等于或小于 1，请使用 A = ones(1,N) 和 b = 1 。

数据类型: double

`Aeq` — 线性等式约束
实矩阵

线性等式约束，指定为实矩阵。 Aeq 是 Me × N 矩阵，其中 Me 是等式的数目，而 N 是变量的数目（ x0 中的元素数）。对于大型问题，将 Aeq 作为稀疏矩阵传递。

Aeq 以如下形式编写 Me 个线性等式

Aeq*x = beq ,

其中， x 是由 N 个变量组成的列向量 x(:) ， beq 是具有 Me 个元素的列向量。

例如，假设有以下不等式：

x ₁ +2x ₂ +3x ₃ =10
2x ₁ +4x ₂ + x ₃ =20，

通过输入以下约束来指定不等式。

Aeq = [1,2,3;2,4,1];
beq = [10;20];

示例: 要指定 x 分量总和为 1，请使用 Aeq = ones(1,N) 和 beq = 1 。

数据类型: double

`beq` — 线性等式约束
实数向量

线性等式约束，指定为实数向量。 beq 是与 Aeq 矩阵相关的包含 Me 个元素的向量。如果将 beq 作为行向量传递，求解器会在内部将 beq 转换为列向量 beq(:) 。对于大型问题，将 beq 作为稀疏向量传递。

beq 以如下形式编写 Me 个线性等式

Aeq*x = beq ,

其中， x 是由 N 个变量组成的列向量 x(:) ， Aeq 是大小为 Me × N 的矩阵。

例如，请参考以下等式：

x ₁ + 2x ₂ + 3x ₃ = 10
2x ₁ + 4x ₂ + x ₃ = 20。

通过输入以下约束来指定等式。

Aeq = [1,2,3;2,4,1];
beq = [10;20];

示例: 要指定 x 分量总和为 1，请使用 Aeq = ones(1,N) 和 beq = 1 。

数据类型: double

`lb` — 下界
实数向量 | 实数数组

下界，指定为实数向量或实数数组。如果 x0 中的元素数等于 lb 中的元素数，则 lb 指定

x(i) >= lb(i) （对于全部 i ）。

如果 numel(lb) < numel(x0) ，则 lb 指定

x(i) >= lb(i) ( 1 <= i <= numel(lb) )。

如果 lb 的元素数少于 x0 ，求解器将发出警告。

示例: 要指定所有 x 分量为正，请使用 lb = zeros(size(x0)) 。

数据类型: double

`ub` — 上界
实数向量 | 实数数组

上界，指定为实数向量或实数数组。如果 x0 中的元素数等于 ub 中的元素数，则 ub 指定

x(i) <= ub(i) （对于全部 i ）。

如果 numel(ub) < numel(x0) ，则 ub 指定

x(i) <= ub(i) ( 1 <= i <= numel(ub) )。

如果 ub 的元素数少于 x0 ，求解器将发出警告。

示例: 要指定 x 的所有分量小于 1，请使用 ub = ones(size(x0)) 。

数据类型: double

`nonlcon` — 非线性约束
函数句柄 | 函数名称

非线性约束，指定为函数句柄或函数名称。 nonlcon 函数接受向量或数组 x ，并返回两个数组 c(x) 和 ceq(x) 。

c(x) 是由 x 处的非线性不等式约束组成的数组。 fmincon 尝试满足

对于 c 的所有项，有 c(x) <= 0 。
ceq(x) 是由 x 处的非线性等式约束组成的数组。 fmincon 尝试满足

对于 ceq 的所有项，有 ceq(x) = 0 。

x = fmincon(@myfun,x0,A,b,Aeq,beq,lb,ub,@mycon)

其中 mycon 是一个 MATLAB 函数，例如

function [c,ceq] = mycon(x)
c = ...     % Compute nonlinear inequalities at x.
ceq = ...   % Compute nonlinear equalities at x.

如果约束的梯度也可以计算且


                          SpecifyConstraintGradient

选项是


                          true

，设置如下：

options = optimoptions('fmincon','SpecifyConstraintGradient',true)

则


                          nonlcon

还必须在第三个输出参量

GC

中返回


                          c(x)

的梯度，在第四个输出参量


                          GCeq

中返回


                          ceq(x)

的梯度。

GC

和


                          GCeq

可以是稀疏的或稠密的。如果

GC

或


                          GCeq

较大，非零项相对较少，则通过将它们表示为稀疏矩阵，可以节省


                          interior-point

算法的运行时间和内存使用量。有关详细信息，请参阅非线性约束。

数据类型: char | function_handle | string

`options` — 优化选项
`optimoptions` 的输出 | 结构体，例如 `optimset` 返回的结构体

优化选项，指定为 optimoptions 的输出或 optimset 等返回的结构体。

一些选项适用于所有算法，其他选项则与特定算法相关。有关详细信息，请参阅优化选项参考。

optimoptions 显示中缺少某些选项。这些选项在下表中以斜体显示。有关详细信息，请参阅查看优化选项。

所有算法


                               Algorithm

选择优化算法：

'interior-point' （默认值）
'trust-region-reflective'
'sqp'
'sqp-legacy' （仅限于 optimoptions ）
'active-set'

有关选择算法的信息，请参阅选择算法。

trust-region-reflective 算法要求：

在目标函数中提供梯度
将 SpecifyObjectiveGradient 设置为 true
具有边界约束或线性等式约束之一，但不能两者都有

如果您选择 'trust-region-reflective' 算法，但这些条件无法全部得到满足， fmincon 会引发错误。

'active-set' 、 'sqp-legacy' 和 'sqp' 算法不是大规模算法。请参阅大规模算法与中等规模算法。


                               CheckGradients

将用户提供的导数（目标或约束的梯度）与有限差分导数进行比较。选项是 false （默认值）或 true 。

对于 optimset ，名称为 DerivativeCheck ，值为 'on' 或 'off' 。请参阅当前选项名称和旧选项名称。

以后的版本中将会删除 CheckGradients 选项。要检查导数，请使用 checkGradients 函数。


                               ConstraintTolerance

约束违反值的容差，非负标量。默认值为 1e-6 。请参阅容差和停止条件。

对于 optimset ，名称是 TolCon 。请参阅当前选项名称和旧选项名称。

Diagnostics

显示关于要最小化或求解的函数的诊断信息。选项是 'off' （默认值）或 'on' 。

DiffMaxChange

有限差分梯度变量的最大变化（正标量）。默认值为 Inf 。

DiffMinChange

有限差分梯度变量的最小变化（正标量）。默认值为 0 。


                               Display

显示级别（请参阅迭代输出）：

'off' 或 'none' 不显示输出。
'iter' 显示每次迭代的输出，并给出默认退出消息。
'iter-detailed' 显示每次迭代的输出，并给出带有技术细节的退出消息。
'notify' 仅当函数不收敛时才显示输出，并给出默认退出消息。
'notify-detailed' 仅当函数不收敛时才显示输出，并给出技术性退出消息。
'final' （默认值）仅显示最终输出，并给出默认退出消息。
'final-detailed' 仅显示最终输出，并给出带有技术细节的退出消息。


                               FiniteDifferenceStepSize

有限差分的标量或向量步长因子。当您将 FiniteDifferenceStepSize 设置为向量 v 时，前向有限差分 delta 是

delta = v.*sign′(x).*max(abs(x),TypicalX);

其中


                               sign′(x) = sign(x)

（例外是


                               sign′(0) = 1

）。中心有限差分是

delta = v.*max(abs(x),TypicalX);

标量


                               FiniteDifferenceStepSize

扩展为向量。对于正向有限差分，默认值为


                               sqrt(eps)

；对于中心有限差分，默认值为


                               eps^(1/3)

。

对于 optimset ，名称是 FinDiffRelStep 。请参阅当前选项名称和旧选项名称。


                               FiniteDifferenceType

用于估计梯度的有限差分，可以是 'forward' （默认值）或 'central' （中心化）。 'central' 需要两倍的函数计算次数，但一般更为准确。仅当 CheckGradients 设置为 true 时，信赖域反射算法才使用 FiniteDifferenceType 。

当同时估计这两种类型的有限差分时， fmincon 小心地遵守边界。因此，例如，为了避免在边界之外的某个点进行计算，它可能采取一个后向差分，而不是前向差分。但是，对于 interior-point 算法，如果 HonorBounds 选项设置为 false ，则 'central' 差分可能会在计算过程中违反边界。

对于 optimset ，名称是 FinDiffType 。请参阅当前选项名称和旧选项名称。

FunValCheck

检查目标函数值是否有效。默认设置 'off' 不执行检查。当目标函数返回的值是 complex 、 Inf 或 NaN 时， 'on' 设置显示错误。


                               MaxFunctionEvaluations

允许的最大函数计算次数，非负整数。除 interior-point 外，所有算法的默认值均为 100*numberOfVariables ；对于 interior-point 算法，默认值为 3000 。请参阅容差和停止条件和迭代和函数计算次数。

对于 optimset ，名称是 MaxFunEvals 。请参阅当前选项名称和旧选项名称。


                               MaxIterations

允许的最大迭代次数，非负整数。除 interior-point 外，所有算法的默认值均为 400 ；对于 interior-point 算法，默认值为 1000 。请参阅容差和停止条件和迭代和函数计算次数。

对于 optimset ，名称是 MaxIter 。请参阅当前选项名称和旧选项名称。


                               OptimalityTolerance

一阶最优性的终止容差（非负标量）。默认值为 1e-6 。请参阅一阶最优性测度。

对于 optimset ，名称是 TolFun 。请参阅当前选项名称和旧选项名称。


                               OutputFcn

指定优化函数在每次迭代中调用的一个或多个用户定义的函数。传递函数句柄或函数句柄的元胞数组。默认值是“无”( [] )。请参阅 Output Function and Plot Function Syntax 。


                               PlotFcn

对算法执行过程中的各种进度测量值绘图，可以选择预定义的绘图，也可以自行编写绘图函数。传递内置绘图函数名称、函数句柄或由内置绘图函数名称或函数句柄组成的元胞数组。对于自定义绘图函数，传递函数句柄。默认值是“无”( [] )：

'optimplotx' 绘制当前点
'optimplotfunccount' 绘制函数计数
'optimplotfval' 绘制函数值
'optimplotfvalconstr' 将找到的最佳可行目标函数值绘制为线图。该图用一种颜色显示不可行点，用另一种颜色显示可行点，可行性容差为 1e-6 。
'optimplotconstrviolation' 绘制最大约束违反值
'optimplotstepsize' 绘制步长
'optimplotfirstorderopt' 绘制一阶最优性测度

自定义绘图函数使用与输出函数相同的语法。请参阅 Optimization Toolbox 的输出函数和 Output Function and Plot Function Syntax 。

对于 optimset ，名称是 PlotFcns 。请参阅当前选项名称和旧选项名称。


                               SpecifyConstraintGradient

用户定义的非线性约束函数梯度。当设置为默认值 false 时， fmincon 通过有限差分估计非线性约束的梯度。当设置为 true 时， fmincon 预计约束函数有四个输出，如 nonlcon 中所述。 trust-region-reflective 算法不接受非线性约束。

对于 optimset ，名称为 GradConstr ，值为 'on' 或 'off' 。请参阅当前选项名称和旧选项名称。


                               SpecifyObjectiveGradient

用户定义的目标函数梯度。请参阅 fun 的说明，了解如何在 fun 中定义梯度。设置为默认值 false 会导致 fmincon 使用有限差分来估计梯度。设置为 true ，以使 fmincon 采用用户定义的目标函数梯度。要使用 'trust-region-reflective' 算法，您必须提供梯度，并将 SpecifyObjectiveGradient 设置为 true 。

对于 optimset ，名称为 GradObj ，值为 'on' 或 'off' 。请参阅当前选项名称和旧选项名称。


                               StepTolerance

x 的终止容差，非负标量。除 'interior-point' 外，所有算法的默认值均为 1e-6 ；对于 'interior-point' 算法，默认值为 1e-10 。请参阅容差和停止条件。

对于 optimset ，名称是 TolX 。请参阅当前选项名称和旧选项名称。


                               TypicalX

典型的 x 值。 TypicalX 中的元素数等于 x0 （即起点）中的元素数。默认值为 ones(numberofvariables,1) 。 fmincon 使用 TypicalX 缩放有限差分来进行梯度估计。

'trust-region-reflective' 算法仅对 CheckGradients 选项使用 TypicalX 。


                               UseParallel

此选项为 true 时， fmincon 以并行方式估计梯度。设置为默认值 false 将禁用此功能。 trust-region-reflective 要求目标中有梯度，因此 UseParallel 不适用。请参阅并行计算。

信赖域反射算法


                               FunctionTolerance

函数值的终止容差，非负标量。默认值为 1e-6 。请参阅容差和停止条件。

对于 optimset ，名称是 TolFun 。请参阅当前选项名称和旧选项名称。


                               HessianFcn

如果为 [] （默认值），则 fmincon 使用有限差分逼近黑塞矩阵，或使用黑塞矩阵乘法函数（通过选项 HessianMultiplyFcn ）。如果为 'objective' ，则 fmincon 使用用户定义的黑塞矩阵（在 fun 中定义）。请参阅作为输入的黑塞矩阵。

对于 optimset ，名称是 HessFcn 。请参阅当前选项名称和旧选项名称。


                               HessianMultiplyFcn

黑塞矩阵乘法函数，指定为函数句柄。对于大规模结构问题，此函数计算黑塞矩阵乘积 H*Y ，而并不实际构造 H 。函数的形式是

W = hmfun(Hinfo,Y)

其中 Hinfo 包含用于计算 H*Y 的矩阵。

上述第一个参量与目标函数 fun 返回的第三个参量相同，例如

[f,g,Hinfo] = fun(x)

Y 是矩阵，其行数与问题中的维数相同。矩阵 W = H*Y （尽管其中 H 未显式构造）。 fmincon 使用 Hinfo 计算预条件子。要了解如何为 hmfun 所需的额外参数提供值的信息，请参阅传递额外参数。

注意

要使用 HessianMultiplyFcn 选项， HessianFcn 必须设置为 [] ，且 SubproblemAlgorithm 必须为 'cg' （默认值）。

请参阅黑塞矩阵乘法函数。有关示例，请参阅 Minimization with Dense Structured Hessian, Linear Equalities 。

对于 optimset ，名称是 HessMult 。请参阅当前选项名称和旧选项名称。

HessPattern

用于有限差分的黑塞矩阵稀疏模式。如果存在 ∂ ² fun /∂ x(i) ∂ x(j) ≠ 0，则设置 HessPattern(i,j) = 1 。否则，设置 HessPattern(i,j) = 0 。

如果不方便在 fun 中计算黑塞矩阵 H ，但您可以确定（例如，通过检查） fun 的梯度的第 i 个分量何时依赖 x(j) ，请使用 HessPattern 。如果您提供 H 的 稀疏结构 作为 HessPattern 的值， fmincon 可以通过稀疏有限差分（梯度）逼近 H 。这相当于提供非零元的位置。

当结构未知时，不要设置 HessPattern 。默认行为是将 HessPattern 视为由 1 组成的稠密矩阵。然后， fmincon 在每次迭代中计算满有限差分逼近。对于大型问题，这种计算可能成本非常高昂，因此通常最好确定稀疏结构。

MaxPCGIter

预条件共轭梯度 (PCG) 迭代的最大次数，正标量。对于边界约束问题，默认值为 max(1,floor(numberOfVariables/2)) ；对于等式约束问题，默认值为 numberOfVariables 。有关详细信息，请参阅预条件共轭梯度法。

PrecondBandWidth

PCG 的预条件子上带宽，非负整数。默认情况下，使用对角预条件（上带宽为 0）。对于某些问题，增加带宽会减少 PCG 迭代次数。将 PrecondBandWidth 设置为 Inf 会使用直接分解（乔列斯基分解），而不是共轭梯度 (CG)。直接分解的计算成本较 CG 高，但所得的求解步质量更好。


                               SubproblemAlgorithm

确定迭代步的计算方式。与 'factorization' 相比，默认值 'cg' 采用的步执行速度更快，但不够准确。请参阅 fmincon 信赖域反射算法。

对于 optimset ，您无法设置非默认值。要使用 'factorization' ，请使用 optimoptions 设置选项。

TolPCG

PCG 迭代的终止容差，正标量。默认值为 0.1 。

活动集算法


                               FunctionTolerance

函数值的终止容差，非负标量。默认值为 1e-6 。请参阅容差和停止条件。

对于 optimset ，名称是 TolFun 。请参阅当前选项名称和旧选项名称。

MaxSQPIter

允许的 SQP 迭代最大次数，正整数。默认值为 10*max(numberOfVariables, numberOfInequalities + numberOfBounds) 。

RelLineSrchBnd

线搜索步长的相对边界（非负实数标量值）。x 中的总位移满足 |Δx(i)| ≤ relLineSrchBnd· max(|x(i)|,|typicalx(i)|) 。当认为求解器采取的步过大时，可使用此选项控制 x 中位移的模。默认值为无边界 ( [] )。

RelLineSrchBndDuration

RelLineSrchBnd 所指定的边界应处于活动状态的迭代次数（默认值为 1 ）。

TolConSQP

内部迭代 SQP 约束违反值的终止容差，正标量。默认值为 1e-6 。

内点算法


                               BarrierParamUpdate

指定 fmincon 如何更新障碍参数（请参阅 fmincon 内点算法）。选项包括：

'monotone' （默认值）
'predictor-corrector'

此选项会影响求解器的速度和收敛，但效果不容易预测。


                               EnableFeasibilityMode

当为 true 时， fmincon 使用不同算法来获得可行性。在某些情况下，此设置可以帮助 fmincon 找到可行解。默认值为 false 。

当 SubproblemAlgorithm 为 'cg' 时，可行性模式通常表现更好。有关详细信息，请参阅可行性模式。有关示例，请参阅使用可行性模式获得解。


                               HessianApproximation

指定 fmincon 计算黑塞矩阵的方法（请参阅作为输入的黑塞矩阵）。选项包括：

'bfgs' （默认值）
'finite-difference'
'lbfgs'
{'lbfgs',Positive Integer}

注意

要使用 HessianApproximation ， HessianFcn 和 HessianMultiplyFcn 都必须为空 ( [] )。

对于 optimset ，名称为 Hessian ，值为 'user-supplied' 、 'bfgs' 、 'lbfgs' 、 'fin-diff-grads' 、 'on' 或 'off' 。请参阅当前选项名称和旧选项名称。


                               HessianFcn

如果为 [] （默认值），则 fmincon 使用 HessianApproximation 中指定的方法逼近黑塞矩阵，或使用提供的 HessianMultiplyFcn 。如果为函数句柄，则 fmincon 使用 HessianFcn 来计算黑塞矩阵。请参阅作为输入的黑塞矩阵。

对于 optimset ，名称是 HessFcn 。请参阅当前选项名称和旧选项名称。


                               HessianMultiplyFcn

用户提供的函数，它给出黑塞矩阵乘以向量的乘积（请参阅黑塞矩阵乘法函数）。传递函数句柄。

注意

要使用 HessianMultiplyFcn 选项， HessianFcn 必须设置为 [] 且 SubproblemAlgorithm 必须为 'cg' 。

对于 optimset ，名称是 HessMult 。请参阅当前选项名称和旧选项名称。


                               HonorBounds

默认值 true 确保每次迭代都满足边界约束。通过设置为 false 来禁用。

对于 optimset ，名称为 AlwaysHonorConstraints ，值为 'bounds' 或 'none' 。请参阅当前选项名称和旧选项名称。

InitBarrierParam

初始障碍值，正标量。有时尝试高于默认值 0.1 的值可能会有所帮助，尤其是当目标或约束函数很大时。

InitTrustRegionRadius

信赖域的初始半径，正标量。对于未正确缩放的问题，选择小于默认值 $\sqrt{n}$ 的值可能会有所帮助，其中 n 是变量的数目。

MaxProjCGIter

投影共轭梯度迭代次数的容差（停止条件）；这是内部迭代，而不是算法的迭代次数。它是一个正整数，默认值为 2*(numberOfVariables - numberOfEqualities) 。


                               ObjectiveLimit

容差（停止条件），标量。如果目标函数值低于 ObjectiveLimit 并且迭代可行，则迭代停止，因为问题很可能是无界的。默认值为 -1e20 。


                               ScaleProblem

true 使算法对所有约束和目标函数进行归一化。要禁用，请设置为默认值 false 。

对于 optimset ，值为 'obj-and-constr' 或 'none' 。请参阅当前选项名称和旧选项名称。


                               SubproblemAlgorithm

确定迭代步的计算方式。默认值 'factorization' 通常比 'cg' （共轭梯度）更快，但对于具有稠密黑塞矩阵的大型问题， 'cg' 可能更快。请参阅 fmincon 内点算法。

对于 optimset ，值为 'cg' 和 'ldl-factorization' 。请参阅当前选项名称和旧选项名称。

TolProjCG

投影共轭梯度算法的相对容差（停止条件）；它针对内部迭代，而不是算法迭代。它是一个正标量，默认值为 0.01 。

TolProjCGAbs

投影共轭梯度算法的绝对容差（停止条件）；它针对内部迭代，而不是算法迭代。它是一个正标量，默认值为 1e-10 。

SQP 和 SQP 传统算法


                               ObjectiveLimit

容差（停止条件），标量。如果目标函数值低于 ObjectiveLimit 并且迭代可行，则迭代停止，因为问题很可能是无界的。默认值为 -1e20 。


                               ScaleProblem

true 使算法对所有约束和目标函数进行归一化。要禁用，请设置为默认值 false 。

对于 optimset ，值为 'obj-and-constr' 或 'none' 。请参阅当前选项名称和旧选项名称。

单精度代码生成


                               Algorithm

必须为 'sqp' 或 'sqp-legacy' 。


                               ConstraintTolerance

约束违反值的容差，非负标量。默认值为 1e-3 。请参阅容差和停止条件。


                               FiniteDifferenceStepSize

有限差分的标量或向量步长因子。当您将 FiniteDifferenceStepSize 设置为向量 v 时，前向有限差分 delta 是

delta = v.*sign′(x).*max(abs(x),TypicalX); (1)

其中


                               sign′(x) = sign(x)

（例外是


                               sign′(0) = 1

）。中心有限差分是

delta = v.*max(abs(x),TypicalX); (2)

标量


                               FiniteDifferenceStepSize

扩展为向量。对于正向有限差分，默认值为


                               sqrt(eps('single'))

；对于中心有限差分，默认值为


                               eps('single')^(1/3)

。


                               FiniteDifferenceType

用于估计梯度的有限差分，可以是 'forward' （默认值）或 'central' （中心化）。 'central' 需要两倍的函数计算次数，但一般更为准确。

当同时估计这两种类型的有限差分时， fmincon 小心地遵守边界。因此，例如，为了避免在边界之外的某个点进行计算，它可能采取一个后向差分，而不是前向差分。


                               MaxFunctionEvaluations

允许的最大函数计算次数，非负整数。默认值为 100*numberOfVariables 。请参阅容差和停止条件和迭代和函数计算次数。


                               MaxIterations

允许的最大迭代次数，非负整数。默认值为 400 。请参阅容差和停止条件和迭代和函数计算次数。


                               ObjectiveLimit

容差（停止条件），标量。如果目标函数值低于 ObjectiveLimit 并且迭代可行，则迭代停止，因为问题很可能是无界的。默认值为 -1e20 。


                               OptimalityTolerance

一阶最优性的终止容差（非负标量）。默认值为 1e-3 。请参阅一阶最优性测度。


                               ScaleProblem

true 使算法对所有约束和目标函数进行归一化。要禁用，请设置为默认值 false 。


                               SpecifyConstraintGradient

用户定义的非线性约束函数梯度。当设置为默认值 false 时， fmincon 通过有限差分估计非线性约束的梯度。当设置为 true 时， fmincon 预计约束函数有四个输出，如 nonlcon 中所述。


                               SpecifyObjectiveGradient

用户定义的目标函数梯度。请参阅 fun 的说明，了解如何在 fun 中定义梯度。设置为默认值 false 会导致 fmincon 使用有限差分来估计梯度。设置为 true ，以使 fmincon 采用用户定义的目标函数梯度。


                               StepTolerance

x 的终止容差，非负标量。默认值为 1e-4 。请参阅容差和停止条件。


                               TypicalX

示例: options = optimoptions('fmincon','SpecifyObjectiveGradient',true,'SpecifyConstraintGradient',true)

`problem` — 问题结构体
结构体

问题结构体，指定为含有以下字段的结构体：

字段名称	条目
`objective`	目标函数
`x0`	`x` 的初始点
`Aineq`	线性不等式约束的矩阵
`bineq`	线性不等式约束的向量
`Aeq`	线性等式约束的矩阵
`beq`	线性等式约束的向量
`lb`	由下界组成的向量
`ub`	由上界组成的向量
`nonlcon`	非线性约束函数
`solver`	`'fmincon'`
`options`	用 `optimoptions` 创建的选项

您必须在 problem 结构体中至少提供 objective 、 x0 、 solver 和 options 字段。

数据类型: struct

输出参量

全部折叠

`x` — 解
实数向量 | 实数数组

解，以实数向量或实数数组形式返回。 x 的大小与 x0 的大小相同。通常情况下，当 exitflag 为正时， x 是该问题的局部解。有关解质量的信息，请参阅求解成功后。

`fval` — 解处的目标函数值
实数

解处的目标函数值，以实数形式返回。通常， fval = fun(x) 。

`exitflag` — `fmincon` 停止的原因
整数

fmincon 停止的原因，以整数形式返回。

所有算法：
`1`	一阶最优性测度小于 `options.OptimalityTolerance` ，最大约束违反值小于 `options.ConstraintTolerance` 。
`0`	迭代次数超出 `options.MaxIterations` 或函数计算次数超过 `options.MaxFunctionEvaluations` 。
`-1`	由输出函数或绘图函数停止。
`-2`	找不到可行点。
除 `active-set` 外的所有算法：
`2`	`x` 的变化小于 `options.StepTolerance` ，最大约束违反值小于 `options.ConstraintTolerance` 。
仅 `trust-region-reflective` 算法：
`3`	目标函数值的变化小于 `options.FunctionTolerance` ，最大约束违反值小于 `options.ConstraintTolerance` 。
仅 `active-set` 算法：
`4`	搜索方向的模小于 2* `options.StepTolerance` ，最大约束违反值小于 `options.ConstraintTolerance` 。
`5`	搜索方向中方向导数的模小于 2* `options.OptimalityTolerance` ，最大约束违反值小于 `options.ConstraintTolerance` 。
`interior-point` 、 `sqp-legacy` 和 `sqp` 算法：
`-3`	当前迭代的目标函数低于 `options.ObjectiveLimit` ，最大约束违反值小于 `options.ConstraintTolerance` 。

`output` — 有关优化过程的信息
结构体

有关优化过程的信息，以包含下列字段的结构体形式返回：

`iterations`	执行的迭代次数
`funcCount`	函数计算次数
`lssteplength`	相对于搜索方向的线搜索步的大小（仅适用于 `active-set` 和 `sqp` 算法）
`constrviolation`	约束函数的最大值
`stepsize`	`x` 的最后位移的长度（不适用于 `active-set` 算法中）
`algorithm`	使用的优化算法
`cgiterations`	PCG 迭代总次数（适用于 `trust-region-reflective` 和 `interior-point` 算法）
`firstorderopt`	一阶最优性的测度
`bestfeasible`	遇到的最佳（最低目标函数）可行点。具有以下字段的结构体： `x` `fval` `firstorderopt` `constrviolation` 如果找不到可行点，则 `bestfeasible` 字段为空。为此，当约束函数的最大值不超过 `options.ConstraintTolerance` 时，点是可行的。由于各种原因， `bestfeasible` 点可能与返回的解点 `x` 不同。有关示例，请参阅 Obtain Best Feasible Point 。
`message`	退出消息

`lambda` — 解处的拉格朗日乘数
结构体

解处的拉格朗日乘数，以包含下列字段的结构体形式返回：

`lower`	对应于 `lb` 的下界
`upper`	对应于 `ub` 的上界
`ineqlin`	对应于 `A` 和 `b` 的线性不等式
`eqlin`	对应于 `Aeq` 和 `beq` 的线性等式
`ineqnonlin`	对应于 `nonlcon` 中 `c` 的非线性不等式
`eqnonlin`	对应于 `nonlcon` 中 `ceq` 的非线性等式

`grad` — 解处的梯度

解处的梯度，以实数向量形式返回。 `grad` 给出 `fun` 在 `x(:)` 点处的梯度。

`hessian` — 逼近黑塞矩阵
实矩阵

逼近黑塞矩阵，以实矩阵形式返回。有关 hessian 的含义，请参阅黑塞矩阵输出。

局限性

fmincon 是基于梯度的方法，旨在处理目标函数和约束函数均为连续且具有连续一阶导数的问题。
对于 'trust-region-reflective' 算法，您必须在 fun 中提供梯度，并将 'SpecifyObjectiveGradient' 选项设置为 true 。

'trust-region-reflective' 算法不允许相等的上界和下界。例如，如果 lb(2)==ub(2) ，则 fmincon 给出以下错误：

Equal upper and lower bounds not permitted in trust-region-reflective algorithm. Use
either interior-point or SQP algorithms instead.

传递黑塞矩阵有两种不同的语法，传递 HessianMultiplyFcn 函数也有两种不同的语法；一种针对 trust-region-reflective ，另一种针对 interior-point 。请参阅包含黑塞函数。
- 对于 trust-region-reflective ，拉格朗日函数的黑塞矩阵与目标函数的黑塞矩阵相同。您将黑塞矩阵作为目标函数的第三个输出进行传递。
- 对于 interior-point ，拉格朗日函数的黑塞矩阵涉及拉格朗日乘数和非线性约束函数的黑塞矩阵。您将黑塞函数作为单独的函数传递，该函数同时考虑当前点 x 和拉格朗日乘数结构体 lambda 。
当问题不可行时， fmincon 会尝试将最大约束值最小化。

详细信息

全部折叠

作为输入的黑塞矩阵

fmincon 将黑塞矩阵作为可选输入。此黑塞矩阵是拉格朗日函数二阶导数的矩阵（请参阅公式 1 ），即，

\nabla_{x x}^{2} L (x, λ) = \nabla^{2} f (x) + \sum λ_{i} \nabla^{2} c_{i} (x) + \sum λ_{i} \nabla^{2} c e q_{i} (x) .

(3)

有关如何向 trust-region-reflective 或 interior-point 算法提供黑塞矩阵的详细信息，请参阅包含黑塞函数。

active-set 和 sqp 算法不接受黑塞矩阵作为输入。它们计算拉格朗日函数的黑塞矩阵的拟牛顿逼近。

interior-point 算法提供多种 'HessianApproximation' 选项；请参阅为内点 fmincon 选择输入黑塞函数逼近方法：

'bfgs' - fmincon 通过稠密矩阵拟牛顿逼近来计算黑塞矩阵。这是默认黑塞逼近。
'lbfgs' - fmincon 通过限制内存使用量的大规模拟牛顿逼近计算黑塞矩阵。此选项使用默认内存量，即进行 10 次迭代。
{'lbfgs',positive integer} - fmincon 通过限制内存使用量的大规模拟牛顿逼近计算黑塞矩阵。正整数指定要保留记录的最近迭代次数。
'finite-difference' - fmincon 通过梯度的有限差分计算黑塞矩阵乘以向量的乘积。您必须提供目标函数的梯度，还要提供非线性约束的梯度（如果存在）。将 'SpecifyObjectiveGradient' 选项设置为 true ，并在适用时将 'SpecifyConstraintGradient' 选项设置为 true 。您必须将 'SubproblemAlgorithm' 设置为 'cg' 。

黑塞矩阵乘法函数

interior-point 和 trust-region-reflective 算法允许您提供黑塞矩阵乘法函数。此函数给出黑塞矩阵乘以向量的乘积结果，而不直接计算黑塞矩阵。这可以节省内存。有关详细信息，请参阅黑塞矩阵乘法函数。

算法

全部折叠

选择算法

有关选择算法的帮助，请参阅 fmincon 算法。要设置算法，请使用 optimoptions 创建 options ，并使用 'Algorithm' 名称-值对组。

本节在后续部分提供每种算法的简要总结或信息指南。

内点优化

fmincon 内点算法中说明了此算法。在 [1] 、 [41] 和 [9] 中有更广泛的说明。

SQP 和 SQP 传统优化

fmincon 'sqp' 和 'sqp-legacy' 算法类似于活动集优化中所述的 'active-set' 算法。 fmincon SQP 算法说明了主要区别。这些区别总结如下：

活动集优化

fmincon 使用序列二次规划 (SQP) 方法。在此方法中，函数在每次迭代中求解二次规划 (QP) 子问题。 fmincon 使用 BFGS 公式在每次迭代中更新拉格朗日函数的黑塞矩阵估计值（请参阅 fminunc 以及参考文献 [7] 和 [8] ）。

fmincon 使用评价函数执行线搜索， [6] 、 [7] 和 [8] 都提及了类似的函数。QP 子问题使用活动集策略进行求解， [5] 提及了类似的策略。 fmincon 活动集算法详细说明了此算法。

另请参阅 SQP 实现以了解所用算法的详细信息。

信赖域反射优化

'trust-region-reflective' 算法是一种子空间信赖域方法，基于 [3] 和 [4] 中所述的内部反射牛顿法。每次迭代都涉及使用预条件共轭梯度法 (PCG) 来近似求解大型线性系统。请参阅 fmincon 信赖域反射算法中有关信赖域和预条件共轭梯度法的说明。

替代功能

App

优化实时编辑器任务为 fmincon 提供可视化界面。

参考

[1] Byrd, R. H., J. C. Gilbert, and J. Nocedal. “A Trust Region Method Based on Interior Point Techniques for Nonlinear Programming.” Mathematical Programming, Vol 89, No. 1, 2000, pp. 149–185.

[2] Byrd, R. H., Mary E. Hribar, and Jorge Nocedal. “An Interior Point Algorithm for Large-Scale Nonlinear Programming.” SIAM Journal on Optimization, Vol 9, No. 4, 1999, pp. 877–900.

[3] Coleman, T. F. and Y. Li. “An Interior, Trust Region Approach for Nonlinear Minimization Subject to Bounds.” SIAM Journal on Optimization, Vol. 6, 1996, pp. 418–445.

[4] Coleman, T. F. and Y. Li. “On the Convergence of Reflective Newton Methods for Large-Scale Nonlinear Minimization Subject to Bounds.” Mathematical Programming, Vol. 67, Number 2, 1994, pp. 189–224.

[5] Gill, P. E., W. Murray, and M. H. Wright. Practical Optimization, London, Academic Press, 1981.

[6] Han, S. P. “A Globally Convergent Method for Nonlinear Programming.” Journal of Optimization Theory and Applications, Vol. 22, 1977, pp. 297.

[7] Powell, M. J. D. “A Fast Algorithm for Nonlinearly Constrained Optimization Calculations.” Numerical Analysis, ed. G. A. Watson, Lecture Notes in Mathematics, Springer-Verlag, Vol. 630, 1978.

[8] Powell, M. J. D. “The Convergence of Variable Metric Methods For Nonlinearly Constrained Optimization Calculations.” Nonlinear Programming 3 (O. L. Mangasarian, R. R. Meyer, and S. M. Robinson, eds.), Academic Press, 1978.

[9] Waltz, R. A., J. L. Morales, J. Nocedal, and D. Orban. “An interior algorithm for nonlinear optimization that combines line search and trust region steps.” Mathematical Programming, Vol 107, No. 3, 2006, pp. 391–408.

扩展功能

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

用法说明和限制：

fmincon 支持使用 codegen (MATLAB Coder) 函数或 MATLAB Coder™ 生成代码。您必须拥有 MATLAB Coder 许可证才能生成代码。
目标硬件必须支持标准双精度浮点计算或标准单精度浮点计算。
代码生成目标与 MATLAB 求解器不使用相同的数学核心函数库。因此，代码生成解可能不同于求解器解，尤其是对于病态问题。
生成的所有代码必须为 MATLAB 代码。特别是，您不能将自定义黑盒函数用作 fmincon 的目标函数。您可以使用 coder.ceval 计算用 C 或 C++ 编码的自定义函数。但是，自定义函数必须在 MATLAB 函数中调用。
在生成代码时， fmincon 不支持 problem 参量。
```
[x,fval] = fmincon(problem) % Not supported
```
您必须使用函数句柄（而不是字符串或字符名称）来指定目标函数和任何非线性约束函数。
```
x = fmincon(@fun,x0,A,b,Aeq,beq,lb,ub,@nonlcon) % Supported
% Not supported: fmincon('fun',...) or fmincon("fun",...)
```
所有 fmincon 输入矩阵（如 A 、 Aeq 、 lb 和 ub ）都必须是满矩阵，而不能是稀疏矩阵。您可以使用 full 函数将稀疏矩阵转换为满矩阵。
lb 和 ub 参量的条目数必须与 x0 参量相同，或必须为空 [] 。
如果您的目标硬件不支持无限边界，请使用 optim.coder.infbound 。
对于涉及嵌入式处理器的高级代码优化，您还需要 Embedded Coder ^® 许可证。
您必须包括适用于 fmincon 的选项，并使用 optimoptions 指定这些选项。选项中必须包括 Algorithm 并将其设置为 'sqp' 或 'sqp-legacy' 。
```
options = optimoptions('fmincon','Algorithm','sqp');
[x,fval,exitflag] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options);
```
代码生成支持以下选项：
- Algorithm - 必须为 'sqp' 或 'sqp-legacy' 。
- ConstraintTolerance
- FiniteDifferenceStepSize
- FiniteDifferenceType
- MaxFunctionEvaluations
- MaxIterations
- ObjectiveLimit
- OptimalityTolerance
- ScaleProblem
- SpecifyConstraintGradient
- SpecifyObjectiveGradient
- StepTolerance
- TypicalX

生成的代码只会对选项进行有限的错误检查。更新选项的推荐方法是使用 optimoptions ，而不是圆点表示法。

opts = optimoptions('fmincon','Algorithm','sqp');
opts = optimoptions(opts,'MaxIterations',1e4); % Recommended
opts.MaxIterations = 1e4; % Not recommended

不要从文件中加载选项。否则会导致代码生成失败。请在代码中创建选项。
通常，如果您指定了不受支持的选项，在代码生成过程中会以静默方式忽略该选项。但是，如果使用圆点表示法指定绘图函数或输出函数，代码生成可能引发错误。为确保可靠性，请仅指定支持的选项。
由于不支持输出函数和绘图函数， fmincon 不会返回退出标志 –1。
为 fmincon 生成的代码中返回的 output 结构体不包含 bestfeasible 字段。

有关示例，请参阅优化代码生成基础知识。

自动并行支持
通过使用 Parallel Computing Toolbox™ 自动运行并行计算来加快代码执行。

要并行运行，请将 'UseParallel' 选项设置为 true 。

options = optimoptions(' solvername ','UseParallel',true)

有关详细信息，请参阅在 Optimization Toolbox 中使用并行计算。

版本历史记录

在 R2006a 之前推出

全部展开

R2024a: 单精度代码生成

您可以在单精度浮点硬件上为 fmincon 生成代码。有关说明，请参阅单精度代码生成。

R2023b: `CheckGradients` 选项将被删除

以后的版本中将会删除 CheckGradients 选项。要检查目标函数或非线性约束函数的一阶导数，请使用 checkGradients 函数。

另请参阅

fminbnd | fminsearch | fminunc | optimoptions | 优化

fmincon

语法

说明

示例

线性不等式约束

线性不等式和等式约束

具有边界约束的最小化

非线性约束

非默认选项

使用梯度

使用问题结构体

获得目标函数值

使用额外输出检查解

获取所有输出

输入参数

fun — 要计算最小值的函数 函数句柄 | 函数名称

x0 — 初始点 实数向量 | 实数数组

A — 线性不等式约束 实矩阵

b — 线性不等式约束 实数向量

Aeq — 线性等式约束 实矩阵

beq — 线性等式约束 实数向量

lb — 下界 实数向量 | 实数数组

ub — 上界 实数向量 | 实数数组

nonlcon — 非线性约束 函数句柄 | 函数名称

options — 优化选项 optimoptions 的输出 | 结构体，例如 optimset 返回的结构体

problem — 问题结构体 结构体

输出参量

x — 解 实数向量 | 实数数组

fval — 解处的目标函数值 实数

exitflag — fmincon 停止的原因 整数

output — 有关优化过程的信息 结构体

lambda — 解处的拉格朗日乘数 结构体

grad — 解处的梯度 解处的梯度，以实数向量形式返回。 grad 给出 fun 在 x(:) 点处的梯度。

hessian — 逼近黑塞矩阵 实矩阵

局限性

详细信息

作为输入的黑塞矩阵

黑塞矩阵乘法函数

算法

选择算法

内点优化

SQP 和 SQP 传统优化

活动集优化

信赖域反射优化

替代功能

App

参考

扩展功能

C/C++ 代码生成 使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

自动并行支持 通过使用 Parallel Computing Toolbox™ 自动运行并行计算来加快代码执行。

版本历史记录

R2024a: 单精度代码生成

R2023b: CheckGradients 选项将被删除

另请参阅

主题

`fun` — 要计算最小值的函数
函数句柄 | 函数名称

`x0` — 初始点
实数向量 | 实数数组

`A` — 线性不等式约束
实矩阵

`b` — 线性不等式约束
实数向量

`Aeq` — 线性等式约束
实矩阵

`beq` — 线性等式约束
实数向量

`lb` — 下界
实数向量 | 实数数组

`ub` — 上界
实数向量 | 实数数组

`nonlcon` — 非线性约束
函数句柄 | 函数名称

`options` — 优化选项
`optimoptions` 的输出 | 结构体，例如 `optimset` 返回的结构体

`problem` — 问题结构体
结构体

`x` — 解
实数向量 | 实数数组

`fval` — 解处的目标函数值
实数

`exitflag` — `fmincon` 停止的原因
整数

`output` — 有关优化过程的信息
结构体

`lambda` — 解处的拉格朗日乘数
结构体

`grad` — 解处的梯度

解处的梯度，以实数向量形式返回。 `grad` 给出 `fun` 在 `x(:)` 点处的梯度。

`hessian` — 逼近黑塞矩阵
实矩阵

C/C++ 代码生成
使用 MATLAB® Coder™ 生成 C 代码和 C++ 代码。

自动并行支持
通过使用 Parallel Computing Toolbox™ 自动运行并行计算来加快代码执行。

R2023b: `CheckGradients` 选项将被删除