CGHelpers.h

Go to the documentation of this file.

/**********************************************************************************************************************
This file is part of the Control Toolbox (https://github.com/ethz-adrl/control-toolbox), copyright by ETH Zurich.
Licensed under the BSD-2 license (see LICENSE file in main directory)
**********************************************************************************************************************/

#pragma once

#ifdef CPPADCG

#include "SparsityPattern.h"

namespace ct {
namespace core {
namespace internal {


class CGHelpers
{
public:
    CGHelpers() = default;

    virtual ~CGHelpers() = default;


    template <typename AD_SCALAR, typename SCALAR = double>
    static std::string generateJacobianSource(CppAD::ADFun<AD_SCALAR>& f,
        SparsityPattern& pattern,
        const size_t jacDim,
        size_t& maxTempVarCount,
        bool useReverse = false,
        bool ignoreZero = true,
        std::string jacName = "jac",
        std::string inputName = "x_in",
        std::string tempName = "v_",
        std::string scalarName = "double")
    {
        CppAD::cg::CodeHandler<SCALAR> codeHandler;

        size_t n = f.Domain();

        CppAD::vector<AD_SCALAR> input(n);
        codeHandler.makeVariables(input);
        for (size_t i = 0; i < n; i++)
        {
            // init to rand to avoid floating point problems in user's code
            input[i].setValue(static_cast<double>(rand()) / static_cast<double>(RAND_MAX));
        }

        CppAD::vector<AD_SCALAR> jac(jacDim);

        if (useReverse)
            f.SparseJacobianReverse(
                input, pattern.sparsity(), pattern.row(), pattern.col(), jac, pattern.workJacobian());
        else
            f.SparseJacobianForward(
                input, pattern.sparsity(), pattern.row(), pattern.col(), jac, pattern.workJacobian());

        CppAD::cg::LanguageC<SCALAR> langC(scalarName, 4);
        langC.setIgnoreZeroDepAssign(ignoreZero);
        CppAD::cg::LangCDefaultVariableNameGenerator<SCALAR> nameGen(jacName, inputName, tempName);

        std::ostringstream code;
        codeHandler.generateCode(code, langC, jac, nameGen);

        std::cout << "temporary variables: " << codeHandler.getTemporaryVariableCount() << std::endl;
        maxTempVarCount = codeHandler.getTemporaryVariableCount();

        return code.str();
    }


    template <typename AD_SCALAR>
    static std::string generateForwardZeroSource(CppAD::ADFun<AD_SCALAR>& f,
        size_t& maxTempVarCount,
        bool ignoreZero = true,
        std::string jacName = "forwardZero",
        std::string inputName = "x_in",
        std::string tempName = "v_")
    {
        CppAD::cg::CodeHandler<double> codeHandler;

        // input vector, needs to be dynamic size
        size_t n = f.Domain();

        CppAD::vector<AD_SCALAR> input(n);

        for (size_t i = 0; i < input.size(); i++)
        {
            // init to rand to avoid floating point problems in user's code
            input[i].setValue(static_cast<double>(rand()) / static_cast<double>(RAND_MAX));
        }


        // mark independent as variables
        codeHandler.makeVariables(input);

        CppAD::vector<AD_SCALAR> forwardZero = f.Forward(0, input);

        CppAD::cg::LanguageC<double> langC("double", 4);
        langC.setIgnoreZeroDepAssign(ignoreZero);
        CppAD::cg::LangCDefaultVariableNameGenerator<double> nameGen(jacName, inputName, tempName);

        std::ostringstream code;
        codeHandler.generateCode(code, langC, forwardZero, nameGen);

        std::cout << "temporary variables: " << codeHandler.getTemporaryVariableCount() << std::endl;
        maxTempVarCount = codeHandler.getTemporaryVariableCount();

        return code.str();
    }


    template <typename AD_SCALAR>
    static std::string generateHessianSource(CppAD::ADFun<AD_SCALAR>& f,
        SparsityPattern& pattern,
        const size_t hesDim,
        size_t& maxTempVarCount,
        bool ignoreZero = true,
        std::string jacName = "hes",
        std::string inputName = "x_in",
        std::string tempName = "v_")
    {
        CppAD::cg::CodeHandler<double> codeHandler;

        size_t m = f.Range();
        size_t n = f.Domain();

        CppAD::vector<AD_SCALAR> input(n);
        codeHandler.makeVariables(input);
        // setting some typical values here.
        for (size_t i = 0; i < input.size(); i++)
        {
            // init to rand to avoid floating point problems in user's code
            input[i].setValue(static_cast<double>(rand()) / static_cast<double>(RAND_MAX));
        }

        CppAD::vector<AD_SCALAR> weights(m);
        codeHandler.makeVariables(weights);
        // settings some typical values for the weights
        for (size_t i = 0; i < m; ++i)
        {
            // init to rand to avoid floating point problems in user's code
            weights[i].setValue(static_cast<double>(rand()) / static_cast<double>(RAND_MAX));
        }


        CppAD::vector<AD_SCALAR> hes(hesDim);
        f.SparseHessian(input, weights, pattern.sparsity(), pattern.row(), pattern.col(), hes, pattern.workHessian());

        // make use of the symmetry of the hessian
        for (size_t i = 0; i < n; i++)
            for (size_t j = 0; j < i; j++)
                hes[i * n + j] = hes[j * n + i];

        CppAD::cg::LanguageC<double> langC("double", 4);
        langC.setIgnoreZeroDepAssign(ignoreZero);
        CppAD::cg::LangCDefaultVariableNameGenerator<double> nameGenTmp(jacName, inputName, tempName);
        CppAD::cg::LangCDefaultHessianVarNameGenerator<double> nameGen(&nameGenTmp, "w_in", m);

        std::ostringstream code;
        codeHandler.generateCode(code, langC, hes, nameGen);

        std::cout << "temporary variables: " << codeHandler.getTemporaryVariableCount() << std::endl;
        maxTempVarCount = codeHandler.getTemporaryVariableCount();

        return code.str();
    }



    static void replaceAll(std::string& text, const std::string& placeholder, const std::string replaceWith)
    {
        size_t pos = text.find(placeholder);
        while (pos != std::string::npos)
        {
            text.replace(pos, placeholder.length(), replaceWith);
            pos = text.find(placeholder);
        }
    }


    static void replaceOnce(std::string& text, const std::string& placeholder, const std::string replaceWith)
    {
        text.replace(text.find(placeholder), placeholder.length(), replaceWith);
    }


    static void writeFile(const std::string& outputFile, const std::string& content)
    {
        std::ofstream out(outputFile);

        if (!out.good())
        {
            std::cout << "Could not open output file for writing " << outputFile << std::endl;
            out.close();
            throw std::runtime_error("Code generation failed. Exiting.");
        }

        std::cout << "Writing generated code to file... " << std::endl;

        out << content;
        out.close();
    }


    static std::string parseFile(const std::string& filename)
    {
        std::ifstream t(filename);

        if (!t.good())
        {
            std::cout << "Could not open template file " << filename << std::endl;
            std::cout << "Code generation failed. Exiting." << std::endl;
            t.close();
            throw std::runtime_error("Code generation failed. Exiting.");
        }

        std::stringstream stream;
        stream << t.rdbuf();

        std::string source(stream.str());

        t.close();

        return source;
    }


    template <typename SC = double>
    static std::shared_ptr<CppAD::cg::DynamicLib<SC>> loadDynamicLibCppad(const std::string& libName)
    {
#if CPPAD_CG_SYSTEM_LINUX
        return std::shared_ptr<CppAD::cg::DynamicLib<SC>>(
            new CppAD::cg::LinuxDynamicLib<SC>(libName + CppAD::cg::system::SystemInfo<>::DYNAMIC_LIB_EXTENSION));
#else
        throw std::runtime_error("Loading dynamic Cppad codegen libraries only supported in Linux.");
#endif
    }
};


} /* namespace internal */
} /* namespace core */
} /* namespace ct */

#endif