Add perfect forwarding and constexpr to reverse mode functions

make/compiler_flags

@@ -120,32 +120,8 @@ INC_GTEST ?= -I $(GTEST)/include -I $(GTEST)
 CPPFLAGS_BOOST ?= -DBOOST_DISABLE_ASSERTS
 CPPFLAGS_SUNDIALS ?= -DNO_FPRINTF_OUTPUT $(CPPFLAGS_OPTIM_SUNDIALS) $(CXXFLAGS_FLTO_SUNDIALS)
 #CPPFLAGS_GTEST ?=
-STAN_HAS_CXX17 ?= false
-ifeq ($(CXX_TYPE), gcc)
-  GCC_GE_73 := $(shell [ $(CXX_MAJOR) -gt 7 -o \( $(CXX_MAJOR) -eq 7 -a $(CXX_MINOR) -ge 1 \) ] && echo true)
-  ifeq ($(GCC_GE_73),true)
-    STAN_HAS_CXX17 := true
-  endif
-else ifeq ($(CXX_TYPE), clang)
-  CLANG_GE_5 := $(shell [ $(CXX_MAJOR) -gt 5 -o \( $(CXX_MAJOR) -eq 5 -a $(CXX_MINOR) -ge 0 \) ] && echo true)
-  ifeq ($(CLANG_GE_5),true)
-    STAN_HAS_CXX17 := true
-  endif
-else ifeq ($(CXX_TYPE), mingw32-gcc)
-  MINGW_GE_50 := $(shell [ $(CXX_MAJOR) -gt 5 -o \( $(CXX_MAJOR) -eq 5 -a $(CXX_MINOR) -ge 0 \) ] && echo true)
-  ifeq ($(MINGW_GE_50),true)
-    STAN_HAS_CXX17 := true
-  endif
-endif
-
-ifeq ($(STAN_HAS_CXX17), true)
-  CXXFLAGS_LANG ?= -std=c++17
-  CXXFLAGS_STANDARD ?= c++17
-else
-  $(warning "Stan cannot detect if your compiler has the C++17 standard. If it does, please set STAN_HAS_CXX17=true in your make/local file. C++17 support is mandatory in the next release of Stan. Defaulting to C++14")
-  CXXFLAGS_LANG ?= -std=c++1y
-  CXXFLAGS_STANDARD ?= c++1y
-endif
+CXXFLAGS_LANG ?= -std=c++17
+CXXFLAGS_STANDARD ?= c++17
 #CXXFLAGS_BOOST ?=
 CXXFLAGS_SUNDIALS ?= -pipe $(CXXFLAGS_OPTIM_SUNDIALS) $(CPPFLAGS_FLTO_SUNDIALS)
 #CXXFLAGS_GTEST

stan/math/prim/fun/grad_reg_inc_gamma.hpp

@@ -49,9 +49,9 @@ namespace math {
  (a-1)_k\right) \frac{1}{z^k} \end{array} \f]
  */
 template <typename T1, typename T2>
-return_type_t<T1, T2> grad_reg_inc_gamma(T1 a, T2 z, T1 g, T1 dig,
-                                         double precision = 1e-6,
-                                         int max_steps = 1e5) {
+inline return_type_t<T1, T2> grad_reg_inc_gamma(T1 a, T2 z, T1 g, T1 dig,
+                                                double precision = 1e-6,
+                                                int max_steps = 1e5) {
   using std::exp;
   using std::fabs;
   using std::log;

stan/math/prim/meta/is_autodiff.hpp

@@ -19,6 +19,14 @@ struct is_autodiff
     : bool_constant<math::disjunction<is_var<std::decay_t<T>>,
                                       is_fvar<std::decay_t<T>>>::value> {};
 
+template <typename... Types>
+inline constexpr bool is_autodiff_v
+    = math::conjunction<is_autodiff<Types>...>::value;
+
+template <typename... Types>
+inline constexpr bool is_autodiffable_v
+    = math::conjunction<is_autodiff<scalar_type_t<Types>>...>::value;
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup autodiff_types autodiff  */
 /*! \addtogroup autodiff_types */

stan/math/prim/meta/is_constant.hpp

@@ -62,5 +62,12 @@ template <typename T>
 struct is_constant<T, require_eigen_t<T>>
     : bool_constant<is_constant<typename std::decay_t<T>::Scalar>::value> {};
 
+template <typename... Types>
+inline constexpr bool is_constant_all_v = is_constant_all<Types...>::value;
+
+template <typename... Types>
+inline constexpr bool is_constant_v
+    = std::conjunction<is_constant<Types>...>::value;
+
 }  // namespace stan
 #endif

stan/math/prim/meta/is_matrix.hpp

@@ -17,6 +17,10 @@ template <typename T>
 struct is_matrix
     : bool_constant<math::disjunction<is_rev_matrix<T>, is_eigen<T>>::value> {};
 
+template <typename... Types>
+inline constexpr bool is_matrix_v
+    = stan::math::conjunction<is_matrix<Types>...>::value;
+
 /*! \ingroup require_eigens_types */
 /*! \defgroup matrix_types matrix  */
 /*! \addtogroup matrix_types */

stan/math/prim/meta/is_stan_scalar.hpp

@@ -28,6 +28,10 @@ struct is_stan_scalar
           is_fvar<std::decay_t<T>>, std::is_arithmetic<std::decay_t<T>>,
           is_complex<std::decay_t<T>>>::value> {};
 
+template <typename... Types>
+inline constexpr bool is_stan_scalar_v
+    = std::conjunction<is_stan_scalar<Types>...>::value;
+
 /*! \ingroup require_stan_scalar_real */
 /*! \defgroup stan_scalar_types stan_scalar  */
 /*! \addtogroup stan_scalar_types */

stan/math/rev/fun/append_col.hpp

@@ -35,24 +35,24 @@ template <typename T1, typename T2, require_any_var_matrix_t<T1, T2>* = nullptr>
 inline auto append_col(const T1& A, const T2& B) {
   check_size_match("append_col", "columns of A", A.rows(), "columns of B",
                    B.rows());
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+  if constexpr (is_autodiffable_v<T1, T2>) {
+    arena_t<T1> arena_A = A;
+    arena_t<T2> arena_B = B;
     return make_callback_var(
         append_col(value_of(arena_A), value_of(arena_B)),
         [arena_A, arena_B](auto& vi) mutable {
           arena_A.adj() += vi.adj().leftCols(arena_A.cols());
           arena_B.adj() += vi.adj().rightCols(arena_B.cols());
         });
-  } else if (!is_constant<T1>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
+  } else if constexpr (is_autodiffable_v<T1>) {
+    arena_t<T1> arena_A = A;
     return make_callback_var(append_col(value_of(arena_A), value_of(B)),
                              [arena_A](auto& vi) mutable {
                                arena_A.adj()
                                    += vi.adj().leftCols(arena_A.cols());
                              });
   } else {
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+    arena_t<T2> arena_B = B;
     return make_callback_var(append_col(value_of(A), value_of(arena_B)),
                              [arena_B](auto& vi) mutable {
                                arena_B.adj()
@@ -79,21 +79,21 @@ template <typename Scal, typename RowVec,
           require_stan_scalar_t<Scal>* = nullptr,
           require_t<is_eigen_row_vector<RowVec>>* = nullptr>
 inline auto append_col(const Scal& A, const var_value<RowVec>& B) {
-  if (!is_constant<Scal>::value && !is_constant<RowVec>::value) {
+  if constexpr (is_autodiffable_v<Scal, RowVec>) {
     var arena_A = A;
-    arena_t<promote_scalar_t<var, RowVec>> arena_B = B;
+    arena_t<RowVec> arena_B = B;
     return make_callback_var(append_col(value_of(arena_A), value_of(arena_B)),
                              [arena_A, arena_B](auto& vi) mutable {
                                arena_A.adj() += vi.adj().coeff(0);
                                arena_B.adj() += vi.adj().tail(arena_B.size());
                              });
-  } else if (!is_constant<Scal>::value) {
+  } else if constexpr (is_autodiffable_v<Scal>) {
     var arena_A = A;
     return make_callback_var(
         append_col(value_of(arena_A), value_of(B)),
         [arena_A](auto& vi) mutable { arena_A.adj() += vi.adj().coeff(0); });
   } else {
-    arena_t<promote_scalar_t<var, RowVec>> arena_B = B;
+    arena_t<RowVec> arena_B = B;
     return make_callback_var(append_col(value_of(A), value_of(arena_B)),
                              [arena_B](auto& vi) mutable {
                                arena_B.adj() += vi.adj().tail(arena_B.size());
@@ -119,17 +119,17 @@ template <typename RowVec, typename Scal,
           require_t<is_eigen_row_vector<RowVec>>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr>
 inline auto append_col(const var_value<RowVec>& A, const Scal& B) {
-  if (!is_constant<RowVec>::value && !is_constant<Scal>::value) {
-    arena_t<promote_scalar_t<var, RowVec>> arena_A = A;
+  if constexpr (is_autodiffable_v<RowVec, Scal>) {
+    arena_t<RowVec> arena_A = A;
     var arena_B = B;
     return make_callback_var(append_col(value_of(arena_A), value_of(arena_B)),
                              [arena_A, arena_B](auto& vi) mutable {
                                arena_A.adj() += vi.adj().head(arena_A.size());
                                arena_B.adj()
                                    += vi.adj().coeff(vi.adj().size() - 1);
                              });
-  } else if (!is_constant<RowVec>::value) {
-    arena_t<promote_scalar_t<var, RowVec>> arena_A = A;
+  } else if constexpr (is_autodiffable_v<RowVec>) {
+    arena_t<RowVec> arena_A = A;
     return make_callback_var(append_col(value_of(arena_A), value_of(B)),
                              [arena_A](auto& vi) mutable {
                                arena_A.adj() += vi.adj().head(arena_A.size());

stan/math/rev/fun/append_row.hpp

@@ -33,24 +33,24 @@ template <typename T1, typename T2, require_any_var_matrix_t<T1, T2>* = nullptr>
 inline auto append_row(const T1& A, const T2& B) {
   check_size_match("append_row", "columns of A", A.cols(), "columns of B",
                    B.cols());
-  if (!is_constant<T1>::value && !is_constant<T2>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+  if constexpr (is_autodiffable_v<T1, T2>) {
+    arena_t<T1> arena_A = A;
+    arena_t<T2> arena_B = B;
     return make_callback_var(
         append_row(value_of(arena_A), value_of(arena_B)),
         [arena_A, arena_B](auto& vi) mutable {
           arena_A.adj() += vi.adj().topRows(arena_A.rows());
           arena_B.adj() += vi.adj().bottomRows(arena_B.rows());
         });
-  } else if (!is_constant<T1>::value) {
-    arena_t<promote_scalar_t<var, T1>> arena_A = A;
+  } else if constexpr (is_autodiffable_v<T1>) {
+    arena_t<T1> arena_A = A;
     return make_callback_var(append_row(value_of(arena_A), value_of(B)),
                              [arena_A](auto& vi) mutable {
                                arena_A.adj()
                                    += vi.adj().topRows(arena_A.rows());
                              });
   } else {
-    arena_t<promote_scalar_t<var, T2>> arena_B = B;
+    arena_t<T2> arena_B = B;
     return make_callback_var(append_row(value_of(A), value_of(arena_B)),
                              [arena_B](auto& vi) mutable {
                                arena_B.adj()
@@ -76,21 +76,21 @@ template <typename Scal, typename ColVec,
           require_stan_scalar_t<Scal>* = nullptr,
           require_t<is_eigen_col_vector<ColVec>>* = nullptr>
 inline auto append_row(const Scal& A, const var_value<ColVec>& B) {
-  if (!is_constant<Scal>::value && !is_constant<ColVec>::value) {
+  if constexpr (is_autodiffable_v<Scal, ColVec>) {
     var arena_A = A;
-    arena_t<promote_scalar_t<var, ColVec>> arena_B = B;
+    arena_t<ColVec> arena_B = B;
     return make_callback_var(append_row(value_of(arena_A), value_of(arena_B)),
                              [arena_A, arena_B](auto& vi) mutable {
                                arena_A.adj() += vi.adj().coeff(0);
                                arena_B.adj() += vi.adj().tail(arena_B.size());
                              });
-  } else if (!is_constant<Scal>::value) {
+  } else if constexpr (is_autodiffable_v<Scal>) {
     var arena_A = A;
     return make_callback_var(
         append_row(value_of(arena_A), value_of(B)),
         [arena_A](auto& vi) mutable { arena_A.adj() += vi.adj().coeff(0); });
   } else {
-    arena_t<promote_scalar_t<var, ColVec>> arena_B = B;
+    arena_t<ColVec> arena_B = B;
     return make_callback_var(append_row(value_of(A), value_of(arena_B)),
                              [arena_B](auto& vi) mutable {
                                arena_B.adj() += vi.adj().tail(arena_B.size());
@@ -115,23 +115,23 @@ template <typename ColVec, typename Scal,
           require_t<is_eigen_col_vector<ColVec>>* = nullptr,
           require_stan_scalar_t<Scal>* = nullptr>
 inline auto append_row(const var_value<ColVec>& A, const Scal& B) {
-  if (!is_constant<ColVec>::value && !is_constant<Scal>::value) {
-    arena_t<promote_scalar_t<var, ColVec>> arena_A = A;
+  if constexpr (is_autodiffable_v<ColVec, Scal>) {
+    arena_t<ColVec> arena_A = A;
     var arena_B = B;
     return make_callback_var(append_row(value_of(arena_A), value_of(arena_B)),
                              [arena_A, arena_B](auto& vi) mutable {
                                arena_A.adj() += vi.adj().head(arena_A.size());
                                arena_B.adj()
                                    += vi.adj().coeff(vi.adj().size() - 1);
                              });
-  } else if (!is_constant<ColVec>::value) {
-    arena_t<promote_scalar_t<var, ColVec>> arena_A = A;
+  } else if constexpr (is_autodiffable_v<ColVec>) {
+    arena_t<ColVec> arena_A = A;
     return make_callback_var(append_row(value_of(arena_A), value_of(B)),
                              [arena_A](auto& vi) mutable {
                                arena_A.adj() += vi.adj().head(arena_A.size());
                              });
   } else {
-    arena_t<promote_scalar_t<var, Scal>> arena_B = B;
+    arena_t<Scal> arena_B = B;
     return make_callback_var(append_row(value_of(A), value_of(arena_B)),
                              [arena_B](auto& vi) mutable {
                                arena_B.adj()