Generic var templates for operators and std::iterator_trait var/fvar specialization

stan/math/fwd/core.hpp

@@ -18,5 +18,6 @@
 #include <stan/math/fwd/core/operator_unary_not.hpp>
 #include <stan/math/fwd/core/operator_unary_plus.hpp>
 #include <stan/math/fwd/core/std_numeric_limits.hpp>
+#include <stan/math/fwd/core/std_iterator_traits.hpp>
 
 #endif

stan/math/fwd/core/std_iterator_traits.hpp

@@ -0,0 +1,42 @@
+#ifndef STAN_MATH_FWD_CORE_STD_ITERATOR_TRAITS_HPP
+#define STAN_MATH_FWD_CORE_STD_ITERATOR_TRAITS_HPP
+
+#include <stan/math/fwd/core/fvar.hpp>
+#include <stan/math/prim/meta.hpp>
+#include <iterator>
+
+namespace std {
+/**
+ * Specialization of iterator traits for Stan math.  These all take
+ * the form of typedefs.
+ */
+template <typename T>
+struct iterator_traits<stan::math::fvar<T>> {
+  /**
+   * Iterator category for traits.
+   */
+  typedef random_access_iterator_tag iterator_category;
+
+  /**
+   * Type for difference between pointers.
+   */
+  typedef ptrdiff_t difference_type;
+
+  /**
+   * Type for value of pointer to values.
+   */
+  typedef stan::math::fvar<T> value_type;
+
+  /**
+   * Type of pointer to variables.
+   */
+  typedef stan::math::fvar<T>* pointer;
+
+  /**
+   * Type of reference to variables.
+   */
+  typedef stan::math::fvar<T>& reference;
+};
+}  // namespace std
+
+#endif

stan/math/prim/meta/require_generics.hpp

@@ -37,7 +37,7 @@ struct is_double_or_int
  * @tparam The type to check
  */
 template <typename T>
-struct is_var_or_fvar
+struct is_autodiff
     : bool_constant<math::disjunction<is_var<std::decay_t<T>>,
                                       is_fvar<std::decay_t<T>>>::value> {};
 
@@ -473,24 +473,22 @@ using require_any_not_fvar_t
     = require_any_not_t<is_fvar<std::decay_t<Types>>...>;
 
 template <typename T>
-using require_var_or_fvar_t = require_t<is_var_or_fvar<T>>;
+using require_autodiff_t = require_t<is_autodiff<T>>;
 
 template <typename T>
-using require_not_var_or_fvar_t = require_not_t<is_var_or_fvar<T>>;
+using require_not_autodiff_t = require_not_t<is_autodiff<T>>;
 
 template <typename... Types>
-using require_all_var_or_fvar_t = require_all_t<is_var_or_fvar<Types>...>;
+using require_all_autodiff_t = require_all_t<is_autodiff<Types>...>;
 
 template <typename... Types>
-using require_any_var_or_fvar_t = require_any_t<is_var_or_fvar<Types>...>;
+using require_any_autodiff_t = require_any_t<is_autodiff<Types>...>;
 
 template <typename... Types>
-using require_all_not_var_or_fvar_t
-    = require_all_not_t<is_var_or_fvar<Types>...>;
+using require_all_not_autodiff_t = require_all_not_t<is_autodiff<Types>...>;
 
 template <typename... Types>
-using require_any_not_var_or_fvar_t
-    = require_any_not_t<is_var_or_fvar<Types>...>;
+using require_any_not_autodiff_t = require_any_not_t<is_autodiff<Types>...>;
 
 template <typename T>
 using require_stan_scalar_t = require_t<is_stan_scalar<T>>;

stan/math/rev/core.hpp

@@ -5,7 +5,9 @@
 #include <stan/math/rev/core/build_vari_array.hpp>
 #include <stan/math/rev/core/chainable_alloc.hpp>
 #include <stan/math/rev/core/chainablestack.hpp>
+#include <stan/math/rev/core/cmath.hpp>
 #include <stan/math/rev/core/init_chainablestack.hpp>
+#include <stan/math/rev/core/std_iterator_traits.hpp>
 #include <stan/math/rev/core/ddv_vari.hpp>
 #include <stan/math/rev/core/dv_vari.hpp>
 #include <stan/math/rev/core/dvd_vari.hpp>

stan/math/rev/core/cmath.hpp

@@ -0,0 +1,119 @@
+#ifndef STAN_MATH_REV_CORE_CMATH_HPP
+#define STAN_MATH_REV_CORE_CMATH_HPP
+
+#include <stan/math/rev/core/var.hpp>
+#include <stan/math/prim/meta.hpp>
+
+namespace stan {
+namespace math {
+
+/**
+ * Return `true` if the specified argument is negative and `false`
+ * otherwise.
+ *
+ * Overloads `std::signbit` from `<cmath>` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of argument
+ * @param[in] v argument
+ * @return `true` if the argument is negative
+ */
+template <typename T, require_autodiff_t<T>...>
+inline bool signbit(T&& v) {
+  using std::signbit;
+  return signbit(v.val());
+}
+
+/**
+ * Return true if specified argument is infinite (positive or
+ * negative).
+ *
+ * Overloads `std::isinf` from `<cmath>` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of argument
+ * @param[in] v argument
+ * @return true if argument is infinite
+ */
+template <typename T, require_autodiff_t<T>...>
+inline bool isinf(T&& v) {
+  using std::isinf;
+  return isinf(v.val());
+}
+
+/**
+ * Return true if specified argument is finite (not infinite and not
+ * not-a-number).
+ *
+ * Overloads `std::isfinite` from `<cmath>` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of argument
+ * @param[in] v argument
+ * @return true if argument is finite
+ */
+template <typename T, require_autodiff_t<T>...>
+inline bool isfinite(T&& v) {
+  using std::isfinite;
+  return isfinite(v.val());
+}
+
+/**
+ * Return true if specified argument is not-a-number.
+ *
+ * Overloads `std::isnan` from `<cmath>` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of argument
+ * @param[in] v argument
+ * @return true if argument is not-a-number
+ */
+template <typename T, require_autodiff_t<T>...>
+inline bool isnan(T&& v) {
+  using std::isnan;
+  return isnan(v.val());
+}
+
+/**
+ * Return true if specified argument is normal.  A number is normal if
+ * it is finite, non-zero and not subnormal.
+ *
+ * Overloads `std::isnormal` from `<cmath>` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of argument
+ * @param[in] v argument
+ * @return true if argument is normal
+ */
+template <typename T, require_autodiff_t<T>...>
+inline bool isnormal(T&& v) {
+  using std::isnormal;
+  return isnormal(v.val());
+}
+
+/**
+ * Return the negation of the first argument if the first and second
+ * argument have different signs, otherwise return a copy of the first
+ * argument.  For the sake of this function, zero is considered
+ * positive.  This function uses negation rather than literally copying
+ * signs to preserve derivatives.
+ *
+ * Overload of `std::copysign` from `cmath` for argument-dependent
+ * lookup.
+ *
+ * @tparam T type of first argument
+ * @tparam U type of second argument
+ * @param[in] x first complex argument
+ * @param[in] y second complex argument
+ * @return copy of second argument, negated if necessary to match sign
+ * of first argument
+ */
+template <typename T, typename U>
+inline T copysign(const T& x, const U& y) {
+  // 0 is considered positive
+  return (x < 0 && y >= 0) || (x > 0 && y < 0) ? -x : x;
+}
+}  // namespace math
+}  // namespace stan
+
+#endif

stan/math/rev/core/operator_addition.hpp

@@ -5,6 +5,7 @@
 #include <stan/math/rev/core/vv_vari.hpp>
 #include <stan/math/rev/core/vd_vari.hpp>
 #include <stan/math/prim/scal/fun/is_any_nan.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <limits>
 
 namespace stan {
@@ -73,11 +74,14 @@ class add_vd_vari : public op_vd_vari {
    \end{cases}
    \f]
  *
+ * @tparam Var1 value type of a var
+ * @tparam Var2 value type of a var
  * @param a First variable operand.
  * @param b Second variable operand.
  * @return Variable result of adding two variables.
  */
-inline var operator+(const var& a, const var& b) {
+template <typename Var1, typename Var2, require_all_var_t<Var1, Var2>...>
+inline auto operator+(Var1&& a, Var2&& b) {
   return var(new internal::add_vv_vari(a.vi_, b.vi_));
 }
 
@@ -88,11 +92,15 @@ inline var operator+(const var& a, const var& b) {
  *
  * \f$\frac{d}{dx} (x + c) = 1\f$.
  *
+ * @tparam Var value type of a var
+ * @tparam Arith An arithmetic type
  * @param a First variable operand.
  * @param b Second scalar operand.
  * @return Result of adding variable and scalar.
  */
-inline var operator+(const var& a, double b) {
+template <typename Var, typename Arith, require_var_t<Var>...,
+          require_arithmetic_t<Arith>...>
+inline auto operator+(Var&& a, Arith b) {
   if (b == 0.0) {
     return a;
   }
@@ -106,11 +114,15 @@ inline var operator+(const var& a, double b) {
  *
  * \f$\frac{d}{dy} (c + y) = 1\f$.
  *
+ * @tparam Arith An arithmetic type
+ * @tparam Var value type of a var
  * @param a First scalar operand.
  * @param b Second variable operand.
  * @return Result of adding variable and scalar.
  */
-inline var operator+(double a, const var& b) {
+template <typename Arith, typename Var, require_arithmetic_t<Arith>...,
+          require_var_t<Var>...>
+inline auto operator+(Arith a, Var&& b) {
   if (a == 0.0) {
     return b;
   }

stan/math/rev/core/operator_divide_equal.hpp

@@ -3,16 +3,18 @@
 
 #include <stan/math/rev/core/var.hpp>
 #include <stan/math/rev/core/operator_division.hpp>
+#include <stan/math/prim/meta.hpp>
 
 namespace stan {
 namespace math {
-
-inline var& var::operator/=(const var& b) {
+template <typename Var, require_var_t<Var>...>
+inline var& var::operator/=(Var&& b) {
   vi_ = new internal::divide_vv_vari(vi_, b.vi_);
   return *this;
 }
 
-inline var& var::operator/=(double b) {
+template <typename Arith, require_arithmetic_t<Arith>...>
+inline var& var::operator/=(Arith b) {
   if (b == 1.0) {
     return *this;
   }

stan/math/rev/core/operator_division.hpp

@@ -6,6 +6,7 @@
 #include <stan/math/rev/core/vd_vari.hpp>
 #include <stan/math/rev/core/dv_vari.hpp>
 #include <stan/math/prim/scal/fun/is_any_nan.hpp>
+#include <stan/math/prim/meta.hpp>
 #include <limits>
 
 namespace stan {
@@ -80,12 +81,15 @@ class divide_dv_vari : public op_dv_vari {
    \end{cases}
    \f]
  *
+ * @tparam Var1 value type of a var
+ * @tparam Var2 value type of a var
  * @param a First variable operand.
  * @param b Second variable operand.
  * @return Variable result of dividing the first variable by the
  * second.
  */
-inline var operator/(const var& a, const var& b) {
+template <typename Var1, typename Var2, require_all_var_t<Var1, Var2>...>
+inline auto operator/(Var1&& a, Var2&& b) {
   return var(new internal::divide_vv_vari(a.vi_, b.vi_));
 }
 
@@ -96,11 +100,15 @@ inline var operator/(const var& a, const var& b) {
  *
  * \f$\frac{\partial}{\partial x} (x/c) = 1/c\f$.
  *
+ * @tparam Var value type of a var
+ * @tparam Arith An arithmetic type
  * @param a Variable operand.
  * @param b Scalar operand.
  * @return Variable result of dividing the variable by the scalar.
  */
-inline var operator/(const var& a, double b) {
+template <typename Var, typename Arith, require_var_t<Var>...,
+          require_arithmetic_t<Arith>...>
+inline var operator/(Var&& a, Arith b) {
   if (b == 1.0) {
     return a;
   }
@@ -114,11 +122,15 @@ inline var operator/(const var& a, double b) {
  *
  * \f$\frac{d}{d y} (c/y) = -c / y^2\f$.
  *
+ * @tparam Arith An arithmetic type
+ * @tparam Var value type of a var
  * @param a Scalar operand.
  * @param b Variable operand.
  * @return Variable result of dividing the scalar by the variable.
  */
-inline var operator/(double a, const var& b) {
+template <typename Arith, typename Var, require_arithmetic_t<Arith>...,
+          require_var_t<Var>...>
+inline auto operator/(Arith a, Var&& b) {
   return var(new internal::divide_dv_vari(a, b.vi_));
 }