Prev
Next
Index->
contents
reference
index
search
external
Up->
CppAD
AD
ADValued
atomic
chkpoint_two
chkpoint_two_get_started.cpp
chkpoint_two_get_started.cpp
Headings->
Purpose
f
g
f[g(x)]
Source Code
@(@\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}} }@)@
Get Started Checkpointing: Example and Test
Purpose
Break a large computation into pieces and only store values at the
interface of the pieces.
In actual applications, there may many uses of each function
and many more functions.
f
The function @(@
f : \B{R}^2 \rightarrow \B{R}^2
@)@
is defined by
@[@
f(y) = \left( \begin{array}{c}
y_0 + y_0 + y_0
\\
y_1 + y_1 + y_1
\end{array} \right)
@]@
g
The function @(@
g : \B{R}^2 \rightarrow \B{R}^2
@)@
defined by
@[@
g(x) = \left( \begin{array}{c}
x_0 \cdot x_0 \cdot x_0
\\
x_1 \cdot x_1 \cdot x_1
\end{array} \right)
@]@
f[g(x)]
The function @(@
f[g(x)]
@)@ is given by
@[@
f[g(x)]
=
f \left[ \begin{array}{c}
x_0^3 \\
x_1^3
\end{array} \right]
=
\left[ \begin{array}{c}
3 x_0^3 \\
3 x_1^3
\end{array} \right]
@]@
Source Code
# include <cppad/cppad.hpp>
namespace {
using CppAD:: AD;
typedef CPPAD_TESTVECTOR ( AD< double >) ADVector;
void f_algo ( const ADVector& y, ADVector& z)
{ z[ 0 ] = 0.0 ;
z[ 1 ] = 0.0 ;
for ( size_t k = 0 ; k < 3 ; k++)
{ z[ 0 ] += y[ 0 ];
z[ 1 ] += y[ 1 ];
}
return ;
}
void g_algo ( const ADVector& x, ADVector& y)
{ y[ 0 ] = 1.0 ;
y[ 1 ] = 1.0 ;
for ( size_t k = 0 ; k < 3 ; k++)
{ y[ 0 ] *= x[ 0 ];
y[ 1 ] *= x[ 1 ];
}
return ;
}
}
bool get_started ( void )
{ bool ok = true ;
using CppAD:: NearEqual;
double eps99 = 99.0 * std:: numeric_limits< double >:: epsilon ();
// AD vectors holding x, y, and z values
size_t nx = 2 , ny = 2 , nz = 2 ;
ADVector ax ( nx), ay ( ny), az ( nz);
// record the function g_fun(x)
for ( size_t j = 0 ; j < nx; j++)
ax[ j] = double ( j + 1 );
Independent ( ax);
g_algo ( ax, ay);
CppAD:: ADFun<double> g_fun ( ax, ay);
// record the function f_fun(y)
Independent ( ay);
f_algo ( ay, az);
CppAD:: ADFun<double> f_fun ( ay, az);
// create checkpoint versions of f and g
bool internal_bool = false ;
bool use_hes_sparsity = false ;
bool use_base2ad = false ;
bool use_in_parallel = false ;
CppAD:: chkpoint_two<double> f_chk ( f_fun, "f_chk" ,
internal_bool, use_hes_sparsity, use_base2ad, use_in_parallel
);
CppAD:: chkpoint_two<double> g_chk ( g_fun, "g_chk" ,
internal_bool, use_hes_sparsity, use_base2ad, use_in_parallel
);
// Record a version of z = f[g(x)] using checkpointing
Independent ( ax);
g_chk ( ax, ay);
f_chk ( ay, az);
CppAD:: ADFun<double> fg ( ax, az);
// zero order forward mode
CPPAD_TESTVECTOR ( double ) x ( nx), z ( nz);
for ( size_t j = 0 ; j < nx; j++)
x[ j] = 1.0 / double ( 1 + j);
z = fg. Forward ( 0 , x);
for ( size_t i = 0 ; i < nz; i++)
{ double check = 3.0 * x[ i] * x[ i] * x[ i];
ok &= NearEqual ( z[ i], check, eps99, eps99);
}
// optimize fg and check that results do not change
fg. optimize ();
for ( size_t i = 0 ; i < nz; i++)
{ double check = 3.0 * x[ i] * x[ i] * x[ i];
ok &= NearEqual ( z[ i], check, eps99, eps99);
}
//
return ok;
}
Input File: example/chkpoint_two/get_started.cpp