Документация

sol = solve(prob) решает задачу оптимизации или задачу уравнения prob.

sol = solve(prob,x0) решает prob начиная с точки x0.

sol = solve(___,Name,Value) изменяет процесс решения, используя один или несколько аргументов пары имя-значение в дополнение к входным аргументам в предыдущих синтаксисах.

[sol,fval] = solve(___) также возвращает значение целевой функции в решении, используя любой из входных аргументов в предыдущих синтаксисах.

[sol,fval,exitflag,output,lambda] = solve(___) также возвращает флаг выхода, описывающий условие выхода, output структура, содержащая дополнительную информацию о процессе решения, и, для задач, не связанных с целочисленной оптимизацией, структура множителя Лагранжа.

Примеры

Решение проблемы линейного программирования

Решение задачи линейного программирования, определяемой задачей оптимизации.

x = optimvar('x');
y = optimvar('y');
prob = optimproblem;
prob.Objective = -x - y/3;
prob.Constraints.cons1 = x + y <= 2;
prob.Constraints.cons2 = x + y/4 <= 1;
prob.Constraints.cons3 = x - y <= 2;
prob.Constraints.cons4 = x/4 + y >= -1;
prob.Constraints.cons5 = x + y >= 1;
prob.Constraints.cons6 = -x + y <= 2;

sol = solve(prob)

Solving problem using linprog.

Optimal solution found.

sol = struct with fields:
    x: 0.6667
    y: 1.3333

Решение проблемы нелинейного программирования с использованием проблемного подхода

Найти минимум peaks функция, включенная в MATLAB ®, в регионе $^{}^{}$ x2+y2≤4. Для этого создайте переменные оптимизацииx и y.

x = optimvar('x');
y = optimvar('y');

Создать проблему оптимизации, имеющую peaks в качестве целевой функции.

prob = optimproblem("Objective",peaks(x,y));

Включите ограничение как неравенство в переменные оптимизации.

prob.Constraints = x^2 + y^2 <= 4;

Задать начальную точку для x в 1 и y до -1 и решить проблему.

x0.x = 1;
x0.y = -1;
sol = solve(prob,x0)

Solving problem using fmincon.

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.

sol = struct with fields:
    x: 0.2283
    y: -1.6255

Неподдерживаемые функции требуют fcn2optimexpr

Если целевые или нелинейные функции ограничения не полностью состоят из элементарных функций, необходимо преобразовать функции в выражения оптимизации с помощью fcn2optimexpr. См. раздел Преобразование нелинейной функции в выражение оптимизации и поддерживаемые операции с переменными и выражениями оптимизации.

Чтобы преобразовать данный пример:

convpeaks = fcn2optimexpr(@peaks,x,y);
prob.Objective = convpeaks;
sol2 = solve(prob,x0)

Solving problem using fmincon.

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.

sol2 = struct with fields:
    x: 0.2283
    y: -1.6255

Авторское право 2018-2020 The MathWorks, Inc.

Решение смешанно-целочисленной линейной программы, начинающейся с начальной точки

Сравните количество шагов для решения задачи целочисленного программирования как с начальной возможной точкой, так и без нее. Задача имеет восемь целых переменных и четыре линейных ограничения равенства, и все переменные ограничены положительными.

prob = optimproblem;
x = optimvar('x',8,1,'LowerBound',0,'Type','integer');

Создайте четыре линейных ограничения равенства и включите их в задачу.

Aeq = [22    13    26    33    21     3    14    26
    39    16    22    28    26    30    23    24
    18    14    29    27    30    38    26    26
    41    26    28    36    18    38    16    26];
beq = [ 7872
       10466
       11322
       12058];
cons = Aeq*x == beq;
prob.Constraints.cons = cons;

Создайте целевую функцию и включите ее в задачу.

f = [2    10    13    17     7     5     7     3];
prob.Objective = f*x;

Решите проблему, не используя начальную точку, и проверьте отображение, чтобы увидеть количество узлов, связанных ветвями.

[x1,fval1,exitflag1,output1] = solve(prob);

Solving problem using intlinprog.
LP:                Optimal objective value is 1554.047531.                                          

Cut Generation:    Applied 8 strong CG cuts.                                                        
                   Lower bound is 1591.000000.                                                      

Branch and Bound:

   nodes     total   num int        integer       relative                                          
explored  time (s)  solution           fval        gap (%)                                         
   10000      0.76         0              -              -                                          
   18027      1.40         1   2.906000e+03   4.509804e+01                                          
   21859      1.80         2   2.073000e+03   2.270974e+01                                          
   23546      1.96         3   1.854000e+03   1.180593e+01                                          
   24121      2.01         3   1.854000e+03   1.563342e+00                                          
   24294      2.02         3   1.854000e+03   0.000000e+00                                          

Optimal solution found.

Intlinprog stopped because the objective value is within a gap tolerance of the
optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon
variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the
default value).

Для сравнения найдите решение, используя начальную осуществимую точку.

x0.x = [8 62 23 103 53 84 46 34]';
[x2,fval2,exitflag2,output2] = solve(prob,x0);

Solving problem using intlinprog.
LP:                Optimal objective value is 1554.047531.                                          

Cut Generation:    Applied 8 strong CG cuts.                                                        
                   Lower bound is 1591.000000.                                                      
                   Relative gap is 59.20%.                                                         

Branch and Bound:

   nodes     total   num int        integer       relative                                          
explored  time (s)  solution           fval        gap (%)                                         
    3627      0.39         2   2.154000e+03   2.593968e+01                                          
    5844      0.60         3   1.854000e+03   1.180593e+01                                          
    6204      0.64         3   1.854000e+03   1.455526e+00                                          
    6400      0.65         3   1.854000e+03   0.000000e+00                                          

Optimal solution found.

Intlinprog stopped because the objective value is within a gap tolerance of the
optimal value, options.AbsoluteGapTolerance = 0 (the default value). The intcon
variables are integer within tolerance, options.IntegerTolerance = 1e-05 (the
default value).

fprintf('Without an initial point, solve took %d steps.\nWith an initial point, solve took %d steps.',output1.numnodes,output2.numnodes)

Without an initial point, solve took 24294 steps.
With an initial point, solve took 6400 steps.

Указание начальной точки не всегда улучшает проблему. Для этой проблемы использование начальной точки экономит время и вычислительные шаги. Однако для некоторых проблем начальная точка может вызвать solve предпринять дополнительные шаги.

Решение проблемы с целочисленным программированием с помощью параметров Nondefault

Решить проблему

$\underset{minx}{} (-_{}_{}_{} 3x1-2x2-x3) \begin{array}{llllllllllllllllllll} _{} \\ _{}_{} \\ _{}_{}_{} \\ _{}_{}_{} \end{array}$ subjectto{x3binaryx1,x2≥0x1+x2+x3≤74x1+2x2+x3=12

без отображения итеративного дисплея.

x = optimvar('x',2,1,'LowerBound',0);
x3 = optimvar('x3','Type','integer','LowerBound',0,'UpperBound',1);
prob = optimproblem;
prob.Objective = -3*x(1) - 2*x(2) - x3;
prob.Constraints.cons1 = x(1) + x(2) + x3 <= 7;
prob.Constraints.cons2 = 4*x(1) + 2*x(2) + x3 == 12;

options = optimoptions('intlinprog','Display','off');

sol = solve(prob,'Options',options)

sol = struct with fields:
     x: [2x1 double]
    x3: 1

Осмотрите решение.

sol.x

sol.x3

ans = 1

Использовать `intlinprog` Решение линейной программы

Сила solve использовать intlinprog в качестве решателя для задачи линейного программирования.

x = optimvar('x');
y = optimvar('y');
prob = optimproblem;
prob.Objective = -x - y/3;
prob.Constraints.cons1 = x + y <= 2;
prob.Constraints.cons2 = x + y/4 <= 1;
prob.Constraints.cons3 = x - y <= 2;
prob.Constraints.cons4 = x/4 + y >= -1;
prob.Constraints.cons5 = x + y >= 1;
prob.Constraints.cons6 = -x + y <= 2;

sol = solve(prob,'Solver', 'intlinprog')

Solving problem using intlinprog.
LP:                Optimal objective value is -1.111111.                                            


Optimal solution found.

No integer variables specified. Intlinprog solved the linear problem.

sol = struct with fields:
    x: 0.6667
    y: 1.3333

Вернуть все выходы

Решите проблему линейного программирования со смешанными целыми числами, описанную в разделе Решение проблемы программирования целочисленными числами с помощью опций Nondefault, и изучите все выходные данные.

x = optimvar('x',2,1,'LowerBound',0);
x3 = optimvar('x3','Type','integer','LowerBound',0,'UpperBound',1);
prob = optimproblem;
prob.Objective = -3*x(1) - 2*x(2) - x3;
prob.Constraints.cons1 = x(1) + x(2) + x3 <= 7;
prob.Constraints.cons2 = 4*x(1) + 2*x(2) + x3 == 12;

[sol,fval,exitflag,output] = solve(prob)

Solving problem using intlinprog.
LP:                Optimal objective value is -12.000000.                                           


Optimal solution found.

Intlinprog stopped at the root node because the objective value is within a gap
tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default
value). The intcon variables are integer within tolerance,
options.IntegerTolerance = 1e-05 (the default value).

sol = struct with fields:
     x: [2x1 double]
    x3: 1

fval = -12

exitflag = 
    OptimalSolution

output = struct with fields:
        relativegap: 0
        absolutegap: 0
      numfeaspoints: 1
           numnodes: 0
    constrviolation: 0
            message: 'Optimal solution found....'
             solver: 'intlinprog'

Для задачи без целочисленных ограничений можно также получить непустую структуру множителя Лагранжа в качестве пятого вывода.

Просмотр решения с индексными переменными

Создание и решение задачи оптимизации с использованием именованных индексных переменных. Проблема заключается в максимальном увеличении взвешенного по прибыли потока фруктов в различные аэропорты с учетом ограничений на взвешенные потоки.

rng(0) % For reproducibility
p = optimproblem('ObjectiveSense', 'maximize');
flow = optimvar('flow', ...
    {'apples', 'oranges', 'bananas', 'berries'}, {'NYC', 'BOS', 'LAX'}, ...
    'LowerBound',0,'Type','integer');
p.Objective = sum(sum(rand(4,3).*flow));
p.Constraints.NYC = rand(1,4)*flow(:,'NYC') <= 10;
p.Constraints.BOS = rand(1,4)*flow(:,'BOS') <= 12;
p.Constraints.LAX = rand(1,4)*flow(:,'LAX') <= 35;
sol = solve(p);

Solving problem using intlinprog.
LP:                Optimal objective value is -1027.472366.                                         

Heuristics:        Found 1 solution using ZI round.                                                 
                   Upper bound is -1027.233133.                                                     
                   Relative gap is 0.00%.                                                          


Optimal solution found.

Intlinprog stopped at the root node because the objective value is within a gap
tolerance of the optimal value, options.AbsoluteGapTolerance = 0 (the default
value). The intcon variables are integer within tolerance,
options.IntegerTolerance = 1e-05 (the default value).

Найдите оптимальный поток апельсинов и ягод в Нью-Йорк и Лос-Анджелес.

[idxFruit,idxAirports] = findindex(flow, {'oranges','berries'}, {'NYC', 'LAX'})

idxFruit = 1×2

     2     4

idxAirports = 1×2

     1     3

orangeBerries = sol.flow(idxFruit, idxAirports)

orangeBerries = 2×2

         0  980.0000
   70.0000         0

Этот дисплей означает, что апельсины не собираются NYC, 70 ягод собираются NYC, 980 апельсинов собираются LAX, и никакие ягоды не собираются LAX.

Перечислите оптимальный поток:

Fruit Airports

----- --------

Berries NYC

Apples BOS

Oranges LAX

idx = findindex(flow, {'berries', 'apples', 'oranges'}, {'NYC', 'BOS', 'LAX'})

idx = 1×3

     4     5    10

optimalFlow = sol.flow(idx)

optimalFlow = 1×3

   70.0000   28.0000  980.0000

Этот дисплей означает, что 70 ягод собираются NYC, 28 яблок собираются BOS, и 980 апельсинов собираются LAX.

Решение нелинейной системы уравнений на основе задач

См. раздел Поддерживаемые операции с переменными и выражениями оптимизации и преобразование нелинейной функции в выражение оптимизации.

Для решения нелинейной системы уравнений

$\begin{array}{l} \exp (- exp {(-}_{} (_{x1} + {x2}_{)})) =_{}^{} x2 \\ _{(} 1 +_{} x12)_{} x1cos_{(} x2 \frac{)}{} \end{array}$ + x2sin (x1) = 12

используя проблемный подход, сначала определите x как двухэлементная переменная оптимизации.

x = optimvar('x',2);

Создайте первое уравнение как выражение равенства оптимизации.

eq1 = exp(-exp(-(x(1) + x(2)))) == x(2)*(1 + x(1)^2);

Аналогично, создайте второе уравнение как выражение равенства оптимизации.

eq2 = x(1)*cos(x(2)) + x(2)*sin(x(1)) == 1/2;

Создайте задачу уравнения и поместите ее в задачу.

prob = eqnproblem;
prob.Equations.eq1 = eq1;
prob.Equations.eq2 = eq2;

Просмотрите проблему.

show(prob)

  EquationProblem : 

	Solve for:
       x


 eq1:
       exp(-exp(-(x(1) + x(2)))) == (x(2) .* (1 + x(1).^2))

 eq2:
       ((x(1) .* cos(x(2))) + (x(2) .* sin(x(1)))) == 0.5

Решение проблемы начиная с точки [0,0]. Для подхода, основанного на проблемах, укажите начальную точку как структуру, а имена переменных - как поля структуры. Для этой задачи существует только одна переменная, x.

x0.x = [0 0];
[sol,fval,exitflag] = solve(prob,x0)

Solving problem using fsolve.

Equation solved.

fsolve completed because the vector of function values is near zero
as measured by the value of the function tolerance, and
the problem appears regular as measured by the gradient.

sol = struct with fields:
    x: [2x1 double]

fval = struct with fields:
    eq1: -2.4070e-07
    eq2: -3.8255e-08

exitflag = 
    EquationSolved

Просмотрите точку решения.

disp(sol.x)

    0.3532
    0.6061

Неподдерживаемые функции требуют fcn2optimexpr

Если функции уравнений не состоят из элементарных функций, необходимо преобразовать функции в выражения оптимизации с помощью fcn2optimexpr. Для настоящего примера:

ls1 = fcn2optimexpr(@(x)exp(-exp(-(x(1)+x(2)))),x);
eq1 = ls1 == x(2)*(1 + x(1)^2);
ls2 = fcn2optimexpr(@(x)x(1)*cos(x(2))+x(2)*sin(x(1)),x);
eq2 = ls2 == 1/2;

Входные аргументы

`prob` - Задача оптимизации или задача уравнения
`OptimizationProblem` объект | `EquationProblem` объект

Задача оптимизации или задача уравнения, указанная как OptimizationProblem объект или EquationProblem объект. Создание проблемы оптимизации с помощью optimproblem; создать задачу уравнения с помощью eqnproblem.

Предупреждение

Проблемный подход не поддерживает комплексные значения в целевой функции, нелинейные равенства или нелинейные неравенства. Если вычисление функции имеет комплексное значение, даже в качестве промежуточного значения, конечный результат может быть неверным.

Пример: prob = optimproblem; prob.Objective = obj; prob.Constraints.cons1 = cons1;

Пример: prob = eqnproblem; prob.Equations = eqs;

`x0` - Начальная точка
структура

Начальная точка, заданная как структура с именами полей, равными именам переменных в prob.

Для примера использования x0 с именованными индексными переменными см. раздел Создание начальной точки для оптимизации с именованными индексными переменными.

Пример: Если prob имеет переменные с именем x и y: x0.x = [3,2,17]; x0.y = [pi/3,2*pi/3].

Типы данных: struct

Аргументы пары «имя-значение»

Укажите дополнительные пары, разделенные запятыми Name,Value аргументы. Name является именем аргумента и Value - соответствующее значение. Name должен отображаться внутри кавычек. Можно указать несколько аргументов пары имен и значений в любом порядке как Name1,Value1,...,NameN,ValueN.

Пример: solve(prob,'options',opts)

`'options'` - Варианты оптимизации
объект, созданный `optimoptions` | структура опций

Опции оптимизации, указанные как пара, разделенная запятыми, состоящая из 'options' и объект, созданный optimoptions или структура опций, например, созданная optimset.

Внутри, solve функция вызывает соответствующий решатель, как подробно описано в 'solver' ссылка на аргумент. Убедитесь, что options совместим с решателем. Например, intlinprog не позволяет опциям быть структурой, и lsqnonneg не позволяет опциям быть объектом.

Для получения предложений по параметрам настройки для улучшения intlinprog или скорость решения, см. раздел Настройка целочисленного линейного программирования. Для linprog, значение по умолчанию 'dual-simplex' алгоритм, как правило, эффективен с точки зрения памяти и быстр. Иногда, linprog решает большую проблему быстрее, когда Algorithm опция - 'interior-point'. Рекомендации по настройке параметров для улучшения решения нелинейной проблемы см. в разделе Часто используемые параметры: настройка и устранение неполадок и улучшение результатов.

Пример: options = optimoptions('intlinprog','Display','none')

`'solver'` - Решатель оптимизации
`'intlinprog'` | `'linprog'` | `'lsqlin'` | `'lsqcurvefit'` | `'lsqnonlin'` | `'lsqnonneg'` | `'quadprog'` | `'fminunc'` | `'fmincon'` | `'fzero'` | `'fsolve'`

Решатель оптимизации, указанный как пара, разделенная запятыми, состоящая из 'solver' и имя перечисленного решателя. Для задач оптимизации эта таблица содержит доступные решатели для каждого типа задач.

Тип проблемы	Решатель по умолчанию	Другие разрешенные решатели
Линейный объект, линейные ограничения	`linprog`	`intlinprog`, `quadprog`, `fmincon`, `fminunc` (`fminunc` не рекомендуется, поскольку неограниченные линейные программы являются постоянными или неограниченными)
Линейные целевые, линейные и целочисленные ограничения	`intlinprog`	`linprog` (целочисленные ограничения игнорируются)
Квадратичный объект, линейные ограничения	`quadprog`	`fmincon`, `fminunc` (без ограничений)
Линейный объект, необязательные линейные ограничения и конические ограничения формы `norm(linear expression) + constant <= linear expression` или `sqrt(sum of squares) + constant <= linear expression`	`coneprog`	`fmincon`
Минимизация \| \| C * x - d \| \| ^ 2 с учетом линейных ограничений	`lsqlin` когда цель является константой плюс сумма квадратов линейных выражений	`quadprog`, `lsqnonneg` (Ограничения, отличные от x > = 0, игнорируются для`lsqnonneg`), `fmincon`, `fminunc` (без ограничений)
Минимизировать \| \| C * x - d \| \| ^ 2 при условии x > = 0	`lsqlin`	`quadprog`, `lsqnonneg`
Минимизировать `sum(e(i).^2)`, где `e(i)` - выражение оптимизации, подчиненное ограничивающим ограничениям	`lsqnonlin` когда цель имеет форму, приведенную в Запись целевой функции для наименьших квадратов, основанных на проблемах	`lsqcurvefit`, `fmincon`, `fminunc` (без ограничений)
Минимизация общей нелинейной функции f (x)	`fminunc`	`fmincon`
Минимизация общей нелинейной функции f (x) с некоторыми ограничениями или минимизация любой функции с нелинейными ограничениями	`fmincon`	Ничего

Примечание

При выборе lsqcurvefit в качестве решателя для задачи наименьших квадратов, solve использование lsqnonlin. lsqcurvefit и lsqnonlin решатели идентичны для solve.

Внимание

Для задач максимизации (prob.ObjectiveSense является "max" или "maximize"), не указывайте решатель наименьших квадратов (с именем, начинающимся lsq). Если вы это сделаете, solve выдает ошибку, поскольку эти решатели не могут максимизировать.

Для решения уравнений эта таблица содержит доступные решатели для каждого типа задачи. В таблице,

* указывает решатель по умолчанию для типа проблемы.
Y обозначает доступный решатель.
N указывает на недоступный решатель.

Поддерживаемые решатели для уравнений

Тип уравнения	`lsqlin`	`lsqnonneg`	`fzero`	`fsolve`	`lsqnonlin`
Линейный	*	N	Y (только скаляр)	Y	Y
Линейные плюс границы	*	Y	N	N	Y
Скалярный нелинейный	N	N	*	Y	Y
Нелинейная система	N	N	N	*	Y
Нелинейная система плюс границы	N	N	N	N	*

Пример: 'intlinprog'

Типы данных: char | string

`'ObjectiveDerivative'` - Индикация использования автоматического дифференцирования для целевой функции
`'auto'` (по умолчанию) | `'auto-forward'` | `'auto-reverse'` | `'finite-differences'`

Указание на использование автоматического дифференцирования (AD) для нелинейной целевой функции, определяемой как разделенная запятыми пара, состоящая из 'ObjectiveDerivative' и 'auto' (используйте AD, если возможно), 'auto-forward' (используйте прямой AD, если это возможно), 'auto-reverse' (используйте обратный AD, если возможно), или 'finite-differences' (не используйте AD). Выбор, включая auto заставить основной решатель использовать информацию о градиенте при решении задачи при условии поддержки целевой функции, как описано в разделе Поддерживаемые операции с переменными и выражениями оптимизации. Пример см. в разделе Эффект автоматического дифференцирования в оптимизации на основе проблем.

Решатели по умолчанию выбирают следующий тип AD:

Для общей нелинейной целевой функции fmincon по умолчанию для целевой функции используется обратный AD. fmincon По умолчанию для функции нелинейных ограничений используется обратная AD, если число нелинейных ограничений меньше числа переменных. В противном случае fmincon по умолчанию пересылает AD для функции нелинейных ограничений.
Для общей нелинейной целевой функции fminunc по умолчанию используется обратный AD.
Для целевой функции наименьших квадратов fmincon и fminunc по умолчанию пересылать AD для целевой функции. Определение целевой функции наименьших квадратов на основе задачи см. в разделе Запись целевой функции для наименьших квадратов на основе задачи.
lsqnonlin по умолчанию пересылается AD, если число элементов в целевом векторе больше или равно числу переменных. В противном случае lsqnonlin по умолчанию используется обратный AD.
fsolve по умолчанию пересылается AD, если число уравнений больше или равно числу переменных. В противном случае fsolve по умолчанию используется обратный AD.

Пример: 'finite-differences'

Типы данных: char | string

`'ConstraintDerivative'` - Указание на использование автоматического дифференцирования для функций ограничения
`'auto'` (по умолчанию) | `'auto-forward'` | `'auto-reverse'` | `'finite-differences'`

Указание на использование автоматического дифференцирования (AD) для нелинейных функций ограничения, указанных как разделенная запятыми пара, состоящая из 'ConstraintDerivative' и 'auto' (используйте AD, если возможно), 'auto-forward' (используйте прямой AD, если это возможно), 'auto-reverse' (используйте обратный AD, если возможно), или 'finite-differences' (не используйте AD). Выбор, включая auto заставить основной решатель использовать информацию о градиенте при решении проблемы при условии поддержки функций ограничения, как описано в разделе Поддерживаемые операции с переменными и выражениями оптимизации. Пример см. в разделе Эффект автоматического дифференцирования в оптимизации на основе проблем.

Решатели по умолчанию выбирают следующий тип AD:

Для общей нелинейной целевой функции fmincon по умолчанию для целевой функции используется обратный AD. fmincon По умолчанию для функции нелинейных ограничений используется обратная AD, если число нелинейных ограничений меньше числа переменных. В противном случае fmincon по умолчанию пересылает AD для функции нелинейных ограничений.
Для общей нелинейной целевой функции fminunc по умолчанию используется обратный AD.
Для целевой функции наименьших квадратов fmincon и fminunc по умолчанию пересылать AD для целевой функции. Определение целевой функции наименьших квадратов на основе задачи см. в разделе Запись целевой функции для наименьших квадратов на основе задачи.
lsqnonlin по умолчанию пересылается AD, если число элементов в целевом векторе больше или равно числу переменных. В противном случае lsqnonlin по умолчанию используется обратный AD.
fsolve по умолчанию пересылается AD, если число уравнений больше или равно числу переменных. В противном случае fsolve по умолчанию используется обратный AD.

Пример: 'finite-differences'

Типы данных: char | string

`'EquationDerivative'` - Указание использования автоматического дифференцирования для уравнений
`'auto'` (по умолчанию) | `'auto-forward'` | `'auto-reverse'` | `'finite-differences'`

Указание на использование автоматического дифференцирования (AD) для нелинейных функций ограничения, указанных как разделенная запятыми пара, состоящая из 'EquationDerivative' и 'auto' (используйте AD, если возможно), 'auto-forward' (используйте прямой AD, если это возможно), 'auto-reverse' (используйте обратный AD, если возможно), или 'finite-differences' (не используйте AD). Выбор, включая auto заставить основной решатель использовать информацию о градиенте при решении задачи при условии поддержки функций уравнений, как описано в разделе Поддерживаемые операции с переменными и выражениями оптимизации. Пример см. в разделе Эффект автоматического дифференцирования в оптимизации на основе проблем.

Решатели по умолчанию выбирают следующий тип AD:

Для общей нелинейной целевой функции fmincon по умолчанию для целевой функции используется обратный AD. fmincon По умолчанию для функции нелинейных ограничений используется обратная AD, если число нелинейных ограничений меньше числа переменных. В противном случае fmincon по умолчанию пересылает AD для функции нелинейных ограничений.
Для общей нелинейной целевой функции fminunc по умолчанию используется обратный AD.
Для целевой функции наименьших квадратов fmincon и fminunc по умолчанию пересылать AD для целевой функции. Определение целевой функции наименьших квадратов на основе задачи см. в разделе Запись целевой функции для наименьших квадратов на основе задачи.
lsqnonlin по умолчанию пересылается AD, если число элементов в целевом векторе больше или равно числу переменных. В противном случае lsqnonlin по умолчанию используется обратный AD.
fsolve по умолчанию пересылается AD, если число уравнений больше или равно числу переменных. В противном случае fsolve по умолчанию используется обратный AD.

Пример: 'finite-differences'

Типы данных: char | string

Выходные аргументы

`sol` - Решение
структура

Решение, возвращенное как структура. Поля структуры являются именами переменных оптимизации. Посмотрите optimvar.

`fval` - Значение целевой функции при решении
вещественное число | вещественный вектор

Значение целевой функции в решении, возвращаемое как вещественное число, или, для систем уравнений, вещественный вектор. Для задач наименьших квадратов fval - сумма квадратов остатков в решении. Для задач решения уравнений fval - значение функции в решении, означающее левую сторону минус правую сторону уравнений.

Совет

Если вы пренебрегаете просить fval для задачи оптимизации ее можно вычислить с помощью:

fval = evaluate(prob.Objective,sol)

`exitflag` - Решатель причин остановлен
переменная перечисления

Причина остановки решателя, возвращаемого в качестве переменной перечисления. Можно преобразовать exitflag к его числовому эквиваленту с использованием double(exitflag)и к его строковому эквиваленту с использованием string(exitflag).

В этой таблице описываются флаги выхода для intlinprog решатель.

Флаг выхода для `intlinprog`	Числовой эквивалент	Значение
`OptimalWithPoorFeasibility`	`3`	Решение возможно по отношению к родственнику `ConstraintTolerance` допуск, но не осуществим в отношении абсолютного допуска.
`IntegerFeasible`	2	`intlinprog` преждевременно остановилась и нашла целую возможную точку.
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	`intlinprog` превышает один из следующих допусков: `LPMaxIterations` `MaxNodes` `MaxTime` `RootLPMaxIterations` См. раздел Допуски и критерии остановки. `solve` также возвращает этот флаг выхода, когда на корневом узле не хватает памяти.
`OutputFcnStop`	`-1`	`intlinprog` останавливается функцией вывода или функцией графика.
`NoFeasiblePointFound`	`-2`	Выполнимая точка не найдена.
`Unbounded`	`-3`	Проблема безгранична.
`FeasibilityLost`	`-9`	Решатель потерял выполнимость.

Exitflags 3 и -9 относятся к решениям, имеющим большие несходимости. Они обычно возникают из матриц линейных ограничений, которые имеют большое число условий, или проблем, которые имеют большие компоненты решения. Чтобы исправить эти проблемы, попробуйте масштабировать матрицы коэффициентов, устранить избыточные линейные ограничения или установить более жесткие границы для переменных.

В этой таблице описываются флаги выхода для linprog решатель.

Флаг выхода для `linprog`	Числовой эквивалент	Значение
`OptimalWithPoorFeasibility`	`3`	Решение возможно по отношению к родственнику `ConstraintTolerance` допуск, но не осуществим в отношении абсолютного допуска.
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations`.
`NoFeasiblePointFound`	`-2`	Выполнимая точка не найдена.
`Unbounded`	`-3`	Проблема безгранична.
`FoundNaN`	`-4`	`NaN` значение, обнаруженное при выполнении алгоритма.
`PrimalDualInfeasible`	`-5`	Как первичные, так и двойственные проблемы неосуществимы.
`DirectionTooSmall`	`-7`	Направление поиска слишком мало. Дальнейшего прогресса достичь не удастся.
`FeasibilityLost`	`-9`	Решатель потерял выполнимость.

В этой таблице описываются флаги выхода для lsqlin решатель.

Флаг выхода для `lsqlin`	Числовой эквивалент	Значение
`FunctionChangeBelowTolerance`	`3`	Изменение остатка меньше указанного допуска `options.FunctionTolerance`. (`trust-region-reflective` алгоритм)
`StepSizeBelowTolerance`	`2`	Размер шага меньше `options.StepTolerance`, ограничения удовлетворены. (`interior-point` алгоритм)
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations`.
`NoFeasiblePointFound`	`-2`	Для задач оптимизации проблема неосуществима. Или, для `interior-point` алгоритм, размер шага меньше `options.StepTolerance`, но ограничения не удовлетворяются. Для задач уравнений решение не найдено.
`IllConditioned`	`-4`	Неправильное кондиционирование предотвращает дальнейшую оптимизацию.
`NoDescentDirectionFound`	`-8`	Направление поиска слишком мало. Дальнейшего прогресса достичь не удастся. (`interior-point` алгоритм)

В этой таблице описываются флаги выхода для quadprog решатель.

Флаг выхода для `quadprog`	Числовой эквивалент	Значение
`LocalMinimumFound`	`4`	Найден локальный минимум; минимум не уникален.
`FunctionChangeBelowTolerance`	`3`	Изменение значения целевой функции меньше указанного допуска `options.FunctionTolerance`. (`trust-region-reflective` алгоритм)
`StepSizeBelowTolerance`	`2`	Размер шага меньше `options.StepTolerance`, ограничения удовлетворены. (`interior-point-convex` алгоритм)
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations`.
`NoFeasiblePointFound`	`-2`	Проблема неосуществима. Или, для `interior-point` алгоритм, размер шага меньше `options.StepTolerance`, но ограничения не удовлетворяются.
`IllConditioned`	`-4`	Неправильное кондиционирование предотвращает дальнейшую оптимизацию.
`Nonconvex`	`-6`	Обнаружена неконвексная проблема. (`interior-point-convex` алгоритм)
`NoDescentDirectionFound`	`-8`	Не удалось вычислить направление шага. (`interior-point-convex` алгоритм)

В этой таблице описываются флаги выхода для coneprog решатель.

Флаг выхода для `coneprog`	Числовой эквивалент	Значение
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations`или превышено время решения в секундах `options.MaxTime`.
`NoFeasiblePointFound`	`-2`	Проблема неосуществима.
`Unbounded`	`-3`	Проблема безгранична.
`DirectionTooSmall`	`-7`	Направление поиска стало слишком маленьким. Дальнейшего прогресса достичь не удалось.
`Unstable`	`-10`	Проблема численно нестабильна.

В этой таблице описываются флаги выхода для lsqcurvefit или lsqnonlin решатель.

Флаг выхода для `lsqnonlin`	Числовой эквивалент	Значение
`SearchDirectionTooSmall`	`4`	Величина направления поиска была меньше `options.StepTolerance`.
`FunctionChangeBelowTolerance`	`3`	Изменение остатка было меньше, чем `options.FunctionTolerance`.
`StepSizeBelowTolerance`	`2`	Размер шага меньше `options.StepTolerance`.
`OptimalSolution`	`1`	Решатель сходится к решению `x`.
`SolverLimitExceeded`	`0`	Превышено число итераций `options.MaxIterations` или количество превышенных оценок функций `options.MaxFunctionEvaluations`.
`OutputFcnStop`	`-1`	Останавливается функцией вывода или функцией графика.
`NoFeasiblePointFound`	`-2`	Для задач оптимизации задача неосуществима: границы `lb` и `ub` несовместимы. Для задач уравнений решение не найдено.

В этой таблице описываются флаги выхода для fminunc решатель.

Флаг выхода для `fminunc`	Числовой эквивалент	Значение
`NoDecreaseAlongSearchDirection`	`5`	Прогнозируемое снижение целевой функции меньше `options.FunctionTolerance` толерантность.
`FunctionChangeBelowTolerance`	`3`	Изменение значения целевой функции меньше `options.FunctionTolerance` толерантность.
`StepSizeBelowTolerance`	`2`	Изменение в `x` меньше, чем `options.StepTolerance` толерантность.
`OptimalSolution`	`1`	Величина градиента меньше `options.OptimalityTolerance` толерантность.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations` или количество оценок функций превышает `options.MaxFunctionEvaluations`.
`OutputFcnStop`	`-1`	Останавливается функцией вывода или функцией графика.
`Unbounded`	`-3`	Целевая функция при текущей итерации ниже `options.ObjectiveLimit`.

В этой таблице описываются флаги выхода для fmincon решатель.

Флаг выхода для `fmincon`	Числовой эквивалент	Значение
`NoDecreaseAlongSearchDirection`	`5`	Величина направленной производной в направлении поиска менее 2 *`options.OptimalityTolerance` и максимальное нарушение ограничения меньше, чем `options.ConstraintTolerance`.
`SearchDirectionTooSmall`	`4`	Величина направления поиска меньше 2 *`options.StepTolerance` и максимальное нарушение ограничения меньше, чем `options.ConstraintTolerance`.
`FunctionChangeBelowTolerance`	`3`	Изменение значения целевой функции меньше `options.FunctionTolerance` и максимальное нарушение ограничения меньше, чем `options.ConstraintTolerance`.
`StepSizeBelowTolerance`	`2`	Изменение в `x` меньше, чем `options.StepTolerance` и максимальное нарушение ограничения меньше, чем `options.ConstraintTolerance`.
`OptimalSolution`	`1`	Показатель оптимальности первого порядка меньше `options.OptimalityTolerance`, а максимальное нарушение ограничения меньше `options.ConstraintTolerance`.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations` или количество оценок функций превышает `options.MaxFunctionEvaluations`.
`OutputFcnStop`	`-1`	Останавливается функцией вывода или функцией графика.
`NoFeasiblePointFound`	`-2`	Выполнимая точка не найдена.
`Unbounded`	`-3`	Целевая функция при текущей итерации ниже `options.ObjectiveLimit` и максимальное нарушение ограничения меньше, чем `options.ConstraintTolerance`.

В этой таблице описываются флаги выхода для fsolve решатель.

Флаг выхода для `fsolve`	Числовой эквивалент	Значение
`SearchDirectionTooSmall`	`4`	Величина направления поиска меньше `options.StepTolerance`, уравнение решено.
`FunctionChangeBelowTolerance`	`3`	Изменение значения целевой функции меньше `options.FunctionTolerance`, уравнение решено.
`StepSizeBelowTolerance`	`2`	Изменение в `x` меньше, чем `options.StepTolerance`, уравнение решено.
`OptimalSolution`	`1`	Показатель оптимальности первого порядка меньше `options.OptimalityTolerance`, уравнение решено.
`SolverLimitExceeded`	`0`	Число итераций превышает `options.MaxIterations` или количество оценок функций превышает `options.MaxFunctionEvaluations`.
`OutputFcnStop`	`-1`	Останавливается функцией вывода или функцией графика.
`NoFeasiblePointFound`	`-2`	Сходится к точке, которая не является корнем.
`TrustRegionRadiusTooSmall`	`-3`	Уравнение не решено. Радиус области доверия стал слишком маленьким (`trust-region-dogleg` алгоритм).

В этой таблице описываются флаги выхода для fzero решатель.

Флаг выхода для `fzero`	Числовой эквивалент	Значение
`OptimalSolution`	`1`	Уравнение решено.
`OutputFcnStop`	`-1`	Останавливается функцией вывода или функцией графика.
`FoundNaNInfOrComplex`	`-4`	`NaN`, `Inf`или сложное значение, встречающееся при поиске интервала, содержащего изменение знака.
`SingularPoint`	`-5`	Возможно, сошлись в единственную точку.
`CannotDetectSignChange`	`-6`	Не найдено двух точек с противоположными знаками значения функции.

`output` - Информация о процессе оптимизации
структура

Информация о процессе оптимизации, возвращенная в виде структуры. Структура вывода содержит поля в соответствующем базовом поле вывода решателя, в зависимости от того, какой решатель solve вызываемые:

'fmincon' output
'fminunc' output
'fsolve' output
'fzero' output
'intlinprog' output
'linprog' output
'lsqcurvefit' или 'lsqnonlin' output
'lsqlin' output
'lsqnonneg' output
'quadprog' output

solve включает дополнительное поле Solver в output структура для идентификации используемого решателя, например, 'intlinprog'.

Когда Solver является нелинейным решателем, solve включает в себя одно или два дополнительных поля, описывающих тип оценки производной. objectivederivative и, при необходимости, constraintderivative поля могут принимать следующие значения:

"reverse-AD" для обратного автоматического дифференцирования
"forward-AD" для прямого автоматического дифференцирования
"finite-differences" для оценки конечных разностей
"closed-form" для линейных или квадратичных функций

`lambda` - Множители лагранжа в решении
структура

Множители лагранжа в решении, возвращаемые как структура.

Примечание

solve не возвращается lambda для задач решения уравнений.

Для intlinprog и fminunc решатели, lambda пуст, []. Для других решателей, lambda имеет следующие поля:

Variables - содержит поля для каждой переменной проблемы. Каждое имя переменной проблемы представляет собой структуру с двумя полями:
- Lower - Множители лагранжа, связанные с переменной LowerBound , возвращаемое как массив того же размера, что и переменная. Ненулевые значения означают, что решение находится на нижней границе. Эти множители находятся в структуре lambda.Variables.variablename.Lower.
- Upper - Множители лагранжа, связанные с переменной UpperBound , возвращаемое как массив того же размера, что и переменная. Ненулевые значения означают, что решение находится на верхней границе. Эти множители находятся в структуре lambda.Variables.variablename.Upper.
Constraints - содержит поле для каждого ограничения проблемы. Каждое проблемное ограничение находится в структуре, имя которой является именем ограничения, а значение - числовым массивом того же размера, что и ограничение. Ненулевые значения означают, что ограничение активно в решении. Эти множители находятся в структуре lambda.Constraints.constraintname.
Примечание
Все элементы массива ограничений имеют одинаковое сравнение (<=, ==, или >=) и все имеют одинаковый тип (линейный, квадратичный или нелинейный).

Алгоритмы