template<class BaseVector , class Fun >

int CppAD::opt_val_hes	(	const BaseVector &	x,
		const BaseVector &	y,
		Fun	fun,
		BaseVector &	jac,
		BaseVector &	hes
	)

Computing Jabobians and Hessians of Optimal Values.

We are given a function $S : {\rm R}^n \times {\rm R}^m \rightarrow {\rm R}^\ell$ and we define $F : {\rm R}^n \times {\rm R}^m \rightarrow {\rm R}$ and $V : {\rm R}^n \rightarrow {\rm R}$ by

$\begin{array}{rcl} F(x, y) & = & \sum_{k=0}^{\ell-1} S_k ( x , y) \\ V(x) & = & F [ x , Y(x) ] \\ 0 & = & \partial_y F [x , Y(x) ] \end{array}$

We wish to compute the Jacobian and possibly also the Hessian, of $ V (x) $ .

Template Parameters

BaseVector The type BaseVector must be a SimpleVector class. We use Base to refer to the type of the elements of BaseVector; i.e., BaseVector::value_type.

Parameters

x	is a vector with size `n`. It specifies the point at which we evaluating the Jacobian $V^{(1)} (x)$ (and possibly the Hessian $V^{(2)} (x)$ ).
y	is a vector with size `m`. It must be equal to ; i.e., it must solve the implicit equation $0 = \partial_y F ( x , y)$
fun	The argument `fun` is an object of type `Fun` wich must support the member functions listed below. CppAD will may be recording operations of the type `AD<Base>` when these member functions are called. These member functions must not stop such a recording; e.g., they must not call `AD<Base>::abort_recording`.

Fun::ad_vector: The type Fun::ad_vector must be a SimpleVector class with elements of type AD<Base>; i.e. Fun::ad_vector::value_type is equal to AD<Base>.

fun.ell

the type Fun must support the syntax

     ell = fun.ell()

where ell is a size_t value that is set to $\ell$ ; i.e., the number of terms in the summation.

fun.s

The type Fun must support the syntax

     s_k = fun.s(k, x, y)

The argument k has prototype size_t k. The argument x has prototype const Fun::ad_vector& x and its size must be equal to n. The argument y has prototype const Fun::ad_vector& y and its size must be equal to m. The return value s_k has prototype AD<Base> s_k and its value must be given by $ s_k = S_k ( x , y ) $

.

fun.sy

The type Fun must support the syntax

     sy_k = fun.sy(k, x, y)

The argument k has prototype size_t k. The argument x has prototype const Fun::ad_vector& x and its size must be equal to n. The argument y has prototype const Fun::ad_vector& y and its size must be equal to m. The return value sy_k has prototype Fun::ad_vector& sy_k, its size is m and its value must be given by $sy_k = \partial_y S_k ( x , y )$ .

Parameters

jac	is a vector with size `n` or zero. The input values of its elements do not matter. If it has size zero, it is not affected. Otherwise, on output it contains the Jacobian of ; i.e., for $j = 0 , \ldots , n-1$ , $jac[ j ] = V^{(1)} (x)_j$ $$ where `x` is the first argument to `opt_val_hes`.
hes	is a vector with size `n * n` or zero. The input values of its elements do not matter. If it has size zero, it is not affected. Otherwise, on output it contains the Hessian of ; i.e., for $i = 0 , \ldots , n-1$ , and $j = 0 , \ldots , n-1$ , $hes[ i * n + j ] = V^{(2)} (x)_{i,j}$

Returns: If hes.size() == 0, the return value is not defined. Otherwise, the return value is the sign of the determinant for $\partial_{yy}^2 F(x , y)$ $. If it is zero, then the matrix is singular and hes is not set to its specified value.

Definition at line 364 of file opt_val_hes.hpp.