Merge pull request #3240 from stan-dev/fix/constexpr-probs

Use `if constexpr` almost everywhere and cleanup type traits

Author: SteveBronder

make/compiler_flags

@@ -162,7 +162,7 @@ CXXFLAGS_SUNDIALS ?= -pipe $(CXXFLAGS_OPTIM_SUNDIALS) $(CPPFLAGS_FLTO_SUNDIALS)
 # Update compiler flags with operating system specific modifications
 ##
 ifeq ($(OS),Windows_NT)
-  CXXFLAGS_WARNINGS ?= -Wall -Wno-unused-function -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-variable -Wno-sign-compare -Wno-unused-local-typedefs -Wno-int-in-bool-context -Wno-attributes
+  CXXFLAGS_WARNINGS ?= -Wall -Wno-template-id-cdtor -Wno-unused-function -Wno-uninitialized -Wno-unused-but-set-variable -Wno-unused-variable -Wno-sign-compare -Wno-unused-local-typedefs -Wno-int-in-bool-context -Wno-attributes
   CPPFLAGS_GTEST ?= -DGTEST_HAS_PTHREAD=0
   CPPFLAGS_OS ?= -D_USE_MATH_DEFINES
   CPPFLAGS_OS += -D_GLIBCXX11_USE_C99_COMPLEX

stan/math/fwd/fun/hypergeometric_1F0.hpp

@@ -35,10 +35,10 @@ FvarT hypergeometric_1F0(const Ta& a, const Tz& z) {
   partials_type_t<Ta> a_val = value_of(a);
   partials_type_t<Tz> z_val = value_of(z);
   FvarT rtn = FvarT(hypergeometric_1F0(a_val, z_val), 0.0);
-  if (!is_constant_all<Ta>::value) {
+  if constexpr (is_autodiff_v<Ta>) {
     rtn.d_ += forward_as<FvarT>(a).d() * -rtn.val() * log1m(z_val);
   }
-  if (!is_constant_all<Tz>::value) {
+  if constexpr (is_autodiff_v<Tz>) {
     rtn.d_ += forward_as<FvarT>(z).d() * rtn.val() * a_val * inv(1 - z_val);
   }
   return rtn;

stan/math/fwd/fun/hypergeometric_2F1.hpp

@@ -45,16 +45,16 @@ inline return_type_t<Ta1, Ta2, Tb, Tz> hypergeometric_2F1(const Ta1& a1,
 
   typename fvar_t::Scalar grad = 0;
 
-  if (!is_constant<Ta1>::value) {
+  if constexpr (is_autodiff_v<Ta1>) {
     grad += forward_as<fvar_t>(a1).d() * std::get<0>(grad_tuple);
   }
-  if (!is_constant<Ta2>::value) {
+  if constexpr (is_autodiff_v<Ta2>) {
     grad += forward_as<fvar_t>(a2).d() * std::get<1>(grad_tuple);
   }
-  if (!is_constant<Tb>::value) {
+  if constexpr (is_autodiff_v<Tb>) {
     grad += forward_as<fvar_t>(b).d() * std::get<2>(grad_tuple);
   }
-  if (!is_constant<Tz>::value) {
+  if constexpr (is_autodiff_v<Tz>) {
     grad += forward_as<fvar_t>(z).d() * std::get<3>(grad_tuple);
   }
 

stan/math/fwd/fun/hypergeometric_pFq.hpp

@@ -25,13 +25,11 @@ namespace math {
  * @param[in] z Scalar z argument
  * @return Generalized hypergeometric function
  */
-template <typename Ta, typename Tb, typename Tz,
-          typename FvarT = return_type_t<Ta, Tb, Tz>,
-          bool grad_a = !is_constant<Ta>::value,
-          bool grad_b = !is_constant<Tb>::value,
-          bool grad_z = !is_constant<Tz>::value,
-          require_all_vector_t<Ta, Tb>* = nullptr,
-          require_fvar_t<FvarT>* = nullptr>
+template <
+    typename Ta, typename Tb, typename Tz,
+    typename FvarT = return_type_t<Ta, Tb, Tz>, bool grad_a = is_autodiff_v<Ta>,
+    bool grad_b = is_autodiff_v<Tb>, bool grad_z = is_autodiff_v<Tz>,
+    require_all_vector_t<Ta, Tb>* = nullptr, require_fvar_t<FvarT>* = nullptr>
 inline FvarT hypergeometric_pFq(Ta&& a, Tb&& b, Tz&& z) {
   auto&& a_ref = to_ref(as_column_vector_or_scalar(a));
   auto&& b_ref = to_ref(as_column_vector_or_scalar(b));

stan/math/fwd/fun/inv_inc_beta.hpp

@@ -55,7 +55,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
 
   T_return inv_d_(0);
 
-  if (is_fvar<T1>::value) {
+  if constexpr (is_fvar<T1>::value) {
     std::vector<T_return> da_a{a_val, a_val, one_m_b};
     std::vector<T_return> da_b{ap1, ap1};
     auto da1 = exp(one_m_b * log1m_w + one_m_a * log_w);
@@ -66,7 +66,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
     inv_d_ += forward_as<fvar<T_return>>(a).d_ * da1 * (da2 - da3);
   }
 
-  if (is_fvar<T2>::value) {
+  if constexpr (is_fvar<T2>::value) {
     std::vector<T_return> db_a{b_val, b_val, one_m_a};
     std::vector<T_return> db_b{bp1, bp1};
     auto db1 = (w - 1) * exp(-b_val * log1m_w + one_m_a * log_w);
@@ -79,7 +79,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
     inv_d_ += forward_as<fvar<T_return>>(b).d_ * db1 * (exp(db2) - db3);
   }
 
-  if (is_fvar<T3>::value) {
+  if constexpr (is_fvar<T3>::value) {
     inv_d_ += forward_as<fvar<T_return>>(p).d_
               * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
   }

stan/math/fwd/fun/log_mix.hpp

@@ -41,16 +41,16 @@ inline void log_mix_partial_helper(
       = 1.0 / t_plus_one_m_t_prod_exp_lam2_m_lam1;
 
   unsigned int offset = 0;
-  if (std::is_same<T_theta, partial_return_type>::value) {
+  if constexpr (std::is_same<T_theta, partial_return_type>::value) {
     partials_array[offset]
         = one_m_exp_lam2_m_lam1 * one_d_t_plus_one_m_t_prod_exp_lam2_m_lam1;
     ++offset;
   }
-  if (std::is_same<T_lambda1, partial_return_type>::value) {
+  if constexpr (std::is_same<T_lambda1, partial_return_type>::value) {
     partials_array[offset] = theta * one_d_t_plus_one_m_t_prod_exp_lam2_m_lam1;
     ++offset;
   }
-  if (std::is_same<T_lambda2, partial_return_type>::value) {
+  if constexpr (std::is_same<T_lambda2, partial_return_type>::value) {
     partials_array[offset] = one_m_t_prod_exp_lam2_m_lam1
                              * one_d_t_plus_one_m_t_prod_exp_lam2_m_lam1;
   }

stan/math/fwd/functor/integrate_1d.hpp

@@ -45,17 +45,17 @@ inline return_type_t<T_a, T_b, Args...> integrate_1d_impl(
   FvarT ret = finite_diff(func, args...);
 
   // Calculate tangents w.r.t. integration bounds if needed
-  if (is_fvar<T_a>::value || is_fvar<T_b>::value) {
+  if constexpr (is_fvar<T_a>::value || is_fvar<T_b>::value) {
     auto val_args = std::make_tuple(value_of(args)...);
-    if (is_fvar<T_a>::value) {
+    if constexpr (is_fvar<T_a>::value) {
       ret.d_ += math::forward_as<FvarT>(a).d_
                 * math::apply(
                     [&](auto &&... tuple_args) {
                       return -f(a_val, 0.0, msgs, tuple_args...);
                     },
                     val_args);
     }
-    if (is_fvar<T_b>::value) {
+    if constexpr (is_fvar<T_b>::value) {
       ret.d_ += math::forward_as<FvarT>(b).d_
                 * math::apply(
                     [&](auto &&... tuple_args) {

stan/math/mix/functor/laplace_marginal_density.hpp

@@ -1075,7 +1075,7 @@ inline auto laplace_marginal_density(const LLFun& ll_fun, LLTupleArgs&& ll_args,
     auto ll_args_filter = internal::filter_var_scalar_types(ll_args_copy);
     stan::math::for_each(
         [](auto&& output_i, auto&& ll_arg_i) {
-          if (is_any_var_scalar_v<decltype(ll_arg_i)>) {
+          if constexpr (is_any_var_scalar_v<decltype(ll_arg_i)>) {
             internal::collect_adjoints<true>(output_i, ll_arg_i);
           }
         },

stan/math/opencl/kernel_generator/broadcast.hpp

@@ -42,10 +42,10 @@ class broadcast_
    */
   explicit broadcast_(T&& a) : base(std::forward<T>(a)) {
     const char* function = "broadcast";
-    if (Colwise) {
+    if constexpr (Colwise) {
       check_size_match(function, "Rows of ", "a", a.rows(), "", "", 1);
     }
-    if (Rowwise) {
+    if constexpr (Rowwise) {
       check_size_match(function, "Columns of ", "a", a.cols(), "", "", 1);
     }
   }
@@ -67,10 +67,10 @@ class broadcast_
    */
   inline void modify_argument_indices(std::string& row_index_name,
                                       std::string& col_index_name) const {
-    if (Colwise) {
+    if constexpr (Colwise) {
       row_index_name = "0";
     }
-    if (Rowwise) {
+    if constexpr (Rowwise) {
       col_index_name = "0";
     }
   }

stan/math/opencl/kernel_generator/calc_if.hpp

@@ -44,7 +44,7 @@ class calc_if_
                                const std::string& col_index_name,
                                const bool view_handled,
                                const std::string& var_name_arg) const {
-    if (Do_Calculate) {
+    if constexpr (Do_Calculate) {
       var_name_ = var_name_arg;
     }
     return {};
@@ -70,7 +70,7 @@ class calc_if_
       std::unordered_map<const void*, const char*>& generated_all,
       name_generator& ng, const std::string& row_index_name,
       const std::string& col_index_name, const T_result& result) const {
-    if (Do_Calculate) {
+    if constexpr (Do_Calculate) {
       return this->template get_arg<0>().get_whole_kernel_parts(
           generated, generated_all, ng, row_index_name, col_index_name, result);
     } else {
@@ -92,7 +92,7 @@ class calc_if_
       std::unordered_map<const void*, const char*>& generated,
       std::unordered_map<const void*, const char*>& generated_all,
       cl::Kernel& kernel, int& arg_num) const {
-    if (Do_Calculate) {
+    if constexpr (Do_Calculate) {
       this->template get_arg<0>().set_args(generated, generated_all, kernel,
                                            arg_num);
     }