lines 8-120 of file: include/cppad/core/rev_hes_sparsity.hpp

{xrst_begin rev_hes_sparsity}

Reverse Mode Hessian Sparsity Patterns
######################################

Syntax
******

| *f* . ``rev_hes_sparsity`` (
| |tab| *select_range* , *transpose* , *internal_bool* , *pattern_out*
| )

Purpose
*******
We use :math:`F : \B{R}^n \rightarrow \B{R}^m` to denote the
:ref:`glossary@AD Function` corresponding to
the operation sequence stored in *f* .
Fix :math:`R \in \B{R}^{n \times \ell}`, :math:`s \in \B{R}^m`
and define the function

.. math::

   H(x) = ( s^\R{T} F )^{(2)} ( x ) R

Given a :ref:`glossary@Sparsity Pattern` for :math:`R`
and for the vector :math:`s`,
``rev_hes_sparsity`` computes a sparsity pattern for :math:`H(x)`.

x
*
Note that the sparsity pattern :math:`H(x)` corresponds to the
operation sequence stored in *f* and does not depend on
the argument *x* .

BoolVector
**********
The type *BoolVector* is a :ref:`SimpleVector-name` class with
:ref:`elements of type<SimpleVector@Elements of Specified Type>`
``bool`` .

SizeVector
**********
The type *SizeVector* is a :ref:`SimpleVector-name` class with
:ref:`elements of type<SimpleVector@Elements of Specified Type>`
``size_t`` .

f
*
The object *f* has prototype

   ``ADFun`` < *Base* > *f*

R
*
The sparsity pattern for the matrix :math:`R` is specified by
:ref:`for_jac_sparsity@pattern_in` in the previous call

| |tab| *f* . ``for_jac_sparsity`` (
| |tab| |tab| *pattern_in* , *transpose* , *dependency* , *internal_bool* , *pattern_out*
| )

select_range
************
The argument *select_range* has prototype

   ``const`` *BoolVector* & *select_range*

It has size :math:`m` and specifies which components of the vector
:math:`s` are non-zero; i.e., *select_range* [ *i* ] is true
if and only if :math:`s_i` is possibly non-zero.

transpose
*********
This argument has prototype

   ``bool`` *transpose*

See :ref:`rev_hes_sparsity@pattern_out` below.

internal_bool
*************
If this is true, calculations are done with sets represented by a vector
of boolean values. Otherwise, a vector of sets of integers is used.
This must be the same as in the previous call to
*f* . ``for_jac_sparsity`` .

pattern_out
***********
This argument has prototype

   ``sparse_rc`` < *SizeVector* >& *pattern_out*

This input value of *pattern_out* does not matter.
If *transpose* it is false (true),
upon return *pattern_out* is a sparsity pattern for
:math:`H(x)` (:math:`H(x)^\R{T}`).

Sparsity for Entire Hessian
***************************
Suppose that :math:`R` is the :math:`n \times n` identity matrix.
In this case, *pattern_out* is a sparsity pattern for
:math:`(s^\R{T} F) F^{(2)} ( x )`.

Example
*******
{xrst_toc_hidden
   example/sparse/rev_hes_sparsity.cpp
}
The file
:ref:`rev_hes_sparsity.cpp-name`
contains an example and test of this operation.

{xrst_end rev_hes_sparsity}