fgoalattain

Solve multiobjective goal attainment problems

Equation

Finds the minimum of a problem specified by

$\underset{x, γ}{minimize} γ such that {\begin{matrix} F (x) - w e i g h t \cdot γ \leq g o a l \\ c (x) \leq 0 \\ c e q (x) = 0 \\ A \cdot x \leq b \\ A e q \cdot x = b e q \\ l b \leq x \leq u b . \end{matrix}$

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.

Syntax

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(...)

Description

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.

Note

If the specified input bounds for a problem are inconsistent, the output x is x0 and the output fval is [].

Input Arguments

Function Input Arguments contains general descriptions of arguments passed into fgoalattain. This section provides function-specific details for fun, goal, nonlcon, options, weight, and problem:

`fun`	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 user-defined values for `x` and `F` are matrices, they are converted to a vector using linear indexing (MATLAB). 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 `EqualityGoalCount` 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 `SpecifyObjectiveGradient` option is `true`, as set by options = optimoptions('fgoalattain','SpecifyObjectiveGradient',true) 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 `n`-by-`m` matrix where `G(i,j)` is the partial derivative of `F(j)` with respect to `x(i)` (i.e., the `j`th column of `G` is the gradient of the `j`th objective function `F(j)`). Note Setting `SpecifyObjectiveGradient` to `true` is effective only when there is no nonlinear constraint, or when the nonlinear constraint has `SpecifyConstraintGradient` set to `true` as well. This is because internally the objective is folded into the constraints, so the solver needs both gradients (objective and constraint) supplied in order to avoid estimating a gradient.
`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`.
`nonlcon`	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 `SpecifyConstraintGradient` option is `true`, as set by options = optimoptions('fgoalattain','SpecifyConstraintGradient',true) 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 `n`-by-`m` matrix, where `GC(i,j)` is the partial derivative of `c(j)` with respect to `x(i)` (i.e., the `j`th column of `GC` is the gradient of the `j`th inequality constraint `c(j)`). Likewise, if `ceq` has `p` components, the gradient `GCeq` of `ceq(x)` is an `n`-by-`p` matrix, where `GCeq(i,j)` is the partial derivative of `ceq(j)` with respect to `x(i)` (i.e., the `j`th column of `GCeq` is the gradient of the `j`th equality constraint `ceq(j)`). Note Setting `SpecifyConstraintGradient` to `true` is effective only when `SpecifyObjectiveGradient` is set to `true` as well. This is because internally the objective is folded into the constraint, so the solver needs both gradients (objective and constraint) supplied in order to avoid estimating a gradient. Note Because Optimization Toolbox™ functions only accept inputs of type `double`, user-supplied objective and nonlinear constraint functions must return outputs of type `double`. Passing Extra Parameters explains how to parameterize the nonlinear constraint function `nonlcon`, if necessary.
`options`	Options provides the function-specific 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.) Note Setting a component of the `weight` vector to zero will cause the corresponding goal constraint to be treated as a hard constraint rather than as a goal constraint. An alternative method to set a hard constraint is to use the input argument `nonlcon`.
`weight`	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 `EqualityGoalCount` 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`

Output Arguments

Function Input Arguments contains general descriptions of arguments returned by fgoalattain. This section provides function-specific 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.ConstraintTolerance`
	`5`	Magnitude of directional derivative less than the specified tolerance and constraint violation less than `options.ConstraintTolerance`
	`0`	Number of iterations exceeded `options.MaxIterations` or number of function evaluations exceeded `options.MaxFunctionEvaluations`
	`-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 first-order optimality
	`constrviolation`	Maximum of constraint functions
	`message`	Exit message

Options

Optimization options used by fgoalattain. Use optimoptions to set or change options. See Optimization Options Reference for detailed information.

Some options are absent from the optimoptions display. These options are listed in italics. For details, see View Options.

`ConstraintTolerance`	Termination tolerance on the constraint violation, a positive scalar. The default is `1e-6`. See Tolerances and Stopping Criteria.
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 finite-difference gradients (a positive scalar). The default is `Inf`.
DiffMinChange	Minimum change in variables for finite-difference gradients (a positive scalar). The default is `0`.
`Display`	Level of display (see Iterative Display): `'off'` or `'none'` displays no output. `'iter'` displays output at each iteration, and gives the default exit message. `'iter-detailed'` displays output at each iteration, and gives the technical exit message. `'notify'` displays output only if the function does not converge, and gives the default exit message. `'notify-detailed'` displays output only if the function does not converge, and gives the technical exit message. `'final'` (default) displays just the final output, and gives the default exit message. `'final-detailed'` displays just the final output, and gives the technical exit message.
`EqualityGoalCount`	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`.
`FiniteDifferenceStepSize`	Scalar or vector step size factor for finite differences. When you set `FiniteDifferenceStepSize` to a vector `v`, forward finite differences steps `delta` are `delta = v.sign′(x).max(abs(x),TypicalX);` where `sign′(x) = sign(x)` except `sign′(0) = 1`. Central finite differences are `delta = v.*max(abs(x),TypicalX);` Scalar `FiniteDifferenceStepSize` expands to a vector. The default is `sqrt(eps)` for forward finite differences, and `eps^(1/3)` for central finite differences.
`FiniteDifferenceType`	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.
`FunctionTolerance`	Termination tolerance on the function value, a positive scalar. The default is `1e-6`. See Tolerances and Stopping Criteria.
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.
`MaxFunctionEvaluations`	Maximum number of function evaluations allowed (a positive integer). The default is `100*numberOfVariables`. See Tolerances and Stopping Criteria and Iterations and Function Counts.
`MaxIterations`	Maximum number of iterations allowed (a positive integer). The default is `400`. See Tolerances and Stopping Criteria and Iterations and Function Counts.
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'`.
`OptimalityTolerance`	Termination tolerance on the first-order optimality, a positive scalar. The default is `1e-6`. See First-Order Optimality Measure.
`OutputFcn`	Specify one or more user-defined 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.
`PlotFcn`	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 (`[]`). `@optimplotx` plots the current point `@optimplotfunccount` plots the function count `@optimplotfval` plots the function value `@optimplotconstrviolation` plots the maximum constraint violation `@optimplotstepsize` plots the step size 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`).
`SpecifyConstraintGradient`	Gradient for nonlinear constraint functions defined by the user. When set to `true`, `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.
`SpecifyObjectiveGradient`	Gradient for the objective function defined by the user. See the preceding description of `fun` in the Input Arguments section to see how to define the gradient in `fun`. Set to `true` to have `fgoalattain` use a user-defined gradient of the objective function. The default, `false`, causes `fgoalattain` to estimate gradients using finite differences.
`StepTolerance`	Termination tolerance on `x`, a positive scalar. The default is 1e-6. See Tolerances and Stopping Criteria.
TolConSQP	Termination tolerance on inner iteration SQP constraint violation, a positive scalar. The default is `1e-6`.
`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.

Examples

Consider a linear system of differential equations.

An output feedback controller, K, is designed producing a closed loop system

$\begin{matrix} \dot{x} = (A + B K C) x + B u, \\ y = C x . \end{matrix}$

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 two-input, two-output, open loop, unstable system, with state-space matrices.

$A = [\begin{matrix} - 0.5 & 0 & 0 \\ 0 & - 2 & 10 \\ 0 & 1 & - 2 \end{matrix}] B = [\begin{matrix} 1 & 0 \\ - 2 & 2 \\ 0 & 1 \end{matrix}] C = [\begin{matrix} 1 & 0 & 0 \\ 0 & 0 & 1 \end{matrix}] .$

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)

After about 11 iterations, a solution is

Active inequalities (to within options.ConstraintTolerance = 1e-006):
  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

Discussion

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 worst-case problem where the objectives must be as near to the goals as possible, use optimoptions to set the EqualityGoalCount 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 EqualityGoalCount option set to 3.

options = optimoptions('fgoalattain','EqualityGoalCount',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.1304e-022

In this case the optimizer has tried to match the objectives to the goals. The attainment factor (of 1.1304e-22 or so, depending on your system) indicates that the goals have been matched almost exactly.

For complete results of this example, including graphs of the system response, see Multi-Objective Goal Attainment Optimization.

Notes

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 least-squares sense.

Limitations

The objectives must be continuous. fgoalattain might give only local solutions.

Algorithms

Multiobjective optimization concerns the minimization of a set of objectives simultaneously. One formulation for this problem, and implemented in fgoalattain, is the goal attainment problem of Gembicki [3]. This entails the construction of a set of goal values for the objective functions. Multiobjective optimization is discussed in Multiobjective Optimization Algorithms.

In this implementation, the slack variable γ is used as a dummy argument to minimize the vector of objectives F(x) simultaneously; goal is a set of values that the objectives attain. Generally, prior to the optimization, it is not known whether the objectives will reach the goals (under attainment) or be minimized less than the goals (overattainment). A weighting vector, weight, controls the relative underattainment or overattainment of the objectives.

fgoalattain uses a sequential quadratic programming (SQP) method, which is described in Sequential Quadratic Programming (SQP). Modifications are made to the line search and Hessian. In the line search an exact merit function (see [1] and [4]) is used together with the merit function proposed by [5] and [6]. The line search is terminated when either merit function shows improvement. A modified Hessian, which takes advantage of the special structure of the problem, is also used (see [1] and [4]). A full description of the modifications used is found in Goal Attainment Method in “Introduction to Algorithms.” Setting the MeritFunction option to 'singleobj' with

options = optimoptions(options,'MeritFunction','singleobj')

uses the merit function and Hessian used in fmincon.

See also SQP Implementation for more details on the algorithm used and the types of procedures displayed under the Procedures heading when the Display option is set to 'iter'.

References

[1] Brayton, R. K., S. W. Director, G. D. Hachtel, and L.Vidigal, “A New Algorithm for Statistical Circuit Design Based on Quasi-Newton Methods and Function Splitting,” IEEE Transactions on Circuits and Systems, Vol. CAS-26, pp 784-794, Sept. 1979.

[2] Fleming, P.J. and A.P. Pashkevich, Computer Aided Control System Design Using a Multi-Objective Optimisation Approach, Control 1985 Conference, Cambridge, UK, pp. 174-179.

[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., “Computer-Aided 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.

Documentation

fgoalattain

Equation

Syntax

Description

Note

Note

Note

Input Arguments

Note

Note

Note

Note

Output Arguments

Options

Examples

Discussion

Notes

Limitations

Algorithms

References

See Also

Topics

Introduced before R2006a

Optimization Toolbox Documentation

Other Documentation

Support