add test

Author: fangfangssj

paddle/phi/kernels/impl/elementwise_grad_kernel_impl.h

@@ -1444,12 +1444,13 @@ struct PowGradDX<phi::dtype::complex<T>> {
       phi::dtype::complex<T> out,
       phi::dtype::complex<T> dout) const {
 #if defined(__CUDA_ARCH__) || defined(__HIPCC__)
-    return dout * y * pow(x, y - phi::dtype::complex<T>(1, 0));
+    return conj(dout * y * pow(x, y - phi::dtype::complex<T>(1, 0)));
 #else
-    return dout * y *
-           static_cast<phi::dtype::complex<T>>(std::pow(
-               static_cast<std::complex<T>>(x),
-               static_cast<std::complex<T>>(y - phi::dtype::complex<T>(1, 0))));
+    return conj(
+        dout * y *
+        static_cast<phi::dtype::complex<T>>(std::pow(
+            static_cast<std::complex<T>>(x),
+            static_cast<std::complex<T>>(y - phi::dtype::complex<T>(1, 0)))));
 #endif
   }
 };
@@ -1462,12 +1463,12 @@ struct PowGradDY<phi::dtype::complex<T>> {
       phi::dtype::complex<T> out,
       phi::dtype::complex<T> dout) const {
 #if defined(__CUDA_ARCH__) || defined(__HIPCC__)
-    return dout * log(x) * pow(x, y);
+    return conj(dout * log(x) * pow(x, y));
 #else
-    return dout * static_cast<phi::dtype::complex<T>>(
-                      std::log(static_cast<std::complex<T>>(x)) *
-                      std::pow(static_cast<std::complex<T>>(x),
-                               static_cast<std::complex<T>>(y)));
+    return conj(dout * static_cast<phi::dtype::complex<T>>(
+                           std::log(static_cast<std::complex<T>>(x)) *
+                           std::pow(static_cast<std::complex<T>>(x),
+                                    static_cast<std::complex<T>>(y))));
 #endif
   }
 };

python/paddle/tensor/math.py

@@ -531,7 +531,7 @@ def pow(x: Tensor, y: float | Tensor, name: str | None = None) -> Tensor:
 
 
     Args:
-        x (Tensor): An N-D Tensor, the data type is bfloat16, float16, float32, float64, int32 or int64.
+        x (Tensor): An N-D Tensor, the data type is bfloat16, float16, float32, float64, int32, int64, complex64 or complex128.
         y (float|int|Tensor): If it is an N-D Tensor, its data type should be the same as `x`.
         name (str|None, optional): Name for the operation (optional, default is None). For more information, please refer to :ref:`api_guide_Name`.
 
@@ -638,6 +638,7 @@ def _elementwise_op(helper):
         "elementwise_mul",
         "elementwise_div",
         "elementwise_max",
+        "elementwise_pow",
     ]
     if original_op_type in bf16_and_complex_supported_ops:
         data_type = [

test/legacy_test/test_elementwise_pow_op.py

@@ -249,6 +249,126 @@ def test_grad(self):
                 np.testing.assert_array_equal(y.gradient(), self.grad_y)
 
 
+@unittest.skipIf(
+    core.is_compiled_with_xpu(),
+    "Skip XPU for complex dtype is not fully supported",
+)
+class TestElementwisePowComplexOp(OpTest):
+    def setUp(self):
+        self.op_type = "elementwise_pow"
+        self.python_api = paddle.pow
+        self.public_python_api = paddle.pow
+        self.prim_op_type = "prim"
+
+        self.inputs = {
+            'X': np.asarray([1 + 2j, 3 + 4j, 5 + 6j]),
+            'Y': np.asarray([2.0, 3.0, 4.0]),
+        }
+        self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])}
+
+    def _get_places(self):
+        places = [base.CPUPlace()]
+        if core.is_compiled_with_cuda():
+            places.append(base.CUDAPlace(0))
+        return places
+
+    def test_check_output(self):
+        if hasattr(self, 'attrs'):
+            self.check_output(check_dygraph=False)
+        else:
+            self.check_output(check_pir=True, check_symbol_infer=False)
+
+    def test_check_grad_normal(self):
+        if hasattr(self, 'attrs'):
+            self.check_grad(['X', 'Y'], 'Out', check_dygraph=False)
+        else:
+            self.check_grad(
+                ['X', 'Y'],
+                'Out',
+                check_pir=True,
+            )
+
+
+@unittest.skipIf(
+    core.is_compiled_with_xpu(),
+    "Skip XPU for complex dtype is not fully supported",
+)
+class TestElementwisePowComplexOp1(TestElementwisePowComplexOp):
+    def setUp(self):
+        self.op_type = "elementwise_pow"
+        self.python_api = paddle.pow
+        self.public_python_api = paddle.pow
+        self.prim_op_type = "prim"
+
+        real_part = np.random.uniform(-5, 5, size=(3, 4))
+        imag_part = np.random.uniform(-5, 5, size=(3, 4))
+        self.inputs = {
+            'X': real_part + 1j * imag_part,
+            'Y': np.random.uniform(1, 5, size=(3, 4)),
+        }
+        self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])}
+
+
+@unittest.skipIf(
+    core.is_compiled_with_xpu(),
+    "Skip XPU for complex dtype is not fully supported",
+)
+class TestElementwisePowComplexOp2(TestElementwisePowComplexOp):
+    def setUp(self):
+        self.op_type = "elementwise_pow"
+        self.python_api = paddle.pow
+        self.public_python_api = paddle.pow
+        self.prim_op_type = "prim"
+
+        real_part = np.random.uniform(-5, 5, size=(20, 50))
+        imag_part = np.random.uniform(-5, 5, size=(20, 50))
+        self.inputs = {
+            'X': real_part + 1j * imag_part,
+            'Y': np.random.uniform(1, 5, size=(20, 50)),
+        }
+        self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])}
+
+
+@unittest.skipIf(
+    core.is_compiled_with_xpu(),
+    "Skip XPU for complex dtype is not fully supported",
+)
+class TestElementwisePowComplexOp3(TestElementwisePowComplexOp):
+    def setUp(self):
+        self.op_type = "elementwise_pow"
+        self.python_api = paddle.pow
+        self.public_python_api = paddle.pow
+        self.prim_op_type = "prim"
+
+        real_part = np.random.uniform(-5, 5, size=(3, 5, 3))
+        imag_part = np.random.uniform(-5, 5, size=(3, 5, 3))
+        self.inputs = {
+            'X': real_part + 1j * imag_part,
+            'Y': np.random.uniform(1, 5, size=(3, 5, 3)),
+        }
+        self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])}
+
+
+@unittest.skipIf(
+    core.is_compiled_with_xpu(),
+    "Skip XPU for complex dtype is not fully supported",
+)
+class TestElementwisePowComplexOp4(TestElementwisePowComplexOp):
+    def setUp(self):
+        self.op_type = "elementwise_pow"
+        self.python_api = paddle.pow
+        self.public_python_api = paddle.pow
+        self.prim_op_type = "prim"
+
+        real_part = np.random.uniform(-5, 5, size=(3, 5, 3))
+        imag_part = np.random.uniform(-5, 5, size=(3, 5, 3))
+        self.inputs = {
+            'X': real_part + 1j * imag_part,
+            'Y': real_part + 1j * imag_part,
+        }
+        self.outputs = {'Out': np.power(self.inputs['X'], self.inputs['Y'])}
+
+
 class TestElementwisePowOpFP16(OpTest):
     def setUp(self):
         self.op_type = "elementwise_pow"