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

Issue:
silu



Discussion:

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
@@ -221,3 +221,9 @@ def softplus(x, beta=1, threshold=20, name=None):
 @to_ivy_arrays_and_back
 def leaky_relu(x, negative_slope=0.01, name=None):
     return ivy.leaky_relu(x)
+
+
+@with_supported_dtypes({"2.5.0 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def silu(x, name=None):
+    return ivy.silu(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_activation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_activation.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_activation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_functional/test_activation.py
@@ -566,3 +566,29 @@ def test_paddle_leaky_relu(
         negative_slope=0.01,
         x=x[0],
     )
+
+
+# silu
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.silu",
+    dtype_and_input=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+)
+def test_paddle_silu(
+    *,
+    dtype_and_input,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, x = dtype_and_input
+    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:
is_empty



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
@@ -257,3 +257,10 @@ def isclose(x, y, rtol=1e-05, atol=1e-08, equal_nan=False, name=None):
 @handle_out_argument
 def logical_and(x, y, /, *, name=None, out=None):
     return ivy.logical_and(x, y, out=out)
+
+@with_unsupported_dtypes(
+    {"2.5.0 and below": ("uint8", "int8", "int16", "complex64", "complex128")}, "paddle"
+)
+@to_ivy_arrays_and_back
+def is_empty(x, name=None):
+    return ivy.is_empty(x)
\ No newline at end of file


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
@@ -497,3 +497,29 @@ def test_paddle_logical_and(
         x=x[0],
         y=x[1],
     )
+
+
+@handle_frontend_test(
+    fn_tree="paddle.is_empty",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=2,
+        shared_dtype=True,
+        safety_factor_scale="log",
+        small_abs_safety_factor=32,
+    ),
+)
+def test_paddle_is_empty(
+    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],
+    )
\ No newline at end of file
Repository: ivy-llc/ivy

Issue:
__invert__



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/ndarray/ndarray.py b/ivy/functional/frontends/numpy/ndarray/ndarray.py
--- a/ivy/functional/frontends/numpy/ndarray/ndarray.py
+++ b/ivy/functional/frontends/numpy/ndarray/ndarray.py
@@ -500,6 +500,9 @@ def __ixor__(self, value, /):
     def __imod__(self, value, /):
         return np_frontend.mod(self, value, out=self)
 
+    def __invert__(self, /):
+        return ivy.bitwise_invert(self.ivy_array)
+
     def __abs__(self):
         return np_frontend.absolute(self)
 


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_ndarray/test_ndarray.py
@@ -3145,3 +3145,37 @@ def test_numpy_instance_tostring__(
         frontend_method_data=frontend_method_data,
         on_device=on_device,
     )
+
+
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="numpy.array",
+    method_name="__invert__",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes(kind="integer"),
+        num_arrays=1,
+    ),
+)
+def test_numpy_instance_invert__(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+):
+    input_dtypes, xs = dtype_and_x
+
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtypes,
+        init_all_as_kwargs_np={
+            "object": xs[0],
+        },
+        method_input_dtypes=input_dtypes,
+        method_all_as_kwargs_np={},
+        frontend=frontend,
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
searchsorted



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/array.py b/ivy/functional/frontends/jax/array.py
--- a/ivy/functional/frontends/jax/array.py
+++ b/ivy/functional/frontends/jax/array.py
@@ -273,6 +273,9 @@ def __iter__(self):
     def round(self, decimals=0):
         return jax_frontend.numpy.round(self, decimals)
 
+    def searchsorted(self, v, side="left", sorter=None, *, method="scan"):
+        return jax_frontend.numpy.searchsorted(self, v, side=side, sorter=sorter)
+
     def ptp(self, *, axis=None, out=None, keepdims=False):
         return jax_frontend.numpy.ptp(self, axis=axis, keepdims=keepdims)
 


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_array.py
@@ -2279,3 +2279,63 @@ def test_jax_array_ptp(
         method_flags=method_flags,
         on_device=on_device,
     )
+
+
+# searchsorted
+@st.composite
+def _searchsorted(draw):
+    dtype_x, x = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes(
+                "numeric", full=False, key="searchsorted"
+            ),
+            shape=(draw(st.integers(min_value=1, max_value=10)),),
+        ),
+    )
+    dtype_v, v = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes(
+                "numeric", full=False, key="searchsorted"
+            ),
+            min_num_dims=1,
+        )
+    )
+
+    input_dtypes = dtype_x + dtype_v
+    xs = x + v
+    side = draw(st.sampled_from(["left", "right"]))
+    sorter = None
+    xs[0] = np.sort(xs[0], axis=-1)
+    return input_dtypes, xs, side, sorter
+
+
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="jax.numpy.array",
+    method_name="searchsorted",
+    dtype_x_v_side_sorter=_searchsorted(),
+)
+def test_jax_array_searchsorted(
+    dtype_x_v_side_sorter,
+    frontend,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+    backend_fw,
+):
+    input_dtypes, xs, side, sorter = dtype_x_v_side_sorter
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtypes,
+        backend_to_test=backend_fw,
+        init_all_as_kwargs_np={
+            "object": xs[0],
+        },
+        method_input_dtypes=input_dtypes,
+        method_all_as_kwargs_np={"v": xs[0], "side": side, "sorter": sorter},
+        frontend=frontend,
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
imag



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
@@ -28,6 +28,11 @@ def add(x1, x2, /):
     return ivy.add(x1, x2)
 
 
+@to_ivy_arrays_and_back
+def imag(val, /):
+    return ivy.imag(val)
+
+
 @to_ivy_arrays_and_back
 def angle(z, deg=False):
     return ivy.angle(z, deg=deg)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy/test_math.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy/test_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy/test_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy/test_math.py
@@ -2515,6 +2515,37 @@ def test_jax_conj(
     )
 
 
+# imag
+@handle_frontend_test(
+    fn_tree="jax.numpy.imag",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float_and_complex"),
+        min_value=-20,
+        max_value=20,
+    ),
+    test_with_out=st.just(False),
+)
+def test_jax_imag(
+    *,
+    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,
+        rtol=1e-5,
+        atol=1e-5,
+        val=x[0],
+    )
+
+
 # subtract
 @handle_frontend_test(
     fn_tree="jax.numpy.subtract",
@@ -2960,7 +2991,8 @@ def test_jax_signbit(
 #     input_dtypes, x, axis, dtype, where = dtype_x_axis_dtype_where
 #     if ivy.current_backend_str() == "torch":
 #         assume(not test_flags.as_variable[0])
-#     where, input_dtypes, test_flags = np_frontend_helpers.handle_where_and_array_bools(
+#     where, input_dtypes, test_flags = np_frontend_helpers.
+#      handle_where_and_array_bools(
 #         where=where,
 #         input_dtype=input_dtypes,
 #         test_flags=test_flags,
Repository: ivy-llc/ivy

Issue:
rand



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,6 +1,7 @@
 # global
 import ivy
 from ivy.func_wrapper import with_supported_dtypes
+from ivy.func_wrapper import with_supported_device_and_dtypes
 from ivy.functional.frontends.paddle.func_wrapper import (
     to_ivy_arrays_and_back,
 )
@@ -29,6 +30,40 @@ def poisson(x, name=None):
     return ivy.poisson(x, shape=None, device=None, dtype=None, seed=None, out=None)
 
 
+@with_supported_device_and_dtypes(
+    {
+        "2.5.0 and above": {
+            "cpu": (
+                "bfloat16",
+                "float32",
+                "float64",
+            ),
+            "gpu": (
+                "bfloat16",
+                "float16",
+                "float32",
+                "float64",
+            ),
+        },
+        "2.4.2 and below": {
+            "cpu": (
+                "float32",
+                "float64",
+            ),
+            "gpu": (
+                "float16",
+                "float32",
+                "float64",
+            ),
+        },
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def rand(shape, dtype=None, name=None):
+    return ivy.random_uniform(low=0.0, high=1.0, shape=shape, dtype=dtype, seed=None)
+
+
 def randn(shape, dtype=None, name=None):
     if dtype not in ["float32", "float64"]:
         raise ivy.exceptions.IvyError(


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
@@ -98,6 +98,36 @@ def test_paddle_poisson(dtype_and_x, frontend, test_flags, fn_tree):
     )
 
 
+@handle_frontend_test(
+    fn_tree="paddle.rand",
+    input_dtypes=st.sampled_from(["int32", "int64"]),
+    shape=helpers.get_shape(
+        allow_none=False,
+        min_num_dims=0,
+        min_dim_size=1,
+    ),
+    dtype=helpers.get_dtypes("valid", full=False),
+)
+def test_paddle_rand(
+    *,
+    input_dtypes,
+    shape,
+    dtype,
+    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],
+    )
+
+
 @handle_frontend_test(
     fn_tree="paddle.randn",
     input_dtypes=st.sampled_from(["int32", "int64"]),
Repository: ivy-llc/ivy

Issue:
var
paddle frontend


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
@@ -577,6 +577,14 @@ def logical_not(self, out=None, name=None):
     def sign(self, name=None):
         return ivy.sign(self._ivy_array)
 
+    @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+    def var(self, axis=None, unbiased=True, keepdim=False, name=None):
+        return paddle_frontend.Tensor(
+            ivy.var(
+                self._ivy_array, axis=axis, correction=int(unbiased), keepdims=keepdim
+            )
+        )
+
     @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle")
     def sgn(self, name=None):
         return paddle_frontend.Tensor(ivy.sign(self._ivy_array, np_variant=True))


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
@@ -12,6 +12,9 @@
 from ivy_tests.test_ivy.test_functional.test_experimental.test_core.test_manipulation import (  # noqa E501
     _get_dtype_values_k_axes_for_rot90,
 )
+from ivy_tests.test_ivy.test_functional.test_core.test_statistical import (
+    _statistical_dtype_values,
+)
 
 CLASS_TREE = "ivy.functional.frontends.paddle.Tensor"
 
@@ -2654,6 +2657,43 @@ def test_paddle_cond(
     )
 
 
+# var
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="var",
+    dtype_and_x=_statistical_dtype_values(function="var"),
+    keepdim=st.booleans(),
+)
+def test_paddle_instance_var(
+    dtype_and_x,
+    keepdim,
+    frontend,
+    backend_fw,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+):
+    input_dtype, x, axis, correction = 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={
+            "axis": axis,
+            "unbiased": bool(correction),
+            "keepdim": keepdim,
+        },
+        frontend=frontend,
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        backend_to_test=backend_fw,
+        method_flags=method_flags,
+        on_device=on_device,
+    )
+
+
 @handle_frontend_method(
     class_tree=CLASS_TREE,
     init_tree="paddle.to_tensor",
Repository: ivy-llc/ivy

Issue:
SquaredDifference



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/tensorflow/raw_ops.py b/ivy/functional/frontends/tensorflow/raw_ops.py
--- a/ivy/functional/frontends/tensorflow/raw_ops.py
+++ b/ivy/functional/frontends/tensorflow/raw_ops.py
@@ -507,6 +507,24 @@ def Square(*, x, name="Square"):
     return ivy.square(x)
 
 
+SquaredDifference = to_ivy_arrays_and_back(
+    with_supported_dtypes(
+        {
+            "2.13.0 and below": (
+                "complex",
+                "bfloat16",
+                "float16",
+                "float64",
+                "float32",
+                "int32",
+                "int64",
+            ),
+        },
+        "tensorflow",
+    )(map_raw_ops_alias(tf_frontend.math.squared_difference))
+)
+
+
 Squeeze = to_ivy_arrays_and_back(
     map_raw_ops_alias(tf_frontend.general_functions.squeeze)
 )


Test patch:
diff --git a/.idea/runConfigurations/_template__of_py_test.xml b/.idea/runConfigurations/_template__of_py_test.xml
--- a/.idea/runConfigurations/_template__of_py_test.xml
+++ b/.idea/runConfigurations/_template__of_py_test.xml
@@ -50,4 +50,4 @@
     <option name="_new_targetType" value="&quot;PYTHON&quot;" />
     <method v="2" />
   </configuration>
-</component>
\ No newline at end of file
+</component>
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_raw_ops.py
@@ -793,6 +793,35 @@ def test_tensorflow_Square(  # NOQA
     )
 
 
+@handle_frontend_test(
+    fn_tree="tensorflow.raw_ops.SquaredDifference",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("numeric"),
+        num_arrays=2,
+        shared_dtype=True,
+    ),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_SquaredDifference(
+    *,
+    dtype_and_x,
+    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],
+        y=x[1],
+    )
+
+
 @st.composite
 def _squeeze_helper(draw):
     shape = draw(st.shared(helpers.get_shape(), key="value_shape"))
Repository: ivy-llc/ivy

Issue:
qr



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py
--- a/ivy/functional/frontends/tensorflow/linalg.py
+++ b/ivy/functional/frontends/tensorflow/linalg.py
@@ -310,6 +310,11 @@ def band_part(input, num_lower, num_upper, name=None):
     return ivy.where(mask, input, ivy.zeros_like(input))
 
 
+@to_ivy_arrays_and_back
+def qr(input, /, *, full_matrices=False, name=None):
+    return ivy.qr(input)
+
+
 @to_ivy_arrays_and_back
 @with_supported_dtypes(
     {


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
@@ -955,3 +955,47 @@ def test_tensorflow_inv(
         input=x[0],
         adjoint=adjoint,
     )
+
+
+# qr
+@handle_frontend_test(
+    fn_tree="tensorflow.linalg.qr",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_value=0,
+        max_value=10,
+        shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])),
+    ),
+)
+def test_qr(
+    *,
+    dtype_and_x,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    x = np.asarray(x[0], dtype=dtype[0])
+    x = np.matmul(x.T, x) + np.identity(x.shape[0]) * 1e-3
+    ret, frontend_ret = helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=False,
+        atol=1e-03,
+        rtol=1e-05,
+        input=x,
+    )
+    ret = [ivy.to_numpy(x) for x in ret]
+    frontend_ret = [np.asarray(x) for x in frontend_ret]
+
+    assert_all_close(
+        ret_np=ret[0],
+        ret_from_gt_np=frontend_ret[0],
+        rtol=1e-2,
+        atol=1e-2,
+        ground_truth_backend=frontend,
+    )
Repository: ivy-llc/ivy

Issue:
bitwise_not



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
@@ -198,6 +198,25 @@ def bitwise_xor(x, y, /, *, name=None, out=None):
     return ivy.bitwise_xor(x, y, out=out)
 
 
+@with_supported_dtypes(
+    {
+        "2.5.0 and below": (
+            "bool",
+            "uint8",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+@handle_out_argument
+def bitwise_not(x, out=None, name=None):
+    return ivy.bitwise_invert(x, out=out)
+
+
 @with_supported_dtypes(
     {
         "2.5.0 and below": (


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_logic.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_logic.py
@@ -382,6 +382,33 @@ def test_paddle_bitwise_xor(
     )
 
 
+# bitwise_not
+@handle_frontend_test(
+    fn_tree="paddle.bitwise_not",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+    test_with_out=st.just(True),
+)
+def test_paddle_bitwise_not(
+    *,
+    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],
+    )
+
+
 # allclose
 @handle_frontend_test(
     fn_tree="paddle.allclose",
Repository: ivy-llc/ivy

Issue:
atanh



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py
--- a/ivy/functional/frontends/tensorflow/math.py
+++ b/ivy/functional/frontends/tensorflow/math.py
@@ -706,3 +706,8 @@ def top_k(input, k=1, sorted=True, name=None):
 @to_ivy_arrays_and_back
 def real(input, name=None):
     return ivy.real(input)
+
+
+@to_ivy_arrays_and_back
+def atanh(x, name="atanh"):
+    return ivy.atanh(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
@@ -2642,3 +2642,30 @@ def test_tensorflow_real(
         on_device=on_device,
         input=x[0],
     )
+
+
+# atanh
+@handle_frontend_test(
+    fn_tree="tensorflow.math.atanh",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float_and_complex"),
+    ),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_atanh(
+    *,
+    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],
+    )