Add mixed-complex implementations of xsimd::pow()

Author: jatinchowdhury18

include/xsimd/arch/generic/xsimd_generic_math.hpp

@@ -2030,6 +2030,26 @@ namespace xsimd
             return select(absa == ze, cplx_batch(ze), cplx_batch(r * sincosTheta.second, r * sincosTheta.first));
         }
 
+        template <class A, class T>
+        inline batch<std::complex<T>, A> pow(const batch<std::complex<T>, A>& a, const batch<T, A>& z, requires_arch<generic>) noexcept
+        {
+            using cplx_batch = batch<std::complex<T>, A>;
+
+            auto absa = abs(a);
+            auto arga = arg(a);
+            auto r = pow(absa, z);
+
+            auto theta = z * arga;
+            auto sincosTheta = xsimd::sincos(theta);
+            return select(absa == 0, cplx_batch(0), cplx_batch(r * sincosTheta.second, r * sincosTheta.first));
+        }
+
+        template <class A, class T>
+        inline batch<std::complex<T>, A> pow(const batch<T, A>& a, const batch<std::complex<T>, A>& z, requires_arch<generic>) noexcept
+        {
+            return pow(batch<std::complex<T>, A> { a, batch<T, A> {} }, z);
+        }
+
         // reciprocal
         template <class T, class A, class = typename std::enable_if<std::is_floating_point<T>::value, void>::type>
         XSIMD_INLINE batch<T, A> reciprocal(batch<T, A> const& self,

include/xsimd/types/xsimd_api.hpp

@@ -1696,6 +1696,38 @@ namespace xsimd
         return kernel::pow<A>(x, y, A {});
     }
 
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the value of the batch \c x raised to the power
+     * \c y.
+     * @param x batch of complex floating point values.
+     * @param y batch of floating point values.
+     * @return \c x raised to the power \c y.
+     */
+    template <class T, class A>
+    XSIMD_INLINE batch<std::complex<T>, A> pow(batch<std::complex<T>, A> const& x, batch<T, A> const& y) noexcept
+    {
+        detail::static_check_supported_config<T, A>();
+        return kernel::pow<A>(x, y, A {});
+    }
+
+    /**
+     * @ingroup batch_math
+     *
+     * Computes the value of the batch \c x raised to the power
+     * \c y.
+     * @param x batch of complex floating point values.
+     * @param y batch of floating point values.
+     * @return \c x raised to the power \c y.
+     */
+    template <class T, class A>
+    XSIMD_INLINE batch<std::complex<T>, A> pow(batch<T, A> const& x, batch<std::complex<T>, A> const& y) noexcept
+    {
+        detail::static_check_supported_config<T, A>();
+        return kernel::pow<A>(x, y, A {});
+    }
+
     /**
      * @ingroup batch_math
      *

test/test_complex_power.cpp

@@ -26,6 +26,7 @@ struct complex_power_test
     using real_vector_type = std::vector<real_value_type>;
 
     size_t nb_input;
+    real_vector_type lhs_p;
     vector_type lhs_nn;
     vector_type lhs_pn;
     vector_type lhs_np;
@@ -37,6 +38,7 @@ struct complex_power_test
     complex_power_test()
     {
         nb_input = 10000 * size;
+        lhs_p.resize(nb_input);
         lhs_nn.resize(nb_input);
         lhs_pn.resize(nb_input);
         lhs_np.resize(nb_input);
@@ -46,6 +48,7 @@ struct complex_power_test
         {
             real_value_type real = (real_value_type(i) / 4 + real_value_type(1.2) * std::sqrt(real_value_type(i + 0.25))) / 100;
             real_value_type imag = (real_value_type(i) / 7 + real_value_type(1.7) * std::sqrt(real_value_type(i + 0.37))) / 100;
+            lhs_p[i] = real;
             lhs_nn[i] = value_type(-real, -imag);
             lhs_pn[i] = value_type(real, -imag);
             lhs_np[i] = value_type(-real, imag);
@@ -110,6 +113,42 @@ struct complex_power_test
         CHECK_EQ(diff, 0);
     }
 
+    void test_pow_real_complex()
+    {
+        std::transform(lhs_p.cbegin(), lhs_p.cend(), lhs_pp.cbegin(), expected.begin(),
+                       [](const real_value_type& l, const value_type& r)
+                       { using std::pow; return pow(l, r); });
+        batch_type rhs_in, out;
+        real_batch_type lhs_in;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_p, i);
+            detail::load_batch(rhs_in, lhs_pp, i);
+            out = pow(lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff_near(res, expected, std::numeric_limits<real_value_type>::epsilon());
+        CHECK_EQ(diff, 0);
+    }
+
+    void test_pow_complex_real()
+    {
+        std::transform(lhs_pp.cbegin(), lhs_pp.cend(), lhs_p.cbegin(), expected.begin(),
+                       [](const value_type& l, const real_value_type& r)
+                       { using std::pow; return pow(l, r); });
+        batch_type rhs_in, out;
+        real_batch_type lhs_in;
+        for (size_t i = 0; i < nb_input; i += size)
+        {
+            detail::load_batch(lhs_in, lhs_p, i);
+            detail::load_batch(rhs_in, lhs_pp, i);
+            out = pow(lhs_in, rhs_in);
+            detail::store_batch(out, res, i);
+        }
+        size_t diff = detail::get_nb_diff_near(res, expected, std::numeric_limits<real_value_type>::epsilon());
+        CHECK_EQ(diff, 0);
+    }
+
     void test_sqrt_nn()
     {
         std::transform(lhs_nn.cbegin(), lhs_nn.cend(), expected.begin(),
@@ -193,6 +232,16 @@ TEST_CASE_TEMPLATE("[complex power]", B, BATCH_COMPLEX_TYPES)
         Test.test_pow();
     }
 
+    SUBCASE("pow real complex")
+    {
+        Test.test_pow_real_complex();
+    }
+
+    SUBCASE("pow complex real")
+    {
+        Test.test_pow_complex_real();
+    }
+
     SUBCASE("sqrt_nn")
     {
         Test.test_sqrt_nn();