get more non-grepl if constexpr sites

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/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/rowwise_reduction.hpp

@@ -407,8 +407,8 @@ struct max_op {
     return "max(" + a + ", " + b + ")";
   }
 
-  inline static std::string init() {
-    if (std::is_floating_point<T>()) {
+  inline static constexpr std::string init() {
+    if constexpr (std::is_floating_point<T>()) {
       return "-INFINITY";
     }
     return "INT_MIN";

stan/math/opencl/mrrr.hpp

@@ -310,7 +310,7 @@ inline void mrrr_cl(const Eigen::Ref<const Eigen::VectorXd> diagonal,
   const Eigen::VectorXd subdiagonal_squared
       = subdiagonal.array() * subdiagonal.array();
   get_gresgorin(diagonal, subdiagonal, min_eigval, max_eigval);
-  if (!need_eigenvectors) {
+  if constexpr (!need_eigenvectors) {
     matrix_cl<double> diagonal_cl(diagonal);
     matrix_cl<double> subdiagonal_squared_cl(subdiagonal_squared);
     matrix_cl<double> eigenvalues_cl(n, 1);
@@ -458,7 +458,7 @@ inline void tridiagonal_eigensolver_cl(const matrix_cl<double>& diagonal_cl,
   using std::sqrt;
   const int n = diagonal_cl.rows();
   Eigen::MatrixXd eigenvectors;
-  if (need_eigenvectors) {
+  if constexpr (need_eigenvectors) {
     eigenvectors.resize(n, n);
   }
   Eigen::VectorXd eigenvalues(n);
@@ -502,7 +502,7 @@ inline void tridiagonal_eigensolver_cl(const matrix_cl<double>& diagonal_cl,
     }
     eigenvalues[last] = diagonal[last];
   } else {
-    if (need_eigenvectors) {
+    if constexpr (need_eigenvectors) {
       mrrr_cl<need_eigenvectors>(
           diagonal.segment(last, n - last),
           subdiagonal.segment(last, subdiagonal.size() - last),
@@ -516,7 +516,7 @@ inline void tridiagonal_eigensolver_cl(const matrix_cl<double>& diagonal_cl,
     }
   }
   eigenvalues_cl = to_matrix_cl(std::move(eigenvalues));
-  if (need_eigenvectors) {
+  if constexpr (need_eigenvectors) {
     eigenvectors_cl = to_matrix_cl(std::move(eigenvectors));
   }
 }

stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp

@@ -65,13 +65,13 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
   const size_t N = x.rows();
   const size_t M = x.cols();
 
-  if (is_y_vector) {
+  if constexpr (is_y_vector) {
     check_size_match(function, "Rows of ", "x", N, "rows of ", "y",
                      math::size(y));
   }
   check_size_match(function, "Columns of ", "x_cl", M, "size of ", "beta",
                    math::size(beta));
-  if (is_alpha_vector) {
+  if constexpr (is_alpha_vector) {
     check_size_match(function, "Rows of ", "x", N, "size of ", "alpha",
                      math::size(alpha));
   }
@@ -141,7 +141,7 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
         = transpose(beta_val * transpose(theta_derivative_cl));
   }
   if constexpr (is_autodiff_v<T_alpha_cl>) {
-    if (is_alpha_vector) {
+    if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = theta_derivative_cl;
     } else {
       forward_as<internal::broadcast_array<double>>(

stan/math/opencl/prim/bernoulli_lpmf.hpp

@@ -55,7 +55,7 @@ return_type_t<T_prob_cl> bernoulli_lpmf(const T_n_cl& n,
   auto check_n_bounded = check_cl(function, "n", n, "in the interval [0, 1]");
   auto n_bounded_expr = 0 <= n && n <= 1;
 
-  if (is_theta_vector) {
+  if constexpr (is_theta_vector) {
     auto logp_expr
         = colwise_sum(select(n == 1, log(theta_val), log1p(-theta_val)));
     auto deriv_expr = inv(theta_val + select(n == 1, 0, -1));

stan/math/opencl/prim/binomial_logit_glm_lpmf.hpp

@@ -108,7 +108,7 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> binomial_logit_glm_lpmf(
     partials<0>(ops_partials) = transpose(beta_val * transpose(theta_deriv_cl));
   }
   if constexpr (is_autodiff_v<T_alpha_cl>) {
-    if (is_alpha_vector) {
+    if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = theta_deriv_cl;
     } else {
       forward_as<internal::broadcast_array<double>>(

stan/math/opencl/prim/categorical_logit_glm_lpmf.hpp

@@ -59,7 +59,7 @@ return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
   const size_t N_classes = beta.cols();
 
   static constexpr const char* function = "categorical_logit_glm_lpmf";
-  if (is_y_vector) {
+  if constexpr (is_y_vector) {
     check_size_match(function, "Rows of ", "x", N_instances, "size of ", "y",
                      math::size(y));
   }
@@ -124,7 +124,7 @@ return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
 
   auto ops_partials = make_partials_propagator(x, alpha, beta);
   if constexpr (is_autodiff_v<T_x>) {
-    if (is_y_vector) {
+    if constexpr (is_y_vector) {
       partials<0>(ops_partials)
           = indexing(beta_val, col_index(x.rows(), x.cols()),
                      rowwise_broadcast(forward_as<matrix_cl<int>>(y_val) - 1))

stan/math/opencl/prim/neg_binomial_2_log_glm_lpmf.hpp

@@ -81,24 +81,24 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
   const size_t N = x.rows();
   const size_t M = x.cols();
 
-  if (is_y_vector) {
+  if constexpr (is_y_vector) {
     check_size_match(function, "Rows of ", "x", N, "rows of ", "y",
                      math::size(y));
   }
   check_size_match(function, "Columns of ", "x", M, "size of ", "beta",
                    math::size(beta));
-  if (is_phi_vector) {
+  if constexpr (is_phi_vector) {
     check_size_match(function, "Rows of ", "x", N, "size of ", "phi",
                      math::size(phi));
   }
-  if (is_alpha_vector) {
+  if constexpr (is_alpha_vector) {
     check_size_match(function, "Rows of ", "x", N, "size of ", "alpha",
                      math::size(alpha));
   }
   if (N == 0) {
     return 0;
   }
-  if (!include_summand<propto, T_x_cl, T_alpha_cl, T_beta_cl,
+  if constexpr (!include_summand<propto, T_x_cl, T_alpha_cl, T_beta_cl,
                        T_phi_cl>::value) {
     return 0;
   }
@@ -200,7 +200,7 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
     }
   }
   if constexpr (is_autodiff_v<T_alpha_cl>) {
-    if (is_alpha_vector) {
+    if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = std::move(theta_derivative_cl);
     } else {
       forward_as<internal::broadcast_array<double>>(
@@ -209,7 +209,7 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
     }
   }
   if constexpr (is_autodiff_v<T_phi_cl>) {
-    if (is_phi_vector) {
+    if constexpr (is_phi_vector) {
       partials<3>(ops_partials) = std::move(phi_derivative_cl);
     } else {
       forward_as<internal::broadcast_array<double>>(

stan/math/opencl/prim/neg_binomial_2_log_lpmf.hpp

@@ -55,7 +55,7 @@ neg_binomial_2_log_lpmf(const T_n_cl& n, const T_log_location_cl& eta,
   if (N == 0) {
     return 0.0;
   }
-  if (!include_summand<propto, T_n_cl, T_log_location_cl,
+  if constexpr (!include_summand<propto, T_n_cl, T_log_location_cl,
                        T_precision_cl>::value) {
     return 0.0;
   }