[API Compatibility No.6] Sink bitwise_xor and bitwise_xor_ to cpp -part

paddle/phi/ops/yaml/python_api_info.yaml

@@ -85,6 +85,16 @@
   args_alias:
    use_default_mapping : True
 
+- op : bitwise_xor
+  name : [paddle.bitwise_xor, paddle.Tensor.bitwise_xor]
+  args_alias :
+    use_default_mapping : True
+
+- op : bitwise_xor_
+  name : [paddle.bitwise_xor_, paddle.Tensor.bitwise_xor_]
+  args_alias :
+    use_default_mapping : True
+
 - op : argmax
   name : [paddle.argmax, paddle.Tensor.argmax]
   args_mapper :

python/paddle/_paddle_docs.py

@@ -3155,3 +3155,76 @@ def asin(
 ) -> Tensor
 """,
 )
+
+add_doc_and_signature(
+    "bitwise_xor",
+    r"""
+
+    Apply ``bitwise_xor`` on Tensor ``X`` and ``Y`` .
+
+    .. math::
+        Out = X ^\wedge Y
+
+    Note:
+        ``paddle.bitwise_xor`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .
+
+        .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor
+
+    Args:
+        x (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
+            Parameter alias: ``input``.
+        y (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
+            Parameter alias: ``other``.
+        name (str|None, optional): The default value is None.  Normally there is no need for
+            user to set this property.  For more information, please refer to :ref:`api_guide_Name`.
+
+    Returns:
+        Tensor: Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor.
+
+    Examples:
+        .. code-block:: python
+
+            >>> import paddle
+            >>> x = paddle.to_tensor([-5, -1, 1])
+            >>> y = paddle.to_tensor([4,  2, -3])
+            >>> # Using original parameter name
+            >>> res = paddle.bitwise_xor(x, y)
+            >>> print(res)
+            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [-1, -3, -4])
+
+            >>> # Using Pytorch-compatible parameter name
+            >>> res = paddle.bitwise_xor(input=x, other=y)
+            >>> print(res)
+            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [-1, -3, -4])
+    """,
+    """
+def bitwise_xor(
+    x: Tensor,
+    y: Tensor,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
+) -> Tensor
+""",
+)
+
+add_doc_and_signature(
+    "bitwise_xor_",
+    r"""
+    An inplace version of ``bitwise_xor``.
+
+    This API applies bitwise XOR between the elements of `x` and the corresponding elements of `y`,
+    modifies `x` in-place, and returns the modified `x`.
+    """,
+    """
+def bitwise_xor_(
+    x: Tensor,
+    y: Tensor,
+    name: str | None = None,
+    *,
+    out: Tensor | None = None,
+) -> Tensor
+""",
+)

python/paddle/tensor/logic.py

@@ -21,6 +21,8 @@
 import paddle
 from paddle import _C_ops
 from paddle._C_ops import (  # noqa: F401
+    bitwise_xor,
+    bitwise_xor_,
     greater_than,
     isclose,
     logical_and,
@@ -49,6 +51,7 @@
 if TYPE_CHECKING:
     from paddle import Tensor
 
+
 __all__ = []
 
 
@@ -1209,49 +1212,6 @@ def bitwise_or_(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
         return _C_ops.bitwise_or_(x, y)
 
 
-def bitwise_xor(
-    x: Tensor, y: Tensor, out: Tensor | None = None, name: str | None = None
-) -> Tensor:
-    r"""
-
-    Apply ``bitwise_xor`` on Tensor ``X`` and ``Y`` .
-
-    .. math::
-        Out = X ^\wedge Y
-
-    Note:
-        ``paddle.bitwise_xor`` supports broadcasting. If you want know more about broadcasting, please refer to please refer to `Introduction to Tensor`_ .
-
-        .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor
-
-    Args:
-        x (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
-        y (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
-        out (Tensor|None, optional): Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor. Default: None.
-        name (str|None, optional): The default value is None.  Normally there is no need for
-            user to set this property.  For more information, please refer to :ref:`api_guide_Name`.
-
-    Returns:
-        Tensor: Result of ``bitwise_xor`` . It is a N-D Tensor with the same data type of input Tensor.
-
-    Examples:
-        .. code-block:: python
-
-            >>> import paddle
-            >>> x = paddle.to_tensor([-5, -1, 1])
-            >>> y = paddle.to_tensor([4,  2, -3])
-            >>> res = paddle.bitwise_xor(x, y)
-            >>> print(res)
-            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
-            [-1, -3, -4])
-    """
-    if in_dynamic_or_pir_mode() and out is None:
-        return _C_ops.bitwise_xor(x, y)
-    return _bitwise_op(
-        op_name="bitwise_xor", x=x, y=y, name=name, out=out, binary_op=True
-    )
-
-
 def __rxor__(
     x: Tensor,
     y: int | bool,
@@ -1260,28 +1220,13 @@ def __rxor__(
 ) -> Tensor:
     if isinstance(y, (int, bool)):
         y = paddle.to_tensor(y, dtype=x.dtype)
-        return bitwise_xor(y, x, out=out, name=name)
+        return bitwise_xor(y, x, name=name, out=out)
     else:
         raise TypeError(
-            f"unsupported operand type(s) for |: '{type(y).__name__}' and 'Tensor'"
+            f"unsupported operand type(s) for ^: '{type(y).__name__}' and 'Tensor'"
         )
 
 
-@inplace_apis_in_dygraph_only
-def bitwise_xor_(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
-    r"""
-    Inplace version of ``bitwise_xor`` API, the output Tensor will be inplaced with input ``x``.
-    Please refer to :ref:`api_paddle_bitwise_xor`.
-    """
-    out_shape = broadcast_shape(x.shape, y.shape)
-    if out_shape != x.shape:
-        raise ValueError(
-            f"The shape of broadcast output {out_shape} is different from that of inplace tensor {x.shape} in the Inplace operation."
-        )
-    if in_dynamic_mode():
-        return _C_ops.bitwise_xor_(x, y)
-
-
 def bitwise_not(
     x: Tensor, out: Tensor | None = None, name: str | None = None
 ) -> Tensor:

test/legacy_test/test_bitwise_op.py

@@ -559,7 +559,7 @@ def init_data(self):
 class TestBitwiseXor(OpTest):
     def setUp(self):
         self.op_type = "bitwise_xor"
-        self.python_api = paddle.tensor.logic.bitwise_xor
+        self.python_api = paddle.bitwise_xor
 
         self.init_dtype()
         self.init_shape()
@@ -653,7 +653,7 @@ def init_shape(self):
 class TestBitwiseXorBool(TestBitwiseXor):
     def setUp(self):
         self.op_type = "bitwise_xor"
-        self.python_api = paddle.tensor.logic.bitwise_xor
+        self.python_api = paddle.bitwise_xor
 
         self.init_shape()
 
@@ -674,8 +674,8 @@ class TestElementwiseBitwiseXorOp_Stride(OpTest):
 
     def setUp(self):
         self.op_type = "bitwise_xor"
-        self.python_api = paddle.tensor.logic.bitwise_xor
-        self.public_python_api = paddle.tensor.logic.bitwise_xor
+        self.python_api = paddle.bitwise_xor
+        self.public_python_api = paddle.bitwise_xor
         self.transpose_api = paddle.transpose
         self.as_stride_api = paddle.as_strided
         self.init_dtype()

test/legacy_test/test_inplace.py

@@ -14,12 +14,15 @@
 
 import functools
 import unittest
+import warnings
 
 import numpy as np
 from op_test import get_device_place, get_places, is_custom_device
 
 import paddle
 
+warnings.filterwarnings("ignore", category=UserWarning)
+
 
 class TestInplace(unittest.TestCase):
     def test_forward_version(self):
@@ -1547,12 +1550,69 @@ def non_inplace_api_processing(self, var):
 
 class TestDygraphInplacBitwiseXor(TestDygraphInplacBitwiseAnd):
     def inplace_api_processing(self, var):
+        out_shape = paddle.broadcast_shape(var.shape, self.y.shape)
+        if var.shape != out_shape:
+            raise ValueError(
+                f"The shape of broadcast output {out_shape} is different from that of inplace tensor {var.shape} in the Inplace operation."
+            )
         return paddle.bitwise_xor_(var, self.y)
 
     def non_inplace_api_processing(self, var):
         return paddle.bitwise_xor(var, self.y)
 
 
+class TestDygraphInplacBitwiseXorAlias1(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        out_shape = paddle.broadcast_shape(var.shape, self.y.shape)
+        if var.shape != out_shape:
+            raise ValueError(
+                f"The shape of broadcast output {out_shape} is different from that of inplace tensor {var.shape} in the Inplace operation."
+            )
+        return paddle.bitwise_xor_(var, self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(input=var, y=self.y)
+
+
+class TestDygraphInplacBitwiseXorAlias2(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        out_shape = paddle.broadcast_shape(var.shape, self.y.shape)
+        if var.shape != out_shape:
+            raise ValueError(
+                f"The shape of broadcast output {out_shape} is different from that of inplace tensor {var.shape} in the Inplace operation."
+            )
+        return paddle.bitwise_xor_(var, self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(input=var, other=self.y)
+
+
+class TestDygraphInplacBitwiseXorAlias3(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        out_shape = paddle.broadcast_shape(var.shape, self.y.shape)
+        if var.shape != out_shape:
+            raise ValueError(
+                f"The shape of broadcast output {out_shape} is different from that of inplace tensor {var.shape} in the Inplace operation."
+            )
+        return paddle.bitwise_xor_(var, self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(x=var, y=self.y)
+
+
+class TestDygraphInplacBitwiseXorAlias4(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        out_shape = paddle.broadcast_shape(var.shape, self.y.shape)
+        if var.shape != out_shape:
+            raise ValueError(
+                f"The shape of broadcast output {out_shape} is different from that of inplace tensor {var.shape} in the Inplace operation."
+            )
+        return paddle.bitwise_xor_(var, self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(x=var, other=self.y)
+
+
 class TestDygraphInplacBitwiseNot(TestDygraphInplacBitwiseAnd):
     def inplace_api_processing(self, var):
         return paddle.bitwise_not_(var)

test/legacy_test/test_zero_dim_binary_api.py

@@ -167,7 +167,7 @@ def test_dygraph_binary(self):
             # 1) x is 0D, y is 0D
             x_np = np.random.randint(-10, 10, [])
             y_np = np.random.randint(-10, 10, [])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)
@@ -179,7 +179,7 @@ def test_dygraph_binary(self):
             # 2) x is ND, y is 0D
             x_np = np.random.randint(-10, 10, [3, 5])
             y_np = np.random.randint(-10, 10, [])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)
@@ -191,7 +191,7 @@ def test_dygraph_binary(self):
             # 3) x is 0D , y is ND
             x_np = np.random.randint(-10, 10, [])
             y_np = np.random.randint(-10, 10, [3, 5])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)

test/xpu/test_zero_dim_tensor_xpu.py

@@ -345,7 +345,7 @@ def test_dygraph_binary(self):
             # 1) x is 0D, y is 0D
             x_np = np.random.randint(-10, 10, [])
             y_np = np.random.randint(-10, 10, [])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)
@@ -357,7 +357,7 @@ def test_dygraph_binary(self):
             # 2) x is ND, y is 0D
             x_np = np.random.randint(-10, 10, [3, 5])
             y_np = np.random.randint(-10, 10, [])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)
@@ -369,7 +369,7 @@ def test_dygraph_binary(self):
             # 3) x is 0D , y is ND
             x_np = np.random.randint(-10, 10, [])
             y_np = np.random.randint(-10, 10, [3, 5])
-            out_np = eval(f'np.{api.__name__}(x_np, y_np)')
+            out_np = eval(f'np.{api.__name__.lstrip("_")}(x_np, y_np)')
 
             x = paddle.to_tensor(x_np)
             y = paddle.to_tensor(y_np)