merge to upstream

Author: SteveBronder

stan/math/fwd/fun/pow.hpp

@@ -18,24 +18,27 @@ namespace stan {
 namespace math {
 /*
  *
- * @tparam T1 Either an `fvar`, `arithmetic`, or `complex` type with an inner `fvar` or `arithmetic` type.
- * @tparam T2 Either a `fvar`, `arithmetic`, or `complex` type with an inner `fvar` or `arithmetic` type.
+ * @tparam T1 Either an `fvar`, `arithmetic`, or `complex` type with an inner
+ * `fvar` or `arithmetic` type.
+ * @tparam T2 Either a `fvar`, `arithmetic`, or `complex` type with an inner
+ * `fvar` or `arithmetic` type.
  * @param x1 Base variable.
  * @param x2 Exponent variable.
  * @return Base raised to the exponent.
  */
-template <typename T1, typename T2, 
-  require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr,
-  require_all_stan_scalar_t<T1, T2>* = nullptr>
+template <typename T1, typename T2,
+          require_any_fvar_t<base_type_t<T1>, base_type_t<T2>>* = nullptr,
+          require_all_stan_scalar_t<T1, T2>* = nullptr>
 inline auto pow(const T1& x1, const T2& x2) {
   using std::log;
   using std::pow;
   if constexpr (is_complex<T1>::value || is_complex<T2>::value) {
     return internal::complex_pow(x1, x2);
   } else if constexpr (is_fvar<T1>::value && is_fvar<T2>::value) {
     auto pow_x1_x2(stan::math::pow(x1.val_, x2.val_));
-    return T1(pow_x1_x2, (x2.d_ * stan::math::log(x1.val_) + x2.val_ * x1.d_ / x1.val_)
-                                  * pow_x1_x2);
+    return T1(pow_x1_x2,
+              (x2.d_ * stan::math::log(x1.val_) + x2.val_ * x1.d_ / x1.val_)
+                  * pow_x1_x2);
   } else if constexpr (is_fvar<T2>::value) {
     auto u = stan::math::pow(x1, x2.val_);
     return T2(u, x2.d_ * stan::math::log(x1) * u);
@@ -59,10 +62,26 @@ inline auto pow(const T1& x1, const T2& x2) {
     if (x2 == 2.0) {
       return stan::math::square(x1);
     }
-    return T1(stan::math::pow(x1.val_, x2), x1.d_ * x2 * stan::math::pow(x1.val_, x2 - 1));
+    return T1(stan::math::pow(x1.val_, x2),
+              x1.d_ * x2 * stan::math::pow(x1.val_, x2 - 1));
   }
 }
 
+<<<<<<< HEAD
+=======
+// must uniquely match all pairs of:
+//    { complex<fvar<V>>, complex<T>, fvar<V>, T }
+// with at least one fvar<V> and at least one complex, where T is arithmetic:
+// 1) complex<fvar<V>>, complex<fvar<V>>
+// 2) complex<fvar<V>>, complex<T>
+// 3) complex<fvar<V>>, fvar<V>
+// 4) complex<fvar<V>>, T
+// 5) complex<T>, complex<fvar<V>>
+// 6) complex<T>, fvar<V>
+// 7) fvar<V>, complex<fvar<V>>
+// 8) fvar<V>, complex<T>
+// 9) T, complex<fvar<V>>
+>>>>>>> origin/fix/pow-overload-resolution
 
 /**
  * Returns the elementwise raising of the first argument to the power of the

stan/math/prim/fun/pow.hpp

@@ -40,26 +40,26 @@ inline complex_return_t<U, V> complex_pow(const U& x, const V& y) {
  * @return the first argument raised to the power of the second
  * argument.
  */
-template <typename T1, typename T2,
-          require_arithmetic_t<T1>* = nullptr, require_arithmetic_t<T2>* = nullptr>
+template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
+          require_arithmetic_t<T2>* = nullptr>
 inline auto pow(const std::complex<T1>& a, const std::complex<T2>& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2,
-          require_arithmetic_t<T1>* = nullptr, require_arithmetic_t<T2>* = nullptr>
+template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
+          require_arithmetic_t<T2>* = nullptr>
 inline auto pow(const T1& a, const std::complex<T2>& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2,
-          require_arithmetic_t<T1>* = nullptr, require_arithmetic_t<T2>* = nullptr>
+template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
+          require_arithmetic_t<T2>* = nullptr>
 inline auto pow(const std::complex<T1>& a, const T2& b) {
   return std::pow(a, b);
 }
 
-template <typename T1, typename T2,
-          require_arithmetic_t<T1>* = nullptr, require_arithmetic_t<T2>* = nullptr>
+template <typename T1, typename T2, require_arithmetic_t<T1>* = nullptr,
+          require_arithmetic_t<T2>* = nullptr>
 inline auto pow(const T1& a, const T2& b) {
   return std::pow(a, b);
 }

stan/math/rev/fun/pow.hpp

@@ -61,8 +61,10 @@ namespace math {
    \end{cases}
    \f]
  *
- * @tparam Scal1 Either a `var`, `arithmetic`, or `complex` type with an inner `var` or `arithmetic` type.
- * @tparam Scal2 Either a `var`, `arithmetic`, or `complex` type with an inner `var` or `arithmetic` type.
+ * @tparam Scal1 Either a `var`, `arithmetic`, or `complex` type with an inner
+ `var` or `arithmetic` type.
+ * @tparam Scal2 Either a `var`, `arithmetic`, or `complex` type with an inner
+ `var` or `arithmetic` type.
  * @param base Base variable.
  * @param exponent Exponent variable.
  * @return Base raised to the exponent.
@@ -89,22 +91,23 @@ inline auto pow(const Scal1& base, const Scal2& exponent) {
         return inv_sqrt(base);
       }
     }
-    return make_callback_var(
-        std::pow(value_of(base), value_of(exponent)),
-        [base, exponent](auto&& vi) mutable {
-          if (value_of(base) == 0.0) {
-            return;  // partials zero, avoids 0 & log(0)
-          }
-          const double vi_mul = vi.adj() * vi.val();
+    return make_callback_var(std::pow(value_of(base), value_of(exponent)),
+                             [base, exponent](auto&& vi) mutable {
+                               if (value_of(base) == 0.0) {
+                                 return;  // partials zero, avoids 0 & log(0)
+                               }
+                               const double vi_mul = vi.adj() * vi.val();
 
-          if (!is_constant<Scal1>::value) {
-            forward_as<var>(base).adj()
-                += vi_mul * value_of(exponent) / value_of(base);
-          }
-          if (!is_constant<Scal2>::value) {
-            forward_as<var>(exponent).adj() += vi_mul * std::log(value_of(base));
-          }
-        });
+                               if (!is_constant<Scal1>::value) {
+                                 forward_as<var>(base).adj()
+                                     += vi_mul * value_of(exponent)
+                                        / value_of(base);
+                               }
+                               if (!is_constant<Scal2>::value) {
+                                 forward_as<var>(exponent).adj()
+                                     += vi_mul * std::log(value_of(base));
+                               }
+                             });
   }
 }
 
@@ -268,7 +271,6 @@ inline auto pow(Scal1 base, const Mat1& exponent) {
   return ret_type(ret);
 }
 
-
 /**
  * Returns the elementwise raising of the first argument to the power of the
  * second argument.