Add missing pow(Kokkos::complex) overloads

[dalg24]

Fix #3867

See https://eel.is/c++draft/complex.numbers#cmplx.over-3

I also added the Kokkos::polar free function which is provided in <complex>
https://eel.is/c++draft/complex.numbers#complex.value.ops

[dalg24]

I omitted

diff --git a/core/src/Kokkos_Complex.hpp b/core/src/Kokkos_Complex.hpp
index 623700c2..9f14d762 100644
--- a/core/src/Kokkos_Complex.hpp
+++ b/core/src/Kokkos_Complex.hpp
@@ -773,6 +773,19 @@ struct promote_2 {
 };
 template <class T, class U>
 using promote_2_t = typename promote_2<T, U>::type;
+// complex specializations
+template <class T, class U>
+struct promote_2<Kokkos::complex<T>, U> {
+  using type = Kokkos::complex<promote_2_t<T, U>>;
+};
+template <class T, class U>
+struct promote_2<T, Kokkos::complex<U>> {
+  using type = Kokkos::complex<promote_2_t<T, U>>;
+};
+template <class T, class U>
+struct promote_2<Kokkos::complex<T>, Kokkos::complex<U>> {
+  using type = Kokkos::complex<promote_2_t<T, U>>;
+};
 }  // namespace Impl

 template <class T, class U>

on purpose because I thought it was not needed.
I expected the line above would call

kokkos/core/src/Kokkos_Complex.hpp

Lines 740 to 746 in 4258629

	template <class T>
	KOKKOS_INLINE_FUNCTION complex<T> pow(const complex<T>& x,
	const complex<T>& y) {
	using Kokkos::Experimental::log;
	return x == T() ? T() : exp(y * log(x));
	}

instead of

kokkos/core/src/Kokkos_Complex.hpp

Lines 785 to 790 in 4258629

	template <class T, class U>
	KOKKOS_INLINE_FUNCTION complex<Impl::promote_2_t<T, U>> pow(const complex<T>& x,
	const U& y) {
	using type = Impl::promote_2_t<T, U>;
	return pow(complex<type>(x), type(y));
	}

like the error message suggests...

[nliber]

This surprised me too.

[dalg24]

@nliber I think I understand now.

From Daveed'd book (2nd edition):

# 15.7.1 Immediate Context
SFINAE protects against attempts to form invalid types or expressions, including errors due to
ambiguities or access control violation that occurs within the *immediate context* of the function 
template substitution. [...] Specifically, during function template substitution for the purpose
of deduction, anything that happens during the instantiation of
* the definition of a class template (i.e., its body and list of base classes),
* [...]
is not part of the immediate context of that function template substitution. [...]
So if substituting the template parameters of a function template declaration requires the
instantiation of the body of a class template because a member of that class is being referred to,
an error during that instantiation is not in the immediate context of the function template
substitution and is therefore a real error (even if another function template matches without
an error).

[masterleinad]

Looks OK to me.

[vqd8a]

Thanks @dalg24

[nliber]

This surprised me too.

[dalg24]

diff --git a/core/src/Kokkos_Complex.hpp b/core/src/Kokkos_Complex.hpp
index a3f5c3a0..51eae71f 100644
--- a/core/src/Kokkos_Complex.hpp
+++ b/core/src/Kokkos_Complex.hpp
@@ -49,6 +49,7 @@
 #include <Kokkos_NumericTraits.hpp>
 #include <impl/Kokkos_Error.hpp>
 #include <complex>
+#include <type_traits>
 #include <iosfwd>

 #ifdef KOKKOS_ENABLE_SYCL
@@ -727,9 +728,6 @@ KOKKOS_INLINE_FUNCTION complex<T> pow(const complex<T>& x, const T& y) {

 template <class T>
 KOKKOS_INLINE_FUNCTION complex<T> pow(const T& x, const complex<T>& y) {
-  using Kokkos::Experimental::log;
-  using Kokkos::Experimental::pow;
-
   return pow(complex<T>(x), y);
 }

@@ -769,29 +767,18 @@ struct promote_2 {
 };
 template <class T, class U>
 using promote_2_t = typename promote_2<T, U>::type;
-// complex specializations
-template <class T, class U>
-struct promote_2<Kokkos::complex<T>, U> {
-  using type = Kokkos::complex<promote_2_t<T, U>>;
-};
-template <class T, class U>
-struct promote_2<T, Kokkos::complex<U>> {
-  using type = Kokkos::complex<promote_2_t<T, U>>;
-};
-template <class T, class U>
-struct promote_2<Kokkos::complex<T>, Kokkos::complex<U>> {
-  using type = Kokkos::complex<promote_2_t<T, U>>;
-};
 }  // namespace Impl

-template <class T, class U>
+template <class T, class U,
+          class = std::enable_if_t<std::is_arithmetic<T>::value>>
 KOKKOS_INLINE_FUNCTION complex<Impl::promote_2_t<T, U>> pow(
     const T& x, const complex<U>& y) {
   using type = Impl::promote_2_t<T, U>;
   return pow(type(x), complex<type>(y));
 }

-template <class T, class U>
+template <class T, class U,
+          class = std::enable_if_t<std::is_arithmetic<U>::value>>
 KOKKOS_INLINE_FUNCTION complex<Impl::promote_2_t<T, U>> pow(const complex<T>& x,
                                                             const U& y) {
   using type = Impl::promote_2_t<T, U>;