language.hpp

#ifndef CPPAD_CG_LANGUAGE_INCLUDED
#define CPPAD_CG_LANGUAGE_INCLUDED
/* --------------------------------------------------------------------------
 *  CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
 *    Copyright (C) 2012 Ciengis
 *    Copyright (C) 2019 Joao Leal
 *
 *  CppADCodeGen is distributed under multiple licenses:
 *
 *   - Eclipse Public License Version 1.0 (EPL1), and
 *   - GNU General Public License Version 3 (GPL3).
 *
 *  EPL1 terms and conditions can be found in the file "epl-v10.txt", while
 *  terms and conditions for the GPL3 can be found in the file "gpl3.txt".
 * ----------------------------------------------------------------------------
 * Author: Joao Leal
 */

namespace CppAD {
namespace cg {

template<class Base>
class LanguageGenerationData {
public:
    using Node = OperationNode<Base>;
    using ScopeIDType = typename CodeHandler<Base>::ScopeIDType;
public:
    const std::vector<Node *>& independent;
    const ArrayView<CG<Base> >& dependent;
    size_t minTemporaryVarID;
    const CodeHandlerVector<Base, size_t>& varId;
    const std::vector<Node*>& variableOrder;
    const std::vector<std::set<Node*>>& variableDependencies;
    VariableNameGenerator<Base>& nameGen;
    const std::map<size_t, size_t>& atomicFunctionId2Index;
    const std::map<size_t, std::string>& atomicFunctionId2Name;
    const std::vector<int>& atomicFunctionsMaxForward;
    const std::vector<int>& atomicFunctionsMaxReverse;
    const bool reuseIDs;
    //
    const std::set<const Node*>& indexes;
    //
    const std::set<RandomIndexPattern*>& indexRandomPatterns;
    //
    const std::vector<IndexPattern*>& loopDependentIndexPatterns;
    //
    const std::vector<IndexPattern*>& loopIndependentIndexPatterns;
    const CodeHandlerVector<Base, size_t>& totalUseCount;
    const CodeHandlerVector<Base, ScopeIDType>& scope;
    IndexOperationNode<Base>& auxIterationIndexOp;
    const bool zeroDependents;
public:

    LanguageGenerationData(const std::vector<Node *>& ind,
                           const ArrayView<CG<Base> >& dep,
                           size_t minTempVID,
                           const CodeHandlerVector<Base, size_t>& varIds,
                           const std::vector<Node*>& vo,
                           const std::vector<std::set<Node*>>& variableDependencies,
                           VariableNameGenerator<Base>& ng,
                           const std::map<size_t, size_t>& atomicId2Index,
                           const std::map<size_t, std::string>& atomicId2Name,
                           const std::vector<int>& atomicMaxForward,
                           const std::vector<int>& atomicMaxReverse,
                           const bool ri,
                           const std::set<const Node*>& indexes,
                           const std::set<RandomIndexPattern*>& idxRandomPatterns,
                           const std::vector<IndexPattern*>& dependentIndexPatterns,
                           const std::vector<IndexPattern*>& independentIndexPatterns,
                           const CodeHandlerVector<Base, size_t>& totalUseCount,
                           const CodeHandlerVector<Base, ScopeIDType>& scope,
                           IndexOperationNode<Base>& auxIterationIndexOp,
                           bool zero) :
        independent(ind),
        dependent(dep),
        minTemporaryVarID(minTempVID),
        varId(varIds),
        variableOrder(vo),
        variableDependencies(variableDependencies),
        nameGen(ng),
        atomicFunctionId2Index(atomicId2Index),
        atomicFunctionId2Name(atomicId2Name),
        atomicFunctionsMaxForward(atomicMaxForward),
        atomicFunctionsMaxReverse(atomicMaxReverse),
        reuseIDs(ri),
        indexes(indexes),
        indexRandomPatterns(idxRandomPatterns),
        loopDependentIndexPatterns(dependentIndexPatterns),
        loopIndependentIndexPatterns(independentIndexPatterns),
        totalUseCount(totalUseCount),
        scope(scope),
        auxIterationIndexOp(auxIterationIndexOp),
        zeroDependents(zero) {
    }
};

template<class Base>
class Language {
    friend class CodeHandler<Base>;
public:
    using Node = OperationNode<Base>;
protected:
    virtual void generateSourceCode(std::ostream& out,
                                    std::unique_ptr<LanguageGenerationData<Base> > info) = 0;

    virtual bool createsNewVariable(const Node& op,
                                    size_t totalUseCount,
                                    size_t opCount) const = 0;

    virtual bool requiresVariableArgument(enum CGOpCode op,
                                          size_t argIndex) const = 0;

    virtual bool requiresVariableDependencies() const = 0;

};

} // END cg namespace
} // END CppAD namespace

#endif