coneprog

二阶锥规划解算器

所有的页面崩溃

语法

x = coneprog (f, socConstraints)

x = coneprog (f, socConstraints, A、b、Aeq beq)

x = coneprog (f socConstraints A、b Aeq,说真的,磅,乌兰巴托)

x = coneprog (f socConstraints A、b Aeq,说真的,磅,乌兰巴托,选项)

x = coneprog(问题)

[x, fval] = coneprog (___)

[x, fval exitflag,输出]= coneprog (___)

[x, fval exitflag、输出λ)= coneprog (___)

描述

的coneprog函数是一个二阶锥规划求解,找到指定的最小的问题

$\underset{x}{最小值} f^{T} x$

受约束

$\begin{matrix} 为 {一个}_{sc} (我) \cdot x - b_{sc} (我) 为 \leq d_{sc}^{T} (我) \cdot x - γ (我) \\ 一个 \cdot x \leq b \\ Aeq \cdot x = 说真的 \\ 磅 \leq x \leq 乌兰巴托。 \end{matrix}$

f,x,b,说真的,磅,乌兰巴托向量,一个和Aeq矩阵。为每一个我,矩阵一个_sc(我),向量d_sc(我),b_sc(我)和标量γ(我)是在一个二阶锥约束使用您创建的secondordercone。

关于锥约束的更多细节,请参阅二阶锥约束。

例子

x= coneprog (f,socConstraints)解决了二阶锥规划问题的约束socConstraints编码为

一个_sc(我)=socConstraints(我)。
b_sc(我)=socConstraints(我)。b
d_sc(我)=socConstraints .d(我)
γ(我)=socConstraints(我)可以利用

例子

x= coneprog (f,socConstraints,一个,b,Aeq,说真的)解决问题的不等式约束* x≤b和等式约束Aeq * x =说真的。集一个= []和b = []如果不存在不平等。

例子

x= coneprog (f,socConstraints,一个,b,Aeq,说真的,磅,乌兰巴托)定义了一组上下界限的设计变量,x这样的解决方案总是范围磅≤x≤乌兰巴托。集Aeq = []和说真的= []如果没有平等的存在。

例子

x= coneprog (f,socConstraints,一个,b,Aeq,说真的,磅,乌兰巴托,选项)减少使用指定的优化选项选项。使用optimoptions设置这些选项。

例子

x= coneprog (问题)发现的最低标准问题描述的结构问题。

例子

(x,fval)= coneprog (___)同时返回目标函数值的解决方案fval=f ' * x,使用任何输入参数组合在以前的语法。

例子

(x,fval,exitflag,输出)= coneprog (___)此外,返回一个值exitflag描述退出条件和结构输出包含的信息优化过程。

例子

(x,fval,exitflag,输出,λ)= coneprog (___)此外返回一个结构λ字段包含双变量的解决方案吗x。

例子

全部折叠

单锥约束

打开生活的脚本

建立一个二阶锥约束的问题,创建一个二阶锥约束对象。

一个=诊断接头([1,1/2,0]);b = 0 (3,1);d = [0, 0, 1];γ= 0;socConstraints = secondordercone (A, b, d,γ);

创建一个目标函数向量。

f = (1 2 0);

这个问题没有线性约束。为这些约束创建空矩阵。

Aineq = [];bineq = [];Aeq = [];说真的= [];

设置上下界限x (3)。

磅=(负负0);乌兰巴托=(正,正无穷,2);

通过使用解决问题coneprog函数。

[x, fval] = coneprog (f socConstraints Aineq、bineq Aeq,说真的,磅,乌兰巴托)

找到最优解。

x =3×10.4851 3.8806 2.0000

fval = -8.2462

解决方案组件x (3)上界。锥约束是活跃的解决方案:

规范(*取向)- d ' * x% 0附近时,约束是活跃的

ans = -2.5677 e-08

几个锥约束

打开生活的脚本

设置几个问题二阶锥约束,约束对象的创建一个数组。为了节省时间和内存,首先创建最高限制。

一个=诊断接头([1 2 0]);b = 0 (3,1);d = [0, 0, 1];γ= 1;socConstraints (3) = secondordercone (A, b, d,γ);一个=诊断接头([0,1]);d = (0, 1, 0);socConstraints (2) = secondordercone (A, b, d,γ);一个=诊断接头([0;1/2;1/2]);d = (1, 0, 0); socConstraints(1) = secondordercone(A,b,d,gamma);

创建一个线性目标函数向量。

f = [1, 2, 4];

通过使用解决问题coneprog函数。

[x, fval] = coneprog (f, socConstraints)

找到最优解。

x =3×10.4238 1.6477 2.3225

fval = -13.0089

与线性约束锥的编程

打开生活的脚本

指定一个目标函数向量和一个二阶锥约束。

f = (4、9; 2);Asc =诊断接头((1,4,0));b = (0, 0, 0);d = [0, 0, 1];γ= 0;socConstraints = secondordercone (Asc, b, d,γ);

指定一个线性不等式约束。

一个= [1/4、1/9 1];b = 5;

解决这个问题。

[x, fval] = coneprog (f, socConstraints, A, b)

找到最优解。

x =3×13.2304 0.6398 4.1213

fval = -26.9225

锥编程非默认选项

打开生活的脚本

观察的迭代coneprog解算器,设置显示选项“通路”。

选择= optimoptions (“coneprog”,“显示”,“通路”);

创建一个二阶锥规划问题并解决它选项。

Asc =诊断接头([1,1/2,0]);b = 0 (3,1);d = [0, 0, 1];γ= 0;socConstraints = secondordercone (Asc, b, d,γ);f = (1 2 0);Aineq = [];bineq = [];Aeq = [];说真的= []; lb = [-Inf,-Inf,0]; ub = [Inf,Inf,2]; [x,fval] = coneprog(f,socConstraints,Aineq,bineq,Aeq,beq,lb,ub,options)

Iter Fval原始Infeas双重Infeas对偶间隙时间1 0.000000 1.250000 5.714286 0.000000 e + e + 00 00 e-01 e-01 0.03 - 2 -7.558066 1.564306 7.151114 0.000000 e + e + 00 00 e-02 e-02 0.04 3 -7.366973 1.075440 0.000000 e + e + 00 00 e-02 2.352525 e 03 0.05 4 -8.243432 1.135724 5.191882 0.000000 e + e + 00 00 e-05 e-05 2.430813 1.387779 -8.246067 0.05 - 5 e + 00 e-17 e-06 5.317403 e-07 0.05 6 -8.246211 1.346298 6.154504 0.000000 e + e + 00 00 e-09 e-09 0.05找到最优解。

x =3×10.4851 3.8806 2.0000

fval = -8.2462

锥结构编程问题

打开生活的脚本

创建一个二阶锥规划问题的元素。为了节省时间和内存,首先创建最高限制。

一个=诊断接头([1 2 0]);b = 0 (3,1);d = [0, 0, 1];γ= 1;socConstraints (3) = secondordercone (A, b, d,γ);一个=诊断接头([0,1]);d = (0, 1, 0);socConstraints (2) = secondordercone (A, b, d,γ);一个=诊断接头([0;1/2;1/2]);d = (1, 0, 0); socConstraints(1) = secondordercone(A,b,d,gamma); f = [-1;-2;-4]; options = optimoptions(“coneprog”,“显示”,“通路”);

结构所需的字段创建一个问题,因为所描述的问题。

问题=结构(“f”f…“socConstraints”socConstraints,…“Aineq”[],“bineq”[],…“Aeq”[],“说真的”[],…“磅”[],乌兰巴托的[],…“规划求解”,“coneprog”,…“选项”、选择);

通过调用解决问题coneprog。

[x, fval] = coneprog(问题)

Iter Fval原始Infeas双重Infeas对偶间隙时间1 0.000000 5.555556 5.333333 0.000000 e + e + 00 00 e-01 e-02 7.631901 1.850372 -9.696012 0.18 - 2 e + 00 e-17 e-02 7.949897 e 03 0.20 3 -1.178942 e + 01 9.251859 e-18 1.261803 e-02 1.314378 e 03 01 1.850372 e-17 1.683078 -1.294426 0.20 - 4 e + e 03 1.753206 e-04 0.20 5 -1.295217 e + 01 -1.295331 1.850372 0.21 9.369370 8.994595 e-17 e-04 e-05 6 e + 01 -1.300753 1.850372 0.21 4.946709 4.748841 e-17 e-04 e-05 7 e + 01 -1.300671 0.21 2.916606 2.799942 9.251859 e-18 e-05 e-06 8 e + 01 9.251859 e-18 2.366136 e-05 2.464725 e-06 0.21 9 -1.300850 e + 01 1.850372 e-17 8.187205 e-06 8.528338 e-07 0.21十-1.300843 e + 01 4.625929 e-18 7.326330 e-06 7.631594 e-07 0.21 11 -1.300862 e + 01 9.251859 e-18 2.707005 e-06 2.819797 e-07 0.21 12 -1.300892 e + 01 0.000000 0.22 9.587976 9.204457 e + 00 e-08 e-09找到最优解。

x =3×10.4238 1.6477 2.3225

fval = -13.0089

检查`coneprog`解决方案的过程

打开生活的脚本

创建一个二阶锥规划问题。为了节省时间和内存,首先创建最高限制。

一个=诊断接头([1 2 0]);b = 0 (3,1);d = [0, 0, 1];γ= 1;socConstraints (3) = secondordercone (A, b, d,γ);一个=诊断接头([0,1]);d = (0, 1, 0);socConstraints (2) = secondordercone (A, b, d,γ);一个=诊断接头([0;1/2;1/2]);d = (1, 0, 0); socConstraints(1) = secondordercone(A,b,d,gamma); f = [-1;-2;-4]; options = optimoptions(“coneprog”,“显示”,“通路”);一个= [];b = [];Aeq = [];说真的= [];磅= [];乌兰巴托= [];

解决问题,请求信息解决方案的过程。

[x, fval exitflag、输出]= coneprog (f socConstraints A、b Aeq,说真的,磅,乌兰巴托,选项)

Iter Fval原始Infeas双重Infeas对偶间隙时间1 0.000000 5.555556 5.333333 0.000000 e + e + 00 00 e-01 e-02 7.631901 5.551115 -9.696012 0.03 - 2 e + 00 e-17 e-02 7.949897 e 03 0.03 3 -1.178942 e + 01 3.700743 e-17 1.261803 e-02 1.314378 e 03 01 1.850372 e-17 1.683078 -1.294426 0.03 - 4 e + e 03 1.753206 e-04 0.03 5 -1.295217 e + 01 -1.295331 9.251859 0.03 9.369370 8.994595 e-18 e-04 e-05 6 e + 01 -1.300753 9.251859 0.03 4.946709 4.748841 e-18 e-04 e-05 7 e + 01 -1.300671 0.03 2.916606 2.799942 9.251859 e-18 e-05 e-06 8 e + 01 -1.300850 0.04 2.464725 2.366136 9.251859 e-18 e-05 e-06 9 e + 01 9.251859 e-18 8.222244 e-06 8.564838 e-07 0.04十-1.300843 e + 01 1.850372 e-17 7.318333 e-06 7.623264 e-07 0.04 11 -1.300865 e + 01 9.251859 e-18 2.636568 e-06 2.746425 e-07 0.04 12 -1.300892 1.850372 e + 01 e-17 3.407939 e-08 3.549936 e-09 0.04找到最优解。

x =3×10.4238 1.6477 2.3225

fval = -13.0089

exitflag = 1

输出=结构体字段:迭代:12 primalfeasibility: 1.8504 e-17 dualfeasibility: 3.4079 e-08 dualitygap: 3.5499 e-09算法:“内点”linearsolver:“增强”的信息:“找到最优解。”

迭代显示和输出结构显示coneprog使用12个迭代得出解决方案。
出口标志值1和output.message价值找到最优解。表明,该解决方案是可靠的。
的输出结构表明,通过解决方案的过程,不可能实行倾向于减少的二元性差距。
你可以复制fval输出乘以f ' * x。

f ' * x

ans = -13.0089

获得`coneprog`双变量

打开生活的脚本

创建一个二阶锥规划问题。为了节省时间和内存,首先创建最高限制。

一个=诊断接头([1 2 0]);b = 0 (3,1);d = [0, 0, 1];γ= 1;socConstraints (3) = secondordercone (A, b, d,γ);一个=诊断接头([0,1]);d = (0, 1, 0);socConstraints (2) = secondordercone (A, b, d,γ);一个=诊断接头([0;1/2;1/2]);d = (1, 0, 0); socConstraints(1) = secondordercone(A,b,d,gamma); f = [-1;-2;-4];

解决这个问题,要求双变量以及所有其他的解决方案coneprog输出. .

[x, fval exitflag、输出λ)= coneprog (f, socConstraints);

找到最优解。

检查返回的λ结构。因为唯一的问题约束锥约束检查的soc字段λ结构。

disp (lambda.soc)

1.0 e-05 * 0.0879 0.3002 0.0589

约束有非零的双重价值,说明解决方案的约束是活跃的。

输入参数

全部折叠

`f`- - - - - -系数向量
真正的向量|真正的数组

系数向量,向量指定为一个真正的或真正的数组。代表了目标函数的系数向量f ' * x。假定的符号f是一个列向量,但是您可以使用一个行向量或数组。在内部,coneprog转换f的列向量f (:)。

例子:f = (1、3、5、6)

数据类型:双

`socConstraints`- - - - - -二阶锥约束
向量的`SecondOrderConeConstraint`对象

二阶锥约束条件,指定为矢量SecondOrderConeConstraint对象。创建这些对象使用secondordercone函数。

socConstraints编码的约束

$为 {一个}_{sc} (我) \cdot x - b_{sc} (我) 为 \leq d_{sc}^{T} (我) \cdot x - γ (我)$

数组之间的映射和方程如下:

一个_sc(我)=socConstraints.A(我)
b_sc(我)=socConstraints.b(我)
d_sc(我)=socConstraints.d(我)
γ(我)=socConstraints.gamma(我)

例子:Asc =诊断接头([1 1/2 0]);二元同步通信= 0 (3,1);dsc = [0, 0, 1];γ= 1;socConstraints = secondordercone (Asc, bsc、dsc、伽马);

数据类型:结构体

`一个`- - - - - -线性不等式约束
真正的矩阵

线性不等式约束,指定为一个真正的矩阵。一个是一个米——- - - - - -N矩阵,米不平等的数量,N是变量的数量(长度f)。对于大型问题,通过一个作为一个稀疏矩阵。

一个编码米线性不等式

A * x < =,

在哪里x的列向量N变量x (:),b是一个列向量米元素。

例如,考虑这些不平等:

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

输入以下命令来指定不等式约束条件。

= [1,2,3,4,5,6);b = (10、20、30);

例子:指定的x分量加起来1或更少,一个= 1 (1,N)和b = 1。

数据类型:双

`b`- - - - - -线性不等式约束
真正的向量

线性不等式约束,指定为一个真正的向量。b是一个米元向量相关一个矩阵。如果你通过b作为一个行向量,解决内部转换b的列向量b (:)。对于大型问题,通过b作为一个稀疏的向量。

b编码米线性不等式

A * x < =,

在哪里x的列向量N变量x (:),一个是一个矩阵的大小米——- - - - - -N。

例如,考虑这些不平等:

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

输入以下命令来指定不等式约束条件。

= [1,2,3,4,5,6);b = (10、20、30);

例子:指定的x分量总和为1或更少,使用一个= 1 (1,N)和b = 1。

数据类型:双

`Aeq`- - - - - -线性等式约束
真正的矩阵

线性等式约束,指定为一个真正的矩阵。Aeq是一个我——- - - - - -N矩阵,我是平等的,N是变量的数量(长度f)。对于大型问题,通过Aeq作为一个稀疏矩阵。

Aeq编码我线性等式

Aeq * x =说真的,

在哪里x的列向量N变量x (:),说真的是一个列向量我元素。

例如,考虑这些等式:

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

输入以下命令来指定等式约束。

Aeq = [1、2、3、2、4、1];说真的= (10、20);

例子:指定x分量之和为1,Aeq = 1 (1, N)和说真的= 1。

数据类型:双

`说真的`- - - - - -线性等式约束
真正的向量

线性等式约束,指定为一个真正的向量。说真的是一个我元向量相关Aeq矩阵。如果你通过说真的作为一个行向量,解决内部转换说真的的列向量说真的(:)。对于大型问题,通过说真的作为一个稀疏的向量。

说真的编码我线性等式

Aeq * x =说真的,

在哪里x的列向量N变量x (:),Aeq是一个矩阵的大小我——- - - - - -N。

例如,考虑这些等式:

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

输入以下命令来指定等式约束。

Aeq = [1、2、3、2、4、1];说真的= (10、20);

例子:指定的x分量之和为1,使用Aeq = 1 (1, N)和说真的= 1。

数据类型:双

`磅`- - - - - -下界
真正的向量|真正的数组

下界,指定为一个真正的向量或真正的数组。如果的长度f等于的长度磅,然后磅指定

x(我)> =磅(我)对所有我。

如果元素个数(磅)<元素个数(f),然后磅指定

x(我)> =磅(我)为1我< < = =元素个数(磅)。

在这种情况下,解决者发出警告。

例子:指定,所有的x分量都是积极的,使用磅= 0(大小(f))。

数据类型:双

`乌兰巴托`- - - - - -上界
真正的向量|真正的数组

上界,指定为一个真正的向量或真正的数组。如果的长度f等于的长度乌兰巴托,然后乌兰巴托指定

x (i) < =乌兰巴托(我)对所有我。

如果元素个数(乌兰巴托)<元素个数(f),然后乌兰巴托指定

x (i) < =乌兰巴托(我)为1我< < = =元素个数(乌兰巴托)。

在这种情况下,解决者发出警告。

例子:指定所有的x分量都不到1,使用乌兰巴托= 1(大小(f))。

数据类型:双

`选项`- - - - - -优化选项
的输出`optimoptions`

优化选项,指定的输出optimoptions。

选项	描述
`ConstraintTolerance`	对可行性约束,一个标量`0`通过`1`。`ConstraintTolerance`措施的可行性宽容。默认值是`1 e-6`。
`显示`	显示(见水平迭代显示): `“最后一次”`(默认)只显示最终的输出。 `“通路”`在每一次迭代时显示输出。 `“关闭”`或`“没有”`显示没有输出。
`LinearSolver`	在迭代算法求解一个步骤: `“汽车”`(默认)`coneprog`选择步骤解决。如果问题是稀疏的,步骤解决`“prodchol”`。否则,步骤解决`“增强”`。 `“增强”`——增强形成步骤解决。看到[1]。 `“正常”`——范式步骤解决。看到[1]。 `“prodchol”`柯列斯基一步解算器,产品形式。看到[4]和[5]。 `“舒尔”`-舒尔补充方法步骤解决。看到[2]。如果`“汽车”`不执行,试一试这些建议来吗`LinearSolver`: 如果问题是稀疏的,试一试`“正常”`。如果问题是稀疏一些密集的列或大型锥,试一试`“prodchol”`或`“舒尔”`。如果问题是密集的,使用`“增强”`。一个稀疏的例子,请参阅比较coneprog算法的速度。
`MaxIterations`	最大允许的迭代次数,一个正整数。默认值是`200年`。看到公差和停止条件和迭代和函数计算。
`MaxTime`	最大算法运行时间以秒为单位,一个正数或`正`。默认值是`正`禁用这个停止准则。
`OptimalityTolerance`	终止宽容对偶可行性,积极的标量。默认值是`1 e-6`。

例子:optimoptions (‘coneprog’,‘显示’,‘iter’,‘MaxIterations’, 100)

`问题`- - - - - -问题的结构
结构

问题的结构,与以下字段指定为一个结构。

字段名	条目
`f`	线性目标函数向量`f`
`socConstraints`	结构的二阶锥约束
`Aineq`	矩阵的线性不等式约束
`bineq`	向量的线性不等式约束
`Aeq`	矩阵的线性等式约束
`说真的`	向量的线性等式约束
`磅`	向量的下界
`乌兰巴托`	向量的上界
`解算器`	`“coneprog”`
`选项`	选择创建`optimoptions`

数据类型:结构体

输出参数

全部折叠

`x`——解决方案
真正的向量|数组

解决方案,作为真正的向量或返回数组。的大小x是一样的尺寸吗f。的x输出时是空的exitflag值是-2,3,或者,10。

`fval`——目标函数值的解决方案
实数

目标函数值的解决方案,作为一个实数返回。一般来说,fval=f ' * x。的fval输出时是空的exitflag值是-2,3,或者,10。

`exitflag`- - -原因`coneprog`停止
整数

原因coneprog停止,返回一个整数。

价值	描述
`1`	功能融合到一个解决方案`x`。
`0`	迭代的数量超过了`options.MaxIterations`在几秒钟内,或者解决方案时间超过`options.MaxTime`。
`2`	没有找到可行点。
`3`	问题是无限的。
`7`	搜索方向变得太小了。不可能取得进一步进展。
`-10年`	问题是数值不稳定。

提示

如果你退出旗0,7,或-10年,尝试使用不同的值LinearSolver选择。

`输出`——优化过程的信息
结构

优化过程的信息,作为一个结构返回这些字段。

场	描述
`算法`	优化算法
`dualfeasibility`	最大的双重约束违反
`dualitygap`	二元性的差距
`迭代`	的迭代次数
`消息`	退出消息
`primalfeasibility`	最大的约束违反
`linearsolver`	内部步骤规划求解算法

的输出字段dualfeasibility,dualitygap,primalfeasibility是空的时exitflag值是2、3、或-10年。

`λ`解决方案——双变量
结构

双变量的解决方案,作为结构返回这些字段。

场	描述
`较低的`	下界对应`磅`
`上`	上界对应`乌兰巴托`
`ineqlin`	线性不等式对应`一个`和`b`
`eqlin`	线性等式对应`Aeq`和`说真的`
`soc`	二阶锥约束对应`socConstraints`

λ是空的([])当exitflag值是-2,3,或者,10。

拉格朗日乘数法(双变量)下列拉格朗日的一部分,这是固定的(零梯度)在一个解决方案:

$\begin{array}{l} f^{T} x + \sum_{我} λ_{soc} (我) (d_{soc}^{T} (我) x - γ (我) - 为 {一个}_{soc} (我) x - b_{soc} (我) 为) \\ + λ_{ineqlin}^{T} (b - 一个 x) + λ_{eqlin}^{T} (Aeq x - 说真的) + λ_{上}^{T} (乌兰巴托 - x) + λ_{较低的}^{T} (x - 磅) 。 \end{array}$

用的不平等条款λ字段是负的。

算法

该算法使用一个内点法。有关详细信息,请参见二阶锥规划算法。

选择功能

应用程序

的优化住编辑任务提供了一个可视化界面coneprog。

版本历史

介绍了R2020b

全部展开

R2021a:两个`coneprogλ`结构重命名

行为改变R2021a

的coneprogλ输出参数字段lambda.eq和lambda.ineq已经更名为lambda.eqlin和lambda.ineqlin,分别。这种变化导致coneprogλ结构字段具有相同的名称作为相应的字段在其他解决方案。

另请参阅

linprog|quadprog|secondordercone|SecondOrderConeConstraint|优化

coneprog

语法

描述

例子

单锥约束

几个锥约束

与线性约束锥的编程

锥编程非默认选项

锥结构编程问题

检查`coneprog`解决方案的过程

获得`coneprog`双变量

输入参数

`f`- - - - - -系数向量
真正的向量|真正的数组

`socConstraints`- - - - - -二阶锥约束
向量的`SecondOrderConeConstraint`对象

`一个`- - - - - -线性不等式约束
真正的矩阵

`b`- - - - - -线性不等式约束
真正的向量

`Aeq`- - - - - -线性等式约束
真正的矩阵

`说真的`- - - - - -线性等式约束
真正的向量

`磅`- - - - - -下界
真正的向量|真正的数组

`乌兰巴托`- - - - - -上界
真正的向量|真正的数组

`选项`- - - - - -优化选项
的输出`optimoptions`

`问题`- - - - - -问题的结构
结构

输出参数

`x`——解决方案
真正的向量|数组

`fval`——目标函数值的解决方案
实数

`exitflag`- - -原因`coneprog`停止
整数

`输出`——优化过程的信息
结构

`λ`解决方案——双变量
结构

更多关于

二阶锥约束

算法

选择功能

应用程序

版本历史

R2021a:两个`coneprogλ`结构重命名

另请参阅

主题

coneprog

语法

描述

例子

单锥约束

几个锥约束

与线性约束锥的编程

锥编程非默认选项

锥结构编程问题

检查coneprog解决方案的过程

获得coneprog双变量

输入参数

f- - - - - -系数向量真正的向量|真正的数组

socConstraints- - - - - -二阶锥约束向量的SecondOrderConeConstraint对象

一个- - - - - -线性不等式约束真正的矩阵

b- - - - - -线性不等式约束真正的向量

Aeq- - - - - -线性等式约束真正的矩阵

说真的- - - - - -线性等式约束真正的向量

磅- - - - - -下界真正的向量|真正的数组

乌兰巴托- - - - - -上界真正的向量|真正的数组

选项- - - - - -优化选项的输出optimoptions

问题- - - - - -问题的结构结构

输出参数

x——解决方案真正的向量|数组

fval——目标函数值的解决方案实数

exitflag- - -原因coneprog停止整数

输出——优化过程的信息结构

λ解决方案——双变量结构

更多关于

二阶锥约束

算法

选择功能

应用程序

版本历史

R2021a:两个coneprogλ结构重命名

另请参阅

主题

检查`coneprog`解决方案的过程

获得`coneprog`双变量

`f`- - - - - -系数向量
真正的向量|真正的数组

`socConstraints`- - - - - -二阶锥约束
向量的`SecondOrderConeConstraint`对象

`一个`- - - - - -线性不等式约束
真正的矩阵

`b`- - - - - -线性不等式约束
真正的向量

`Aeq`- - - - - -线性等式约束
真正的矩阵

`说真的`- - - - - -线性等式约束
真正的向量

`磅`- - - - - -下界
真正的向量|真正的数组

`乌兰巴托`- - - - - -上界
真正的向量|真正的数组

`选项`- - - - - -优化选项
的输出`optimoptions`

`问题`- - - - - -问题的结构
结构

`x`——解决方案
真正的向量|数组

`fval`——目标函数值的解决方案
实数

`exitflag`- - -原因`coneprog`停止
整数

`输出`——优化过程的信息
结构

`λ`解决方案——双变量
结构

R2021a:两个`coneprogλ`结构重命名