Prev

Next

Index-> contents reference index search external

Up-> CppAD AD ADValued atomic atomic_base atomic_rev_sparse_hes

ADValued-> Arithmetic unary_standard_math binary_math CondExp Discrete numeric_limits atomic

atomic-> checkpoint atomic_base

atomic_base-> atomic_ctor atomic_option atomic_afun atomic_forward atomic_reverse atomic_for_sparse_jac atomic_rev_sparse_jac atomic_for_sparse_hes atomic_rev_sparse_hes atomic_base_clear atomic_get_started.cpp atomic_norm_sq.cpp atomic_reciprocal.cpp atomic_set_sparsity.cpp atomic_tangent.cpp atomic_eigen_mat_mul.cpp atomic_eigen_mat_inv.cpp atomic_eigen_cholesky.cpp atomic_mat_mul.cpp

atomic_rev_sparse_hes-> atomic_rev_sparse_hes.cpp

Headings-> Syntax Deprecated 2016-06-27 Purpose Implementation ---..vx ---..s ---..t ---..q ---..r u ---..v ---..x Examples

@(@\newcommand{\W}[1]{ \; #1 \; } \newcommand{\R}[1]{ {\rm #1} } \newcommand{\B}[1]{ {\bf #1} } \newcommand{\D}[2]{ \frac{\partial #1}{\partial #2} } \newcommand{\DD}[3]{ \frac{\partial^2 #1}{\partial #2 \partial #3} } \newcommand{\Dpow}[2]{ \frac{\partial^{#1}}{\partial {#2}^{#1}} } \newcommand{\dpow}[2]{ \frac{ {\rm d}^{#1}}{{\rm d}\, {#2}^{#1}} }@)@ Atomic Reverse Hessian Sparsity Patterns
Syntax
ok = afun.rev_sparse_hes(vx, s, t, q, r, u, v, x)

Deprecated 2016-06-27
ok = afun.rev_sparse_hes(vx, s, t, q, r, u, v)

Purpose
This function is used by RevSparseHes to compute Hessian sparsity patterns. If you are using RevSparseHes to compute one of the versions of this virtual function muse be defined by the atomic_user class.

There is an unspecified scalar valued function @(@ g : B^m \rightarrow B @)@. Given a sparsity pattern for @(@ R \in B^{n \times q} @)@, and information about the function @(@ z = g(y) @)@, this routine computes the sparsity pattern for @[@ V(x) = (g \circ f)^{(2)}( x ) R @]@

Implementation
If you are using and RevSparseHes , this virtual function must be defined by the atomic_user class.

vx
The argument vx has prototype
     const CppAD:vector<bool>& vx
vx.size() == n , and for @(@ j = 0 , \ldots , n-1 @)@, vx[j] is true if and only if ax[j] is a variable in the corresponding call to
     afun(ax, ay)

s
The argument s has prototype
     const CppAD:vector<bool>& s
and its size is m . It is a sparsity pattern for @(@ S(x) = g^{(1)} [ f(x) ] \in B^{1 \times m} @)@.

t
This argument has prototype
     CppAD:vector<bool>& t
and its size is m . The input values of its elements are not specified (must not matter). Upon return, t is a sparsity pattern for @(@ T(x) \in B^{1 \times n} @)@ where @[@ T(x) = (g \circ f)^{(1)} (x) = S(x) * f^{(1)} (x) @]@

q
The argument q has prototype
     size_t q
It specifies the number of columns in @(@ R \in B^{n \times q} @)@, @(@ U(x) \in B^{m \times q} @)@, and @(@ V(x) \in B^{n \times q} @)@.

r
This argument has prototype
     const atomic_sparsity& r
and is a atomic_sparsity pattern for @(@ R \in B^{n \times q} @)@.

u
This argument has prototype
     const atomic_sparsity& u
and is a atomic_sparsity pattern for @(@ U(x) \in B^{m \times q} @)@ which is defined by @[@ \begin{array}{rcl} U(x) & = & \{ \partial_u \{ \partial_y g[ y + f^{(1)} (x) R u ] \}_{y=f(x)} \}_{u=0} \\ & = & \partial_u \{ g^{(1)} [ f(x) + f^{(1)} (x) R u ] \}_{u=0} \\ & = & g^{(2)} [ f(x) ] f^{(1)} (x) R \end{array} @]@

v
This argument has prototype
     atomic_sparsity& v
The input value of its elements are not specified (must not matter). Upon return, v is a atomic_sparsity pattern for @(@ V(x) \in B^{n \times q} @)@ which is defined by @[@ \begin{array}{rcl} V(x) & = & \partial_u [ \partial_x (g \circ f) ( x + R u ) ]_{u=0} \\ & = & \partial_u [ (g \circ f)^{(1)}( x + R u ) ]_{u=0} \\ & = & (g \circ f)^{(2)}( x ) R \\ & = & f^{(1)} (x)^\R{T} g^{(2)} [ f(x) ] f^{(1)} (x) R + \sum_{i=1}^m g_i^{(1)} [ f(x) ] \; f_i^{(2)} (x) R \\ & = & f^{(1)} (x)^\R{T} U(x) + \sum_{i=1}^m S_i (x) \; f_i^{(2)} (x) R \end{array} @]@

x
The argument has prototype
     const CppAD::vector<Base>& x
and size is equal to the n . This is the Value value corresponding to the parameters in the vector ax (when the atomic function was called). To be specific, if
     if( Parameter(ax[i]) == true )
          x[i] = Value( ax[i] );
     else
          x[i] = CppAD::numeric_limits<Base>::quiet_NaN();
The version of this function with out the x argument is deprecated; i.e., you should include the argument even if you do not use it.

Examples
The file atomic_rev_sparse_hes.cpp contains an example and test that uses this routine. It returns true if the test passes and false if it fails.

---

Input File: cppad/core/atomic_base.hpp