To use a MATLAB™ function in the problem-based approach when it is not composed of supported functions, first convert it to an optimization expression. SeeSupported Operations for Optimization Variables and Expressionsand将非线性函数优化表达ion.

To use the objective functiongamma(the mathematical function $$\Gamma (x)$$, an extension of the factorial function), create an optimization variablexand use it in a converted anonymous function.

x = optimvar('x'); obj = fcn2optimexpr(@gamma,x); prob = optimproblem('Objective',obj); show(prob)

OptimizationProblem : Solve for: x minimize : gamma(x)

To solve the resulting problem, give an initial point structure and callsolve.

x0.x = 1/2; sol = solve(prob,x0)

Solving problem using fminunc. Local minimum found. Optimization completed because the size of the gradient is less than the value of the optimality tolerance.

sol =struct with fields:x: 1.4616

For more complex functions, convert a function file. The function filegammabrock.mcomputes an objective of two optimization variables.

typegammabrock

function f = gammabrock(x,y) f = (10*(y - gamma(x)))^2 + (1 - x)^2;

Include this objective in a problem.

x = optimvar('x','LowerBound',0); y = optimvar('y'); obj = fcn2optimexpr(@gammabrock,x,y); prob = optimproblem('Objective',obj); show(prob)

OptimizationProblem : Solve for: x, y minimize : gammabrock(x, y) variable bounds: 0 <= x

Thegammabrockfunction is a sum of squares. You get a more efficient problem formulation by expressing the function as an explicit sum of squares of optimization expressions.

f = fcn2optimexpr(@(x,y)y - gamma(x),x,y); obj2 = (10*f)^2 + (1-x)^2; prob2 = optimproblem('Objective',obj2);

To see the difference in efficiency, solveprobandprob2并检查iterat数量的差异ions.

x0.x = 1/2; x0.y = 1/2; [sol,fval,~,output] = solve(prob,x0);

使用fmincon解决问题。发现局部最小值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,fval2,~,output2] = solve(prob2,x0);

Solving problem using lsqnonlin. Local minimum found. Optimization completed because the size of the gradient is less than the value of the optimality tolerance.

fprintf('prob took %d iterations, but prob2 took %d iterations\n',output.iterations,output2.iterations)

prob took 21 iterations, but prob2 took 2 iterations

If your function has several outputs, you can use them as elements of the objective function. In this case,uis a 2-by-2 variable,vis a 2-by-1 variable, andexpfn3has three outputs.

typeexpfn3

function [f,g,mineval] = expfn3(u,v) mineval = min(eig(u)); f = v'*u*v; f = -exp(-f); t = u*v; g = t'*t + sum(t) - 3;

Create appropriately sized optimization variables, and create an objective function from the first two outputs.

u = optimvar('u',2,2); v = optimvar('v',2); [f,g,mineval] = fcn2optimexpr(@expfn3,u,v); prob = optimproblem; prob.Objective = f*g/(1 + f^2); show(prob)

OptimizationProblem : Solve for: u, v minimize : ((arg2 .* arg3) ./ (1 + arg1.^2)) where: [arg1,~,~] = expfn3(u, v); [arg2,~,~] = expfn3(u, v); [~,arg3,~] = expfn3(u, v);

You can use theminevaloutput in a subsequent constraint expression.

In problem-based optimization, constraints are two optimization expressions with a comparison operator (==,<=, or>=) between them. You can usefcn2optimexprto create one or both optimization expressions. See将非线性函数优化表达ion.

Create the nonlinear constraint thatgammafn2is less than or equal to –1/2. This function of two variables is in thegammafn2.mfile.

typegammafn2

function f = gammafn2(x,y) f = -gamma(x)*(y/(1+y^2));

Create optimization variables, convert the function file to an optimization expression, and then express the constraint asconfn.

x = optimvar('x','LowerBound',0); y = optimvar('y','LowerBound',0); expr1 = fcn2optimexpr(@gammafn2,x,y); confn = expr1 <= -1/2; show(confn)

gammafn2(x, y) <= -0.5

Create another constraint thatgammafn2is greater than or equal tox + y.

confn2 = expr1 >= x + y;

Create an optimization problem and place the constraints in the problem.

prob = optimproblem; prob.Constraints.confn = confn; prob.Constraints.confn2 = confn2; show(prob)

OptimizationProblem : Solve for: x, y minimize : subject to confn: gammafn2(x, y) <= -0.5 subject to confn2: gammafn2(x, y) >= (x + y) variable bounds: 0 <= x 0 <= y

If your problem involves a common, time-consuming function to compute the objective and nonlinear constraint, you can save time by using theReuseEvaluationname-value argument. Therosenbrocknormfunction computes both the Rosenbrock objective function and the norm of the argument for use in the constraint $$\Vert x{\Vert }^2\le 4$$.

typerosenbrocknorm

function [f,c] = rosenbrocknorm(x) pause(1) % Simulates time-consuming function c = dot(x,x); f = 100*(x(2) - x(1)^2)^2 + (1 - x(1))^2;

Create a 2-D optimization variablex. Then convertrosenbrocknormto an optimization expression by usingfcn2optimexprand set theReuseEvaluationname-value argument totrue. To ensure thatfcn2optimexprkeeps thepausestatement, set theAnalysisname-value argument to 'off'.

x = optimvar('x',2); [f,c] = fcn2optimexpr(@rosenbrocknorm,x,...'ReuseEvaluation',true,'Analysis','off');

Create objective and constraint expressions from the returned expressions. Include the objective and constraint expressions in an optimization problem. Review the problem usingshow.

prob = optimproblem('Objective',f); prob.Constraints.cineq = c <= 4; show(prob)

OptimizationProblem : Solve for: x minimize : [argout,~] = rosenbrocknorm(x) subject to cineq: arg_LHS <= 4 where: [~,arg_LHS] = rosenbrocknorm(x);

Solve the problem starting from the initial pointx0.x = [-1;1], timing the result.

x0.x = [-1;1]; tic [sol,fval,exitflag,output] = solve(prob,x0)

使用fmincon解决问题。发现局部最小值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: [2×1 double]

fval = 4.5793e-11

exitflag = OptimalSolution

output =struct with fields:iterations: 44 funcCount: 164 constrviolation: 0 stepsize: 4.3124e-08 algorithm: 'interior-point' firstorderopt: 5.1691e-07 cgiterations: 10 message: '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.↵↵↵↵Optimization completed: The relative first-order optimality measure, 5.169074e-07,↵is less than options.OptimalityTolerance = 1.000000e-06, and the relative maximum constraint↵violation, 0.000000e+00, is less than options.ConstraintTolerance = 1.000000e-06.' bestfeasible: [1×1 struct] objectivederivative: "finite-differences" constraintderivative: "finite-differences" solver: 'fmincon'

toc

Elapsed time is 165.623157 seconds.

The solution time in seconds is nearly the same as the number of function evaluations. This result indicates that the solver reused function values, and did not waste time by reevaluating the same point twice.

For a more extensive example, seeObjective and Constraints Having a Common Function in Serial or Parallel, Problem-Based. For more information on usingfcn2optimexpr, see将非线性函数优化表达ion.