solve
Solve optimization problem or equation problem
Syntax
Description
Use solve to find the solution of an optimization problem
or equation problem.
Tip
For the full workflow, see Problem-Based Optimization Workflow or Problem-Based Workflow for Solving Equations.
sol = solve(___,Name,Value)
Examples
Solve a linear programming problem defined by an optimization problem.
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
Find a minimum of the peaks function, which is included in MATLAB®, in the region . To do so, create optimization variables x and y.
x = optimvar('x'); y = optimvar('y');
Create an optimization problem having peaks as the objective function.
prob = optimproblem("Objective",peaks(x,y));Include the constraint as an inequality in the optimization variables.
prob.Constraints = x^2 + y^2 <= 4;
Set the initial point for x to 1 and y to –1, and solve the problem.
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. <stopping criteria details>
sol = struct with fields:
x: 0.2283
y: -1.6255
Unsupported Functions Require fcn2optimexpr
If your objective or nonlinear constraint functions are not entirely composed of elementary functions, you must convert the functions to optimization expressions using fcn2optimexpr. See Convert Nonlinear Function to Optimization Expression and Supported Operations for Optimization Variables and Expressions.
To convert the present example:
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. <stopping criteria details>
sol2 = struct with fields:
x: 0.2283
y: -1.6255
Copyright 2018–2020 The MathWorks, Inc.
Compare the number of steps to solve an integer programming problem both with and without an initial feasible point. The problem has eight integer variables and four linear equality constraints, and all variables are restricted to be positive.
prob = optimproblem; x = optimvar('x',8,1,'LowerBound',0,'Type','integer');
Create four linear equality constraints and include them in the problem.
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;Create an objective function and include it in the problem.
f = [2 10 13 17 7 5 7 3]; prob.Objective = f*x;
Solve the problem without using an initial point, and examine the display to see the number of branch-and-bound nodes.
[x1,fval1,exitflag1,output1] = solve(prob);
Solving problem using intlinprog.
Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms
Coefficient ranges:
Matrix [3e+00, 4e+01]
Cost [2e+00, 2e+01]
Bound [0e+00, 0e+00]
RHS [8e+03, 1e+04]
Presolving model
4 rows, 8 cols, 32 nonzeros 0s
4 rows, 8 cols, 27 nonzeros 0s
Objective function is integral with scale 1
Solving MIP model with:
4 rows
8 cols (0 binary, 8 integer, 0 implied int., 0 continuous)
27 nonzeros
Nodes | B&B Tree | Objective Bounds | Dynamic Constraints | Work
Proc. InQueue | Leaves Expl. | BestBound BestSol Gap | Cuts InLp Confl. | LpIters Time
0 0 0 0.00% 0 inf inf 0 0 0 0 0.0s
0 0 0 0.00% 1554.047531 inf inf 0 0 4 4 0.0s
T 20753 210 8189 98.04% 1783.696925 1854 3.79% 30 8 9884 19222 3.0s
Solving report
Status Optimal
Primal bound 1854
Dual bound 1854
Gap 0% (tolerance: 0.01%)
Solution status feasible
1854 (objective)
0 (bound viol.)
9.63673585375e-14 (int. viol.)
0 (row viol.)
Timing 3.10 (total)
0.00 (presolve)
0.00 (postsolve)
Nodes 21163
LP iterations 19608 (total)
223 (strong br.)
76 (separation)
1018 (heuristics)
Optimal solution found.
Intlinprog stopped because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 1e-06. The intcon variables are integer within tolerance, options.ConstraintTolerance = 1e-06.
For comparison, find the solution using an initial feasible point.
x0.x = [8 62 23 103 53 84 46 34]'; [x2,fval2,exitflag2,output2] = solve(prob,x0);
Solving problem using intlinprog.
Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms
Coefficient ranges:
Matrix [3e+00, 4e+01]
Cost [2e+00, 2e+01]
Bound [0e+00, 0e+00]
RHS [8e+03, 1e+04]
Assessing feasibility of MIP using primal feasibility and integrality tolerance of 1e-06
Solution has num max sum
Col infeasibilities 0 0 0
Integer infeasibilities 0 0 0
Row infeasibilities 0 0 0
Row residuals 0 0 0
Presolving model
4 rows, 8 cols, 32 nonzeros 0s
4 rows, 8 cols, 27 nonzeros 0s
MIP start solution is feasible, objective value is 3901
Objective function is integral with scale 1
Solving MIP model with:
4 rows
8 cols (0 binary, 8 integer, 0 implied int., 0 continuous)
27 nonzeros
Nodes | B&B Tree | Objective Bounds | Dynamic Constraints | Work
Proc. InQueue | Leaves Expl. | BestBound BestSol Gap | Cuts InLp Confl. | LpIters Time
0 0 0 0.00% 0 3901 100.00% 0 0 0 0 0.0s
0 0 0 0.00% 1554.047531 3901 60.16% 0 0 4 4 0.0s
T 6266 708 2644 73.61% 1662.791423 3301 49.63% 20 6 9746 10699 1.5s
T 9340 919 3970 80.72% 1692.410008 2687 37.01% 29 6 9995 16120 2.3s
T 21750 192 9514 96.83% 1791.542628 1854 3.37% 20 6 9984 40278 5.6s
Solving report
Status Optimal
Primal bound 1854
Dual bound 1854
Gap 0% (tolerance: 0.01%)
Solution status feasible
1854 (objective)
0 (bound viol.)
1.42108547152e-13 (int. viol.)
0 (row viol.)
Timing 5.68 (total)
0.00 (presolve)
0.00 (postsolve)
Nodes 22163
LP iterations 40863 (total)
538 (strong br.)
64 (separation)
2782 (heuristics)
Optimal solution found.
Intlinprog stopped because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 1e-06. The intcon variables are integer within tolerance, options.ConstraintTolerance = 1e-06.
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 21163 steps. With an initial point, solve took 22163 steps.
Giving an initial point does not always improve the problem. For this problem, using an initial point saves time and computational steps. However, for some problems, an initial point can cause solve to take more steps.
For some solvers, you can pass the objective and constraint function values, if any, to solve in the x0 argument. This can save time in the solver. Pass a vector of OptimizationValues objects. Create this vector using the optimvalues function.
The solvers that can use the objective function values are:
gagamultiobjparetosearchsurrogateopt
The solvers that can use nonlinear constraint function values are:
paretosearchsurrogateopt
For example, minimize the peaks function using surrogateopt, starting with values from a grid of initial points. Create a grid from -10 to 10 in the x variable, and –5/2 to 5/2 in the y variable with spacing 1/2. Compute the objective function values at the initial points.
x = optimvar("x",LowerBound=-10,UpperBound=10); y = optimvar("y",LowerBound=-5/2,UpperBound=5/2); prob = optimproblem("Objective",peaks(x,y)); xval = -10:10; yval = (-5:5)/2; [x0x,x0y] = meshgrid(xval,yval); peaksvals = peaks(x0x,x0y);
Pass the values in the x0 argument by using optimvalues. This saves time for solve, as solve does not need to compute the values. Pass the values as row vectors.
x0 = optimvalues(prob,'x',x0x(:)','y',x0y(:)',... "Objective",peaksvals(:)');
Solve the problem using surrogateopt with the initial values.
[sol,fval,eflag,output] = solve(prob,x0,Solver="surrogateopt")Solving problem using surrogateopt.
surrogateopt stopped because it exceeded the function evaluation limit set by 'options.MaxFunctionEvaluations'.
sol = struct with fields:
x: 0.2279
y: -1.6258
fval = -6.5511
eflag =
SolverLimitExceeded
output = struct with fields:
elapsedtime: 17.3146
funccount: 200
constrviolation: 0
ineq: [1×1 struct]
rngstate: [1×1 struct]
message: 'surrogateopt stopped because it exceeded the function evaluation limit set by ↵'options.MaxFunctionEvaluations'.'
solver: 'surrogateopt'
Find a local minimum of the peaks function on the range starting from the point [–1,2].
x = optimvar("x",LowerBound=-5,UpperBound=5); y = optimvar("y",LowerBound=-5,UpperBound=5); x0.x = -1; x0.y = 2; prob = optimproblem(Objective=peaks(x,y)); opts = optimoptions("fmincon",Display="none"); [sol,fval] = solve(prob,x0,Options=opts)
sol = struct with fields:
x: -3.3867
y: 3.6341
fval = 1.1224e-07
Try to find a better solution by using the GlobalSearch solver. This solver runs fmincon multiple times, which potentially yields a better solution.
ms = GlobalSearch; [sol2,fval2] = solve(prob,x0,ms)
Solving problem using GlobalSearch. GlobalSearch stopped because it analyzed all the trial points. All 15 local solver runs converged with a positive local solver exit flag.
sol2 = struct with fields:
x: 0.2283
y: -1.6255
fval2 = -6.5511
GlobalSearch finds a solution with a better (lower) objective function value. The exit message shows that fmincon, the local solver, runs 15 times. The returned solution has an objective function value of about –6.5511, which is lower than the value at the first solution, 1.1224e–07.
Solve the problem
without showing iterative display.
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: [2×1 double]
x3: 0
Examine the solution.
sol.x
ans = 2×1
0
6
sol.x3
ans = 0
Force solve to use intlinprog as the solver for a linear programming problem.
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.
Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms
Coefficient ranges:
Matrix [2e-01, 1e+00]
Cost [3e-01, 1e+00]
Bound [0e+00, 0e+00]
RHS [1e+00, 2e+00]
Presolving model
6 rows, 2 cols, 12 nonzeros 0s
4 rows, 2 cols, 8 nonzeros 0s
4 rows, 2 cols, 8 nonzeros 0s
Presolve : Reductions: rows 4(-2); columns 2(-0); elements 8(-4)
Solving the presolved LP
Using EKK dual simplex solver - serial
Iteration Objective Infeasibilities num(sum)
0 -1.3333333333e+03 Ph1: 3(4499); Du: 2(1.33333) 0s
3 -1.1111111111e+00 Pr: 0(0) 0s
Solving the original LP from the solution after postsolve
Model status : Optimal
Simplex iterations: 3
Objective value : -1.1111111111e+00
HiGHS run time : 0.00
Optimal solution found.
No integer variables specified. Intlinprog solved the linear problem.
sol = struct with fields:
x: 0.6667
y: 1.3333
Solve the mixed-integer linear programming problem described in Solve Integer Programming Problem with Nondefault Options and examine all of the output data.
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.
Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms
Coefficient ranges:
Matrix [1e+00, 4e+00]
Cost [1e+00, 3e+00]
Bound [1e+00, 1e+00]
RHS [7e+00, 1e+01]
Presolving model
2 rows, 3 cols, 6 nonzeros 0s
0 rows, 0 cols, 0 nonzeros 0s
Presolve: Optimal
Solving report
Status Optimal
Primal bound -12
Dual bound -12
Gap 0% (tolerance: 0.01%)
Solution status feasible
-12 (objective)
0 (bound viol.)
0 (int. viol.)
0 (row viol.)
Timing 0.02 (total)
0.02 (presolve)
0.00 (postsolve)
Nodes 0
LP iterations 0 (total)
0 (strong br.)
0 (separation)
0 (heuristics)
Optimal solution found.
Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 1e-06. The intcon variables are integer within tolerance, options.ConstraintTolerance = 1e-06.
sol = struct with fields:
x: [2×1 double]
x3: 0
fval = -12
exitflag =
OptimalSolution
output = struct with fields:
relativegap: 0
absolutegap: 0
numfeaspoints: 1
numnodes: 0
constrviolation: 0
algorithm: 'highs'
message: 'Optimal solution found.↵↵Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 1e-06. The intcon variables are integer within tolerance, options.ConstraintTolerance = 1e-06.'
solver: 'intlinprog'
For a problem without any integer constraints, you can also obtain a nonempty Lagrange multiplier structure as the fifth output.
Create and solve an optimization problem using named index variables. The problem is to maximize the profit-weighted flow of fruit to various airports, subject to constraints on the weighted flows.
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.
Running HiGHS 1.7.1: Copyright (c) 2024 HiGHS under MIT licence terms
Coefficient ranges:
Matrix [4e-02, 1e+00]
Cost [1e-01, 1e+00]
Bound [0e+00, 0e+00]
RHS [1e+01, 4e+01]
Presolving model
3 rows, 12 cols, 12 nonzeros 0s
3 rows, 12 cols, 12 nonzeros 0s
Solving MIP model with:
3 rows
12 cols (0 binary, 12 integer, 0 implied int., 0 continuous)
12 nonzeros
Nodes | B&B Tree | Objective Bounds | Dynamic Constraints | Work
Proc. InQueue | Leaves Expl. | BestBound BestSol Gap | Cuts InLp Confl. | LpIters Time
0 0 0 0.00% 1160.150059 -inf inf 0 0 0 0 0.0s
S 0 0 0 0.00% 1160.150059 1027.233133 12.94% 0 0 0 0 0.0s
Solving report
Status Optimal
Primal bound 1027.23313332
Dual bound 1027.23313332
Gap 0% (tolerance: 0.01%)
Solution status feasible
1027.23313332 (objective)
0 (bound viol.)
0 (int. viol.)
0 (row viol.)
Timing 0.00 (total)
0.00 (presolve)
0.00 (postsolve)
Nodes 1
LP iterations 3 (total)
0 (strong br.)
0 (separation)
0 (heuristics)
Optimal solution found.
Intlinprog stopped at the root node because the objective value is within a gap tolerance of the optimal value, options.AbsoluteGapTolerance = 1e-06. The intcon variables are integer within tolerance, options.ConstraintTolerance = 1e-06.
Find the optimal flow of oranges and berries to New York and Los Angeles.
[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
70 0
This display means that no oranges are going to NYC, 70 berries are going to NYC, 980 oranges are going to LAX, and no berries are going to LAX.
List the optimal flow of the following:
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 28 980
This display means that 70 berries are going to NYC, 28 apples are going to BOS, and 980 oranges are going to LAX.
To solve the nonlinear system of equations
using the problem-based approach, first define x as a two-element optimization variable.
x = optimvar('x',2);Create the first equation as an optimization equality expression.
eq1 = exp(-exp(-(x(1) + x(2)))) == x(2)*(1 + x(1)^2);
Similarly, create the second equation as an optimization equality expression.
eq2 = x(1)*cos(x(2)) + x(2)*sin(x(1)) == 1/2;
Create an equation problem, and place the equations in the problem.
prob = eqnproblem; prob.Equations.eq1 = eq1; prob.Equations.eq2 = eq2;
Review the problem.
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
Solve the problem starting from the point [0,0]. For the problem-based approach, specify the initial point as a structure, with the variable names as the fields of the structure. For this problem, there is only one variable, 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. <stopping criteria details>
sol = struct with fields:
x: [2×1 double]
fval = struct with fields:
eq1: -2.4070e-07
eq2: -3.8255e-08
exitflag =
EquationSolved
View the solution point.
disp(sol.x)
0.3532
0.6061
Unsupported Functions Require fcn2optimexpr
If your equation functions are not composed of elementary functions, you must convert the functions to optimization expressions using fcn2optimexpr. For the present example:
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;
See Supported Operations for Optimization Variables and Expressions and Convert Nonlinear Function to Optimization Expression.
Input Arguments
Name-Value Arguments
Specify optional pairs of arguments as
Name1=Value1,...,NameN=ValueN, where Name is
the argument name and Value is the corresponding value.
Name-value arguments must appear after other arguments, but the order of the
pairs does not matter.
Before R2021a, use commas to separate each name and value, and enclose
Name in quotes.
Example: solve(prob,'Options',opts)
Minimum number of start points for MultiStart (Global Optimization Toolbox), specified as a
positive integer. This argument applies only when you call
solve using the ms
argument. solve uses all of the values in
x0 as start points. If
MinNumStartPoints is greater than the number of
values in x0, then solve
generates more start points uniformly at random within the problem
bounds. If a component is unbounded, solve
generates points using the default artificial bounds for
MultiStart.
Example: solve(prob,x0,ms,MinNumStartPoints=50)
Data Types: double
Optimization options, specified as an object created by optimoptions or an options
structure such as created by optimset.
Internally, the solve function calls a relevant
solver as detailed in the 'solver' argument reference. Ensure that
options is compatible with the solver. For
example, intlinprog does not allow options to be a
structure, and lsqnonneg does not allow options to be
an object.
For suggestions on options settings to improve an
intlinprog solution or the speed of a solution,
see Tuning Integer Linear Programming. For linprog, the
default 'dual-simplex' algorithm is generally
memory-efficient and speedy. Occasionally, linprog
solves a large problem faster when the Algorithm
option is 'interior-point'. For suggestions on
options settings to improve a nonlinear problem's solution, see Optimization Options in Common Use: Tuning and Troubleshooting and Improve Results.
Example: options =
optimoptions('intlinprog','Display','none')
Optimization solver, specified as the name of a listed solver. For optimization problems, this table contains the available solvers for each problem type, including solvers from Global Optimization Toolbox. Details for equation problems appear below the optimization solver details.
For converting nonlinear problems with integer constraints using
prob2struct, the resulting problem structure can depend on the
chosen solver. If you do not have a Global Optimization Toolbox license, you must specify the solver. See Integer Constraints in Nonlinear Problem-Based Optimization.
The default solver for each optimization problem type is listed here.
| Problem Type | Default Solver |
|---|---|
| Linear Programming (LP) | linprog |
| Mixed-Integer Linear Programming (MILP) | intlinprog |
| Quadratic Programming (QP) | quadprog |
| Second-Order Cone Programming (SOCP) | coneprog |
| Linear Least Squares | lsqlin |
| Nonlinear Least Squares | lsqnonlin |
| Nonlinear Programming (NLP) | |
| Mixed-Integer Nonlinear Programming (MINLP) | ga (Global Optimization Toolbox) |
| Multiobjective | gamultiobj (Global Optimization Toolbox) |
In this table, 
means the solver is available for the problem type,
x means the solver is not available.
Problem Type | LP | MILP | QP | SOCP | Linear Least Squares | Nonlinear Least Squares | NLP | MINLP |
|---|---|---|---|---|---|---|---|---|
| Solver | ||||||||
linprog |
| x | x | x | x | x | x | x |
intlinprog |
|
| x | x | x | x | x | x |
quadprog |
| x |
|
|
| x | x | x |
coneprog |
| x | x |
| x | x | x | x |
lsqlin | x | x | x | x |
| x | x | x |
lsqnonneg | x | x | x | x |
| x | x | x |
lsqnonlin | x | x | x | x |
|
| x | x |
fminunc |
| x |
| x |
|
|
| x |
fmincon |
| x |
|
|
|
|
| x |
fminbnd | x | x | x | x |
|
|
| x |
fminsearch | x | x | x | x |
|
|
| x |
patternsearch (Global Optimization Toolbox) |
| x |
|
|
|
|
| x |
ga (Global Optimization Toolbox) |
|
|
|
|
|
|
|
|
particleswarm (Global Optimization Toolbox) |
| x |
| x |
|
|
| x |
simulannealbnd (Global Optimization Toolbox) |
| x |
| x |
|
|
| x |
surrogateopt (Global Optimization Toolbox) |
|
|
|
|
|
|
|
|
gamultiobj (Global Optimization Toolbox) |
|
|
|
|
|
|
|
|
paretosearch (Global Optimization Toolbox) |
| x |
|
|
|
|
| x |
Note
If you choose lsqcurvefit as the solver for a least-squares
problem, solve uses lsqnonlin. The
lsqcurvefit and lsqnonlin solvers are
identical for solve.
Caution
For maximization problems (prob.ObjectiveSense is
"max" or "maximize"), do not specify a
least-squares solver (one with a name beginning lsq). If you do,
solve throws an error, because these solvers cannot
maximize.
For equation solving, this table contains the available solvers for each problem type. In the table,
* indicates the default solver for the problem type.
Y indicates an available solver.
N indicates an unavailable solver.
Supported Solvers for Equations
| Equation Type | lsqlin | lsqnonneg | fzero | fsolve | lsqnonlin |
|---|---|---|---|---|---|
| Linear | * | N | Y (scalar only) | Y | Y |
| Linear plus bounds | * | Y | N | N | Y |
| Scalar nonlinear | N | N | * | Y | Y |
| Nonlinear system | N | N | N | * | Y |
| Nonlinear system plus bounds | N | N | N | N | * |
Example: 'intlinprog'
Data Types: char | string
Indication to use automatic differentiation (AD) for nonlinear
objective function, specified as 'auto' (use AD if
possible), 'auto-forward' (use forward AD if
possible), 'auto-reverse' (use reverse AD if
possible), or 'finite-differences' (do not use AD).
Choices including auto cause the underlying solver to
use gradient information when solving the problem provided that the
objective function is supported, as described in Supported Operations for Optimization Variables and Expressions. For
an example, see Effect of Automatic Differentiation in Problem-Based Optimization.
Solvers choose the following type of AD by default:
For a general nonlinear objective function,
fmincondefaults to reverse AD for the objective function.fmincondefaults to reverse AD for the nonlinear constraint function when the number of nonlinear constraints is less than the number of variables. Otherwise,fmincondefaults to forward AD for the nonlinear constraint function.For a general nonlinear objective function,
fminuncdefaults to reverse AD.For a least-squares objective function,
fminconandfminuncdefault to forward AD for the objective function. For the definition of a problem-based least-squares objective function, see Write Objective Function for Problem-Based Least Squares.lsqnonlindefaults to forward AD when the number of elements in the objective vector is greater than or equal to the number of variables. Otherwise,lsqnonlindefaults to reverse AD.fsolvedefaults to forward AD when the number of equations is greater than or equal to the number of variables. Otherwise,fsolvedefaults to reverse AD.
Example: 'finite-differences'
Data Types: char | string
Indication to use automatic differentiation (AD) for nonlinear
constraint functions, specified as 'auto' (use AD if
possible), 'auto-forward' (use forward AD if
possible), 'auto-reverse' (use reverse AD if
possible), or 'finite-differences' (do not use AD).
Choices including auto cause the underlying solver to
use gradient information when solving the problem provided that the
constraint functions are supported, as described in Supported Operations for Optimization Variables and Expressions. For
an example, see Effect of Automatic Differentiation in Problem-Based Optimization.
Solvers choose the following type of AD by default:
For a general nonlinear objective function,
fmincondefaults to reverse AD for the objective function.fmincondefaults to reverse AD for the nonlinear constraint function when the number of nonlinear constraints is less than the number of variables. Otherwise,fmincondefaults to forward AD for the nonlinear constraint function.For a general nonlinear objective function,
fminuncdefaults to reverse AD.For a least-squares objective function,
fminconandfminuncdefault to forward AD for the objective function. For the definition of a problem-based least-squares objective function, see Write Objective Function for Problem-Based Least Squares.lsqnonlindefaults to forward AD when the number of elements in the objective vector is greater than or equal to the number of variables. Otherwise,lsqnonlindefaults to reverse AD.fsolvedefaults to forward AD when the number of equations is greater than or equal to the number of variables. Otherwise,fsolvedefaults to reverse AD.
Example: 'finite-differences'
Data Types: char | string
Indication to use automatic differentiation (AD) for nonlinear
constraint functions, specified as 'auto' (use AD if
possible), 'auto-forward' (use forward AD if
possible), 'auto-reverse' (use reverse AD if
possible), or 'finite-differences' (do not use AD).
Choices including auto cause the underlying solver to
use gradient information when solving the problem provided that the
equation functions are supported, as described in Supported Operations for Optimization Variables and Expressions. For
an example, see Effect of Automatic Differentiation in Problem-Based Optimization.
Solvers choose the following type of AD by default:
For a general nonlinear objective function,
fmincondefaults to reverse AD for the objective function.fmincondefaults to reverse AD for the nonlinear constraint function when the number of nonlinear constraints is less than the number of variables. Otherwise,fmincondefaults to forward AD for the nonlinear constraint function.For a general nonlinear objective function,
fminuncdefaults to reverse AD.For a least-squares objective function,
fminconandfminuncdefault to forward AD for the objective function. For the definition of a problem-based least-squares objective function, see Write Objective Function for Problem-Based Least Squares.lsqnonlindefaults to forward AD when the number of elements in the objective vector is greater than or equal to the number of variables. Otherwise,lsqnonlindefaults to reverse AD.fsolvedefaults to forward AD when the number of equations is greater than or equal to the number of variables. Otherwise,fsolvedefaults to reverse AD.
Example: 'finite-differences'
Data Types: char | string
