optimoptions

Create optimization options

Syntax

options = optimoptions(SolverName)

options = optimoptions(SolverName,Name,Value)

options = optimoptions(oldoptions,Name,Value)

options = optimoptions(SolverName,oldoptions)

options = optimoptions(prob)

options = optimoptions(prob,Name,Value)

Description

options = optimoptions(SolverName) returns a set of default options for the SolverName solver.

options = optimoptions(SolverName,Name,Value) returns options with specified parameters set using one or more name-value pair arguments.

options = optimoptions(oldoptions,Name,Value) returns a copy of oldoptions with the named parameters altered with the specified values.

options = optimoptions(SolverName,oldoptions) returns default options for the SolverName solver, and copies the applicable options in oldoptions to options.

options = optimoptions(prob) returns a set of default options for the prob optimization problem or equation problem.

options = optimoptions(prob,Name,Value) returns options with specified parameters set using one or more name-value pair arguments.

Examples

Create Default Options

Create default options for the fmincon solver.

options = optimoptions('fmincon')

options = 
  fmincon options:

   Options used by current Algorithm ('interior-point'):
   (Other available algorithms: 'active-set', 'sqp', 'sqp-legacy', 'trust-region-reflective')

   Set properties:
     No options set.

   Default properties:
                    Algorithm: 'interior-point'
           BarrierParamUpdate: 'monotone'
          ConstraintTolerance: 1.0000e-06
                      Display: 'final'
        EnableFeasibilityMode: 0
     FiniteDifferenceStepSize: 'sqrt(eps)'
         FiniteDifferenceType: 'forward'
         HessianApproximation: 'bfgs'
                   HessianFcn: []
           HessianMultiplyFcn: []
                  HonorBounds: 1
       MaxFunctionEvaluations: 3000
                MaxIterations: 1000
               ObjectiveLimit: -1.0000e+20
          OptimalityTolerance: 1.0000e-06
                    OutputFcn: []
                      PlotFcn: []
                 ScaleProblem: 0
    SpecifyConstraintGradient: 0
     SpecifyObjectiveGradient: 0
                StepTolerance: 1.0000e-10
          SubproblemAlgorithm: 'factorization'
                     TypicalX: 'ones(numberOfVariables,1)'
                  UseParallel: 0

   Options not used by current Algorithm ('interior-point')
   Default properties:
    FunctionTolerance: 1.0000e-06

Create Nondefault Options

Set options for fmincon to use the sqp algorithm and at most 1500 iterations.

options = optimoptions(@fmincon,'Algorithm','sqp','MaxIterations',1500)

options = 
  fmincon options:

   Options used by current Algorithm ('sqp'):
   (Other available algorithms: 'active-set', 'interior-point', 'sqp-legacy', 'trust-region-reflective')

   Set properties:
                    Algorithm: 'sqp'
                MaxIterations: 1500

   Default properties:
          ConstraintTolerance: 1.0000e-06
                      Display: 'final'
     FiniteDifferenceStepSize: 'sqrt(eps)'
         FiniteDifferenceType: 'forward'
       MaxFunctionEvaluations: '100*numberOfVariables'
               ObjectiveLimit: -1.0000e+20
          OptimalityTolerance: 1.0000e-06
                    OutputFcn: []
                      PlotFcn: []
                 ScaleProblem: 0
    SpecifyConstraintGradient: 0
     SpecifyObjectiveGradient: 0
                StepTolerance: 1.0000e-06
                     TypicalX: 'ones(numberOfVariables,1)'
                  UseParallel: 0

   Options not used by current Algorithm ('sqp')
   Default properties:
       BarrierParamUpdate: 'monotone'
    EnableFeasibilityMode: 0
        FunctionTolerance: 1.0000e-06
     HessianApproximation: 'not applicable'
               HessianFcn: []
       HessianMultiplyFcn: []
              HonorBounds: 1
      SubproblemAlgorithm: 'factorization'

Update Options

Update existing options with new values.

Set options for the lsqnonlin solver to use the levenberg-marquardt algorithm and at most 1500 function evaluations

oldoptions = optimoptions(@lsqnonlin,'Algorithm','levenberg-marquardt',...
    'MaxFunctionEvaluations',1500)

oldoptions = 
  lsqnonlin options:

   Options used by current Algorithm ('levenberg-marquardt'):
   (Other available algorithms: 'interior-point', 'trust-region-reflective')

   Set properties:
                   Algorithm: 'levenberg-marquardt'
      MaxFunctionEvaluations: 1500

   Default properties:
                     Display: 'final'
    FiniteDifferenceStepSize: 'sqrt(eps)'
        FiniteDifferenceType: 'forward'
           FunctionTolerance: 1.0000e-06
               MaxIterations: 400
                   OutputFcn: []
                     PlotFcn: []
    SpecifyObjectiveGradient: 0
               StepTolerance: 1.0000e-06
                    TypicalX: 'ones(numberOfVariables,1)'
                 UseParallel: 0

   Options not used by current Algorithm ('levenberg-marquardt')
   Default properties:
           BarrierParamUpdate: 'monotone'
          ConstraintTolerance: 1.0000e-06
          JacobianMultiplyFcn: []
          OptimalityTolerance: 1.0000e-06
    SpecifyConstraintGradient: 0
          SubproblemAlgorithm: 'factorization'

Increase MaxFunctionEvaluations to 2000.

options = optimoptions(oldoptions,'MaxFunctionEvaluations',2000)

options = 
  lsqnonlin options:

   Options used by current Algorithm ('levenberg-marquardt'):
   (Other available algorithms: 'interior-point', 'trust-region-reflective')

   Set properties:
                   Algorithm: 'levenberg-marquardt'
      MaxFunctionEvaluations: 2000

   Default properties:
                     Display: 'final'
    FiniteDifferenceStepSize: 'sqrt(eps)'
        FiniteDifferenceType: 'forward'
           FunctionTolerance: 1.0000e-06
               MaxIterations: 400
                   OutputFcn: []
                     PlotFcn: []
    SpecifyObjectiveGradient: 0
               StepTolerance: 1.0000e-06
                    TypicalX: 'ones(numberOfVariables,1)'
                 UseParallel: 0

   Options not used by current Algorithm ('levenberg-marquardt')
   Default properties:
           BarrierParamUpdate: 'monotone'
          ConstraintTolerance: 1.0000e-06
          JacobianMultiplyFcn: []
          OptimalityTolerance: 1.0000e-06
    SpecifyConstraintGradient: 0
          SubproblemAlgorithm: 'factorization'

Use Dot Notation to Update Options

Update existing options with new values by using dot notation.

Set options for the lsqnonlin solver to use the levenberg-marquardt algorithm and at most 1500 function evaluations

options = optimoptions(@lsqnonlin,'Algorithm','levenberg-marquardt',...
    'MaxFunctionEvaluations',1500)

options = 
  lsqnonlin options:

   Options used by current Algorithm ('levenberg-marquardt'):
   (Other available algorithms: 'interior-point', 'trust-region-reflective')

   Set properties:
                   Algorithm: 'levenberg-marquardt'
      MaxFunctionEvaluations: 1500

   Default properties:
                     Display: 'final'
    FiniteDifferenceStepSize: 'sqrt(eps)'
        FiniteDifferenceType: 'forward'
           FunctionTolerance: 1.0000e-06
               MaxIterations: 400
                   OutputFcn: []
                     PlotFcn: []
    SpecifyObjectiveGradient: 0
               StepTolerance: 1.0000e-06
                    TypicalX: 'ones(numberOfVariables,1)'
                 UseParallel: 0

   Options not used by current Algorithm ('levenberg-marquardt')
   Default properties:
           BarrierParamUpdate: 'monotone'
          ConstraintTolerance: 1.0000e-06
          JacobianMultiplyFcn: []
          OptimalityTolerance: 1.0000e-06
    SpecifyConstraintGradient: 0
          SubproblemAlgorithm: 'factorization'

Increase MaxFunctionEvaluations to 2000 by using dot notation.

options.MaxFunctionEvaluations = 2000

options = 
  lsqnonlin options:

   Options used by current Algorithm ('levenberg-marquardt'):
   (Other available algorithms: 'interior-point', 'trust-region-reflective')

   Set properties:
                   Algorithm: 'levenberg-marquardt'
      MaxFunctionEvaluations: 2000

   Default properties:
                     Display: 'final'
    FiniteDifferenceStepSize: 'sqrt(eps)'
        FiniteDifferenceType: 'forward'
           FunctionTolerance: 1.0000e-06
               MaxIterations: 400
                   OutputFcn: []
                     PlotFcn: []
    SpecifyObjectiveGradient: 0
               StepTolerance: 1.0000e-06
                    TypicalX: 'ones(numberOfVariables,1)'
                 UseParallel: 0

   Options not used by current Algorithm ('levenberg-marquardt')
   Default properties:
           BarrierParamUpdate: 'monotone'
          ConstraintTolerance: 1.0000e-06
          JacobianMultiplyFcn: []
          OptimalityTolerance: 1.0000e-06
    SpecifyConstraintGradient: 0
          SubproblemAlgorithm: 'factorization'

Copy Options to Another Solver

Transfer nondefault options for the fmincon solver to options for the fminunc solver.

Set options for fmincon to use the sqp algorithm and at most 1500 iterations.

oldoptions = optimoptions(@fmincon,'Algorithm','sqp','MaxIterations',1500)

oldoptions = 
  fmincon options:

   Options used by current Algorithm ('sqp'):
   (Other available algorithms: 'active-set', 'interior-point', 'sqp-legacy', 'trust-region-reflective')

   Set properties:
                    Algorithm: 'sqp'
                MaxIterations: 1500

   Default properties:
          ConstraintTolerance: 1.0000e-06
                      Display: 'final'
     FiniteDifferenceStepSize: 'sqrt(eps)'
         FiniteDifferenceType: 'forward'
       MaxFunctionEvaluations: '100*numberOfVariables'
               ObjectiveLimit: -1.0000e+20
          OptimalityTolerance: 1.0000e-06
                    OutputFcn: []
                      PlotFcn: []
                 ScaleProblem: 0
    SpecifyConstraintGradient: 0
     SpecifyObjectiveGradient: 0
                StepTolerance: 1.0000e-06
                     TypicalX: 'ones(numberOfVariables,1)'
                  UseParallel: 0

   Options not used by current Algorithm ('sqp')
   Default properties:
       BarrierParamUpdate: 'monotone'
    EnableFeasibilityMode: 0
        FunctionTolerance: 1.0000e-06
     HessianApproximation: 'not applicable'
               HessianFcn: []
       HessianMultiplyFcn: []
              HonorBounds: 1
      SubproblemAlgorithm: 'factorization'

Transfer the applicable options to the fminunc solver.

options = optimoptions(@fminunc,oldoptions)

options = 
  fminunc options:

   Options used by current Algorithm ('quasi-newton'):
   (Other available algorithms: 'trust-region')

   Set properties:
        FiniteDifferenceType: 'forward'
               MaxIterations: 1500
         OptimalityTolerance: 1.0000e-06
                     PlotFcn: []
    SpecifyObjectiveGradient: 0
               StepTolerance: 1.0000e-06

   Default properties:
                   Algorithm: 'quasi-newton'
                     Display: 'final'
    FiniteDifferenceStepSize: 'sqrt(eps)'
        HessianApproximation: 'bfgs'
      MaxFunctionEvaluations: '100*numberOfVariables'
              ObjectiveLimit: -1.0000e+20
                   OutputFcn: []
                    TypicalX: 'ones(numberOfVariables,1)'
                 UseParallel: 0

   Options not used by current Algorithm ('quasi-newton')
   Set properties:
      FunctionTolerance: 1.0000e-06
             HessianFcn: []
     HessianMultiplyFcn: []
    SubproblemAlgorithm: 'factorization'

The algorithm option does not transfer to fminunc because 'sqp' is not a valid algorithm option for fminunc.

Find Solver and Default Options for Optimization Problem

Create an optimization problem and find the default solver and options.

rng default
x = optimvar('x',3,'LowerBound',0);
expr = x'*(eye(3) + randn(3))*x - randn(1,3)*x;
prob = optimproblem('Objective',expr);
options = optimoptions(prob)

options = 
  quadprog options:

   Options used by current Algorithm ('interior-point-convex'):
   (Other available algorithms: 'active-set', 'trust-region-reflective')

   Set properties:
     No options set.

   Default properties:
              Algorithm: 'interior-point-convex'
    ConstraintTolerance: 1.0000e-08
                Display: 'final'
           LinearSolver: 'auto'
          MaxIterations: 200
    OptimalityTolerance: 1.0000e-08
          StepTolerance: 1.0000e-12

   Options not used by current Algorithm ('interior-point-convex')
   Default properties:
      FunctionTolerance: 'default dependent on problem'
     HessianMultiplyFcn: []
         ObjectiveLimit: -1.0000e+20
    SubproblemAlgorithm: 'cg'
               TypicalX: 'ones(numberOfVariables,1)'

The default solver is quadprog.

Set the options to use iterative display. Find the solution.

options.Display = 'iter';
sol = solve(prob,'Options',options);

Solving problem using quadprog.
Your Hessian is not symmetric. Resetting H=(H+H')/2.

 Iter            Fval  Primal Infeas    Dual Infeas  Complementarity  
    0    2.018911e+00   0.000000e+00   2.757660e+00     6.535839e-01  
    1   -2.170204e+00   0.000000e+00   8.881784e-16     2.586177e-01  
    2   -3.405808e+00   0.000000e+00   8.881784e-16     2.244054e-03  
    3   -3.438788e+00   0.000000e+00   3.356690e-16     7.261144e-09  

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.

sol.x

ans = 3×1

    1.6035
    0.0000
    0.8029

Input Arguments

SolverName — Solver name

character vector | string | function handle

Solver name, specified as a character vector, string, or function handle.

Example: 'fmincon'

Example: @fmincon

Data Types: char | function_handle | string

oldoptions — Options created with optimoptions

options object

Options created with the optimoptions function, specified as an options object.

Example: oldoptions = optimoptions(@fminunc)

prob — Problem object

OptimizationProblem object | EquationProblem object

Problem object, specified as an OptimizationProblem object or an EquationProblem object. Create prob using the Problem-Based Optimization Workflow or Problem-Based Workflow for Solving Equations.

The syntaxes using prob enable you to determine the default solver for your problem and to modify the algorithm or other options.

Example: prob = optimproblem('Objective',myobj), where myobj is an optimization expression

Name-Value Arguments

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Before R2021a, use commas to separate each name and value, and enclose Name in quotes.

Example: optimoptions(@fmincon,'Display','iter','FunctionTolerance',1e-10) sets fmincon options to have iterative display and a FunctionTolerance of 1e-10.

For relevant name-value pair arguments, consult the options table for your solver:

• fgoalattain options

• fmincon options

• fminimax options

• fminunc options

• fseminf options

• fsolve options

• ga options (Global Optimization Toolbox)

• gamultiobj options (Global Optimization Toolbox)

• intlinprog options

• linprog options

• lsqcurvefit options

• lsqlin options

• lsqnonlin options

• paretosearch options (Global Optimization Toolbox)

• particleswarm options (Global Optimization Toolbox)

• patternsearch options (Global Optimization Toolbox)

• quadprog options

• simulannealbnd options (Global Optimization Toolbox)

• surrogateopt options (Global Optimization Toolbox)

Output Arguments

options — Optimization options

options object

Optimization options for the SolverName solver, returned as an options object.

Alternative Functionality

Live Editor Task

The Optimize Live Editor task lets you set options visually. For an example, see Optimize Live Editor Task with fmincon Solver.

Extended Capabilities

C/C++ Code Generation

Generate C and C++ code using MATLAB® Coder™.

Usage notes and limitations:

Code generation supports a limited set of options for each solver. For the supported options, see each solver reference page:

• coneprog C/C++ Code Generation

• fmincon Code Generation

• fsolve Code Generation

• lsqlin Code Generation

• lsqcurvefit Code Generation

• lsqnonlin Code Generation

• quadprog Code Generation

Version History

Introduced in R2013a