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

paddle/phi/ops/yaml/python_api_info.yaml

@@ -80,6 +80,11 @@
   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

@@ -3039,3 +3039,108 @@ 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``.
+        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])
+            >>> # 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,
+) -> 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`.
+
+    Note:
+        - Broadcasting is supported; see `Introduction to Tensor`_ for broadcasting rules.
+          .. _Introduction to Tensor: ../../guides/beginner/tensor_en.html#chapter5-broadcasting-of-tensor
+        - This is an in-place operation. It mutates `x`. Use with care in dynamic graph / autograd
+          scenarios as it may affect gradients and the computation graph.
+
+    Args:
+        x (Tensor): The input tensor to be modified in-place. Supported dtypes: bool, uint8, int8,
+            int16, int32, int64.
+        y (Tensor): The tensor whose values are XORed with `x`. Must have a dtype compatible with `x`.
+            Broadcasting with `x` is supported.
+        name (str|None, optional): Name for the operation (optional, default is None). Typically not required.
+
+    Returns:
+        Tensor: The modified tensor `x`.
+
+    Examples:
+        .. code-block:: python
+            >>> import paddle
+            >>> # Integer example
+            >>> x = paddle.to_tensor([-5, -1, 1], dtype='int64')
+            >>> y = paddle.to_tensor([ 4,  2, -3], dtype='int64')
+            >>> paddle.bitwise_xor_(x, y)       # in-place; equivalent to x.bitwise_xor_(y)
+            >>> print(x)
+            Tensor(shape=[3], dtype=int64, place=Place(cpu), stop_gradient=True,
+            [-1, -3, -4])
+            >>> # Boolean example
+            >>> x = paddle.to_tensor([True, False, True], dtype='bool')
+            >>> y = paddle.to_tensor([True, True, False], dtype='bool')
+            >>> x.bitwise_xor_(y)               # in-place
+            >>> print(x)
+            Tensor(shape=[3], dtype=bool, place=Place(cpu), stop_gradient=True,
+            [False, True, True])
+
+""",
+    """
+def bitwise_xor_(
+    x: Tensor,
+    y: Tensor,
+    name: str | None = None,
+) -> Tensor
+""",
+)

python/paddle/tensor/logic.py

@@ -49,6 +49,7 @@
 if TYPE_CHECKING:
     from paddle import Tensor
 
+
 __all__ = []
 
 
@@ -1226,7 +1227,9 @@ def bitwise_xor(
 
     Args:
         x (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
+            Alias: ``input``
         y (Tensor): Input Tensor of ``bitwise_xor`` . It is a N-D Tensor of bool, uint8, int8, int16, int32, int64.
+            Alias: ``other``
         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`.
@@ -1240,10 +1243,17 @@ def bitwise_xor(
             >>> 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])
     """
     if in_dynamic_or_pir_mode() and out is None:
         return _C_ops.bitwise_xor(x, y)
@@ -1268,6 +1278,7 @@ def __rxor__(
 
 
 @inplace_apis_in_dygraph_only
+@ParamAliasDecorator({"x": ["input"], "y": ["other"]})
 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``.

test/legacy_test/test_inplace.py

@@ -1553,6 +1553,22 @@ def non_inplace_api_processing(self, var):
         return paddle.bitwise_xor(var, self.y)
 
 
+class TestDygraphInplacBitwiseXorAlias1(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        return paddle.bitwise_xor_(var, other=self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(var, other=self.y)
+
+
+class TestDygraphInplacBitwiseXorAlias2(TestDygraphInplacBitwiseAnd):
+    def inplace_api_processing(self, var):
+        return paddle.bitwise_xor_(input=var, other=self.y)
+
+    def non_inplace_api_processing(self, var):
+        return paddle.bitwise_xor(input=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)