Merge remote-tracking branch 'origin/develop' into fix/jachymb-inv_logistic

SteveBronder · SteveBronder · commit 3703953efabb · 2025-03-06T14:29:15.000-05:00
diff --git a/stan/math/fwd/fun/pow.hpp b/stan/math/fwd/fun/pow.hpp
@@ -75,7 +75,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>
 inline auto pow(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [](const auto& c, const auto& d) { return stan::math::pow(c, d); });
+      [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/fwd/functor/finite_diff.hpp b/stan/math/fwd/functor/finite_diff.hpp
@@ -45,7 +45,7 @@ template <typename FuncTangent, typename InputArg,
           require_st_fvar<InputArg>* = nullptr>
 inline auto aggregate_tangent(const FuncTangent& tangent, const InputArg& arg) {
   return sum(apply_scalar_binary(
-      tangent, arg, [](const auto& x, const auto& y) { return x * y.d_; }));
+      [](const auto& x, const auto& y) { return x * y.d_; }, tangent, arg));
 }
 }  // namespace internal
 
diff --git a/stan/math/prim/fun/atan2.hpp b/stan/math/prim/fun/atan2.hpp
@@ -38,7 +38,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto atan2(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [](const auto& c, const auto& d) { return atan2(c, d); });
+      [](const auto& c, const auto& d) { return atan2(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/bessel_first_kind.hpp b/stan/math/prim/fun/bessel_first_kind.hpp
@@ -54,9 +54,9 @@ inline T2 bessel_first_kind(int v, const T2 z) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_not_var_matrix_t<T2>* = nullptr>
 inline auto bessel_first_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return bessel_first_kind(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return bessel_first_kind(c, d); }, a,
+      b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/bessel_second_kind.hpp b/stan/math/prim/fun/bessel_second_kind.hpp
@@ -54,9 +54,9 @@ inline T2 bessel_second_kind(int v, const T2 z) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto bessel_second_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return bessel_second_kind(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return bessel_second_kind(c, d); }, a,
+      b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/beta.hpp b/stan/math/prim/fun/beta.hpp
@@ -69,7 +69,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto beta(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [](const auto& c, const auto& d) { return beta(c, d); });
+      [](const auto& c, const auto& d) { return beta(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/binary_log_loss.hpp b/stan/math/prim/fun/binary_log_loss.hpp
@@ -45,9 +45,8 @@ inline T binary_log_loss(int y, const T& y_hat) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_not_var_matrix_t<T2>* = nullptr>
 inline auto binary_log_loss(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return binary_log_loss(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return binary_log_loss(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/binomial_coefficient_log.hpp b/stan/math/prim/fun/binomial_coefficient_log.hpp
@@ -162,9 +162,11 @@ inline return_type_t<T_n, T_k> binomial_coefficient_log(const T_n n,
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto binomial_coefficient_log(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return binomial_coefficient_log(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) {
+        return binomial_coefficient_log(c, d);
+      },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/choose.hpp b/stan/math/prim/fun/choose.hpp
@@ -51,7 +51,7 @@ inline int choose(int n, int k) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto choose(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return choose(c, d); });
+      [](const auto& c, const auto& d) { return choose(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/falling_factorial.hpp b/stan/math/prim/fun/falling_factorial.hpp
@@ -81,9 +81,9 @@ inline return_type_t<T> falling_factorial(const T& x, int n) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto falling_factorial(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return falling_factorial(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return falling_factorial(c, d); }, a,
+      b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fdim.hpp b/stan/math/prim/fun/fdim.hpp
@@ -37,7 +37,7 @@ inline double fdim(T1 x, T2 y) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fdim(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return fdim(c, d); });
+      [](const auto& c, const auto& d) { return fdim(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmax.hpp b/stan/math/prim/fun/fmax.hpp
@@ -35,7 +35,7 @@ inline double fmax(T1 x, T2 y) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fmax(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return fmax(c, d); });
+      [](const auto& c, const auto& d) { return fmax(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmin.hpp b/stan/math/prim/fun/fmin.hpp
@@ -35,7 +35,7 @@ inline double fmin(T1 x, T2 y) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fmin(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return fmin(c, d); });
+      [](const auto& c, const auto& d) { return fmin(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/fmod.hpp b/stan/math/prim/fun/fmod.hpp
@@ -35,10 +35,12 @@ inline double fmod(const T1& a, const T2& b) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto fmod(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    using std::fmod;
-    return fmod(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) {
+        using std::fmod;
+        return fmod(c, d);
+      },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/gamma_p.hpp b/stan/math/prim/fun/gamma_p.hpp
@@ -89,7 +89,7 @@ inline double gamma_p(double z, double a) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto gamma_p(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return gamma_p(c, d); });
+      [](const auto& c, const auto& d) { return gamma_p(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/gamma_q.hpp b/stan/math/prim/fun/gamma_q.hpp
@@ -67,7 +67,7 @@ inline double gamma_q(double x, double a) { return boost::math::gamma_q(x, a); }
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto gamma_q(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return gamma_q(c, d); });
+      [](const auto& c, const auto& d) { return gamma_q(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/hypot.hpp b/stan/math/prim/fun/hypot.hpp
@@ -41,7 +41,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
               T1, T2>* = nullptr>
 inline auto hypot(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return hypot(c, d); });
+      [](const auto& c, const auto& d) { return hypot(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lbeta.hpp b/stan/math/prim/fun/lbeta.hpp
@@ -129,7 +129,7 @@ return_type_t<T1, T2> lbeta(const T1 a, const T2 b) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto lbeta(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return lbeta(c, d); });
+      [](const auto& c, const auto& d) { return lbeta(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/ldexp.hpp b/stan/math/prim/fun/ldexp.hpp
@@ -38,7 +38,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
               T1, T2>* = nullptr>
 inline auto ldexp(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return ldexp(c, d); });
+      [](const auto& c, const auto& d) { return ldexp(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lmgamma.hpp b/stan/math/prim/fun/lmgamma.hpp
@@ -72,7 +72,7 @@ inline return_type_t<T> lmgamma(int k, T x) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto lmgamma(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return lmgamma(c, d); });
+      [](const auto& c, const auto& d) { return lmgamma(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/lmultiply.hpp b/stan/math/prim/fun/lmultiply.hpp
@@ -45,7 +45,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto lmultiply(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return lmultiply(c, d); });
+      [](const auto& c, const auto& d) { return lmultiply(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_diff_exp.hpp b/stan/math/prim/fun/log_diff_exp.hpp
@@ -68,7 +68,7 @@ inline return_type_t<T1, T2> log_diff_exp(const T1 x, const T2 y) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_diff_exp(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return log_diff_exp(c, d); });
+      [](const auto& c, const auto& d) { return log_diff_exp(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_falling_factorial.hpp b/stan/math/prim/fun/log_falling_factorial.hpp
@@ -73,9 +73,9 @@ inline return_type_t<T1, T2> log_falling_factorial(const T1 x, const T2 n) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_falling_factorial(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return log_falling_factorial(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return log_falling_factorial(c, d); },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_inv_logit_diff.hpp b/stan/math/prim/fun/log_inv_logit_diff.hpp
@@ -53,9 +53,9 @@ inline return_type_t<T1, T2> log_inv_logit_diff(const T1& x, const T2& y) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_inv_logit_diff(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return log_inv_logit_diff(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return log_inv_logit_diff(c, d); }, a,
+      b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_modified_bessel_first_kind.hpp b/stan/math/prim/fun/log_modified_bessel_first_kind.hpp
@@ -233,9 +233,11 @@ inline return_type_t<T1, T2, double> log_modified_bessel_first_kind(
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_modified_bessel_first_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return log_modified_bessel_first_kind(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) {
+        return log_modified_bessel_first_kind(c, d);
+      },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_rising_factorial.hpp b/stan/math/prim/fun/log_rising_factorial.hpp
@@ -71,9 +71,9 @@ inline return_type_t<T1, T2> log_rising_factorial(const T1& x, const T2& n) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_rising_factorial(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return log_rising_factorial(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return log_rising_factorial(c, d); },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/log_sum_exp.hpp b/stan/math/prim/fun/log_sum_exp.hpp
@@ -106,7 +106,7 @@ inline auto log_sum_exp(const T& x) {
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto log_sum_exp(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [](const auto& c, const auto& d) { return log_sum_exp(c, d); });
+      [](const auto& c, const auto& d) { return log_sum_exp(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/modified_bessel_first_kind.hpp b/stan/math/prim/fun/modified_bessel_first_kind.hpp
@@ -64,9 +64,11 @@ inline double modified_bessel_first_kind(int v, int z) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto modified_bessel_first_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return modified_bessel_first_kind(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) {
+        return modified_bessel_first_kind(c, d);
+      },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/modified_bessel_second_kind.hpp b/stan/math/prim/fun/modified_bessel_second_kind.hpp
@@ -56,9 +56,11 @@ inline T2 modified_bessel_second_kind(int v, const T2 z) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto modified_bessel_second_kind(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return modified_bessel_second_kind(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) {
+        return modified_bessel_second_kind(c, d);
+      },
+      a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/multiply_log.hpp b/stan/math/prim/fun/multiply_log.hpp
@@ -69,7 +69,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_matrix_t<T1, T2>* = nullptr>
 inline auto multiply_log(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [&](const auto& c, const auto& d) { return multiply_log(c, d); });
+      [](const auto& c, const auto& d) { return multiply_log(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/owens_t.hpp b/stan/math/prim/fun/owens_t.hpp
@@ -71,7 +71,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_not_var_and_matrix_types<T1, T2>* = nullptr>
 inline auto owens_t(const T1& a, const T2& b) {
   return apply_scalar_binary(
-      a, b, [](const auto& c, const auto& d) { return owens_t(c, d); });
+      [](const auto& c, const auto& d) { return owens_t(c, d); }, a, b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/pow.hpp b/stan/math/prim/fun/pow.hpp
@@ -111,7 +111,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
 inline auto pow(const T1& a, const T2& b) {
   return apply_scalar_binary(
       // Qualified pow since only Arithmetic types are accepted here
-      a, b, [](const auto& c, const auto& d) { return stan::math::pow(c, d); });
+      [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);
 }
 }  // namespace math
 }  // namespace stan
diff --git a/stan/math/prim/fun/rising_factorial.hpp b/stan/math/prim/fun/rising_factorial.hpp
@@ -79,9 +79,9 @@ inline return_type_t<T> rising_factorial(const T& x, int n) {
  */
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>
 inline auto rising_factorial(const T1& a, const T2& b) {
-  return apply_scalar_binary(a, b, [&](const auto& c, const auto& d) {
-    return rising_factorial(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return rising_factorial(c, d); }, a,
+      b);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/fun/select.hpp b/stan/math/prim/fun/select.hpp
@@ -86,10 +86,10 @@ inline ReturnT select(const bool c, const T_true& y_true,
     return y_true;
   } else {
     return apply_scalar_binary(
-        y_true, y_false,
         [](const auto& y_true_inner, const auto& y_false_inner) {
           return y_false_inner;
-        });
+        },
+        y_true, y_false);
   }
 }
 
@@ -119,10 +119,10 @@ inline ReturnT select(const bool c, const T_true y_true,
                       const T_false y_false) {
   if (c) {
     return apply_scalar_binary(
-        y_true, y_false,
         [](const auto& y_true_inner, const auto& y_false_inner) {
           return y_true_inner;
-        });
+        },
+        y_true, y_false);
   } else {
     return y_false;
   }
diff --git a/stan/math/prim/fun/to_complex.hpp b/stan/math/prim/fun/to_complex.hpp
@@ -38,9 +38,9 @@ constexpr inline std::complex<stan::real_return_t<T, S>> to_complex(
 template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,
           require_all_st_stan_scalar<T1, T2>* = nullptr>
 inline auto to_complex(const T1& re, const T2& im) {
-  return apply_scalar_binary(re, im, [&](const auto& c, const auto& d) {
-    return stan::math::to_complex(c, d);
-  });
+  return apply_scalar_binary(
+      [](const auto& c, const auto& d) { return stan::math::to_complex(c, d); },
+      re, im);
 }
 
 }  // namespace math
diff --git a/stan/math/prim/functor/apply_scalar_binary.hpp b/stan/math/prim/functor/apply_scalar_binary.hpp
diff --git a/stan/math/prim/functor/apply_scalar_ternary.hpp b/stan/math/prim/functor/apply_scalar_ternary.hpp
diff --git a/stan/math/rev/fun/pow.hpp b/stan/math/rev/fun/pow.hpp
diff --git a/stan/math/rev/functor/apply_scalar_binary.hpp b/stan/math/rev/functor/apply_scalar_binary.hpp
diff --git a/test/unit/math/prim/functor/apply_scalar_binary_test.cpp b/test/unit/math/prim/functor/apply_scalar_binary_test.cpp

Original file line number	Diff line number	Diff line change
`@@ -75,7 +75,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,`
`75`	`75`	`require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr>`
`76`	`76`	`inline auto pow(const T1& a, const T2& b) {`
`77`	`77`	`return apply_scalar_binary(`
`78`		`- a, b, [](const auto& c, const auto& d) { return stan::math::pow(c, d); });`
	`78`	`+ [](const auto& c, const auto& d) { return stan::math::pow(c, d); }, a, b);`
`79`	`79`	`}`
`80`	`80`
`81`	`81`	`} // namespace math`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ template <typename FuncTangent, typename InputArg,`
`45`	`45`	`require_st_fvar<InputArg>* = nullptr>`
`46`	`46`	`inline auto aggregate_tangent(const FuncTangent& tangent, const InputArg& arg) {`
`47`	`47`	`return sum(apply_scalar_binary(`
`48`		`- tangent, arg, [](const auto& x, const auto& y) { return x * y.d_; }));`
	`48`	`+ [](const auto& x, const auto& y) { return x * y.d_; }, tangent, arg));`
`49`	`49`	`}`
`50`	`50`	`} // namespace internal`
`51`	`51`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,`
`38`	`38`	`require_all_not_var_matrix_t<T1, T2>* = nullptr>`
`39`	`39`	`inline auto atan2(const T1& a, const T2& b) {`
`40`	`40`	`return apply_scalar_binary(`
`41`		`- a, b, [](const auto& c, const auto& d) { return atan2(c, d); });`
	`41`	`+ [](const auto& c, const auto& d) { return atan2(c, d); }, a, b);`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`} // namespace math`
Original file line number	Diff line number	Diff line change
`@@ -69,7 +69,7 @@ template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr,`
`69`	`69`	`require_all_not_var_matrix_t<T1, T2>* = nullptr>`
`70`	`70`	`inline auto beta(const T1& a, const T2& b) {`
`71`	`71`	`return apply_scalar_binary(`
`72`		`- a, b, [](const auto& c, const auto& d) { return beta(c, d); });`
	`72`	`+ [](const auto& c, const auto& d) { return beta(c, d); }, a, b);`
`73`	`73`	`}`
`74`	`74`
`75`	`75`	`} // namespace math`
Original file line number	Diff line number	Diff line change
`@@ -51,7 +51,7 @@ inline int choose(int n, int k) {`
`51`	`51`	`template <typename T1, typename T2, require_any_container_t<T1, T2>* = nullptr>`
`52`	`52`	`inline auto choose(const T1& a, const T2& b) {`
`53`	`53`	`return apply_scalar_binary(`
`54`		`- a, b, [&](const auto& c, const auto& d) { return choose(c, d); });`
	`54`	`+ [](const auto& c, const auto& d) { return choose(c, d); }, a, b);`
`55`	`55`	`}`
`56`	`56`
`57`	`57`	`} // namespace math`