fminimax

Solve minimax constraint problem

collapse all in page

Syntax

x = fminimax(fun,x0)

x = fminimax(fun,x0,A,b)

x = fminimax(fun,x0,A,b,Aeq,beq)

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub)

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

x = fminimax(problem)

[x,fval]
= fminimax(___)

[x,fval,maxfval,exitflag,output]
= fminimax(___)

[x,fval,maxfval,exitflag,output,lambda]
= fminimax(___)

Description

fminimax seeks a point that minimizes the maximum of a set of objective functions.

The problem includes any type of constraint. In detail, fminimax seeks the minimum of a problem specified by

$\min_{x} \max_{i} F_{i} (x) such that {\begin{matrix} 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}$

where 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.

You can also solve max-min problems with fminimax, using the identity

$\max_{x} \min_{i} F_{i} (x) = - \min_{x} \max_{i} (- F_{i} (x)) .$

You can solve problems of the form

$\min_{x} \max_{i} | F_{i} (x) |$

by using the AbsoluteMaxObjectiveCount option; see Solve Minimax Problem Using Absolute Value of One Objective.

x = fminimax(fun,x0) starts at x0 and finds a minimax solution x to the functions described in fun.

Note

Passing Extra Parameters explains how to pass extra parameters to the objective functions and nonlinear constraint functions, if necessary.

example

x = fminimax(fun,x0,A,b) solves the minimax problem subject to the linear inequalities A*x ≤ b.

example

x = fminimax(fun,x0,A,b,Aeq,beq) solves the minimax problem subject to the linear equalities Aeq*x = beq as well. If no inequalities exist, set A = [] and b = [].

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub) solves the minimax problem subject to the bounds lb ≤ x ≤ ub. If no equalities exist, set Aeq = [] and beq = []. If x(i) is unbounded below, set lb(i) = –Inf; if x(i) is unbounded above, set ub(i) = Inf.

Note

See Iterations Can Violate Constraints.

Note

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

example

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon) solves the minimax problem subject to the nonlinear inequalities c(x) or equalities ceq(x) defined in nonlcon. The function optimizes such that c(x) ≤ 0 and ceq(x) = 0. If no bounds exist, set lb = [] or ub = [], or both.

example

x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options) solves the minimax problem with the optimization options specified in options. Use optimoptions to set these options.

example

x = fminimax(problem) solves the minimax problem for problem, a structure described in problem.

[x,fval] = fminimax(___), for any syntax, returns the values of the objective functions computed in fun at the solution x.

example

[x,fval,maxfval,exitflag,output] = fminimax(___) additionally returns the maximum value of the objective functions at the solution x, a value exitflag that describes the exit condition of fminimax, and a structure output with information about the optimization process.

example

[x,fval,maxfval,exitflag,output,lambda] = fminimax(___) additionally returns a structure lambda whose fields contain the Lagrange multipliers at the solution x.

example

Examples

collapse all

Minimize Maximum of `sin` and `cos`

Open Live Script

Create a plot of the sin and cos functions and their maximum over the interval [–pi,pi].

t = linspace(-pi,pi);
plot(t,sin(t),'r-')
hold on
plot(t,cos(t),'b-');
plot(t,max(sin(t),cos(t)),'ko')
legend('sin(t)','cos(t)','max(sin(t),cos(t))','Location','NorthWest')

Figure contains an axes object. The axes object contains 3 objects of type line. One or more of the lines displays its values using only markers These objects represent sin(t), cos(t), max(sin(t),cos(t)).

The plot shows two local minima of the maximum, one near 1, and the other near –2. Find the minimum near 1.

fun = @(x)[sin(x);cos(x)];
x0 = 1;
x1 = fminimax(fun,x0)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x1 = 
0.7854

Find the minimum near –2.

x0 = -2;
x2 = fminimax(fun,x0)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x2 = 
-2.3562

Solve Linearly Constrained Minimax Problem

Open Live Script

The objective functions for this example are linear plus constants. For a description and plot of the objective functions, see Compare fminimax and fminunc.

Set the objective functions as three linear functions of the form $d o t (x, v) + v_{0}$ for three vectors $v$ and three constants $v_{0}$ .

a = [1;1];
b = [-1;1];
c = [0;-1];
a0 = 2;
b0 = -3;
c0 = 4;
fun = @(x)[x*a+a0,x*b+b0,x*c+c0];

Find the minimax point subject to the inequality x(1) + 3*x(2) <= –4.

A = [1,3];
b = -4;
x0 = [-1,-2];
x = fminimax(fun,x0,A,b)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2

   -5.8000    0.6000

Solve Bound-Constrained Minimax Problem

Open Live Script

The objective functions for this example are linear plus constants. For a description and plot of the objective functions, see Compare fminimax and fminunc.

Set the objective functions as three linear functions of the form $d o t (x, v) + v_{0}$ for three vectors $v$ and three constants $v_{0}$ .

a = [1;1];
b = [-1;1];
c = [0;-1];
a0 = 2;
b0 = -3;
c0 = 4;
fun = @(x)[x*a+a0,x*b+b0,x*c+c0];

Set bounds that –2 <= x(1) <= 2 and –1 <= x(2) <= 1 and solve the minimax problem starting from [0,0].

lb = [-2,-1];
ub = [2,1];
x0 = [0,0];
A = []; % No linear constraints
b = [];
Aeq = [];
beq = [];
[x,fval] = fminimax(fun,x0,A,b,Aeq,beq,lb,ub)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2

   -0.0000    1.0000

fval = 1×3

    3.0000   -2.0000    3.0000

In this case, the solution is not unique. Many points satisfy the constraints and have the same minimax value. Plot the surface representing the maximum of the three objective functions, and plot a red line showing the points that have the same minimax value.

[X,Y] = meshgrid(linspace(-2,2),linspace(-1,1));
Z = max(fun([X(:),Y(:)]),[],2);
Z = reshape(Z,size(X));
surf(X,Y,Z,'LineStyle','none')
view(-118,28)
hold on
line([-2,0],[1,1],[3,3],'Color','r','LineWidth',8)
hold off

Figure contains an axes object. The axes object contains 2 objects of type surface, line.

Find Minimax Subject to Nonlinear Constraints

Open Live Script

The objective functions for this example are linear plus constants. For a description and plot of the objective functions, see Compare fminimax and fminunc.

Set the objective functions as three linear functions of the form $d o t (x, v) + v_{0}$ for three vectors $v$ and three constants $v_{0}$ .

a = [1;1];
b = [-1;1];
c = [0;-1];
a0 = 2;
b0 = -3;
c0 = 4;
fun = @(x)[x*a+a0,x*b+b0,x*c+c0];

The unitdisk function represents the nonlinear inequality constraint $‖ x ‖^{2} \leq 1$ .

type unitdisk

function [c,ceq] = unitdisk(x)
c = x(1)^2 + x(2)^2 - 1;
ceq = [];

Solve the minimax problem subject to the unitdisk constraint, starting from x0 = [0,0].

x0 = [0,0];
A = []; % No other constraints
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
nonlcon = @unitdisk;
x = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2

   -0.0000    1.0000

Solve Minimax Problem Using Absolute Value of One Objective

Open Live Script

fminimax can minimize the maximum of either $F_{i} (x)$ or $| F_{i} (x) |$ for the first several values of $i$ by using the AbsoluteMaxObjectiveCount option. To minimize the absolute values of $k$ of the objectives, arrange the objective function values so that $F_{1} (x)$ through $F_{k} (x)$ are the objectives for absolute minimization, and set the AbsoluteMaxObjectiveCount option to k.

In this example, minimize the maximum of sin and cos, specify sin as the first objective, and set AbsoluteMaxObjectiveCount to 1.

fun = @(x)[sin(x),cos(x)];
options = optimoptions('fminimax','AbsoluteMaxObjectiveCount',1);
x0 = 1;
A = []; % No constraints
b = [];
Aeq = [];
beq = [];
lb = [];
ub = [];
nonlcon = [];
x1 = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x1 = 
0.7854

Try starting from x0 = –2.

x0 = -2;
x2 = fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x2 = 
-3.1416

Plot the function.

t = linspace(-pi,pi);
plot(t,max(abs(sin(t)),cos(t)))

Figure contains an axes object. The axes object contains an object of type line.

To see the effect of the AbsoluteMaxObjectiveCount option, compare this plot to the plot in the example Minimize Maximum of sin and cos.

Obtain Minimax Value

Open Live Script

Obtain both the location of the minimax point and the value of the objective functions. For a description and plot of the objective functions, see Compare fminimax and fminunc.

Set the objective functions as three linear functions of the form $d o t (x, v) + v_{0}$ for three vectors $v$ and three constants $v_{0}$ .

a = [1;1];
b = [-1;1];
c = [0;-1];
a0 = 2;
b0 = -3;
c0 = 4;
fun = @(x)[x*a+a0,x*b+b0,x*c+c0];

Set the initial point to [0,0] and find the minimax point and value.

x0 = [0,0];
[x,fval] = fminimax(fun,x0)

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2

   -2.5000    2.2500

fval = 1×3

    1.7500    1.7500    1.7500

All three objective functions have the same value at the minimax point. Unconstrained problems typically have at least two objectives that are equal at the solution, because if a point is not a local minimum for any objective and only one objective has the maximum value, then the maximum objective can be lowered.

Obtain All Minimax Outputs

Open Live Script

The objective functions for this example are linear plus constants. For a description and plot of the objective functions, see Compare fminimax and fminunc.

Set the objective functions as three linear functions of the form $d o t (x, v) + v_{0}$ for three vectors $v$ and three constants $v_{0}$ .

a = [1;1];
b = [-1;1];
c = [0;-1];
a0 = 2;
b0 = -3;
c0 = 4;
fun = @(x)[x*a+a0,x*b+b0,x*c+c0];

Find the minimax point subject to the inequality x(1) + 3*x(2) <= –4.

A = [1,3];
b = -4;
x0 = [-1,-2];

Set options for iterative display, and obtain all solver outputs.

options = optimoptions('fminimax','Display','iter');
Aeq = []; % No other constraints
beq = [];
lb = [];
ub = [];
nonlcon = [];
[x,fval,maxfval,exitflag,output,lambda] =...
    fminimax(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon,options)

                  Objective        Max     Line search     Directional 
 Iter F-count         value    constraint   steplength      derivative   Procedure 
    0      4              0             6                                            
    1      9              5             0            1           0.981     
    2     14          4.889             0            1          -0.302    Hessian modified twice  
    3     19            3.4     8.132e-09            1          -0.302    Hessian modified twice  

Local minimum possible. Constraints satisfied.

fminimax stopped because the size of the current search direction is less than
twice the value of the step size tolerance and constraints are 
satisfied to within the value of the constraint tolerance.

x = 1×2

   -5.8000    0.6000

fval = 1×3

   -3.2000    3.4000    3.4000

maxfval = 
3.4000

exitflag = 
4

output = struct with fields:
         iterations: 4
          funcCount: 19
       lssteplength: 1
           stepsize: 6.0684e-10
          algorithm: 'active-set'
      firstorderopt: []
    constrviolation: 8.1323e-09
            message: 'Local minimum possible. Constraints satisfied....'

lambda = struct with fields:
         lower: [2x1 double]
         upper: [2x1 double]
         eqlin: [0x1 double]
      eqnonlin: [0x1 double]
       ineqlin: 0.2000
    ineqnonlin: [0x1 double]

Examine the returned information:

Two objective function values are equal at the solution.
The solver converges in 4 iterations and 19 function evaluations.
The lambda.ineqlin value is nonzero, indicating that the linear constraint is active at the solution.

Input Arguments

collapse all

`fun` — Objective functions
function handle | function name

Objective functions, specified as a function handle or function name. fun is a function that accepts a vector x and returns a vector F, the objective functions evaluated at x. You can specify the function fun as a function handle for a function file:

x = fminimax(@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 = fminimax(@(x)sin(x.*x),x0,goal,weight);

fminimax passes x to your objective function and any nonlinear constraint functions in the shape of the x0 argument. For example, if x0 is a 5-by-3 array, then fminimax passes x to fun as a 5-by-3 array. However, fminimax multiplies linear constraint matrices A or Aeq with x after converting x to the column vector x(:).

To minimize the worst-case absolute values of some elements of the vector F(x) (that is, min{max abs{F(x)} } ), partition those objectives into the first elements of F and use optimoptions to set the AbsoluteMaxObjectiveCount option to the number of these objectives. These objectives must be partitioned into the first elements of the vector F returned by fun. For an example, see Solve Minimax Problem Using Absolute Value of One Objective.

Assume that the gradients of the objective functions can also be computed and the SpecifyObjectiveGradient option is true, as set by:

options = optimoptions('fminimax','SpecifyObjectiveGradient',true)

In this case, the function fun must return, in the second output argument, the gradient values 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) (that is, the jth column of G is the gradient of the jth objective function F(j)). If you define F as an array, then the preceding discussion applies to F(:), the linear ordering of the F array. In any case, G is a 2-D matrix.

Note

Setting SpecifyObjectiveGradient to true is effective only when the problem has no nonlinear constraint, or when the problem has a nonlinear constraint with SpecifyConstraintGradient set to true. 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.

Data Types: char | string | function_handle

`x0` — Initial point
real vector | real array

Initial point, specified as a real vector or real array. Solvers use the number of elements in x0 and the size of x0 to determine the number and size of variables that fun accepts.

Example: x0 = [1,2,3,4]

Data Types: double

`A` — Linear inequality constraints
real matrix

Linear inequality constraints, specified as a real matrix. A is an M-by-N matrix, where M is the number of inequalities, and N is the number of variables (number of elements in x0). For large problems, pass A as a sparse matrix.

A encodes the M linear inequalities

A*x <= b,

where x is the column vector of N variables x(:), and b is a column vector with M elements.

For example, consider these inequalities:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30,

Specify the inequalities by entering the following constraints.

A = [1,2;3,4;5,6];
b = [10;20;30];

Example: To specify that the x components sum to 1 or less, use A = ones(1,N) and b = 1.

Data Types: single | double

`b` — Linear inequality constraints
real vector

Linear inequality constraints, specified as a real vector. b is an M-element vector related to the A matrix. If you pass b as a row vector, solvers internally convert b to the column vector b(:). For large problems, pass b as a sparse vector.

b encodes the M linear inequalities

A*x <= b,

where x is the column vector of N variables x(:), and A is a matrix of size M-by-N.

For example, consider these inequalities:

x₁ + 2x₂ ≤ 10
3x₁ + 4x₂ ≤ 20
5x₁ + 6x₂ ≤ 30.

Specify the inequalities by entering the following constraints.

A = [1,2;3,4;5,6];
b = [10;20;30];

Example: To specify that the x components sum to 1 or less, use A = ones(1,N) and b = 1.

Data Types: single | double

`Aeq` — Linear equality constraints
real matrix

Linear equality constraints, specified as a real matrix. Aeq is an Me-by-N matrix, where Me is the number of equalities, and N is the number of variables (number of elements in x0). For large problems, pass Aeq as a sparse matrix.

Aeq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and beq is a column vector with Me elements.

For example, consider these inequalities:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20,

Specify the inequalities by entering the following constraints.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Example: To specify that the x components sum to 1, use Aeq = ones(1,N) and beq = 1.

Data Types: single | double

`beq` — Linear equality constraints
real vector

Linear equality constraints, specified as a real vector. beq is an Me-element vector related to the Aeq matrix. If you pass beq as a row vector, solvers internally convert beq to the column vector beq(:). For large problems, pass beq as a sparse vector.

beq encodes the Me linear equalities

Aeq*x = beq,

where x is the column vector of N variables x(:), and Aeq is a matrix of size Me-by-N.

For example, consider these equalities:

x₁ + 2x₂ + 3x₃ = 10
2x₁ + 4x₂ + x₃ = 20.

Specify the equalities by entering the following constraints.

Aeq = [1,2,3;2,4,1];
beq = [10;20];

Example: To specify that the x components sum to 1, use Aeq = ones(1,N) and beq = 1.

Data Types: single | double

`lb` — Lower bounds
real vector | real array

Lower bounds, specified as a real vector or real array. If the number of elements in x0 is equal to the number of elements in lb, then lb specifies that

x(i) >= lb(i) for all i.

If numel(lb) < numel(x0), then lb specifies that

x(i) >= lb(i) for 1 <= i <= numel(lb).

If lb has fewer elements than x0, solvers issue a warning.

Example: To specify that all x components are positive, use lb = zeros(size(x0)).

Data Types: single | double

`ub` — Upper bounds
real vector | real array

Upper bounds, specified as a real vector or real array. If the number of elements in x0 is equal to the number of elements in ub, then ub specifies that

x(i) <= ub(i) for all i.

If numel(ub) < numel(x0), then ub specifies that

x(i) <= ub(i) for 1 <= i <= numel(ub).

If ub has fewer elements than x0, solvers issue a warning.

Example: To specify that all x components are less than 1, use ub = ones(size(x0)).

Data Types: single | double

`nonlcon` — Nonlinear constraints
function handle | function name

Nonlinear constraints, specified as a function handle or function name. nonlcon is a function that accepts a vector or array x and returns two arrays, c(x) and ceq(x).

c(x) is the array of nonlinear inequality constraints at x. fminimax attempts to satisfy
c(x) <= 0 for all entries of c.
ceq(x) is the array of nonlinear equality constraints at x. fminimax attempts to satisfy
ceq(x) = 0 for all entries of ceq.

For example,

x = fminimax(@myfun,x0,...,@mycon)

where mycon is a MATLAB function such as the following:

function [c,ceq] = mycon(x)
c = ...     % Compute nonlinear inequalities at x.
ceq = ...   % Compute nonlinear equalities at x.

Suppose that the gradients of the constraints can also be computed and the SpecifyConstraintGradient option is true, as set by:

options = optimoptions('fminimax','SpecifyConstraintGradient',true)

In this case, 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). See Nonlinear Constraints for an explanation of 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) (that is, 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 n-by-p matrix, where GCeq(i,j) is the partial derivative of ceq(j) with respect to x(i) (that is, the jth column of GCeq is the gradient of the jth equality constraint ceq(j)).

Note

Setting SpecifyConstraintGradient to true is effective only when SpecifyObjectiveGradient is set to true. 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 accept only inputs of type double, user-supplied objective and nonlinear constraint functions must return outputs of type double.

See Passing Extra Parameters for an explanation of how to parameterize the nonlinear constraint function nonlcon, if necessary.

Data Types: char | function_handle | string

`options` — Optimization options
output of `optimoptions` | structure such as `optimset` returns

Optimization options, specified as the output of optimoptions or a structure such as optimset returns.

Some options are absent from the optimoptions display. These options appear in italics in the following table. For details, see View Optimization Options.

For details about options that have different names for optimset, see Current and Legacy Option Names.

Option	Description
`AbsoluteMaxObjectiveCount`	Number of elements of F_i(x) for which to minimize the absolute value of F_i. See Solve Minimax Problem Using Absolute Value of One Objective. For `optimset`, the name is `MinAbsMax`.
`ConstraintTolerance`	Termination tolerance on the constraint violation (a nonnegative scalar). The default is `1e-6`. See Tolerances and Stopping Criteria. For `optimset`, the name is `TolCon`.
Diagnostics	Display of diagnostic information about the function to be minimized or solved. The choices are `'on'` or `'off'` (the default).
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 only the final output, and gives the default exit message. `'final-detailed'` displays only the final output, and gives the technical exit message.
`FiniteDifferenceStepSize`	Scalar or vector step size factor for finite differences. When you set `FiniteDifferenceStepSize` to a vector `v`, the forward finite differences `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);` A scalar `FiniteDifferenceStepSize` expands to a vector. The default is `sqrt(eps)` for forward finite differences, and `eps^(1/3)` for central finite differences. For `optimset`, the name is `FinDiffRelStep`.
`FiniteDifferenceType`	Type of finite differences used to estimate gradients, either `'forward'` (default) or `'central'` (centered). `'central'` takes twice as many function evaluations, but is generally more accurate. The algorithm is careful to obey bounds when estimating both types of finite differences. For example, it might take a backward difference, rather than a forward difference, to avoid evaluating at a point outside the bounds. For `optimset`, the name is `FinDiffType`.
`FunctionTolerance`	Termination tolerance on the function value (a nonnegative scalar). The default is `1e-6`. See Tolerances and Stopping Criteria. For `optimset`, the name is `TolFun`.
FunValCheck	Check that signifies whether the objective function and constraint 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 nonnegative integer). The default is `100*numberOfVariables`. See Tolerances and Stopping Criteria and Iterations and Function Counts. For `optimset`, the name is `MaxFunEvals`.
`MaxIterations`	Maximum number of iterations allowed (a nonnegative integer). The default is `400`. See Tolerances and Stopping Criteria and Iterations and Function Counts. For `optimset`, the name is `MaxIter`.
MaxSQPIter	Maximum number of SQP iterations allowed (a positive integer). The default is `10*max(numberOfVariables, numberOfInequalities + numberOfBounds)`.
MeritFunction	If this option is set to `'multiobj'` (the default), use the goal attainment or minimax merit function. If this option is set to `'singleobj'`, use the `fmincon` merit function.
`OptimalityTolerance`	Termination tolerance on the first-order optimality (a nonnegative scalar). The default is `1e-6`. See First-Order Optimality Measure. For `optimset`, the name is `TolFun`.
`OutputFcn`	One or more user-defined functions that an optimization function calls at each iteration. Pass a function handle or a cell array of function handles. The default is none (`[]`). See Output Function and Plot Function Syntax.
`PlotFcn`	Plots showing various measures of progress while the algorithm executes. Select from predefined plots or write your own. Pass a name, function handle, or cell array of names or function handles. For custom plot functions, pass function handles. The default is none (`[]`). `'optimplotx'` plots the current point. `'optimplotfunccount'` plots the function count. `'optimplotfval'` plots the objective function values. `'optimplotconstrviolation'` plots the maximum constraint violation. `'optimplotstepsize'` plots the step size. Custom plot functions use the same syntax as output functions. See Output Functions for Optimization Toolbox and Output Function and Plot Function Syntax. For `optimset`, the name is `PlotFcns`.
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` when the solver takes steps that are too large. The default is none (`[]`).
RelLineSrchBndDuration	Number of iterations for which the bound specified in `RelLineSrchBnd` should be active. The default is `1`.
`SpecifyConstraintGradient`	Gradient for nonlinear constraint functions defined by the user. When this option is set to `true`, `fminimax` expects the constraint function to have four outputs, as described in `nonlcon`. When this option is set to `false` (the default), `fminimax` estimates gradients of the nonlinear constraints using finite differences. For `optimset`, the name is `GradConstr` and the values are `'on'` or `'off'`.
`SpecifyObjectiveGradient`	Gradient for the objective function defined by the user. Refer to the description of `fun` to see how to define the gradient. Set this option to `true` to have `fminimax` use a user-defined gradient of the objective function. The default, `false`, causes `fminimax` to estimate gradients using finite differences. For `optimset`, the name is `GradObj` and the values are `'on'` or `'off'`.
`StepTolerance`	Termination tolerance on `x` (a nonnegative scalar). The default is 1e-6. See Tolerances and Stopping Criteria. For `optimset`, the name is `TolX`.
TolConSQP	Termination tolerance on the 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)`. The `fminimax` function uses `TypicalX` for scaling finite differences for gradient estimation.
`UseParallel`	Option for using parallel computing. When this option is set to `true`, `fminimax` estimates gradients in parallel. The default is `false`. See Parallel Computing.

Example: optimoptions('fminimax','PlotFcn','optimplotfval')

`problem` — Problem structure
structure

Problem structure, specified as a structure with the fields in this table.

Field Name	Entry
`objective`	Objective function `fun`
`x0`	Initial point for `x`
`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`	`'fminimax'`
`options`	Options created with `optimoptions`

You must supply at least the objective, x0, solver, and options fields in the problem structure.

Data Types: struct

Output Arguments

collapse all

`x` — Solution
real vector | real array

Solution, returned as a real vector or real array. The size of x is the same as the size of x0. Typically, x is a local solution to the problem when exitflag is positive. For information on the quality of the solution, see When the Solver Succeeds.

`fval` — Objective function values at solution
real array

Objective function values at the solution, returned as a real array. Generally, fval = fun(x).

`maxfval` — Maximum of objective function values at solution
real scalar

Maximum of the objective function values at the solution, returned as a real scalar. maxfval = max(fval(:)).

`exitflag` — Reason `fminimax` stopped
integer

Reason fminimax stopped, returned as an integer.

`1`	Function converged to a solution `x`
`4`	Magnitude of the search direction was less than the specified tolerance, and the constraint violation was less than `options.ConstraintTolerance`
`5`	Magnitude of the directional derivative was less than the specified tolerance, and the constraint violation was less than `options.ConstraintTolerance`
`0`	Number of iterations exceeded `options.MaxIterations` or the number of function evaluations exceeded `options.MaxFunctionEvaluations`
`-1`	Stopped by an output function or plot function
`-2`	No feasible point was found.

`output` — Information about optimization process
structure

Information about the optimization process, returned as a structure with the fields in this table.

`iterations`	Number of iterations taken
`funcCount`	Number of function evaluations
`lssteplength`	Size of the line search step relative to the search direction
`constrviolation`	Maximum of the constraint functions
`stepsize`	Length of the last displacement in `x`
`algorithm`	Optimization algorithm used
`firstorderopt`	Measure of first-order optimality
`message`	Exit message

`lambda` — Lagrange multipliers at solution
structure

Lagrange multipliers at the solution, returned as a structure with the fields in this table.

`lower`	Lower bounds corresponding to `lb`
`upper`	Upper bounds corresponding to `ub`
`ineqlin`	Linear inequalities corresponding to `A` and `b`
`eqlin`	Linear equalities corresponding to `Aeq` and `beq`
`ineqnonlin`	Nonlinear inequalities corresponding to the `c` in `nonlcon`
`eqnonlin`	Nonlinear equalities corresponding to the `ceq` in `nonlcon`

Algorithms

fminimax solves a minimax problem by converting it into a goal attainment problem, and then solving the converted goal attainment problem using fgoalattain. The conversion sets all goals to 0 and all weights to 1. See Equation 1 in Multiobjective Optimization Algorithms.

Alternative Functionality

App

The Optimize Live Editor task provides a visual interface for fminimax.

Extended Capabilities

Automatic Parallel Support
Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.

To run in parallel, set the 'UseParallel' option to true.

options = optimoptions('solvername','UseParallel',true)

For more information, see Using Parallel Computing in Optimization Toolbox.

Version History

Introduced before R2006a

fminimax

Syntax

Description

Examples

Minimize Maximum of `sin` and `cos`

Solve Linearly Constrained Minimax Problem

Solve Bound-Constrained Minimax Problem

Find Minimax Subject to Nonlinear Constraints

Solve Minimax Problem Using Absolute Value of One Objective

Obtain Minimax Value

Obtain All Minimax Outputs

Input Arguments

`fun` — Objective functions
function handle | function name

`x0` — Initial point
real vector | real array

`A` — Linear inequality constraints
real matrix

`b` — Linear inequality constraints
real vector

`Aeq` — Linear equality constraints
real matrix

`beq` — Linear equality constraints
real vector

`lb` — Lower bounds
real vector | real array

`ub` — Upper bounds
real vector | real array

`nonlcon` — Nonlinear constraints
function handle | function name

`options` — Optimization options
output of `optimoptions` | structure such as `optimset` returns

`problem` — Problem structure
structure

Output Arguments

`x` — Solution
real vector | real array

`fval` — Objective function values at solution
real array

`maxfval` — Maximum of objective function values at solution
real scalar

`exitflag` — Reason `fminimax` stopped
integer

`output` — Information about optimization process
structure

`lambda` — Lagrange multipliers at solution
structure

Algorithms

Alternative Functionality

App

Extended Capabilities

Automatic Parallel Support
Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.

Version History

See Also

Topics

fminimax

Syntax

Description

Examples

Minimize Maximum of sin and cos

Solve Linearly Constrained Minimax Problem

Solve Bound-Constrained Minimax Problem

Find Minimax Subject to Nonlinear Constraints

Solve Minimax Problem Using Absolute Value of One Objective

Obtain Minimax Value

Obtain All Minimax Outputs

Input Arguments

fun — Objective functions function handle | function name

x0 — Initial point real vector | real array

A — Linear inequality constraints real matrix

b — Linear inequality constraints real vector

Aeq — Linear equality constraints real matrix

beq — Linear equality constraints real vector

lb — Lower bounds real vector | real array

ub — Upper bounds real vector | real array

nonlcon — Nonlinear constraints function handle | function name

options — Optimization options output of optimoptions | structure such as optimset returns

problem — Problem structure structure

Output Arguments

x — Solution real vector | real array

fval — Objective function values at solution real array

maxfval — Maximum of objective function values at solution real scalar

exitflag — Reason fminimax stopped integer

output — Information about optimization process structure

lambda — Lagrange multipliers at solution structure

Algorithms

Alternative Functionality

App

Extended Capabilities

Automatic Parallel Support Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.

Version History

See Also

Topics

Minimize Maximum of `sin` and `cos`

`fun` — Objective functions
function handle | function name

`x0` — Initial point
real vector | real array

`A` — Linear inequality constraints
real matrix

`b` — Linear inequality constraints
real vector

`Aeq` — Linear equality constraints
real matrix

`beq` — Linear equality constraints
real vector

`lb` — Lower bounds
real vector | real array

`ub` — Upper bounds
real vector | real array

`nonlcon` — Nonlinear constraints
function handle | function name

`options` — Optimization options
output of `optimoptions` | structure such as `optimset` returns

`problem` — Problem structure
structure

`x` — Solution
real vector | real array

`fval` — Objective function values at solution
real array

`maxfval` — Maximum of objective function values at solution
real scalar

`exitflag` — Reason `fminimax` stopped
integer

`output` — Information about optimization process
structure

`lambda` — Lagrange multipliers at solution
structure

Automatic Parallel Support
Accelerate code by automatically running computation in parallel using Parallel Computing Toolbox™.