Main Content

optimoptions

Create optimization options

Description

example

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

example

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

example

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

example

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

example

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

collapse all

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


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 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'


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'


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.

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

collapse all

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

Example: 'fmincon'

Example: @fmincon

Data Types: char | function_handle | string

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

Example: oldoptions = optimoptions(@fminunc)

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:

Output Arguments

collapse all

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

Version History

Introduced in R2013a