cg.hpp

#ifndef CPPAD_CG_CG_INCLUDED
#define CPPAD_CG_CG_INCLUDED
/* --------------------------------------------------------------------------
 *  CppADCodeGen: C++ Algorithmic Differentiation with Source Code Generation:
 *    Copyright (C) 2012 Ciengis
 *
 *  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 CG {
private:
    OperationNode<Base>* node_;
    std::unique_ptr<Base> value_;
 
public:
    inline CG();

    inline CG(OperationNode<Base>& node);

    inline CG(const CG<Base>& orig);

    inline CG(CG<Base>&& orig);

    inline CG& operator=(const CG<Base>& rhs);

    inline CG& operator=(CG<Base>&& rhs);

    inline CG(const Base& val);

    inline CG& operator=(const Base& rhs);
 
    // destructor
    virtual ~CG();

    inline CodeHandler<Base>* getCodeHandler() const;
 
    // variable classification methods
    inline bool isVariable() const;

    inline bool isParameter() const;

    inline bool isValueDefined() const;

    inline const Base& getValue() const;

    inline void setValue(const Base& val);
 
    inline bool isIdenticalZero() const;
    inline bool isIdenticalOne() const;
 
    inline OperationNode<Base>* getOperationNode() const;
 
    // computed assignment operators
    inline CG<Base>& operator+=(const CG<Base>& right);
    inline CG<Base>& operator-=(const CG<Base>& right);
    inline CG<Base>& operator*=(const CG<Base>& right);
    inline CG<Base>& operator/=(const CG<Base>& right);
    inline CG<Base>& operator+=(const Base& right);
    inline CG<Base>& operator-=(const Base& right);
    inline CG<Base>& operator*=(const Base& right);
    inline CG<Base>& operator/=(const Base& right);
 
    template< class T>
    inline CG<Base>& operator+=(const T &right);
    template<class T>
    inline CG<Base>& operator-=(const T &right);
    template<class T>
    inline CG<Base>& operator/=(const T &right);
    template<class T>
    inline CG<Base>& operator*=(const T &right);
 
    // unary operators
    inline CG<Base> operator+() const;
    inline CG<Base> operator-() const;
protected:
    inline CG(const Argument<Base>& arg);
 
    //
    inline void makeParameter(const Base& b);
 
    inline void makeVariable(OperationNode<Base>& operation);
 
    inline void makeVariable(OperationNode<Base>& operation,
                             std::unique_ptr<Base>& value);
 
    // creating an argument out of this node
    inline Argument<Base> argument() const;
 
    /***************************************************************************
     *                               friends
     **************************************************************************/
 
    friend class CodeHandler<Base>;
    friend class CGAbstractAtomicFun<Base>;
    friend class Loop<Base>;
    friend class LoopModel<Base>;

    friend CG<Base> CppAD::cg::operator+ <Base>(const CG<Base>& left, const CG<Base>& right);
    friend CG<Base> CppAD::cg::operator- <Base>(const CG<Base>& left, const CG<Base>& right);
    friend CG<Base> CppAD::cg::operator* <Base>(const CG<Base>& left, const CG<Base>& right);
    friend CG<Base> CppAD::cg::operator/ <Base>(const CG<Base>& left, const CG<Base>& right);

    friend bool GreaterThanZero <Base> (const CG<Base>& x);
    friend bool GreaterThanOrZero <Base> (const CG<Base>& x);
    friend bool LessThanZero <Base> (const CG<Base>& x);
    friend bool LessThanOrZero <Base> (const CG<Base>& x);
    friend bool abs_geq <Base> (const CG<Base>& x, const CG<Base>& y);
 
    // EqualOpSeq function
    friend bool EqualOpSeq <Base> (const CG<Base>& u, const CG<Base>& v);
 
    // NearEqual function
    friend bool NearEqual <Base> (const CG<Base>& x, const CG<Base>& y, const Base& r, const Base& a);
    friend bool NearEqual <Base> (const Base& x, const CG<Base>& y, const Base& r, const Base& a);
    friend bool NearEqual <Base> (const CG<Base>& x, const Base& y, const Base& r, const Base& a);
 
    // CondExp function
    friend CG<Base> CondExp<Base>(CGOpCode op,
            const CG<Base>& left,
            const CG<Base>& right,
            const CG<Base>& trueCase,
            const CG<Base>& falseCase,
            bool (*compare)(const Base&, const Base&));
 
    friend CG<Base> sign<Base>(const CG<Base>& x);

    friend CG<Base> pow<Base>(const CG<Base> &x, const CG<Base> &y);
    friend CG<Base> abs<Base>(const CG<Base>& var);
    friend CG<Base> fabs<Base>(const CG<Base>& var);
    friend CG<Base> acos<Base>(const CG<Base>& var);
    friend CG<Base> asin<Base>(const CG<Base>& var);
    friend CG<Base> atan<Base>(const CG<Base>& var);
    friend CG<Base> cos<Base>(const CG<Base>& var);
    friend CG<Base> cosh<Base>(const CG<Base>& var);
    friend CG<Base> exp<Base>(const CG<Base>& var);
    friend CG<Base> log<Base>(const CG<Base>& var);
    friend CG<Base> sin<Base>(const CG<Base>& var);
    friend CG<Base> sinh<Base>(const CG<Base>& var);
    friend CG<Base> sqrt<Base>(const CG<Base>& var);
    friend CG<Base> tan<Base>(const CG<Base>& var);
    friend CG<Base> tanh<Base>(const CG<Base>& var);
 
#if CPPAD_USE_CPLUSPLUS_2011
    // c++11 functions
    friend CG<Base> erf<Base>(const CG<Base>& var); // error function
    friend CG<Base> erfc<Base>(const CG<Base>& var); // complementary error function
    friend CG<Base> asinh<Base>(const CG<Base>& var); // inverse hyperbolic sin
    friend CG<Base> acosh<Base>(const CG<Base>& var); // inverse hyperbolic cosine
    friend CG<Base> atanh<Base>(const CG<Base>& var); // inverse hyperbolic tangent
    friend CG<Base> expm1<Base>(const CG<Base>& var); // exponential of x minus one
    friend CG<Base> log1p<Base>(const CG<Base>& var); // logarithm of one plus x
#endif
};
 

template<class Base>
struct CGOStreamFunc {
    static thread_local std::function<std::ostream& (std::ostream&, const CG<Base>&)> FUNC;
};
 
template<class Base>
thread_local std::function<std::ostream& (std::ostream&, const CG<Base>&)> CGOStreamFunc<Base>::FUNC = nullptr;

template<class Base>
inline std::ostream& operator<<(
        std::ostream& os, //< stream to write to
        const CG<Base>& v//< vector that is output
        ) {
    if(CGOStreamFunc<Base>::FUNC != nullptr) {
        return CGOStreamFunc<Base>::FUNC(os, v);
    }
 
    if (v.isParameter()) {
        os << v.getValue();
    } else {
        os << *v.getOperationNode();
        if (v.isValueDefined()) {
            os << " (" << v.getValue() << ")";
        }
    }
    return os;
}
 
template<class Base>
inline std::ostringstream& operator<<(
        std::ostringstream& os, //< steam to write the vector to
        const CG<Base>& v//< vector that is output
        ) {
    if (v.isParameter()) {
        os << v.getValue();
    } else {
        os << *v.getOperationNode();
        if (v.isValueDefined()) {
            os << " (" << v.getValue() << ")";
        }
    }
    return os;
}
 
template<class Base>
inline std::istream& operator>>(
        std::istream& is, //< stream to load a parameter value
        CG<Base>& v//< the variable that will be assign the value
        ) {
    Base value;
    is >> value;
    v = value;
    return is;
}
 
} // END cg namespace
 
template <class Base>
int Integer(const CppAD::cg::CG<Base>& x) {
    if (x.isValueDefined()) {
        return Integer(x.getValue());
    } else {
        CppAD::ErrorHandler::Call(false, __LINE__, __FILE__, "Integer()", "No value defined");
        return 0;
    }
}
 
} // END CppAD namespace
 
#endif