Evaluate a Function That Has a Sparse Hessian
Keywords: evaluate function that has sparse hessian sparse_hes_fun syntax purpose inclusion float floatvector n x row col p fp example source code

| Prev | Next |  |  |  |  |  |  |

Evaluate a Function That Has a Sparse Hessian
Syntax
`# include <cppad/speed/sparse_hes_fun.hpp>
` `sparse_hes_fun(n, x, row, col, p, fp)`
Purpose
This routine evaluates f ( x ) , f ( 1 ) ( x ) , or f ( 2 ) ( x ) where the Hessian f ( 2 ) ( x ) is sparse. The function f : R n → R only depends on the size and contents of the index vectors `row` and `col` . The non-zero entries in the Hessian of this function have one of the following forms: ∂ 2 f ∂ x [ row [ k ] ] ∂ x [ row [ k ] ] , ∂ 2 f ∂ x [ row [ k ] ] ∂ x [ col [ k ] ] , ∂ 2 f ∂ x [ col [ k ] ] ∂ x [ row [ k ] ] , ∂ 2 f ∂ x [ col [ k ] ] ∂ x [ col [ k ] ] for some k between zero and K -1 . All the other terms of the Hessian are zero.
Inclusion
The template function `sparse_hes_fun` is defined in the `CppAD` namespace by including the file `cppad/speed/sparse_hes_fun.hpp` (relative to the CppAD distribution directory). It is only intended for example and testing purposes, so it is not automatically included by cppad.hpp .
Float
The type `Float` must be a NumericType . In addition, if `y` and `z` are `Float` objects, `
y = exp(z)
` must set the `y` equal the exponential of `z` , i.e., the derivative of `y` with respect to `z` is equal to `y` .
FloatVector
The type `FloatVector` is any SimpleVector , or it can be a raw pointer, with elements of type `Float` .
n
The argument `n` has prototype `
size_t n
` It specifies the dimension for the domain space for f ( x ) .
x
The argument `x` has prototype `
const FloatVector& x
` It contains the argument value for which the function, or its derivative, is being evaluated. We use n to denote the size of the vector `x` .
row
The argument `row` has prototype `
const CppAD::vector<size_t>& row
` It specifies one of the first index of x for each non-zero Hessian term (see purpose above). All the elements of `row` must be between zero and `n-1` . The value K is defined by `K = row.size()` .
col
The argument `col` has prototype `
const CppAD::vector<size_t>& col
` and its size must be K ; i.e., the same as for `col` . It specifies the second index of x for the non-zero Hessian terms. All the elements of `col` must be between zero and `n-1` . There are no duplicated entries requested, to be specific, if `k1 != k2` then `
( row[k1] , col[k1] ) != ( row[k2] , col[k2] )
`
p
The argument `p` has prototype `
size_t p
` It is either zero or two and specifies the order of the derivative of f that is being evaluated, i.e., f ( p ) ( x ) is evaluated.
fp
The argument `fp` has prototype `
FloatVector& fp
` The input value of the elements of `fp` does not matter.
Function
If `p` is zero, `fp` has size one and `fp[0]` is the value of f ( x ) .
Hessian
If `p` is two, `fp` has size `K` and for k = 0 , … , K -1 , ∂ 2 f ∂ x [ row [ k ] ] ∂ x [ col [ k ] ] = fp [ k ]
Example
The file sparse_hes_fun.cpp contains an example and test of `sparse_hes_fun.hpp`. It returns true if it succeeds and false otherwise.
Source Code
The file sparse_hes_fun.hpp contains the source code for this template function.

Input File: cppad/speed/sparse_hes_fun.hpp