internlm/SWE-Fixer-Train-110K huggingface dataset:
Repository: ivy-llc/ivy

Issue:
prelu



Discussion:
- [ ] #16337

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/activation.py b/ivy/functional/frontends/paddle/nn/functional/activation.py
--- a/ivy/functional/frontends/paddle/nn/functional/activation.py
+++ b/ivy/functional/frontends/paddle/nn/functional/activation.py
@@ -103,3 +103,9 @@ def log_softmax(x, axis=-1, dtype=None, name=None):
     ret = ivy.log_softmax(x, axis=axis)
     ret = ivy.astype(ret, dtype) if dtype else ret
     return ret
+
+
+@with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def prelu(x, weight, data_format="NCHW", name=None):
+    return ivy.add(ivy.maximum(0, x), ivy.multiply(weight, ivy.minimum(0, x)))


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
@@ -284,3 +284,44 @@ def test_paddle_log_softmax(
         axis=axis,
         dtype=ivy.as_ivy_dtype(dtypes[0]),
     )
+
+
+@st.composite
+def _generate_prelu_arrays(draw):
+    arr_size = draw(helpers.ints(min_value=2, max_value=5))
+    dtype = draw(helpers.get_dtypes("float", index=1, full=False))
+    input = draw(
+        helpers.array_values(
+            dtype=dtype[0], shape=(arr_size), min_value=0, max_value=10
+        )
+    )
+    weight = draw(
+        helpers.array_values(dtype=dtype[0], shape=(1,), min_value=0, max_value=1.0)
+    )
+    input_weight = input, weight
+    return dtype, input_weight
+
+
+# prelu
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.prelu",
+    dtype_input_and_weight=_generate_prelu_arrays(),
+)
+def test_paddle_prelu(
+    *,
+    dtype_input_and_weight,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    dtype, x = dtype_input_and_weight
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+        weight=x[1],
+    )
Repository: ivy-llc/ivy

Issue:
relu_



Discussion:
- [ ] #16343

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/activation.py b/ivy/functional/frontends/paddle/nn/functional/activation.py
--- a/ivy/functional/frontends/paddle/nn/functional/activation.py
+++ b/ivy/functional/frontends/paddle/nn/functional/activation.py
@@ -183,3 +183,11 @@ def tanhshrink(
     name=None,
 ):
     return ivy.subtract(x, ivy.tanh(x))
+
+
+@with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def relu_(x, name=None):
+    ret = ivy.relu(x)
+    ivy.inplace_update(x, ret)
+    return x


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_paddle_activation.py
@@ -434,3 +434,26 @@ def test_paddle_tanhshrink(
         test_values=False,
         x=x[0],
     )
+
+
+# relu_
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.relu_",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+)
+def test_paddle_relu_(
+    dtype_and_x,
+    frontend,
+    test_flags,
+    fn_tree,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        x=x[0],
+    )
Repository: ivy-llc/ivy

Issue:
weibull_min



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/random.py b/ivy/functional/frontends/jax/random.py
--- a/ivy/functional/frontends/jax/random.py
+++ b/ivy/functional/frontends/jax/random.py
@@ -242,3 +242,22 @@ def exponential(key, shape=(), dtype="float64"):
     uniform = ivy.random_uniform(seed=seed, shape=shape, dtype=dtype)
     exp = -ivy.log(1 - uniform)
     return exp
+
+
+@handle_jax_dtype
+@to_ivy_arrays_and_back
+@with_unsupported_dtypes(
+    {
+        "0.3.14 and below": (
+            "float16",
+            "bfloat16",
+        )
+    },
+    "jax",
+)
+def weibull_min(key, scale, concentration, shape=(), dtype="float64"):
+    seed = _get_seed(key)
+    uniform_x = ivy.random_uniform(seed=seed, shape=shape, dtype=dtype)
+    x = 1 - uniform_x
+    weibull = x ** (concentration - 1) * -ivy.log(x / scale)
+    return weibull


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
@@ -1072,3 +1072,60 @@ def call():
     for u, v in zip(ret_np, ret_from_np):
         assert u.dtype == v.dtype
         assert u.shape == v.shape
+
+
+@pytest.mark.xfail
+@handle_frontend_test(
+    fn_tree="jax.random.weibull_min",
+    dtype_key=helpers.dtype_and_values(
+        available_dtypes=["uint32"],
+        min_value=0,
+        max_value=2000,
+        min_num_dims=1,
+        max_num_dims=1,
+        min_dim_size=2,
+        max_dim_size=2,
+    ),
+    shape=helpers.get_shape(allow_none=False, min_num_dims=1, min_dim_size=1),
+    dtype=helpers.get_dtypes("float", full=False),
+)
+def test_jax_weibull_min(
+    *,
+    dtype_key,
+    shape,
+    scale,
+    concentration,
+    dtype,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, key = dtype_key
+
+    def call():
+        return helpers.test_frontend_function(
+            input_dtypes=input_dtype,
+            frontend=frontend,
+            test_flags=test_flags,
+            fn_tree=fn_tree,
+            on_device=on_device,
+            test_values=False,
+            key=key[0],
+            shape=shape,
+            scale=scale,
+            concentration=concentration,
+            dtype=dtype[0],
+        )
+
+    ret = call()
+
+    if not ivy.exists(ret):
+        return
+
+    ret_np, ret_from_np = ret
+    ret_np = helpers.flatten_and_to_np(ret=ret_np)
+    ret_from_np = helpers.flatten_and_to_np(ret=ret_from_np)
+    for u, v in zip(ret_np, ret_from_np):
+        assert u.dtype == v.dtype
+        assert u.shape == v.shape
Repository: ivy-llc/ivy

Issue:
numel



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/stat.py b/ivy/functional/frontends/paddle/tensor/stat.py
--- a/ivy/functional/frontends/paddle/tensor/stat.py
+++ b/ivy/functional/frontends/paddle/tensor/stat.py
@@ -12,3 +12,14 @@ def mean(input, axis=None, keepdim=False, out=None):
     ret = ivy.mean(input, axis=axis, keepdims=keepdim, out=out)
     ret = ivy.expand_dims(ret, axis=-1) if ret.ndim == 0 else ret
     return ret
+
+
+@with_unsupported_dtypes({"2.4.2 and below": ("complex", "int8")}, "paddle")
+@to_ivy_arrays_and_back
+def numel(x, name=None):
+    prod = ivy.prod(x.size, dtype=ivy.int64)
+    try:
+        length = len(x)
+    except (ValueError, TypeError):
+        length = 1  # if 0 dimensional tensor with 1 element
+    return ivy.array([prod if prod > 0 else ivy.array(length, dtype=ivy.int64)])


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_stat.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_stat.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_stat.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_stat.py
@@ -37,3 +37,29 @@ def test_paddle_mean(
         axis=axis,
         keepdim=keepdim,
     )
+
+
+# numel
+@handle_frontend_test(
+    fn_tree="paddle.numel",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+)
+def test_paddle_numel(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )
Repository: ivy-llc/ivy

Issue:
cond



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py
--- a/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py
+++ b/ivy/functional/frontends/numpy/linalg/norms_and_other_numbers.py
@@ -60,3 +60,12 @@ def slogdet(a):
 def trace(a, offset=0, axis1=0, axis2=1, out=None):
     ret = ivy.trace(a, offset=offset, axis1=axis1, axis2=axis2, out=out)
     return ret
+
+
+# cond
+@with_unsupported_dtypes({"1.24.3 and below": ("float16",)}, "numpy")
+@from_zero_dim_arrays_to_scalar
+@inputs_to_ivy_arrays
+def cond(x, p=None):
+    ret = ivy.cond(x, p=p)
+    return ret


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linear_algebra/test_norms_and_other_numbers.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linear_algebra/test_norms_and_other_numbers.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_linear_algebra/test_norms_and_other_numbers.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_linear_algebra/test_norms_and_other_numbers.py
@@ -1,6 +1,8 @@
 # global
 from hypothesis import strategies as st, assume
 
+import ivy
+
 # local
 import ivy_tests.test_ivy.helpers as helpers
 from ivy_tests.test_ivy.helpers import handle_frontend_test
@@ -9,6 +11,9 @@
     matrix_is_stable,
     _matrix_rank_helper,
 )
+from ivy_tests.test_ivy.test_frontends.test_torch.test_linalg import (
+    _get_dtype_and_matrix_non_singular,
+)
 
 
 # norm
@@ -231,3 +236,31 @@ def test_numpy_trace(
         axis1=axes[0],
         axis2=axes[1],
     )
+
+
+@handle_frontend_test(
+    fn_tree="numpy.linalg.cond",
+    p=st.sampled_from([ivy.inf, -ivy.inf, "fro", None, 1, -1, 2, -2]),
+    dtype_and_x=_get_dtype_and_matrix_non_singular(),
+)
+def test_numpy_cond(
+    dtype_and_x,
+    p,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+        p=p,
+        test_values=False,
+        atol=1e-3,
+        rtol=1e-2,
+    )
Repository: ivy-llc/ivy

Issue:
conjugate



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/mathematical_functions.py b/ivy/functional/frontends/jax/numpy/mathematical_functions.py
--- a/ivy/functional/frontends/jax/numpy/mathematical_functions.py
+++ b/ivy/functional/frontends/jax/numpy/mathematical_functions.py
@@ -702,3 +702,8 @@ def product(
 @to_ivy_arrays_and_back
 def round(x, decimals=0, /):
     return ivy.round(x, decimals)
+
+
+@to_ivy_arrays_and_back
+def conjugate(x, /):
+    return ivy.conj(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_math.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_math.py
@@ -2929,3 +2929,29 @@ def test_jax_numpy_product(
         where=where,
         promote_integers=promote_integers,
     )
+
+
+# conjugate
+@handle_frontend_test(
+    fn_tree="jax.numpy.conjugate",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("numeric"),
+    ),
+)
+def test_jax_numpy_conjugate(
+    *,
+    dtype_and_x,
+    test_flags,
+    on_device,
+    fn_tree,
+    frontend,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        test_flags=test_flags,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )
Repository: ivy-llc/ivy

Issue:
bitwise_and



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/logic.py b/ivy/functional/frontends/paddle/tensor/logic.py
--- a/ivy/functional/frontends/paddle/tensor/logic.py
+++ b/ivy/functional/frontends/paddle/tensor/logic.py
@@ -158,3 +158,22 @@ def logical_not(x, /, *, name=None, out=None):
 @handle_out_argument
 def bitwise_or(x, y, name=None, out=None):
     return ivy.bitwise_or(x, y, out=out)
+
+
+@with_supported_dtypes(
+    {
+        "2.4.2 and below": (
+            "bool",
+            "uint8",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+@handle_out_argument
+def bitwise_and(x, y, /, *, name=None, out=None):
+    return ivy.bitwise_and(x, y, out=out)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
@@ -321,3 +321,32 @@ def test_paddle_bitwise_or(
         x=x[0],
         y=x[1],
     )
+
+
+@handle_frontend_test(
+    fn_tree="paddle.bitwise_and",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=2,
+        shared_dtype=True,
+    ),
+    test_with_out=st.just(True),
+)
+def test_paddle_bitwise_and(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+        y=x[1],
+    )
Repository: ivy-llc/ivy

Issue:
solve_ex



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py
--- a/ivy/functional/frontends/torch/linalg.py
+++ b/ivy/functional/frontends/torch/linalg.py
@@ -249,3 +249,18 @@ def vander(x, N=None):
 @with_unsupported_dtypes({"2.0.1 and below": ("bfloat16", "float16")}, "torch")
 def multi_dot(tensors, *, out=None):
     return ivy.multi_dot(tensors, out=out)
+
+
+@to_ivy_arrays_and_back
+def solve_ex(A, B, *, left=True, check_errors=False, out=None):
+    try:
+        result = ivy.solve(A, B, out=out)
+        info = ivy.zeros(A.shape[:-2], dtype=ivy.int32)
+        return result, info
+    except RuntimeError as e:
+        if check_errors:
+            raise RuntimeError(e)
+        else:
+            result = A * math.nan
+            info = ivy.ones(A.shape[:-2], dtype=ivy.int32)
+            return result, info


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
@@ -1257,3 +1257,46 @@ def test_torch_multi_dot(
         test_values=True,
         tensors=x,
     )
+
+
+# solve_ex
+@handle_frontend_test(
+    fn_tree="torch.linalg.solve_ex",
+    dtype_and_data=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        min_value=0,
+        max_value=10,
+        shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x + 1])),
+        safety_factor_scale="log",
+        small_abs_safety_factor=6,
+    ).filter(
+        lambda x: "float16" not in x[0]
+        and "bfloat16" not in x[0]
+        and np.linalg.cond(x[1][0][:, :-1]) < 1 / sys.float_info.epsilon
+        and np.linalg.det(x[1][0][:, :-1]) != 0
+        and np.linalg.cond(x[1][0][:, -1].reshape(-1, 1)) < 1 / sys.float_info.epsilon
+    ),
+    check=st.booleans(),
+)
+def test_torch_solve_ex(
+    *,
+    dtype_and_data,
+    check,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, data = dtype_and_data
+    input = data[0][:, :-1]
+    other = data[0][:, -1].reshape(-1, 1)
+    helpers.test_frontend_function(
+        input_dtypes=[input_dtype[0], input_dtype[0]],
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        A=input,
+        B=other,
+        check_errors=check,
+    )
Repository: ivy-llc/ivy

Issue:
uniform



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/random.py b/ivy/functional/frontends/paddle/tensor/random.py
--- a/ivy/functional/frontends/paddle/tensor/random.py
+++ b/ivy/functional/frontends/paddle/tensor/random.py
@@ -1 +1,15 @@
 # global
+import ivy
+from ivy.func_wrapper import with_supported_dtypes
+from ivy.functional.frontends.paddle.func_wrapper import (
+    to_ivy_arrays_and_back,
+)
+
+
+@with_supported_dtypes(
+    {"2.4.2 and below": ("float32", "float64")},
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def uniform(shape, dtype=None, min=-1.0, max=1.0, seed=0, name=None):
+    return ivy.random_uniform(low=min, high=max, shape=shape, dtype=dtype, seed=seed)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_random.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_random.py
@@ -1,3 +1,42 @@
 # global
+from hypothesis import strategies as st
 
 # local
+import ivy_tests.test_ivy.helpers as helpers
+from ivy_tests.test_ivy.helpers import handle_frontend_test
+
+
+@handle_frontend_test(
+    fn_tree="paddle.uniform",
+    input_dtypes=helpers.get_dtypes("float"),
+    shape=st.tuples(
+        st.integers(min_value=2, max_value=5), st.integers(min_value=2, max_value=5)
+    ),
+    dtype=helpers.get_dtypes("valid", full=False),
+    min=st.floats(allow_nan=False, allow_infinity=False, width=32),
+    max=st.floats(allow_nan=False, allow_infinity=False, width=32),
+    seed=st.integers(min_value=2, max_value=5),
+)
+def test_paddle_uniform(
+    input_dtypes,
+    shape,
+    dtype,
+    min,
+    max,
+    seed,
+    frontend,
+    test_flags,
+    fn_tree,
+):
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        test_values=False,
+        shape=shape,
+        dtype=dtype[0],
+        min=min,
+        max=max,
+        seed=seed,
+    )
Repository: ivy-llc/ivy

Issue:
log1p
This is created for to added log1p in paddle.tensor.tensor.Tensor from issue #15115


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/tensor.py b/ivy/functional/frontends/paddle/tensor/tensor.py
--- a/ivy/functional/frontends/paddle/tensor/tensor.py
+++ b/ivy/functional/frontends/paddle/tensor/tensor.py
@@ -249,6 +249,10 @@ def sort(self, axis=-1, descending=False, name=None):
             ivy.sort(self._ivy_array, axis=axis, descending=descending)
         )
 
+    @with_unsupported_dtypes({"2.5.0 and below": ("float16", "bfloat16")}, "paddle")
+    def log1p(self, name=None):
+        return ivy.log1p(self._ivy_array)
+
     @with_supported_dtypes(
         {
             "2.4.2 and below": (


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_tensor.py
@@ -2974,3 +2974,40 @@ def test_paddle_atanh(
         frontend=frontend,
         on_device=on_device,
     )
+
+
+# log1p
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="log1p",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        safety_factor_scale="log",
+        small_abs_safety_factor=32,
+    ),
+)
+def test_paddle_log1p(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    backend_fw,
+    frontend,
+    on_device,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        frontend_method_data=frontend_method_data,
+        backend_to_test=backend_fw,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
bitwise_xor



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/logic.py b/ivy/functional/frontends/paddle/tensor/logic.py
--- a/ivy/functional/frontends/paddle/tensor/logic.py
+++ b/ivy/functional/frontends/paddle/tensor/logic.py
@@ -177,3 +177,22 @@ def bitwise_or(x, y, name=None, out=None):
 @handle_out_argument
 def bitwise_and(x, y, /, *, name=None, out=None):
     return ivy.bitwise_and(x, y, out=out)
+
+
+@with_supported_dtypes(
+    {
+        "2.4.2 and below": (
+            "bool",
+            "uint8",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+@handle_out_argument
+def bitwise_xor(x, y, /, *, name=None, out=None):
+    return ivy.bitwise_xor(x, y, out=out)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
@@ -350,3 +350,33 @@ def test_paddle_bitwise_and(
         x=x[0],
         y=x[1],
     )
+
+
+# bitwise_xor
+@handle_frontend_test(
+    fn_tree="paddle.bitwise_xor",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=2,
+        shared_dtype=True,
+    ),
+    test_with_out=st.just(True),
+)
+def test_paddle_bitwise_xor(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+        y=x[1],
+    )