The `fmincon`

and `fminunc`

solvers return
an approximate Hessian as an optional output:

```
[x,fval,exitflag,output,grad,hessian] = fminunc(fun,x0)
% or
[x,fval,exitflag,output,lambda,grad,hessian] = fmincon(fun,x0,A,b,Aeq,beq,lb,ub,nonlcon)
```

This section describes the meaning of the returned Hessian, and the accuracy you can expect.

You can also specify the type of Hessian that the solvers use as input Hessian
arguments. For `fmincon`

, see Hessian as an Input. For `fminunc`

, see Including Gradients and Hessians.

`fminunc`

HessianThe Hessian for an unconstrained problem is the matrix of second derivatives of
the objective function *f*:

$$\text{Hessian}{H}_{ij}=\frac{{\partial}^{2}f}{\partial {x}_{i}\partial {x}_{j}}.$$

**Quasi-Newton Algorithm**—`fminunc`

returns an estimated Hessian matrix at the solution.`fminunc`

computes the estimate by finite differences, so the estimate is generally accurate.**Trust-Region Algorithm**—`fminunc`

returns a Hessian matrix at the next-to-last iterate.If you supply a Hessian in the objective function and set the

`HessianFcn`

option to`'objective'`

,`fminunc`

returns this Hessian.If you supply a

`HessianMultiplyFcn`

function,`fminunc`

returns the`Hinfo`

matrix from the`HessianMultiplyFcn`

function. For more information, see`HessianMultiplyFcn`

in the`trust-region`

section of the`fminunc`

`options`

table.Otherwise,

`fminunc`

returns an approximation from a sparse finite difference algorithm on the gradients.

This Hessian is accurate for the next-to-last iterate. However, the next-to-last iterate might not be close to the final point.

The reason the

`trust-region`

algorithm returns the Hessian at the next-to-last point is for efficiency.`fminunc`

uses the Hessian internally to compute its next step. When`fminunc`

reaches a stopping condition, it does not need to compute the next step, so does not compute the Hessian.

`fmincon`

HessianThe Hessian for a constrained problem is the Hessian of the Lagrangian. For an
objective function *f*, nonlinear inequality constraint vector
*c*, and nonlinear equality constraint vector
*ceq*, the Lagrangian is

$$L=f+{\displaystyle \sum _{i}{\lambda}_{i}{c}_{i}}+{\displaystyle \sum _{j}{\lambda}_{j}ce{q}_{j}}.$$

The *λ _{i}* are Lagrange multipliers; see
First-Order Optimality Measure and Lagrange Multiplier Structures. The Hessian of the Lagrangian is

$$H={\nabla}^{2}L={\nabla}^{2}f+{\displaystyle \sum _{i}{\lambda}_{i}{\nabla}^{2}{c}_{i}}+{\displaystyle \sum _{j}{\lambda}_{j}{\nabla}^{2}ce{q}_{j}}.$$

`fmincon`

has four algorithms, with
several options for Hessians, as described in fmincon Trust Region Reflective Algorithm, fmincon Active Set Algorithm, and fmincon Interior Point Algorithm. `fmincon`

returns
the following for the Hessian:

—`active-set`

or`sqp`

Algorithm`fmincon`

returns the Hessian approximation it computes at the next-to-last iterate.`fmincon`

computes a quasi-Newton approximation of the Hessian matrix at the solution in the course of its iterations. This approximation does not, in general, match the true Hessian in every component, but only in certain subspaces. Therefore the Hessian that`fmincon`

returns can be inaccurate. For more details of the`active-set`

calculation, see SQP Implementation.—`trust-region-reflective`

Algorithm`fmincon`

returns the Hessian it computes at the next-to-last iterate.If you supply a Hessian in the objective function and set the

`HessianFcn`

option to`'objective'`

,`fmincon`

returns this Hessian.If you supply a

`HessianMultiplyFcn`

function,`fmincon`

returns the`Hinfo`

matrix from the`HessianMultiplyFcn`

function. For more information, see**Trust-Region-Reflective Algorithm**in`fmincon`

`options`

.Otherwise,

`fmincon`

returns an approximation from a sparse finite difference algorithm on the gradients.

This Hessian is accurate for the next-to-last iterate. However, the next-to-last iterate might not be close to the final point.

The reason the

`trust-region-reflective`

algorithm returns the Hessian at the next-to-last point is for efficiency.`fmincon`

uses the Hessian internally to compute its next step. When`fmincon`

reaches a stopping condition, it does not need to compute the next step, so does not compute the Hessian.`interior-point`

AlgorithmIf the

`HessianApproximation`

option is`'lbfgs'`

or`'finite-difference'`

, or if you supply a Hessian multiply function (`HessianMultiplyFcn`

),`fmincon`

returns`[]`

for the Hessian.If the

`HessianApproximation`

option is`'bfgs'`

(the default),`fmincon`

returns a quasi-Newton approximation to the Hessian at the final point. This Hessian can be inaccurate, as in the`active-set`

or`sqp`

algorithm Hessian.If the

`HessianFcn`

option is a function handle,`fmincon`

returns this function as the Hessian at the final point.