dual_unary_operator.hpp

Go to the documentation of this file.

#pragma once
#include "algo/ad/detail/dual_helper_function.hpp"
#include "algo/ad/detail/dual_unary_operator_helper.hpp"
#include "algo/ad/dual_expression.hpp"
#include "algo/ad/fwd.h"
#include "algo/ad/traits.hpp"

namespace algo { namespace ad {
    /*--------------------------------------------------------------------------
     * dual_negate
     *------------------------------------------------------------------------*/
    template<typename E>
    class dual_negate : public dual_expression<dual_negate<E> > {
    //private typedef
    private:
    //public typedef
    public:
        typedef typename const_closure_type_traits<E>::type const_closure_type;
    //public function
    public:
        dual_negate()
        : _e(0)
        {
        }
        dual_negate(const E& e)
        : _e(e)
        {
        }
        double getValue()
        {
            return -detail::getValue(_e);
        }
        double getValue() const
        {
            return -detail::getValue(_e);
        }
        decltype(detail::dual_negate_helper(E()))
        getDerivative()
        {
            return detail::dual_negate_helper(_e);
        }
        decltype(detail::dual_negate_helper(E()))
        getDerivative() const
        {
            return detail::dual_negate_helper(_e);
        }
    //private function
    private:
    //private members
    private:
        const_closure_type _e;
    };
    template<typename E>
    dual_negate<E> operator -(const dual_expression<E>& e)
    {
        return dual_negate<E>(e());
    }
    /*--------------------------------------------------------------------------
     * dual_exp
     *------------------------------------------------------------------------*/
    template<typename E>
    class dual_exp : public dual_expression<dual_exp<E> > {
    //private typedef
    private:
    //public typedef
    public:
        typedef typename const_closure_type_traits<E>::type const_closure_type;
    //public function
    public:
        dual_exp()
        : _e(0)
        {
        }
        dual_exp(const E& e)
        : _e(e)
        {
        }
        double getValue()
        {
            return std::exp(detail::getValue(_e));
        }
        double getValue() const
        {
            return std::exp(detail::getValue(_e));
        }
        decltype(detail::dual_exp_helper(E()))
        getDerivative()
        {
            return detail::dual_exp_helper(_e);
        }
        decltype(detail::dual_exp_helper(E()))
        getDerivative() const
        {
            return detail::dual_exp_helper(_e);
        }
    //private function
    private:
    //private members
    private:
        const_closure_type _e;
    };
    template<typename E>
    dual_exp<E> exp(const dual_expression<E>& e)
    {
        return dual_exp<E>(e());
    }
    /*--------------------------------------------------------------------------
     * dual_log
     *------------------------------------------------------------------------*/
    template<typename E>
    class dual_log : public dual_expression<dual_log<E> > {
    //private typedef
    private:
    //public typedef
    public:
        typedef typename const_closure_type_traits<E>::type const_closure_type;
    //public function
    public:
        dual_log()
        : _e(0)
        {
        }
        dual_log(const E& e)
        : _e(e)
        {
        }
        double getValue()
        {
            return std::log(detail::getValue(_e));
        }
        double getValue() const
        {
            return std::log(detail::getValue(_e));
        }
        decltype(detail::dual_log_helper(E()))
        getDerivative()
        {
            return detail::dual_log_helper(_e);
        }
        decltype(detail::dual_log_helper(E()))
        getDerivative() const
        {
            return detail::dual_log_helper(_e);
        }
    //private function
    private:
    //private members
    private:
        const_closure_type _e;
    };
    template<typename E>
    dual_log<E> log(const dual_expression<E>& e)
    {
        return dual_log<E>(e());
    }
    /*--------------------------------------------------------------------------
     * dual_sin
     *------------------------------------------------------------------------*/
    template<typename E>
    class dual_sin : public dual_expression<dual_sin<E> > {
    //private typedef
    private:
    //public typedef
    public:
        typedef typename const_closure_type_traits<E>::type const_closure_type;
    //public function
    public:
        dual_sin()
        : _e(0)
        {
        }
        dual_sin(const E& e)
        : _e(e)
        {
        }
        double getValue()
        {
            return std::sin(detail::getValue(_e));
        }
        double getValue() const
        {
            return std::sin(detail::getValue(_e));
        }
        decltype(detail::dual_sin_helper(E()))
        getDerivative()
        {
            return detail::dual_sin_helper(_e);
        }
        decltype(detail::dual_sin_helper(E()))
        getDerivative() const
        {
            return detail::dual_sin_helper(_e);
        }
    //private function
    private:
    //private members
    private:
        const_closure_type _e;
    };
    template<typename E>
    dual_sin<E> sin(const dual_expression<E>& e)
    {
        return dual_sin<E>(e());
    }
    /*--------------------------------------------------------------------------
     * dual_cos
     *------------------------------------------------------------------------*/
    template<typename E>
    class dual_cos : public dual_expression<dual_cos<E> > {
    //private typedef
    private:
    //public typedef
    public:
        typedef typename const_closure_type_traits<E>::type const_closure_type;
    //public function
    public:
        dual_cos()
        : _e(0)
        {
        }
        dual_cos(const E& e)
        : _e(e)
        {
        }
        double getValue()
        {
            return std::cos(detail::getValue(_e));
        }
        double getValue() const
        {
            return std::cos(detail::getValue(_e));
        }
        decltype(detail::dual_cos_helper(E()))
        getDerivative()
        {
            return detail::dual_cos_helper(_e);
        }
        decltype(detail::dual_cos_helper(E()))
        getDerivative() const
        {
            return detail::dual_cos_helper(_e);
        }
    //private function
    private:
    //private members
    private:
        const_closure_type _e;
    };
    template<typename E>
    dual_cos<E> cos(const dual_expression<E>& e)
    {
        return dual_cos<E>(e());
    }
} } // namespace algo { namespace ad {