dual.hpp

Go to the documentation of this file.

#pragma once
#include "algo/ad/dual_expression.hpp"

namespace algo { namespace ad {
    template <typename I = boost::numeric::ublas::vector<double> >
    class dual : public dual_expression<dual<I> > {
    private:
        typedef dual<I> self_type;
    public:
        //closure
        typedef const self_type& const_closure_type;
        //inf
        typedef I infinitesimal_type;
        typedef I& infinitesimal_reference;
        typedef const I& const_infinitesimal_reference;

    public:
        explicit dual() 
        : _value(0), _derivative(0)
        {
        }
        template <typename AE>
        dual(const dual_expression<AE>& ae) 
        : _value(ae().getValue()), _derivative(ae().getDerivative())
        {
        }
        dual(const double v) 
        : _value(v), _derivative(0)
        {
        }
        dual(
            const double& v, 
            const infinitesimal_type& d) 
        : _value(v), _derivative(d)
        {
        }
        double& getValue()
        {
            return _value;
        }
        const double& getValue() const
        {
            return _value;
        }
        infinitesimal_reference getDerivative()
        {
            return _derivative;
        }
        const_infinitesimal_reference getDerivative() const
        {
            return _derivative;
        }
    private:
        double _value;
        infinitesimal_type _derivative;
    };
} } // namespace algo { namespace ad {