var.hpp

Go to the documentation of this file.

#ifndef STAN__AGRAD__REV__VAR_HPP
#define STAN__AGRAD__REV__VAR_HPP

#include <ostream>
#include <stan/math/matrix/Eigen.hpp>
#include <stan/agrad/rev/vari.hpp>

namespace stan {
  namespace agrad {

    // forward declare
    static void grad(chainable* vi);
    
    class var {
    public:

      // FIXME: doc what this is for
      typedef double Scalar;

      vari * vi_;

      bool is_uninitialized() {
        return (vi_ == static_cast<vari*>(0U));
      }

      explicit var(vari* vi)
        : vi_(vi) 
      {  }

      var() 
        : vi_(static_cast<vari*>(0U))
      { }

      var(bool b) :
        vi_(new vari(static_cast<double>(b))) {
      }

      var(char c) :
        vi_(new vari(static_cast<double>(c))) {
      }

      var(short n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(unsigned short n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(int n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(unsigned int n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(long int n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(unsigned long int n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(unsigned long long n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(long long n) :
        vi_(new vari(static_cast<double>(n))) {
      }

      var(float x) :
        vi_(new vari(static_cast<double>(x))) {
      }

      var(double x) :
        vi_(new vari(x)) {
      }

      var(long double x) :
        vi_(new vari(static_cast<double>(x))) {
      }

      inline double val() const {
        return vi_->val_;
      }

      inline double adj() const {
        return vi_->adj_;
      }

      void grad(std::vector<var>& x,
                std::vector<double>& g) {
        stan::agrad::grad(vi_); // defined in chainable.hpp
        g.resize(x.size());
        for (size_t i = 0; i < x.size(); ++i) 
          g[i] = x[i].vi_->adj_;
      }
      
      // POINTER OVERRIDES
      
      inline vari& operator*() {
        return *vi_;
      }

      inline vari* operator->() {
        return vi_;
      }

      // COMPOUND ASSIGNMENT OPERATORS
    
      inline var& operator+=(const var& b); 

      inline var& operator+=(const double b);

      inline var& operator-=(const var& b);

      inline var& operator-=(const double b);

      inline var& operator*=(const var& b);

      inline var& operator*=(const double b);

      inline var& operator/=(const var& b);

      inline var& operator/=(const double b);

      friend std::ostream& operator<<(std::ostream& os, const var& v) {
        if (v.vi_ == 0)
          return os << "uninitialized";
        return os << v.val() << ':' << v.adj();
      }
    };

  }
}
#endif