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

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® в области $x^{2} + y^{2} \leq 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

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

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

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.74         0              -              -                                          
   18027      1.31         1   2.906000e+03   4.509804e+01                                          
   21859      1.73         2   2.073000e+03   2.270974e+01                                          
   23546      1.87         3   1.854000e+03   1.180593e+01                                          
   24121      1.92         3   1.854000e+03   1.563342e+00                                          
   24294      1.94         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.32         2   2.154000e+03   2.593968e+01                                          
    5844      0.51         3   1.854000e+03   1.180593e+01                                          
    6204      0.55         3   1.854000e+03   1.455526e+00                                          
    6400      0.56         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 сделать больше шагов.

Решите задачу целочисленного программирования с опциями не по умолчанию

Решите задачу

$\min_{x} (- 3 x_{1} - 2 x_{2} - x_{3}) s u b j e c t t o {\begin{array}{llllllllllllllllllll} x_{3} b i n a r y \\ x_{1}, x_{2} \geq 0 \\ x_{1} + x_{2} + x_{3} \leq 7 \\ 4 x_{1} + 2 x_{2} + x_{3} = 12 \end{array}$

не показывая итеративное отображение.

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

Возвратите все выходные параметры

Решите смешано-целочисленную задачу линейного программирования, описанную в, Решают задачу Целочисленного программирования с Опциями Не по умолчанию и исследуют все выходные данные.

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 (- (x_{1} + x_{2}))) = x_{2} (1 + x_{1}^{2}) \\ x_{1} \cos (x_{2}) + x_{2} \sin (x_{1}) = \frac{1}{2} \end{array}$

с помощью подхода, основанного на проблеме сначала задайте 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.4069e-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` (без ограничений)
Минимизируйте \|\| 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`	'none'

Примечание

Если вы выбираете 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'` (значение по умолчанию) | `'finite-differences'`

Индикация, чтобы использовать автоматическое дифференцирование (AD) для нелинейной целевой функции в виде разделенной запятой пары, состоящей из 'ObjectiveDerivative' и любой 'auto' (используйте AD если возможный), или 'finite-differences' (не используйте AD). 'auto' вызывает базовый решатель (fmincon или fminunc) использовать информацию о градиенте при решении задачи при условии, что целевая функция поддерживается, как описано в Поддерживаемых Операциях на Переменных и выражениях Оптимизации. Для примера смотрите Эффект Автоматического Дифференцирования в Основанной на проблеме Оптимизации.

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

'ObjectiveDerivative' и 'ConstraintDerivative' аргументы пары "имя-значение" в настоящее время применяются только к задачам, решенным fmincon или fminunc. При попытке использовать эти аргументы при решении уравнения с solve или преобразование уравнения с prob2struct, MATLAB^® выдает ошибку.

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

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

`'ConstraintDerivative'` — Индикация, чтобы использовать автоматическое дифференцирование для ограничительных функций
`'auto'` (значение по умолчанию) | `'finite-differences'`

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

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

Пример: '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 относитесь к решениям, которые имеют большой infeasibilities. Они обычно являются результатом линейных ограничительных матриц, которые имеют большое число обусловленности или проблемы, которые имеют большие компоненты решения. Чтобы откорректировать эти проблемы, попытайтесь масштабировать содействующие матрицы, устранить избыточные линейные ограничения или дать более трудные границы на переменных.

Эта таблица описывает выходные флаги для 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` алгоритм)

Эта таблица описывает выходные флаги для 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	`NaNInf`, или комплексное число, с которым сталкиваются во время поиска интервала, содержащего изменение знака.
`SingularPoint`	-5	Может сходиться к особой точке.
`CannotDetectSignChange`	-6	Не нашел две точки с противоположными знаками значения функции.

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

Информация о процессе оптимизации, возвращенном как структура. Структура 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'.

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

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

Примечание

solve не возвращает lambda для решающих уравнение проблем.

Для intlinprog и fminunc решатели, lambda isempty. Для других решателей, lambda имеет эти поля:

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

Алгоритмы