getting started with CppADCodeGen about cppadcodegen HOT 24 CLOSED

cmake -D GOOGLETEST_GIT=ON ..

-- The CXX compiler identification is GNU 9.2.1
-- The C compiler identification is GNU 9.2.1
... snip ...
-- Valgrind found
CMake Warning at test/cppad/cg/dae_index_reduction/CMakeLists.txt:31 (MESSAGE):
     'Eigen3notfound:Dummyderivativestestsdisabled!'
-- Configuring done
-- Generating done
-- Build files have been written to: /home/bradbell/repo/cppad_cg.git/build

make example
cd example
make
make all

make examples
make build_tests
make test
make doc
make install

make test

Running tests...
Test project /home/bradbell/repo/cppad_cg.git/build
        Start   1: array_view
Could not find executable /home/bradbell/repo/cppad_cg.git/build/test/cppad/cg/array_view
Looked in the following places:
/home/bradbell/repo/cppad_cg.git/build/test/cppad/cg/array_view
...

cd test/cppad/cg
make array_view

Scanning dependencies of target create_tmp_folder_cg
[  0%] Creating tmp folder
[  0%] Built target create_tmp_folder_cg
Scanning dependencies of target googletest
[  0%] Creating directories for 'googletest'
[  0%] Performing download step (git clone) for 'googletest'
... snip ...
home/bradbell/prefix/cppad/include/cppad/utility/sparse2eigen.hpp:97:11: 
fatal error: Eigen/Sparse: No such file or directory
97 | # include <Eigen/Sparse>
   |           ^~~~~~~~~~~~~~
compilation terminated.

home/bradbell/prefix/cppad/include/cppad/utility/sparse2eigen.hpp:97:11: 
fatal error: Eigen/Sparse: No such file or directory
97 | # include <Eigen/Sparse>
   |           ^~~~~~~~~~~~~~
compilation terminated.

#! /bin/bash -e
web_page='https://github.com/joaoleal/CppADCodeGen.git'
cppad_install_prefix="$HOME/prefix/cppad"
colpack_install_prefix="$HOME/prefix/colpack"
eigen_include_dir="$HOME/prefix/eigen/include"
# -----------------------------------------------------------------------------
# bash function that echos and executes a command
echo_eval() {
    echo $*
    eval $*
}
# -----------------------------------------------------------------------------
libdir='none'
for dir in lib lib64
do
    if [ -e "$cppad_install_prefix/$dir" ]
    then
        libdir="$dir"
    fi
done
if [ "$libdir" == 'none' ]
then
    echo 'Cannot find lib or lib64 below cppad_install_prefix:'
    echo "$cppad_install_prefix"
    exit 1
fi
# -----------------------------------------------------------------------------
# Get the source code
echo_eval cd $HOME/install
if [ ! -e cppadcg.git ]
then
    echo_eval git clone "$web_page" cppadcg.git 
fi
echo_eval cd cppadcg.git
echo_eval git checkout master
echo_eval git pull
echo_eval git reset --hard
# -----------------------------------------------------------------------------
# remove old install
if [ -e $HOME/prefix/cppadcg ]
then
    echo_eval rm -r $HOME/prefix/cppadcg
fi
# -----------------------------------------------------------------------------
# Configure and install cppadcg
if [ ! -e build ]
then
    echo_eval mkdir build
fi
cd build
if [ -e CMakeCache.txt ]
then
    rm CMakeCache.txt
fi
cmake \
    -D CREATE_DOXYGEN_DOC=ON \
    -D GOOGLETEST_GIT=ON \
    -D CMAKE_INSTALL_PREFIX="$cppad_install_prefix" \
    -D EIGEN3_INCLUDE_DIR="$eigen_include_dir" \
    ..
make install
#
# -----------------------------------------------------------------------------
# Create get_started.cpp
if [ ! -e get_started ]
then
    echo_eval mkdir get_started
fi
echo_eval cd get_started
cat << EOF > get_started.cpp
# include <iosfwd>
# include <cppad/cg/cppadcg.hpp>
int main(void)
{   typedef CppAD::cg::CG<double>    c_double;
    typedef CppAD::AD<c_double>      ac_double;
    typedef CppAD::vector<c_double>  c_vector;
    typedef CppAD::vector<ac_double> ac_vector;

    // declare independent variables for f(x)
    size_t nx = 2;
    ac_vector ac_x(nx);
    ac_x[0] = 2.0;
    ac_x[1] = 3.0;
    CppAD::Independent(ac_x);

    // create dependent variables and values for f(x)
    size_t nz = 1;
    ac_vector ac_z(nz);
    ac_double ac_diff = ac_x[0] - ac_x[1];
    ac_double ac_sum  = ac_x[0] + ac_x[1];
    ac_z[0] = ac_diff * ac_sum / 2.0;

    // create AD function mapping independent to dependent variables
    // f(x) = (x[0] - x[1]) * (x[0] + x[1]) / 2.0
    CppAD::ADFun<c_double> c_f(ac_x, ac_z);

    // create the source code generator for function g(x) = d/dx f(x)
    // g(x)_0 = ( +(x[0] + x[1]) + (x[0] - x[1]) ) / 2.0 = + x[0]
    // g(x)_1 = ( -(x[0] + x[1]) + (x[0] - x[1]) ) / 2.0 = - x[1]
    CppAD::cg::CodeHandler<double> code_handler;

    // declare the independent variables for g(x)
    c_vector  c_x(nx);
    code_handler.makeVariables(c_x);

    // Compute the dependent variables and values for g(x)
    size_t ny = nz * nx;
    c_vector c_y(ny);
    c_y = c_f.Jacobian(c_x);

    // Mapping from variables in this program to variables in source_code
    // independent variable = x
    // dependent variable   = y
    // temporary variable   = v
    CppAD::cg::LanguageC<double> langC("double");
    CppAD::cg::LangCDefaultVariableNameGenerator<double> nameGen;

    // generate the source code
    std::ostringstream source_code;
    code_handler.generateCode(source_code, langC, c_y, nameGen);

    // number of temporary variables
    size_t nv = code_handler.getTemporaryVariableCount();

    // wrap the string generated by code_handler into a function y = g(x)
    std::string source_str = 
        "namespace {\\n"
        "\\ttemplate <class Vector>\\n"
        "\\tvoid g(const Vector& x, Vector& y)\\n"
        "\\t{\\n"
    ;
    source_str += "\\t\\tVector v(" + CppAD::to_string(nv) + ");\\n"; 
    source_str += "// Begin code generated by CppADCodeGen\\n";
    source_str += source_code.str();
    source_str += 
        "// End code generated by CppADCodeGen\\n"
        "\\t}\\n"
        "} // end namespace\\n"
    ;
    // C souce code corresponding to y = g(x)
    std::cout << source_str;
    
    return 0;
}
EOF
# -----------------------------------------------------------------------------
# Compile get_started.cpp
echo_eval g++ \
    -g \
    -std=c++11 \
    -I $cppad_install_prefix/include \
    -I $eigen_include_dir \
    get_started.cpp -o get_started \
    -L $cppad_install_prefix/$libdir -lcppad_lib \
    -L $colpack_install_prefix/$libdir -lColPack
# -----------------------------------------------------------------------------
# Test y = g(x)
./get_started > test.cpp
cat << EOF >> test.cpp
# include <vector>
# include <limits>
# include <cmath>
int main(void)
{   // initialize flag
    bool   ok   = true;
    // numerical precision for tests
    double eps99 = 99.0 * std::numeric_limits<double>::epsilon();
    // number of components in vectors
    size_t nx    = 2;
    size_t nz    = 1;
    size_t ny    = nz * nx;
    //
    // compute y = g(x)
    std::vector<double> x(nx), y(ny);
    x[0] = 2.0;
    x[1] = 3.0;
    g(x, y);
    //
    // check results
    ok  &= std::fabs(y[0] - x[0] ) < eps99;
    ok  &= std::fabs(y[1] + x[1] ) < eps99;
    if( ! ok ) 
        return 1;
    return 0;  
}
EOF
#
# Compile test
echo_eval g++ \
    -g \
    -std=c++11 \
    -I $cppad_install_prefix/include \
    -I $eigen_include_dir \
    test.cpp -o test \
    -L $cppad_install_prefix/$libdir -lcppad_lib \
    -L $colpack_install_prefix/$libdir -lColPack
# -----------------------------------------------------------------------------
if ! ./test
then
    file="$HOME/install/cppadcg/build/get_started/test.cpp"
    echo "install_cppadcg.sh: Error in $file"
    exit 1
fi
#
echo 'install_cppadcg.sh: OK'
exit 0

// save to files (not really required)
// SaveFilesModelLibraryProcessor<double> p2(libcgen);
// p2.saveSources();

#include <vector>
#include <cppad/cg.hpp>


const std::string global_library_file_name = "./gradient_norm_squared";

void create_library() {
    // types used for source generation
    typedef CppAD::cg::CG<double>  c_double;
    typedef CppAD::AD<c_double>    ac_double;

    // Start a CppAD recording with ac_x as the independent variable vector
    size_t nx = 2;
    std::vector<ac_double> ac_x(nx);
    CppAD::Independent(ac_x);

    // Dependent variable vector
    size_t ny = 1;
    std::vector<ac_double> ac_y(ny);
    ac_y[0] = ( ac_x[0] * ac_x[0]  + ac_x[1] * ac_x[1] );

    // Stop recording and created c_double verson of
    // f(x) = ( x_0^2 + x_1^2 ) = Euclidean norm of x squared.
    CppAD::ADFun<c_double> c_f(ac_x, ac_y);

    // Create an ac_double version of f(x); i.e.,
    // ac_double is the type for operations by this function and
    // c_double is the Base type when this function was recorded.
    CppAD::ADFun< ac_double, c_double > ac_f;
    ac_f = c_f.base2ad();

    // Start a CppAD recording with ac_x as the independent variable vector
    CppAD::Independent(ac_x);

    // Compute gradient of f(x) using any CppAD operations you like
    ac_f.Forward(0, ac_x);
    std::vector<ac_double> ac_w(ny);
    ac_w[0] = 1.0;
    std::vector<ac_double> ac_z = ac_f.Reverse(1, ac_w); 

    // Stop recrding and create c_double version of g(x) = f'(x)
    CppAD::ADFun<c_double> c_g(ac_x, ac_z);

    // Generate source code
    CppAD::cg::ModelCSourceGen<double> cgen(c_g, "model");
    CppAD::cg::ModelLibraryCSourceGen<double> libcgen(cgen);

    // Compile source code and generator a dynamic library
    CppAD::cg::DynamicModelLibraryProcessor<double> 
        p(libcgen, global_library_file_name);

    CppAD::cg::GccCompiler<double> compiler;
    bool loadLib = false;
    p.createDynamicLibrary(compiler, loadLib);

    // Save to library and source to a file (not required)
    // CppAD::cg::SaveFilesModelLibraryProcessor<double> p2(libcgen);
    // p2.saveSources();
}

bool check_library() {
    bool ok = true;

    // add extension used for dynamic libraries on this system
    const std::string name_plus_ext = global_library_file_name + 
        CppAD::cg::system::SystemInfo<>::DYNAMIC_LIB_EXTENSION;

    // load the library
    CppAD::cg::LinuxDynamicLib<double> dynamicLib(name_plus_ext);
    std::unique_ptr< CppAD::cg::GenericModel<double> > model = 
        dynamicLib.model("model");

    // evaluate f(x)
    std::vector<double> x{2.5, 3.5};
    std::vector<double> z = model->ForwardZero(x);

    // check the result
    ok &= z.size() == 2;
    ok &= z[0] == 2.0 * x[0];
    ok &= z[1] == 2.0 * x[1];

    // return result of check
    return ok;
}

int main() {

    // Add extension used for dynamic libraries on this system
    const std::string name_plus_ext = global_library_file_name + 
        CppAD::cg::system::SystemInfo<>::DYNAMIC_LIB_EXTENSION;

    if (! CppAD::cg::system::isFile(name_plus_ext) ) {
        std::cout << "Creating a new library" << std::endl;
        create_library();
    } else {
        std::cout << "Using existing library" << std::endl;
    }

    bool ok = check_library();
    if( ok )
        return 0;
    return 1;
}

# define BRACE 1
void useLibrary() {
    std::unique_ptr<GenericModel<double>> model;
# if BRACE
    {
# endif
        LinuxDynamicLib<double> dynamicLib(LIBRARY_NAME_EXT);
        model = dynamicLib.model("model");
# if BRACE
    }
# endif
    std::vector<double> xv{2.5, 3.5};
    std::vector<double> jac = model->Jacobian(xv);
    std::cout << jac[0] << " " << jac[1] << std::endl;
}

cppad-20200131 error from a known source:
Model library is not ready (possibly closed)
Error detected by false result for
    _isLibraryReady
at line 364 in the file 
    /home/bradbell/prefix/cppad/include/cppad/cg/model/functor_generic_model.hpp