Documentation 
Solve multiobjective goal attainment problems
Finds the minimum of a problem specified by
$$\underset{x,\gamma}{\text{minimize}}\gamma \text{}\text{suchthat}\text{}\{\begin{array}{c}F(x)weight\cdot \gamma \le goal\\ c(x)\le 0\\ ceq(x)=0\\ A\cdot x\le b\\ Aeq\cdot x=beq\\ lb\le x\le ub.\end{array}$$
weight, goal, b, and beq are vectors, A and Aeq are matrices, and c(x), ceq(x), and F(x) are functions that return vectors. F(x), c(x), and ceq(x) can be nonlinear functions.
x, lb, and ub can be passed as vectors or matrices; see Matrix Arguments.
x = fgoalattain(fun,x0,goal,weight)
x = fgoalattain(fun,x0,goal,weight,A,b)
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq)
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub)
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub,nonlcon)
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub,nonlcon,options)
x = fgoalattain(problem)
[x,fval] = fgoalattain(...)
[x,fval,attainfactor] = fgoalattain(...)
[x,fval,attainfactor,exitflag] = fgoalattain(...)
[x,fval,attainfactor,exitflag,output]
= fgoalattain(...)
[x,fval,attainfactor,exitflag,output,lambda]
= fgoalattain(...)
fgoalattain solves the goal attainment problem, which is one formulation for minimizing a multiobjective optimization problem.
Note: Passing Extra Parameters explains how to pass extra parameters to the objective functions and nonlinear constraint functions, if necessary. 
x = fgoalattain(fun,x0,goal,weight) tries to make the objective functions supplied by fun attain the goals specified by goal by varying x, starting at x0, with weight specified by weight.
x = fgoalattain(fun,x0,goal,weight,A,b) solves the goal attainment problem subject to the linear inequalities A*x ≤ b.
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq) solves the goal attainment problem subject to the linear equalities Aeq*x = beq as well. Set A = [] and b = [] if no inequalities exist.
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub) defines a set of lower and upper bounds on the design variables in x, so that the solution is always in the range lb ≤ x ≤ ub.
Note: See Iterations Can Violate Constraints. 
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub,nonlcon) subjects the goal attainment problem to the nonlinear inequalities c(x) or nonlinear equality constraints ceq(x) defined in nonlcon. fgoalattain optimizes such that c(x) ≤ 0 and ceq(x) = 0. Set lb = [] and/or ub = [] if no bounds exist.
x = fgoalattain(fun,x0,goal,weight,A,b,Aeq,beq,lb,ub,nonlcon,options) minimizes with the optimization options specified in options. Use optimoptions to set these options.
x = fgoalattain(problem) finds the minimum for problem, where problem is a structure described in Input Arguments.
Create the problem structure by exporting a problem from Optimization app, as described in Exporting Your Work.
[x,fval] = fgoalattain(...) returns the values of the objective functions computed in fun at the solution x.
[x,fval,attainfactor] = fgoalattain(...) returns the attainment factor at the solution x.
[x,fval,attainfactor,exitflag] = fgoalattain(...) returns a value exitflag that describes the exit condition of fgoalattain.
[x,fval,attainfactor,exitflag,output] = fgoalattain(...) returns a structure output that contains information about the optimization.
[x,fval,attainfactor,exitflag,output,lambda] = fgoalattain(...) returns a structure lambda whose fields contain the Lagrange multipliers at the solution x.
Function Arguments contains general descriptions of arguments passed into fgoalattain. This section provides functionspecific details for fun, goal, nonlcon, options, weight, and problem:
The function to be minimized. fun is a function that accepts a vector x and returns a vector F, the objective functions evaluated at x. The function fun can be specified as a function handle for a function file: x = fgoalattain(@myfun,x0,goal,weight) where myfun is a MATLAB^{®} function such as function F = myfun(x) F = ... % Compute function values at x. fun can also be a function handle for an anonymous function. x = fgoalattain(@(x)sin(x.*x),x0,goal,weight); If the userdefined values for x and F are matrices, they are converted to a vector using linear indexing. To make an objective function as near as possible to a goal value, (i.e., neither greater than nor less than) use optimoptions to set the GoalsExactAchieve option to the number of objectives required to be in the neighborhood of the goal values. Such objectives must be partitioned into the first elements of the vector F returned by fun. If the gradient of the objective function can also be computed and the GradObj option is 'on', as set by options = optimoptions('fgoalattain','GradObj','on') then the function fun must return, in the second output argument, the gradient value G, a matrix, at x. The gradient consists of the partial derivative dF/dx of each F at the point x. If F is a vector of length m and x has length n, where n is the length of x0, then the gradient G of F(x) is an nbym matrix where G(i,j) is the partial derivative of F(j) with respect to x(i) (i.e., the jth column of G is the gradient of the jth objective function F(j)).
 
goal  Vector of values that the objectives attempt to attain. The vector is the same length as the number of objectives F returned by fun. fgoalattain attempts to minimize the values in the vector F to attain the goal values given by goal.  
The function that computes the nonlinear inequality constraints c(x) ≤ 0 and the nonlinear equality constraints ceq(x) = 0. The function nonlcon accepts a vector x and returns two vectors c and ceq. The vector c contains the nonlinear inequalities evaluated at x, and ceq contains the nonlinear equalities evaluated at x. The function nonlcon can be specified as a function handle. x = fgoalattain(@myfun,x0,goal,weight,A,b,Aeq,beq,... lb,ub,@mycon) where mycon is a MATLAB function such as function [c,ceq] = mycon(x) c = ... % compute nonlinear inequalities at x. ceq = ... % compute nonlinear equalities at x. If the gradients of the constraints can also be computed and the GradConstr option is 'on', as set by options = optimoptions('fgoalattain','GradConstr','on') then the function nonlcon must also return, in the third and fourth output arguments, GC, the gradient of c(x), and GCeq, the gradient of ceq(x). Nonlinear Constraints explains how to "conditionalize" the gradients for use in solvers that do not accept supplied gradients. If nonlcon returns a vector c of m components and x has length n, where n is the length of x0, then the gradient GC of c(x) is an nbym matrix, where GC(i,j) is the partial derivative of c(j) with respect to x(i) (i.e., the jth column of GC is the gradient of the jth inequality constraint c(j)). Likewise, if ceq has p components, the gradient GCeq of ceq(x) is an nbyp matrix, where GCeq(i,j) is the partial derivative of ceq(j) with respect to x(i) (i.e., the jth column of GCeq is the gradient of the jth equality constraint ceq(j)).
Passing Extra Parameters explains how to parameterize the nonlinear constraint function nonlcon, if necessary.  
Options provides the functionspecific details for the options values.  
weight  A weighting vector to control the relative underattainment or overattainment of the objectives in fgoalattain. When the values of goal are all nonzero, to ensure the same percentage of under or overattainment of the active objectives, set the weighting function to abs(goal). (The active objectives are the set of objectives that are barriers to further improvement of the goals at the solution.)  
When the weighting function weight is positive, fgoalattain attempts to make the objectives less than the goal values. To make the objective functions greater than the goal values, set weight to be negative rather than positive. To make an objective function as near as possible to a goal value, use the GoalsExactAchieve option and put that objective as the first element of the vector returned by fun (see the preceding description of fun and options).  
problem  objective  Vector of objective functions  
x0  Initial point for x  
goal  Goals to attain  
weight  Relative importance factors of goals  
Aineq  Matrix for linear inequality constraints  
bineq  Vector for linear inequality constraints  
Aeq  Matrix for linear equality constraints  
beq  Vector for linear equality constraints  
lb  Vector of lower bounds  
ub  Vector of upper bounds  
nonlcon  Nonlinear constraint function  
solver  'fgoalattain'  
options  Options created with optimoptions 
Function Arguments contains general descriptions of arguments returned by fgoalattain. This section provides functionspecific details for attainfactor, exitflag, lambda, and output:
attainfactor  The amount of over or underachievement of the goals. attainfactor contains the value of γ at the solution. If attainfactor is negative, the goals have been overachieved; if attainfactor is positive, the goals have been underachieved.  
exitflag  Integer identifying the reason the algorithm terminated. The following lists the values of exitflag and the corresponding reasons the algorithm terminated.  
1  Function converged to a solutions x.  
4  Magnitude of the search direction less than the specified tolerance and constraint violation less than options.TolCon  
5  Magnitude of directional derivative less than the specified tolerance and constraint violation less than options.TolCon  
0  Number of iterations exceeded options.MaxIter or number of function evaluations exceeded options.MaxFunEvals  
1  Stopped by an output function or plot function.  
2  No feasible point was found.  
lambda  Structure containing the Lagrange multipliers at the solution x (separated by constraint type). The fields of the structure are  
lower  Lower bounds lb  
upper  Upper bounds ub  
ineqlin  Linear inequalities  
eqlin  Linear equalities  
ineqnonlin  Nonlinear inequalities  
eqnonlin  Nonlinear equalities  
output  Structure containing information about the optimization. The fields of the structure are  
iterations  Number of iterations taken  
funcCount  Number of function evaluations  
lssteplength  Size of final line search step relative to search direction  
stepsize  Final displacement in x  
algorithm  Optimization algorithm used  
firstorderopt  Measure of firstorder optimality  
constrviolation  Maximum of constraint functions  
message  Exit message 
Optimization options used by fgoalattain. Use optimoptions to set or change options. See Optimization Options Reference for detailed information.
DerivativeCheck  Compare usersupplied derivatives (gradients of objective or constraints) to finitedifferencing derivatives. The choices are 'on' or the default, 'off'. 
Diagnostics  Display diagnostic information about the function to be minimized or solved. The choices are 'on' or the default, 'off'. 
DiffMaxChange  Maximum change in variables for finitedifference gradients (a positive scalar). The default is Inf. 
DiffMinChange  Minimum change in variables for finitedifference gradients (a positive scalar). The default is 0. 
Display  Level of display.

FinDiffRelStep  Scalar or vector step size factor. When you set FinDiffRelStep to a vector v, forward finite differences delta are delta = v.*sign(x).*max(abs(x),TypicalX); and central finite differences are delta = v.*max(abs(x),TypicalX); Scalar FinDiffRelStep expands to a vector. The default is sqrt(eps) for forward finite differences, and eps^(1/3) for central finite differences. 
FinDiffType  Finite differences, used to estimate gradients, are either 'forward' (default), or 'central' (centered). 'central' takes twice as many function evaluations, but should be more accurate. The algorithm is careful to obey bounds when estimating both types of finite differences. So, for example, it could take a backward, rather than a forward, difference to avoid evaluating at a point outside bounds. 
FunValCheck  Check whether objective function and constraints values are valid. 'on' displays an error when the objective function or constraints return a value that is complex, Inf, or NaN. The default, 'off', displays no error. 
GoalsExactAchieve  Specifies the number of objectives for which it is required for the objective fun to equal the goal goal (a nonnegative integer). Such objectives should be partitioned into the first few elements of F. The default is 0. 
GradConstr  Gradient for nonlinear constraint functions defined by the user. When set to 'on', fgoalattain expects the constraint function to have four outputs, as described in nonlcon in the Input Arguments section. When set to the default, 'off', gradients of the nonlinear constraints are estimated by finite differences. 
GradObj  Gradient for the objective function defined by the user. See the preceding description of fun to see how to define the gradient in fun. Set to 'on' to have fgoalattain use a userdefined gradient of the objective function. The default, 'off', causes fgoalattain to estimate gradients using finite differences. 
MaxFunEvals  Maximum number of function evaluations allowed (a positive integer). The default is 100*numberOfVariables. 
MaxIter  Maximum number of iterations allowed (a positive integer). The default is 400. 
MaxSQPIter  Maximum number of SQP iterations allowed (a positive integer). The default is 10*max(numberOfVariables, numberOfInequalities + numberOfBounds) 
MeritFunction  Use goal attainment/minimax merit function if set to 'multiobj', the default. Use fmincon merit function if set to 'singleobj'. 
OutputFcn  Specify one or more userdefined functions that an optimization function calls at each iteration, either as a function handle or as a cell array of function handles. The default is none ([]). See Output Function. 
PlotFcns  Plots various measures of progress while the algorithm executes, select from predefined plots or write your own. Pass a function handle or a cell array of function handles. The default is none ([]).
For information on writing a custom plot function, see Plot Functions. 
RelLineSrchBnd  Relative bound (a real nonnegative scalar value) on the line search step length such that the total displacement in x satisfies Δx(i) ≤ relLineSrchBnd· max(x(i),typicalx(i)). This option provides control over the magnitude of the displacements in x for cases in which the solver takes steps that are considered too large. The default is none ([]). 
RelLineSrchBndDuration  Number of iterations for which the bound specified in RelLineSrchBnd should be active (default is 1). 
TolCon  Termination tolerance on the constraint violation, a positive scalar. The default is 1e6. 
TolConSQP  Termination tolerance on inner iteration SQP constraint violation, a positive scalar. The default is 1e6. 
TolFun  Termination tolerance on the function value, a positive scalar. The default is 1e6. 
TolX  Termination tolerance on x, a positive scalar. The default is 1e6. 
TypicalX  Typical x values. The number of elements in TypicalX is equal to the number of elements in x0, the starting point. The default value is ones(numberofvariables,1). fgoalattain uses TypicalX for scaling finite differences for gradient estimation. 
UseParallel  When true, estimate gradients in parallel. Disable by setting to the default, false. See Parallel Computing. 
Consider a linear system of differential equations.
An output feedback controller, K, is designed producing a closed loop system
$$\begin{array}{c}\dot{x}=(A+BKC)x+Bu,\\ y=Cx.\end{array}$$
The eigenvalues of the closed loop system are determined from the matrices A, B, C, and K using the command eig(A+B*K*C). Closed loop eigenvalues must lie on the real axis in the complex plane to the left of the points [5,3,1]. In order not to saturate the inputs, no element in K can be greater than 4 or be less than 4.
The system is a twoinput, twooutput, open loop, unstable system, with statespace matrices.
$$A=\left[\begin{array}{ccc}0.5& 0& 0\\ 0& 2& 10\\ 0& 1& 2\end{array}\right]\text{}B=\left[\begin{array}{cc}1& 0\\ 2& 2\\ 0& 1\end{array}\right]\text{}C=\left[\begin{array}{ccc}1& 0& 0\\ 0& 0& 1\end{array}\right].$$
The set of goal values for the closed loop eigenvalues is initialized as
goal = [5,3,1];
To ensure the same percentage of under or overattainment in the active objectives at the solution, the weighting matrix, weight, is set to abs(goal).
Starting with a controller, K = [1,1; 1,1], first write a function file, eigfun.m.
function F = eigfun(K,A,B,C) F = sort(eig(A+B*K*C)); % Evaluate objectives
Next, enter system matrices and invoke an optimization routine.
A = [0.5 0 0; 0 2 10; 0 1 2]; B = [1 0; 2 2; 0 1]; C = [1 0 0; 0 0 1]; K0 = [1 1; 1 1]; % Initialize controller matrix goal = [5 3 1]; % Set goal values for the eigenvalues weight = abs(goal); % Set weight for same percentage lb = 4*ones(size(K0)); % Set lower bounds on the controller ub = 4*ones(size(K0)); % Set upper bounds on the controller options = optimoptions('fgoalattain','Display','iter'); % Set display parameter [K,fval,attainfactor] = fgoalattain(@(K)eigfun(K,A,B,C),... K0,goal,weight,[],[],[],[],lb,ub,[],options)
You can run this example by using the script goaldemogoaldemo. (From the MATLAB Help browser or the MathWorks Web site documentation, you can click the goaldemo name to display the example.) After about 11 iterations, a solution is
Active inequalities (to within options.TolCon = 1e006): lower upper ineqlin ineqnonlin 1 1 2 2 4 K = 4.0000 0.2564 4.0000 4.0000 fval = 6.9313 4.1588 1.4099 attainfactor = 0.3863
The attainment factor indicates that each of the objectives has been overachieved by at least 38.63% over the original design goals. The active constraints, in this case constraints 1 and 2, are the objectives that are barriers to further improvement and for which the percentage of overattainment is met exactly. Three of the lower bound constraints are also active.
In the preceding design, the optimizer tries to make the objectives less than the goals. For a worstcase problem where the objectives must be as near to the goals as possible, use optimoptions to set the GoalsExactAchieve option to the number of objectives for which this is required.
Consider the preceding problem when you want all the eigenvalues to be equal to the goal values. A solution to this problem is found by invoking fgoalattain with the GoalsExactAchieve option set to 3.
options = optimoptions('fgoalattain','GoalsExactAchieve',3); [K,fval,attainfactor] = fgoalattain(... @(K)eigfun(K,A,B,C),K0,goal,weight,[],[],[],[],lb,ub,[],... options);
After about seven iterations, a solution is
K,fval,attainfactor K = 1.5954 1.2040 0.4201 2.9046 fval = 5.0000 3.0000 1.0000 attainfactor = 1.1304e022
In this case the optimizer has tried to match the objectives to the goals. The attainment factor (of 1.1304e22 or so, depending on your system) indicates that the goals have been matched almost exactly.
This problem has discontinuities when the eigenvalues become complex; this explains why the convergence is slow. Although the underlying methods assume the functions are continuous, the method is able to make steps toward the solution because the discontinuities do not occur at the solution point. When the objectives and goals are complex, fgoalattain tries to achieve the goals in a leastsquares sense.
[1] Brayton, R.K., S.W. Director, G.D. Hachtel, and L.Vidigal, "A New Algorithm for Statistical Circuit Design Based on QuasiNewton Methods and Function Splitting," IEEE Transactions on Circuits and Systems, Vol. CAS26, pp 784794, Sept. 1979.
[2] Fleming, P.J. and A.P. Pashkevich, Computer Aided Control System Design Using a MultiObjective Optimisation Approach, Control 1985 Conference, Cambridge, UK, pp. 174179.
[3] Gembicki, F.W., "Vector Optimization for Control with Performance and Parameter Sensitivity Indices," Ph.D. Dissertation, Case Western Reserve Univ., Cleveland, OH, 1974.
[4] Grace, A.C.W., "ComputerAided Control System Design Using Optimization Techniques," Ph.D. Thesis, University of Wales, Bangor, Gwynedd, UK, 1989.
[5] Han, S.P., "A Globally Convergent Method For Nonlinear Programming," Journal of Optimization Theory and Applications, Vol. 22, p. 297, 1977.
[6] Powell, M.J.D., "A Fast Algorithm for Nonlinear Constrained Optimization Calculations," Numerical Analysis, ed. G.A. Watson, Lecture Notes in Mathematics, Vol. 630, Springer Verlag, 1978.