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

stan/math/rev/core/operator_greater_than.hpp

@@ -40,8 +40,7 @@ inline bool operator>(Var1&& a, Var2&& b) {
  * @param b Second value.
  * @return True if first variable's value is greater than second value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator>(Var&& a, Arith b) {
   return a.val() > b;
 }
@@ -56,8 +55,7 @@ inline bool operator>(Var&& a, Arith b) {
  * @param b Second variable.
  * @return True if first value is greater than second variable's value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator>(Arith a, Var&& b) {
   return a > b.val();
 }

stan/math/rev/core/operator_greater_than_or_equal.hpp

@@ -43,8 +43,7 @@ inline bool operator>=(Var1&& a, Var2&& b) {
  * @return True if first variable's value is greater than or equal
  * to second value.
  */
-template <typename Var, typename Arith, require_arithmetic_t<Arith>...,
-          require_var_t<Var>...>
+template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator>=(Var&& a, Arith b) {
   return a.val() >= b;
 }
@@ -60,7 +59,7 @@ inline bool operator>=(Var&& a, Arith b) {
  * @return True if the first value is greater than or equal to the
  * second variable's value.
  */
-template <typename Var, typename Arith, require_arithmetic_t<Arith>...,
+template <typename Arith, typename Var, require_arithmetic_t<Arith>...,
           require_var_t<Var>...>
 inline bool operator>=(Arith a, Var&& b) {
   return a >= b.val();

stan/math/rev/core/operator_less_than.hpp

@@ -39,8 +39,7 @@ inline bool operator<(Var1&& a, Var2&& b) {
  * @param b Second value.
  * @return True if first variable's value is less than second value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator<(Var&& a, Arith b) {
   return a.val() < b;
 }
@@ -55,8 +54,7 @@ inline bool operator<(Var&& a, Arith b) {
  * @param b Second variable.
  * @return True if first value is less than second variable's value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator<(Arith a, Var&& b) {
   return a < b.val();
 }

stan/math/rev/core/operator_less_than_or_equal.hpp

@@ -42,8 +42,7 @@ inline bool operator<=(Var1&& a, Var2&& b) {
  * @return True if first variable's value is less than or equal to
  * the second value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator<=(Var&& a, Arith b) {
   return a.val() <= b;
 }
@@ -59,8 +58,7 @@ inline bool operator<=(Var&& a, Arith b) {
  * @return True if first value is less than or equal to the second
  * variable's value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator<=(Arith a, Var&& b) {
   return a <= b.val();
 }

stan/math/rev/core/operator_logical_and.hpp

@@ -33,8 +33,7 @@ inline bool operator&&(Var1&& x, Var2&& y) {
  * @return conjunction of first argument's value and second
  * argument
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator&&(Var&& x, Arith y) {
   return x.val() && y;
 }
@@ -50,8 +49,7 @@ inline bool operator&&(Var&& x, Arith y) {
  * @return conjunction of first argument and second argument's
  * value
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator&&(Arith x, Var&& y) {
   return x && y.val();
 }

stan/math/rev/core/operator_logical_or.hpp

@@ -33,8 +33,7 @@ inline bool operator||(Var1&& x, Var2&& y) {
  * @return disjunction of first argument's value and second
  * argument
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator||(Var&& x, Arith y) {
   return x.val() || y;
 }
@@ -50,8 +49,7 @@ inline bool operator||(Var&& x, Arith y) {
  * @return disjunction of first argument and the second
  * argument's value
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator||(Arith x, Var&& y) {
   return x || y.val();
 }

stan/math/rev/core/operator_multiplication.hpp

@@ -97,8 +97,7 @@ inline var operator*(Var1&& a, Var2&& b) {
  * @param b Scalar operand.
  * @return Variable result of multiplying operands.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ 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;
@@ -119,8 +118,7 @@ inline var operator*(Var&& a, Arith b) {
  * @param b Variable operand.
  * @return Variable result of multiplying the operands.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline var operator*(Arith a, Var&& b) {
   if (a == 1.0) {
     return b;

stan/math/rev/core/operator_not_equal.hpp

@@ -42,8 +42,7 @@ inline bool operator!=(Var1&& a, Var2&& b) {
  * @return True if the first variable's value is not the same as the
  * second value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline bool operator!=(Var&& a, Arith b) {
   return a.val() != b;
 }
@@ -59,8 +58,7 @@ inline bool operator!=(Var&& a, Arith b) {
  * @return True if the first value is not the same as the
  * second variable's value.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline bool operator!=(Arith a, Var&& b) {
   return a != b.val();
 }

stan/math/rev/core/operator_subtraction.hpp

@@ -111,8 +111,7 @@ inline var operator-(Var1&& a, Var2&& b) {
  * @param b Second scalar operand.
  * @return Result of subtracting the scalar from the variable.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Var, typename Arith, require_var_t<Var>..., require_arithmetic_t<Arith>...>
 inline var operator-(Var&& a, Arith b) {
   if (b == 0.0) {
     return a;
@@ -133,8 +132,7 @@ inline var operator-(Var&& a, Arith b) {
  * @param b Second variable operand.
  * @return Result of sutracting a variable from a scalar.
  */
-template <typename Var, typename Arith, require_var_t<Var>...,
-          require_arithmetic_t<Arith>...>
+ template <typename Arith, typename Var, require_arithmetic_t<Arith>..., require_var_t<Var>...>
 inline var operator-(Arith a, Var&& b) {
   return var(new internal::subtract_dv_vari(a, b.vi_));
 }

stan/math/rev/core/precomputed_gradients.hpp

@@ -48,8 +48,11 @@ class precomputed_gradients_vari : public vari {
    * @throws std::invalid_argument if the sizes of the vectors
    * don't match.
    */
-  precomputed_gradients_vari(double val, const std::vector<var>& vars,
-                             const std::vector<double>& gradients)
+  template <typename Arith, typename VecVar, typename VecArith,
+   require_arithmetic_t<Arith>...,
+   require_vector_like_vt<is_var, VecVar>...,
+   require_vector_like_vt<std::is_arithmetic, VecArith>...>
+  precomputed_gradients_vari(Arith val, VecVar&& vars, VecArith&& gradients)
       : vari(val),
         size_(vars.size()),
         varis_(ChainableStack::instance_->memalloc_.alloc_array<vari*>(
@@ -80,16 +83,22 @@ class precomputed_gradients_vari : public vari {
  * specified value, vector of operands, and vector of partial
  * derivatives of value with respect to the operands.
  *
+ * @tparam Arith An arithmetic type
+ * @tparam VecVar A vector of vars
+ * @tparam VecArith A vector of
  * @param[in] value The value of the resulting dependent variable.
  * @param[in] operands operands.
  * @param[in] gradients vector of partial derivatives of result with
  * respect to operands.
  * @return An auto-diff variable that uses the precomputed
  *   gradients provided.
  */
-inline var precomputed_gradients(double value, const std::vector<var>& operands,
-                                 const std::vector<double>& gradients) {
-  return var(new precomputed_gradients_vari(value, operands, gradients));
+template <typename Arith, typename VecVar, typename VecArith,
+  require_arithmetic_t<Arith>...,
+  require_vector_like_vt<is_var, VecVar>...,
+  require_vector_like_vt<std::is_arithmetic, VecArith>...>
+inline auto precomputed_gradients(Arith value, VecVar&& operands, VecArith&& gradients) {
+  return var(new precomputed_gradients_vari(value, std::forward<VecVar>(operands), std::forward<VecArith>(gradients)));
 }
 }  // namespace math
 }  // namespace stan

stan/math/rev/core/std_isinf.hpp

@@ -13,7 +13,8 @@ namespace std {
  * @param a Argument.
  * @return 1 if argument is infinite and 0 otherwise.
  */
-inline int isinf(const stan::math::var& a) {
+template <typename Var, stan::require_var_t<Var>...>
+inline bool isinf(Var&& a) {
   return stan::math::is_inf(a.val());
 }
 

stan/math/rev/core/std_isnan.hpp

@@ -15,7 +15,8 @@ namespace std {
  * @param a Variable to test.
  * @return <code>true</code> if value is not a number.
  */
-inline int isnan(const stan::math::var& a) { return isnan(a.val()); }
+template <typename Var, stan::require_var_t<Var>...>
+inline bool isnan(Var&& a) { return isnan(a.val()); }
 
 }  // namespace std
 #endif

stan/math/rev/core/vector_vari.hpp

@@ -14,7 +14,8 @@ class op_vector_vari : public vari {
   vari** vis_;
 
  public:
-  op_vector_vari(double f, const std::vector<var>& vs)
+  template <typename Arith, typename VecVar, require_arithmetic_t<Arith>..., require_vector_like_vt<is_var, VecVar>...>
+  op_vector_vari(Arith f, VecVar&& vs)
       : vari(f), size_(vs.size()) {
     vis_ = reinterpret_cast<vari**>(operator new(sizeof(vari*) * vs.size()));
     for (size_t i = 0; i < vs.size(); ++i) {