[Jenkins] auto-formatting by clang-format version 10.0.0-4ubuntu1

stan-buildbot · stan-buildbot · commit 0200562174e8 · 2025-10-01T16:17:14.000-04:00
diff --git a/stan/math/fwd/fun/inv_inc_beta.hpp b/stan/math/fwd/fun/inv_inc_beta.hpp
@@ -80,8 +80,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,
   }
 
   if constexpr (is_fvar<T3>::value) {
-    inv_d_ += p.d_
-              * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
+    inv_d_ += p.d_ * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);
   }
 
   return fvar<T_return>(w, inv_d_);
diff --git a/stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp b/stan/math/opencl/prim/bernoulli_logit_glm_lpmf.hpp
@@ -144,7 +144,8 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(
     if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = theta_derivative_cl;
     } else {
-      partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_derivative_sum_cl));
+      partials<1>(ops_partials)[0]
+          = sum(from_matrix_cl(theta_derivative_sum_cl));
     }
   }
   if constexpr (is_autodiff_v<T_beta_cl>) {
diff --git a/stan/math/opencl/prim/categorical_logit_glm_lpmf.hpp b/stan/math/opencl/prim/categorical_logit_glm_lpmf.hpp
@@ -132,8 +132,7 @@ return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
                            rowwise_broadcast(inv_sum_exp_lin_cl));
     } else {
       partials<0>(ops_partials)
-          = indexing(beta_val, col_index(x.rows(), x.cols()),
-                     y_val - 1)
+          = indexing(beta_val, col_index(x.rows(), x.cols()), y_val - 1)
             - elt_multiply(exp_lin_cl * transpose(beta_val),
                            rowwise_broadcast(inv_sum_exp_lin_cl));
     }
@@ -152,9 +151,8 @@ return_type_t<T_x, T_alpha, T_beta> categorical_logit_glm_lpmf(
       try {
         opencl_kernels::categorical_logit_glm_beta_derivative(
             cl::NDRange(local_size * N_attributes), cl::NDRange(local_size),
-            partials<2>(ops_partials),
-            temp, y_val_cl, x_val, N_instances, N_attributes, N_classes,
-            is_y_vector);
+            partials<2>(ops_partials), temp, y_val_cl, x_val, N_instances,
+            N_attributes, N_classes, is_y_vector);
       } catch (const cl::Error& e) {
         check_opencl_error(function, e);
       }
diff --git a/stan/math/opencl/prim/neg_binomial_2_log_glm_lpmf.hpp b/stan/math/opencl/prim/neg_binomial_2_log_glm_lpmf.hpp
@@ -168,10 +168,7 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
   }
 
   if constexpr (include_summand<propto, T_phi_cl>::value && !is_phi_vector) {
-    logp += N
-            * (multiply_log(phi_val,
-                            phi_val)
-               - lgamma(phi_val));
+    logp += N * (multiply_log(phi_val, phi_val) - lgamma(phi_val));
   }
   if constexpr (include_summand<propto, T_phi_cl>::value && !is_y_vector
                 && !is_phi_vector) {
@@ -203,7 +200,8 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,
     if constexpr (is_alpha_vector) {
       partials<1>(ops_partials) = std::move(theta_derivative_cl);
     } else {
-      partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_derivative_sum_cl));
+      partials<1>(ops_partials)[0]
+          = sum(from_matrix_cl(theta_derivative_sum_cl));
     }
   }
   if constexpr (is_autodiff_v<T_phi_cl>) {
diff --git a/stan/math/opencl/rev/add_diag.hpp b/stan/math/opencl/rev/add_diag.hpp
@@ -40,8 +40,7 @@ inline auto add_diag(const T_m& mat, const T_a& to_add) {
     }
     if constexpr (is_autodiff_v<T_a>) {
       if constexpr (!is_stan_scalar<T_a>::value) {
-        auto& to_add_adj
-            = to_add_arena.adj();
+        auto& to_add_adj = to_add_arena.adj();
         to_add_adj += diagonal(res.adj());
       } else {
         auto& to_add_adj = to_add_arena.adj();
diff --git a/stan/math/prim/prob/bernoulli_logit_glm_lpmf.hpp b/stan/math/prim/prob/bernoulli_logit_glm_lpmf.hpp
@@ -107,8 +107,7 @@ return_type_t<T_x, T_alpha, T_beta> bernoulli_logit_glm_lpmf(
 
   Array<T_partials_return, Dynamic, 1> ytheta(N_instances);
   if constexpr (T_x_rows == 1) {
-    T_ytheta_tmp ytheta_tmp
-        = (x_val * beta_val_vec)(0, 0);
+    T_ytheta_tmp ytheta_tmp = (x_val * beta_val_vec)(0, 0);
     ytheta = signs * (ytheta_tmp + as_array_or_scalar(alpha_val_vec));
   } else {
     ytheta = (x_val * beta_val_vec).array();
@@ -142,16 +141,14 @@ return_type_t<T_x, T_alpha, T_beta> bernoulli_logit_glm_lpmf(
                                   signs * exp_m_ytheta / (exp_m_ytheta + 1)));
     if constexpr (is_autodiff_v<T_beta>) {
       if constexpr (T_x_rows == 1) {
-        edge<2>(ops_partials).partials_
-            = theta_derivative.sum() * x_val;
+        edge<2>(ops_partials).partials_ = theta_derivative.sum() * x_val;
       } else {
         partials<2>(ops_partials) = x_val.transpose() * theta_derivative;
       }
     }
     if constexpr (is_autodiff_v<T_x>) {
       if constexpr (T_x_rows == 1) {
-        edge<0>(ops_partials).partials_
-            = beta_val_vec * theta_derivative.sum();
+        edge<0>(ops_partials).partials_ = beta_val_vec * theta_derivative.sum();
       } else {
         edge<0>(ops_partials).partials_
             = (beta_val_vec * theta_derivative.transpose()).transpose();
diff --git a/stan/math/prim/prob/bernoulli_logit_lpmf.hpp b/stan/math/prim/prob/bernoulli_logit_lpmf.hpp
@@ -65,8 +65,7 @@ return_type_t<T_prob> bernoulli_logit_lpmf(const T_n& n, const T_prob& theta) {
   if constexpr (is_vector<T_n>::value || is_vector<T_prob>::value) {
     ntheta = signs * theta_val;
   } else {
-    T_partials_return ntheta_s
-        = signs * theta_val;
+    T_partials_return ntheta_s = signs * theta_val;
     ntheta = T_partials_array::Constant(1, 1, ntheta_s);
   }
   T_partials_array exp_m_ntheta = exp(-ntheta);
diff --git a/stan/math/prim/prob/binomial_logit_glm_lpmf.hpp b/stan/math/prim/prob/binomial_logit_glm_lpmf.hpp
@@ -134,17 +134,15 @@ return_type_t<T_x, T_alpha, T_beta> binomial_logit_glm_lpmf(
 
     if constexpr (is_autodiff_v<T_beta>) {
       if constexpr (T_x_rows == 1) {
-        edge<2>(ops_partials).partials_
-            = theta_derivative.sum() * x_val;
+        edge<2>(ops_partials).partials_ = theta_derivative.sum() * x_val;
       } else {
         partials<2>(ops_partials) = x_val.transpose() * theta_derivative;
       }
     }
 
     if constexpr (is_autodiff_v<T_x>) {
       if constexpr (T_x_rows == 1) {
-        edge<0>(ops_partials).partials_
-            = beta_val * theta_derivative.sum();
+        edge<0>(ops_partials).partials_ = beta_val * theta_derivative.sum();
       } else {
         edge<0>(ops_partials).partials_
             = (beta_val * theta_derivative.transpose()).transpose();
diff --git a/stan/math/prim/prob/chi_square_lpdf.hpp b/stan/math/prim/prob/chi_square_lpdf.hpp
@@ -88,7 +88,8 @@ return_type_t<T_y, T_dof> chi_square_lpdf(const T_y& y, const T_dof& nu) {
   }
   if constexpr (is_autodiff_v<T_dof>) {
     if constexpr (is_vector<T_dof>::value) {
-      partials<1>(ops_partials) = (log_y - digamma(half_nu)) * 0.5 - HALF_LOG_TWO;
+      partials<1>(ops_partials)
+          = (log_y - digamma(half_nu)) * 0.5 - HALF_LOG_TWO;
     } else {
       partials<1>(ops_partials)[0]
           = sum(log_y - digamma(half_nu)) * 0.5 - HALF_LOG_TWO * N;
diff --git a/stan/math/prim/prob/double_exponential_cdf.hpp b/stan/math/prim/prob/double_exponential_cdf.hpp
@@ -77,23 +77,18 @@ return_type_t<T_y, T_loc, T_scale> double_exponential_cdf(
   if constexpr (is_vector<T_y>::value || is_vector<T_loc>::value) {
     using array_bool = Eigen::Array<bool, Eigen::Dynamic, 1>;
     cdf = (y_val < mu_val)
-              .select(exp_scaled_diff * 0.5,
-                      1.0 - 0.5 / exp_scaled_diff)
+              .select(exp_scaled_diff * 0.5, 1.0 - 0.5 / exp_scaled_diff)
               .prod();
-    rep_deriv =
-        (y_val < mu_val)
-            .select((cdf * inv_sigma),
-                    cdf * inv_sigma
-                                                 / (2 * exp_scaled_diff - 1));
+    rep_deriv = (y_val < mu_val)
+                    .select((cdf * inv_sigma),
+                            cdf * inv_sigma / (2 * exp_scaled_diff - 1));
   } else {
     if constexpr (is_vector<T_scale>::value) {
-      cdf = (y_val < mu_val)
-                ? (exp_scaled_diff * 0.5).prod()
-                : (1.0 - 0.5 / exp_scaled_diff).prod();
+      cdf = (y_val < mu_val) ? (exp_scaled_diff * 0.5).prod()
+                             : (1.0 - 0.5 / exp_scaled_diff).prod();
     } else {
-      cdf = (y_val < mu_val)
-                ? exp_scaled_diff * 0.5
-                : 1.0 - 0.5 / exp_scaled_diff;
+      cdf = (y_val < mu_val) ? exp_scaled_diff * 0.5
+                             : 1.0 - 0.5 / exp_scaled_diff;
     }
     if (y_val < mu_val) {
       rep_deriv = cdf * inv_sigma;
diff --git a/stan/math/prim/prob/exponential_lccdf.hpp b/stan/math/prim/prob/exponential_lccdf.hpp
@@ -45,8 +45,8 @@ return_type_t<T_y, T_inv_scale> exponential_lccdf(const T_y& y,
     using beta_val_scalar = scalar_type_t<decltype(beta_val)>;
     using beta_val_array = Eigen::Array<beta_val_scalar, Eigen::Dynamic, 1>;
     if constexpr (is_vector<T_y>::value && !is_vector<T_inv_scale>::value) {
-      partials<0>(ops_partials) = T_partials_array::Constant(
-          math::size(y), -beta_val);
+      partials<0>(ops_partials)
+          = T_partials_array::Constant(math::size(y), -beta_val);
     } else if constexpr (is_vector<T_inv_scale>::value) {
       partials<0>(ops_partials) = -beta_val;
     } else {
@@ -57,8 +57,8 @@ return_type_t<T_y, T_inv_scale> exponential_lccdf(const T_y& y,
     using y_val_scalar = scalar_type_t<decltype(y_val)>;
     using y_val_array = Eigen::Array<y_val_scalar, Eigen::Dynamic, 1>;
     if constexpr (is_vector<T_inv_scale>::value && !is_vector<T_y>::value) {
-      partials<1>(ops_partials) = T_partials_array::Constant(
-          math::size(beta), -y_val);
+      partials<1>(ops_partials)
+          = T_partials_array::Constant(math::size(beta), -y_val);
     } else if constexpr (is_vector<T_y>::value) {
       partials<1>(ops_partials) = -y_val;
     } else {
diff --git a/stan/math/prim/prob/exponential_lpdf.hpp b/stan/math/prim/prob/exponential_lpdf.hpp
@@ -85,13 +85,12 @@ return_type_t<T_y, T_inv_scale> exponential_lpdf(const T_y& y,
     using beta_val_scalar = scalar_type_t<decltype(beta_val)>;
     using beta_val_array = Eigen::Array<beta_val_scalar, Eigen::Dynamic, 1>;
     if constexpr (is_vector<T_y>::value && !is_vector<T_inv_scale>::value) {
-      partials<0>(ops_partials) = T_partials_array::Constant(
-          math::size(y), -beta_val);
+      partials<0>(ops_partials)
+          = T_partials_array::Constant(math::size(y), -beta_val);
     } else if constexpr (is_vector<T_inv_scale>::value) {
       partials<0>(ops_partials) = -beta_val;
     } else {
-      partials<0>(ops_partials)
-          = -beta_val;
+      partials<0>(ops_partials) = -beta_val;
     }
   }
   if constexpr (is_autodiff_v<T_inv_scale>) {
diff --git a/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp b/stan/math/prim/prob/neg_binomial_2_log_glm_lpmf.hpp
@@ -143,8 +143,7 @@ return_type_t<T_x, T_alpha, T_beta, T_precision> neg_binomial_2_log_glm_lpmf(
 
   Array<T_partials_return, Dynamic, 1> theta(N_instances);
   if constexpr (T_x_rows == 1) {
-    T_theta_tmp theta_tmp
-        = (x_val * beta_val_vec)(0, 0);
+    T_theta_tmp theta_tmp = (x_val * beta_val_vec)(0, 0);
     theta = theta_tmp + as_array_or_scalar(alpha_val_vec);
   } else {
     theta = (x_val * beta_val_vec).array();
@@ -176,10 +175,7 @@ return_type_t<T_x, T_alpha, T_beta, T_precision> neg_binomial_2_log_glm_lpmf(
       }
     } else {
       using T_phi_scalar = scalar_type_t<decltype(phi_val_vec)>;
-      logp += N_instances
-              * (multiply_log(phi_val,
-                              phi_val)
-                 - lgamma(phi_val));
+      logp += N_instances * (multiply_log(phi_val, phi_val) - lgamma(phi_val));
     }
   }
   logp -= sum(y_plus_phi * logsumexp_theta_logphi);
@@ -205,8 +201,7 @@ return_type_t<T_x, T_alpha, T_beta, T_precision> neg_binomial_2_log_glm_lpmf(
           = y_arr - theta_exp * y_plus_phi / (theta_exp + phi_arr);
       if constexpr (is_autodiff_v<T_beta>) {
         if constexpr (T_x_rows == 1) {
-          edge<2>(ops_partials).partials_
-              = theta_derivative.sum() * x_val;
+          edge<2>(ops_partials).partials_ = theta_derivative.sum() * x_val;
         } else {
           edge<2>(ops_partials).partials_
               = x_val.transpose() * theta_derivative;
diff --git a/stan/math/prim/prob/normal_id_glm_lpdf.hpp b/stan/math/prim/prob/normal_id_glm_lpdf.hpp
@@ -122,8 +122,7 @@ return_type_t<T_y, T_x, T_alpha, T_beta, T_scale> normal_id_glm_lpdf(
 
   Array<T_partials_return, Dynamic, 1> y_scaled(N_instances);
   if constexpr (T_x_rows == 1) {
-    T_y_scaled_tmp y_scaled_tmp
-        = (x_val * beta_val_vec).coeff(0, 0);
+    T_y_scaled_tmp y_scaled_tmp = (x_val * beta_val_vec).coeff(0, 0);
     y_scaled = (as_array_or_scalar(y_val_vec) - y_scaled_tmp
                 - as_array_or_scalar(alpha_val_vec))
                * inv_sigma;
@@ -148,17 +147,15 @@ return_type_t<T_y, T_x, T_alpha, T_beta, T_scale> normal_id_glm_lpdf(
     }
     if constexpr (is_autodiff_v<T_x>) {
       if constexpr (T_x_rows == 1) {
-        edge<1>(ops_partials).partials_
-            = beta_val_vec * sum(mu_derivative);
+        edge<1>(ops_partials).partials_ = beta_val_vec * sum(mu_derivative);
       } else {
         edge<1>(ops_partials).partials_
             = (beta_val_vec * mu_derivative.transpose()).transpose();
       }
     }
     if constexpr (is_autodiff_v<T_beta>) {
       if constexpr (T_x_rows == 1) {
-        edge<3>(ops_partials).partials_
-            = mu_derivative.sum() * x_val;
+        edge<3>(ops_partials).partials_ = mu_derivative.sum() * x_val;
       } else {
         partials<3>(ops_partials) = mu_derivative.transpose() * x_val;
       }
diff --git a/stan/math/prim/prob/normal_sufficient_lpdf.hpp b/stan/math/prim/prob/normal_sufficient_lpdf.hpp
@@ -132,14 +132,14 @@ return_type_t<T_y, T_s, T_loc, T_scale> normal_sufficient_lpdf(
     using T_sigma_value_vector
         = Eigen::Array<T_sigma_value_scalar, Eigen::Dynamic, 1>;
     if constexpr (is_vector<T_scale>::value) {
-      edge<1>(ops_partials).partials_
-          = -0.5 / sigma_squared;
+      edge<1>(ops_partials).partials_ = -0.5 / sigma_squared;
     } else {
       if constexpr (is_vector<T_s>::value) {
-        partials<1>(ops_partials) = T_sigma_value_vector::Constant(
-            N, -0.5 / sigma_squared);
+        partials<1>(ops_partials)
+            = T_sigma_value_vector::Constant(N, -0.5 / sigma_squared);
       } else {
-        partials<1>(ops_partials) = -0.5 / sigma_squared * N / math::size(sigma);
+        partials<1>(ops_partials)
+            = -0.5 / sigma_squared * N / math::size(sigma);
       }
     }
   }
diff --git a/stan/math/prim/prob/pareto_lccdf.hpp b/stan/math/prim/prob/pareto_lccdf.hpp
@@ -83,11 +83,9 @@ return_type_t<T_y, T_scale, T_shape> pareto_lccdf(const T_y& y,
       using Log_quot_scalar = partials_return_t<T_y, T_scale>;
       using Log_quot_array = Eigen::Array<Log_quot_scalar, Eigen::Dynamic, 1>;
       if constexpr (is_vector<T_y>::value || is_vector<T_scale>::value) {
-        edge<2>(ops_partials).partials_
-            = std::move(log_quot);
+        edge<2>(ops_partials).partials_ = std::move(log_quot);
       } else {
-        partials<2>(ops_partials) = Log_quot_array::Constant(
-            N, 1, log_quot);
+        partials<2>(ops_partials) = Log_quot_array::Constant(N, 1, log_quot);
       }
     } else {
       partials<2>(ops_partials) = log_quot * N / max_size(y, y_min);
diff --git a/stan/math/prim/prob/pareto_type_2_lccdf.hpp b/stan/math/prim/prob/pareto_type_2_lccdf.hpp
@@ -85,12 +85,10 @@ return_type_t<T_y, T_loc, T_scale, T_shape> pareto_type_2_lccdf(
                     || is_vector<T_scale>::value) {
         partials<3>(ops_partials) = -log_temp;
       } else {
-        partials<3>(ops_partials) = Log_temp_array::Constant(
-            N, 1, -log_temp);
+        partials<3>(ops_partials) = Log_temp_array::Constant(N, 1, -log_temp);
       }
     } else {
-      partials<3>(ops_partials)
-          = -log_temp * N / max_size(y, mu, lambda);
+      partials<3>(ops_partials) = -log_temp * N / max_size(y, mu, lambda);
     }
   }
 
diff --git a/stan/math/prim/prob/poisson_log_glm_lpmf.hpp b/stan/math/prim/prob/poisson_log_glm_lpmf.hpp
@@ -106,8 +106,7 @@ return_type_t<T_x, T_alpha, T_beta> poisson_log_glm_lpmf(const T_y& y,
 
   Array<T_partials_return, Dynamic, 1> theta(N_instances);
   if constexpr (T_x_rows == 1) {
-    T_theta_tmp theta_tmp
-        = (x_val * beta_val_vec).coeff(0, 0);
+    T_theta_tmp theta_tmp = (x_val * beta_val_vec).coeff(0, 0);
     theta = theta_tmp + as_array_or_scalar(alpha_val_vec);
   } else {
     theta = x_val * beta_val_vec;
diff --git a/stan/math/rev/constraint/lub_constrain.hpp b/stan/math/rev/constraint/lub_constrain.hpp
diff --git a/stan/math/rev/fun/fma.hpp b/stan/math/rev/fun/fma.hpp
diff --git a/stan/math/rev/fun/hypergeometric_2F1.hpp b/stan/math/rev/fun/hypergeometric_2F1.hpp
diff --git a/stan/math/rev/fun/inv_inc_beta.hpp b/stan/math/rev/fun/inv_inc_beta.hpp
diff --git a/stan/math/rev/fun/pow.hpp b/stan/math/rev/fun/pow.hpp
diff --git a/test/unit/math/test_ad_matvar.hpp b/test/unit/math/test_ad_matvar.hpp
diff --git a/test/unit/math/test_ad_matvar_test.cpp b/test/unit/math/test_ad_matvar_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -80,8 +80,7 @@ inline fvar<partials_return_t<T1, T2, T3>> inv_inc_beta(const T1& a,`
`80`	`80`	`}`
`81`	`81`
`82`	`82`	`if constexpr (is_fvar<T3>::value) {`
`83`		`- inv_d_ += p.d_`
`84`		`- * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);`
	`83`	`+ inv_d_ += p.d_ * exp(one_m_b * log1m_w + one_m_a * log_w + lbeta_ab);`
`85`	`84`	`}`
`86`	`85`
`87`	`86`	`return fvar<T_return>(w, inv_d_);`
Original file line number	Diff line number	Diff line change
`@@ -144,7 +144,8 @@ return_type_t<T_x_cl, T_alpha_cl, T_beta_cl> bernoulli_logit_glm_lpmf(`
`144`	`144`	`if constexpr (is_alpha_vector) {`
`145`	`145`	`partials<1>(ops_partials) = theta_derivative_cl;`
`146`	`146`	`} else {`
`147`		`- partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_derivative_sum_cl));`
	`147`	`+ partials<1>(ops_partials)[0]`
	`148`	`+ = sum(from_matrix_cl(theta_derivative_sum_cl));`
`148`	`149`	`}`
`149`	`150`	`}`
`150`	`151`	`if constexpr (is_autodiff_v<T_beta_cl>) {`
Original file line number	Diff line number	Diff line change
`@@ -168,10 +168,7 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,`
`168`	`168`	`}`
`169`	`169`
`170`	`170`	`if constexpr (include_summand<propto, T_phi_cl>::value && !is_phi_vector) {`
`171`		`- logp += N`
`172`		`- * (multiply_log(phi_val,`
`173`		`- phi_val)`
`174`		`- - lgamma(phi_val));`
	`171`	`+ logp += N * (multiply_log(phi_val, phi_val) - lgamma(phi_val));`
`175`	`172`	`}`
`176`	`173`	`if constexpr (include_summand<propto, T_phi_cl>::value && !is_y_vector`
`177`	`174`	`&& !is_phi_vector) {`
`@@ -203,7 +200,8 @@ neg_binomial_2_log_glm_lpmf(const T_y_cl& y, const T_x_cl& x,`
`203`	`200`	`if constexpr (is_alpha_vector) {`
`204`	`201`	`partials<1>(ops_partials) = std::move(theta_derivative_cl);`
`205`	`202`	`} else {`
`206`		`- partials<1>(ops_partials)[0] = sum(from_matrix_cl(theta_derivative_sum_cl));`
	`203`	`+ partials<1>(ops_partials)[0]`
	`204`	`+ = sum(from_matrix_cl(theta_derivative_sum_cl));`
`207`	`205`	`}`
`208`	`206`	`}`
`209`	`207`	`if constexpr (is_autodiff_v<T_phi_cl>) {`