fseminf

Find minimum of semi-infinitely constrained multivariable nonlinear function

Syntax

x = fseminf(fun,x0,ntheta,seminfcon)

x = fseminf(fun,x0,ntheta,seminfcon,A,b)

x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq)

x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub)

x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub,options)

x = fseminf(problem)

[x,fval] = fseminf(___)

[x,fval,exitflag,output] = fseminf(___)

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

Description

fseminf is a nonlinear programming solver that finds the minimum of a problem specified by

$$\underset{x}{\min }f(x)\text{ such that }\{\begin{array}{c}A\cdot x\le b,\\ Aeq\cdot x=beq,\\ lb\le x\le ub,\\ c(x)\le 0,\\ ceq(x)=0,\\ K_i(x,w_i)\le 0,1\le i\le n.\end{array}$$

• b and beq are vectors.

• A and Aeq are matrices.

• c(x), ceq(x), and K_i(x,w_i) are functions that return vectors.

• f(x) is a function that returns a scalar.

f(x), c(x), and ceq(x) can be nonlinear functions. The vectors (or matrices) K_i(x,w_i) ≤ 0 are continuous functions of both x and an additional set of variables w₁,w₂,...,w_n. The variables w₁,w₂,...,w_n are vectors of length two, at most.

x, lb, and ub can be passed as vectors or matrices; see Matrix Arguments.

x = fseminf(fun,x0,ntheta,seminfcon) starts at x0 and finds a minimum of the function fun constrained by ntheta semi-infinite constraints defined in seminfcon.

x = fseminf(fun,x0,ntheta,seminfcon,A,b) also tries to satisfy the linear inequalities A*x ≤ b.

x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq) minimizes subject to the linear equalities Aeq*x = beq as well. Set A = [] and b = [] if no inequalities exist.

x = fseminf(fun,x0,ntheta,seminfcon,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.

x = fseminf(fun,x0,ntheta,seminfcon,A,b,Aeq,beq,lb,ub,options) minimizes with the optimization options specified in options. Use optimoptions to set these options.

x = fseminf(problem) finds the minimum for problem, a structure described in problem.

[x,fval] = fseminf(___), for any previous input syntax, returns the value of the objective function fun 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 [].

[x,fval,exitflag,output] = fseminf(___) also returns a value exitflag that describes the exit condition, and a structure output with information about the optimization process.

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

Examples

Minimize Function with Semi-Infinite Constraints

Minimize the function

$$(x-1{)}^2$$,

subject to the constraints

$$0\le x\le 2$$

$$g(x,t)=(x-1/2)-(t-1/2{)}^2\le 0$$ for all $$0\le t\le 1$$.

The unconstrained objective function is minimized at $$x=1$$. However, the constraint

$$g(x,t)\le 0$$ for all $$0\le t\le 1$$

implies $$x\le 1/2$$. Notice that $$(t-1/2{)}^2\ge 0$$, so

$$\underset{t}{\max }g(x,t)=x-1/2$$.

Therefore,

$$\underset{t}{\max }g(x,t)\le 0$$ when $$x\le 1/2$$.

To solve this problem using fseminf, write the objective function as an anonymous function.

objfun = @(x)(x-1)^2;

Write the semi-infinite constraint function seminfcon, which includes the nonlinear constraints [ ], initial sampling interval for $$t$$ (0 to 1 in steps of 0.01), and the semi-infinite constraint function $$g(x,t)$$. The code for the seminfcon function appears at the end of this example.

Set the initial point x0 = 0.2.

x0 = 0.2;

Specify the one semi-infinite constraint.

ntheta = 1;

Solve the problem by calling fseminf and view the result.

x = fseminf(objfun,x0,ntheta,@seminfcon)

Local minimum found that satisfies the constraints.

Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the  value of the constraint tolerance.

<stopping criteria details>

x = 
0.5000

The following code creates the seminfcon function.

function [c, ceq, K1, s] = seminfcon(x,s)

% No finite nonlinear inequality and equality constraints
c = [];
ceq = [];

% Sample set
if isnan(s)
    % Initial sampling interval
    s = [0.01 0];
end
t = 0:s(1):1;

% Evaluate the semi-infinite constraint
K1 = (x - 0.5) - (t - 0.5).^2;
end

Examine fseminf Outputs

Minimize the function

$$(x-1{)}^2$$,

subject to the constraints

$$0\le x\le 2$$

$$g(x,t)=(x-1/2)-(t-1/2{)}^2\le 0$$ for all $$0\le t\le 1$$.

This problem is formulated and solved in the example Minimize Function with Semi-Infinite Constraints which collects more information about the solution and solution process.

To solve this problem using fseminf, write the objective function as an anonymous function.

objfun = @(x)(x-1)^2;

The code for the nonlinear and semi-infinite constraint function seminfcon appears at the end of this example.

Set the initial point x0 = 0.2.

x0 = 0.2;

Specify the one semi-infinite constraint.

ntheta = 1;

Solve the problem by calling fseminf and view the result.

A = [];
b = [];
Aeq = [];
beq = [];
lb = 0;
ub = 2;
[x,fval,exitflag,output,lambda] = fseminf(objfun,x0,ntheta,@seminfcon,...
    A,b,Aeq,beq,lb,ub)

Local minimum found that satisfies the constraints.

Optimization completed because the objective function is non-decreasing in 
feasible directions, to within the value of the optimality tolerance,
and constraints are satisfied to within the  value of the constraint tolerance.

<stopping criteria details>

x = 
0.5000

fval = 
0.2500

exitflag = 
1

output = struct with fields:
         iterations: 2
          funcCount: 4
       lssteplength: 1
           stepsize: 4.6841e-12
          algorithm: 'active-set'
      firstorderopt: 9.3682e-12
    constrviolation: 4.6841e-12
            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.↵↵<stopping criteria details>↵↵Optimization completed: The first-order optimality measure, 9.368173e-12, is less↵than options.OptimalityTolerance = 1.000000e-04, and the maximum constraint violation,↵4.684060e-12,is less than options.ConstraintTolerance = 1.000000e-06.'

lambda = struct with fields:
         lower: 0
         upper: 0
         eqlin: [0×1 double]
      eqnonlin: [0×1 double]
       ineqlin: [0×1 double]
    ineqnonlin: [1×0 double]

The returned values show:

• The problem is solved at $$x=1/2$$.

• The value of the objective function, $$(x-1{)}^2$$, is $$1/4$$.

• The solver takes two iterations and four function evaluations to reach the solution.

• The only constraints other than semi-infinite constraints are bounds, so the lambda structure has no linear or nonlinear values. The lambda.lower and lambda.upper fields, which correspond to bounds, are not empty, but have zero values because the solution is not at either bound.

The following code creates the seminfcon function.

function [c, ceq, K1, s] = seminfcon(x,s)

% No finite nonlinear inequality and equality constraints
c = [];
ceq = [];

% Sample set
if isnan(s)
    % Initial sampling interval
    s = [0.01 0];
end
t = 0:s(1):1;

% Evaluate the semi-infinite constraint
K1 = (x - 0.5) - (t - 0.5).^2;
end

Input Arguments

fun — Function to minimize

function handle | function name

Function to minimize, specified as a function handle or function name. fun is a function that accepts a vector or array x and returns a real scalar f, the objective function evaluated at x.

fseminf 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 fseminf passes x to fun as a 5-by-3 array. However, fseminf multiplies linear constraint matrices A or Aeq with x after converting x to the column vector x(:).

Specify fun as a function handle for a file.

x = fseminf(@myfun,...)

Here, myfun is a MATLAB^® function such as the following.

function f = myfun(x)
f = ...            % Compute function value at x

You can also specify fun as a function handle for an anonymous function.

x = fseminf(@(x)norm(x)^2,...);

If you can compute the gradient of fun and the SpecifyObjectiveGradient option is set to true, as set by

options = optimoptions('fseminf','SpecifyObjectiveGradient',true);

then fun must return the gradient vector g(x) in the second output argument.

Example: fun = @(x)sin(x(1))*cos(x(2))

Data Types: char | function_handle | string

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

ntheta — Number of semi-infinite constraints

positive integer

Number of semi-infinite constraints, specified as a positive integer.

Example: 4

Data Types: double

seminfcon — Function that computes nonlinear constraints and semi-infinite constraints

function handle | function name

Function that computes the vector of nonlinear inequality constraints c, the vector of nonlinear equality constraints ceq, and ntheta semi-infinite constraints (vectors or matrices) K1, K2,..., Kntheta evaluated over an interval S at the point x. You can specify seminfcon as a function handle.

x = fseminf(@myfun,x0,ntheta,@myinfcon)

where myinfcon is a MATLAB function such as

function [c,ceq,K1,K2,...,Kntheta,S] = myinfcon(x,S)
% Initial sampling interval
if isnan(S(1,1)),
   S = ...% S has ntheta rows and 2 columns
end
w1 = ...% Compute sample set
w2 = ...% Compute sample set 
...
wntheta = ... % Compute sample set
K1 = ... % 1st semi-infinite constraint at x and w
K2 = ... % 2nd semi-infinite constraint at x and w
...
Kntheta = ...% Last semi-infinite constraint at x and w
c = ...      % Compute nonlinear inequalities at x
ceq = ...    % Compute nonlinear equalities at x

S is a recommended sampling interval, which the function might not use. Return [] for c and ceq if no such constraints exist.

The vectors or matrices K1, K2, ..., Kntheta contain the semi-infinite constraints evaluated for a sampled set of values for the independent variables w1, w2, ..., wntheta, respectively. The two-column matrix S contains a recommended sampling interval for values of w1, w2, ..., wntheta, which are used to evaluate K1, K2, ..., Kntheta. The ith row of S contains the recommended sampling interval for evaluating Ki. When Ki is a vector, the function uses only S(i,1) (the second column can be all zeros). When Ki is a matrix, the function uses S(i,2) to sample the rows in Ki, and uses S(i,1) for the sampling interval of the columns of Ki (see Two-Dimensional Semi-Infinite Constraint). Because S is NaN on the first iteration, seminfcon must determine some initial sampling interval.

Note

Because Optimization Toolbox™ functions accept inputs of type double only, user-supplied objective and nonlinear constraint functions must return outputs of type double.

For methods to parameterize seminfcon, if necessary, see Passing Extra Parameters. For an example of both one- and two-dimensional sampling points, see Example of Creating Sampling Points.

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 with algorithms that support sparse data, pass A as a sparse matrix. See Sparsity in Optimization Algorithms.

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

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 with algorithms that support sparse data, pass A as a sparse matrix. See Sparsity in Optimization Algorithms.

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

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

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. See Optimization Options Reference for detailed information.

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

Option	Description
CheckGradients	Compare user-supplied derivatives (gradients of objective or constraints) to finite-differencing derivatives. The choices are true or the default false. For optimset, the name is DerivativeCheck and the values are 'on' or 'off'. See Current and Legacy Option Names. The CheckGradients option will be removed in a future release. To check derivatives, use the checkGradients function.
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. See Current and Legacy Option Names.
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 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. See Current and Legacy Option Names.
FiniteDifferenceType	Finite differences, used to estimate gradients, are either 'forward' (the default) or 'central' (centered). 'central' takes twice as many function evaluations, but can be more accurate. The algorithm is careful to obey bounds when estimating both types of finite differences. For example, to avoid evaluating at a point outside the bounds, the algorithm might take a backward difference rather than a forward difference. For optimset, the name is FinDiffType. See Current and Legacy Option Names.
FunctionTolerance	Termination tolerance on the function value (a nonnegative scalar). The default is 1e-4. See Tolerances and Stopping Criteria. For optimset, the name is TolFun. See Current and Legacy Option Names.
FunValCheck	Check whether objective function and constraints values are valid. The setting '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. See Current and Legacy Option Names.
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. See Current and Legacy Option Names.
MaxSQPIter	Maximum number of SQP iterations allowed (a positive integer). The default is 10*max(numberOfVariables, numberOfInequalities + numberOfBounds).
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. See Current and Legacy Option Names.
OutputFcn	Specify one or more user-defined functions called by an optimization function 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	Plot 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 function value. 'optimplotfvalconstr' plots the best feasible objective function value found. The plot shows infeasible points in one color and feasible points in another, using a feasibility tolerance of 1e-6. 'optimplotconstrviolation' plots the maximum constraint violation. 'optimplotstepsize' plots the step size. 'optimplotfirstorderopt' plots the first-order optimality measure. 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. See Current and Legacy Option Names.
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 fseminf considers too large. The default is no bounds ([]).
RelLineSrchBndDuration	Number of iterations for which the bound specified in RelLineSrchBnd should be active (default is 1).
SpecifyObjectiveGradient	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 this option to true to have fseminf use a user-defined gradient of the objective function. The default false causes fseminf to estimate gradients using finite differences. For optimset, the name is GradObj and the values are 'on' or 'off'. See Current and Legacy Option Names.
StepTolerance	Termination tolerance on x, a nonnegative scalar. The default value is 1e-4. See Tolerances and Stopping Criteria. For optimset, the name is TolX. See Current and Legacy Option Names.
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). fseminf uses TypicalX for scaling finite differences for gradient estimation.

Example: options = optimoptions('fseminf','PlotFcn','optimplotfval')

problem — Problem structure

structure

Problem structure, specified as a structure with the following fields.

Field Name	Entry
objective	Objective function
x0	Initial point for x
ntheta	Number of semi-infinite constraints
seminfcon	Semi-infinite constraint function
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
solver	'fmseminf'
options	Options created with optimoptions

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

Data Types: struct

Output Arguments

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 value at solution

real number

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

exitflag — Reason fseminf stopped

integer

Reason fseminf stopped, returned as an integer.

Flag	Description
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 the optimization process

structure

Information about the optimization process, returned as a structure with the following fields.

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

lambda — Lagrange multipliers at the solution

structure

Lagrange multipliers at the solution, returned as a structure with the following fields.

Field Name	Description
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 seminfcon
eqnonlin	Nonlinear equalities corresponding to the ceq in seminfcon

Limitations

• The function to be minimized, the constraints, and the semi-infinite constraints must be continuous functions of x and w.

• fseminf might give local solutions only.

Algorithms

fseminf uses cubic and quadratic interpolation techniques to estimate peak values in the semi-infinite constraints. The algorithm uses the peak values to form a set of constraints supplied to an SQP method, as in the fmincon function. When the number of constraints changes, the algorithm reallocates Lagrange multipliers to the new set of constraints.

The recommended sampling interval calculation uses the difference between the interpolated peak values and the peak values in the data set to estimate whether the function needs to take more or fewer points. The function also evaluates the effectiveness of the interpolation by extrapolating the curve and comparing it to other points in the curve. The recommended sampling interval decreases when the peak values are close to constraint boundaries, that is, zero.

When the problem is not feasible, fseminf attempts to minimize the maximum constraint value.

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' with optimoptions, see SQP Implementation. For more details on the fseminf algorithm, see fseminf Problem Formulation and Algorithm.

Version History

Introduced before R2006a

R2023b: CheckGradients option will be removed

The CheckGradients option will be removed in a future release. To check the first derivatives of objective functions or nonlinear constraint functions, use the checkGradients function.