[Paddle Tensor No.6][BUPT] 新增 Tensor.__ror__

python/paddle/tensor/__init__.py

@@ -104,6 +104,7 @@
     transpose_,
 )
 from .logic import (  # noqa: F401
+    __ror__,
     allclose,
     bitwise_and,
     bitwise_and_,
@@ -859,6 +860,7 @@
 magic_method_func = [
     ('__and__', 'bitwise_and'),
     ('__or__', 'bitwise_or'),
+    ('__ror__', '__ror__'),
     ('__xor__', 'bitwise_xor'),
     ('__invert__', 'bitwise_not'),
     ('__pos__', 'positive'),

python/paddle/tensor/logic.py

@@ -1290,6 +1290,21 @@ def bitwise_or(
     )
 
 
+def __ror__(
+    x: Tensor,
+    y: Tensor | int | bool,
+    out: Tensor | None = None,
+    name: str | None = None,
+) -> Tensor:
+    if isinstance(y, (int, bool)):
+        y = paddle.to_tensor(y, dtype=x.dtype)
+        return bitwise_or(y, x, out=out, name=name)
+    else:
+        raise TypeError(
+            f"unsupported operand type(s) for |: '{type(y).__name__}' and 'Tensor'"
+        )
+
+
 @inplace_apis_in_dygraph_only
 def bitwise_or_(x: Tensor, y: Tensor, name: str | None = None) -> Tensor:
     r"""

test/legacy_test/test_math_op_patch.py

@@ -333,6 +333,42 @@ def test_bitwise_or(self):
         )
         np.testing.assert_array_equal(out[0], out_np)
 
+    @prog_scope()
+    def test_ror(self):
+        place = (
+            paddle.CUDAPlace(0)
+            if paddle.is_compiled_with_cuda()
+            else paddle.CPUPlace()
+        )
+        x_int = 5
+        y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
+        y = paddle.static.data("y", y_np.shape, dtype=y_np.dtype)
+        z = x_int | y
+        exe = paddle.static.Executor(place)
+        out = exe.run(
+            feed={'x': x_int, 'y': y_np},
+            fetch_list=[z],
+        )
+        out_ref = x_int | y_np
+        np.testing.assert_array_equal(out[0], out_ref)
+        x_bool = True
+        res_ror_bool = x_bool | y
+        out_bool = exe.run(
+            feed={'x': x_bool, 'y': y_np},
+            fetch_list=[res_ror_bool],
+        )
+        res_py_bool = x_bool | y_np
+        np.testing.assert_array_equal(out_bool[0], res_py_bool)
+
+        for x_invalid in (
+            np.float32(5.0),
+            np.float64(5.0),
+            np.complex64(5),
+            np.complex128(5.0 + 2j),
+        ):
+            with self.assertRaises(TypeError):
+                x_invalid | y
+
     @prog_scope()
     def test_bitwise_xor(self):
         x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")

test/legacy_test/test_math_op_patch_pir.py

@@ -248,6 +248,60 @@ def test_bitwise_or(self):
                 np.testing.assert_array_equal(res_np_c, c_np)
                 np.testing.assert_array_equal(res_np_d, d_np)
 
+    def test_dygraph_ror(self):
+        paddle.disable_static()
+        x_int32 = 5
+        x_bool = True
+        y_np = np.random.randint(0, 2, [2, 3, 5]).astype("int32")
+        y_tensor = paddle.to_tensor(y_np)
+        res_ror_int32 = x_int32 | y_tensor
+        res_py_int32 = x_int32 | y_tensor.numpy()
+        np.testing.assert_array_equal(res_py_int32, res_ror_int32.numpy())
+        res_ror_bool = x_bool | y_tensor
+        res_py_bool = x_bool | y_tensor.numpy()
+        np.testing.assert_array_equal(res_py_bool, res_ror_bool.numpy())
+        for x_np in (
+            np.float32(5.0),
+            np.float64(5.0),
+            np.complex64(5),
+            np.complex128(5.0 + 2j),
+        ):
+            with self.assertRaises(TypeError):
+                x_np | y_tensor
+        paddle.enable_static()
+        with paddle.pir_utils.IrGuard():
+            main_program, exe, program_guard = new_program()
+            with program_guard:
+                x_int = 5
+                y_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")
+                y = paddle.static.data("y", y_np.shape, dtype=y_np.dtype)
+                z = x_int | y
+                out = exe.run(
+                    main_program,
+                    feed={'x': x_int, 'y': y_np},
+                    fetch_list=[z],
+                )
+                out_ref = x_int | y_np
+                np.testing.assert_array_equal(out[0], out_ref)
+                x_bool = True
+                res_ror_bool = x_bool | y
+                out_bool = exe.run(
+                    main_program,
+                    feed={'x': x_bool, 'y': y_np},
+                    fetch_list=[res_ror_bool],
+                )
+                res_py_bool = x_bool | y_np
+                np.testing.assert_array_equal(out_bool[0], res_py_bool)
+
+                for x_invalid in (
+                    np.float32(5.0),
+                    np.float64(5.0),
+                    np.complex64(5),
+                    np.complex128(5.0 + 2j),
+                ):
+                    with self.assertRaises(TypeError):
+                        x_invalid | y
+
     def test_bitwise_and(self):
         paddle.disable_static()
         x_np = np.random.randint(-100, 100, [2, 3, 5]).astype("int32")