fvar.hpp

Go to the documentation of this file.

#ifndef STAN_MATH_FWD_CORE_FVAR_HPP
#define STAN_MATH_FWD_CORE_FVAR_HPP
 
#include <stan/math/prim/meta.hpp>
#include <stan/math/prim/fun/is_nan.hpp>
#include <ostream>
#include <type_traits>
 
namespace stan {
namespace math {
 
template <typename T>
struct fvar {
  using Scalar = std::decay_t<T>;
 
  Scalar val_;
 
  Scalar val() const { return val_; }
 
  Scalar d_;
 
  Scalar d() const { return d_; }
 
  fvar() : val_(0.0), d_(0.0) {}  // NOLINT
 
  template <typename V, std::enable_if_t<ad_promotable<V, T>::value>* = nullptr,
            require_not_same_t<V, fvar<T>>* = nullptr>
  fvar(const V& v) : val_(v), d_(0) {}  // NOLINT(runtime/explicit)
 
  template <typename V, typename D>
  fvar(const V& v, const D& d) : val_(v), d_(d) {}
 
  inline fvar<T>& operator+=(const fvar<T>& x2) {
    val_ += x2.val_;
    d_ += x2.d_;
    return *this;
  }
 
  inline fvar<T>& operator+=(double x2) {
    val_ += x2;
    return *this;
  }
 
  inline fvar<T>& operator-=(const fvar<T>& x2) {
    val_ -= x2.val_;
    d_ -= x2.d_;
    return *this;
  }
 
  inline fvar<T>& operator-=(double x2) {
    val_ -= x2;
    return *this;
  }
 
  inline fvar<T>& operator*=(const fvar<T>& x2) {
    d_ = d_ * x2.val_ + val_ * x2.d_;
    val_ *= x2.val_;
    return *this;
  }
 
  inline fvar<T>& operator*=(double x2) {
    val_ *= x2;
    d_ *= x2;
    return *this;
  }
 
  inline fvar<T>& operator/=(const fvar<T>& x2) {
    d_ = (d_ * x2.val_ - val_ * x2.d_) / (x2.val_ * x2.val_);
    val_ /= x2.val_;
    return *this;
  }
 
  inline fvar<T>& operator/=(double x2) {
    val_ /= x2;
    d_ /= x2;
    return *this;
  }
 
  inline fvar<T>& operator++() {
    ++val_;
    return *this;
  }
 
  inline fvar<T> operator++(int /*dummy*/) {
    fvar<T> result(val_, d_);
    ++val_;
    return result;
  }
 
  inline fvar<T>& operator--() {
    --val_;
    return *this;
  }
 
  inline fvar<T> operator--(int /*dummy*/) {
    fvar<T> result(val_, d_);
    --val_;
    return result;
  }
 
  friend std::ostream& operator<<(std::ostream& os, const fvar<T>& v) {
    return os << v.val_;
  }
};
 
}  // namespace math
}  // namespace stan
#endif