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/agrad/rev/vari.hpp>

namespace stan {
  namespace agrad {

    // forward declare
    static void recover_memory();
    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_);
        g.resize(x.size());
        for (size_t i = 0; i < x.size(); ++i) 
          g[i] = x[i].vi_->adj_;
        recover_memory();
      }

      void grad() {
        stan::agrad::grad(vi_);
        recover_memory();
      }

      // 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) {
        return os << v.val() << ':' << v.adj();
      }
    };

  }
}
#endif