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

Issue:
 vonmises
numpy.random.vonmises function implementation


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/random/functions.py b/ivy/functional/frontends/numpy/random/functions.py
--- a/ivy/functional/frontends/numpy/random/functions.py
+++ b/ivy/functional/frontends/numpy/random/functions.py
@@ -275,6 +275,33 @@ def uniform(low=0.0, high=1.0, size=None):
     return ivy.random_uniform(low=low, high=high, shape=size, dtype="float64")
 
 
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def vonmises(mu, kappa, size=None):
+    t_size = 0
+    # Output shape. If the given shape is, e.g., (m, n, k),
+    # then m * n * k samples are drawn.
+    if size is None or len(size) == 0:
+        t_size = 1
+    else:
+        for x in size:
+            t_size = t_size * x
+    size = t_size
+    li = []
+    while len(li) < size:
+        # Generate samples from the von Mises distribution using numpy
+        u = ivy.random_uniform(low=-ivy.pi, high=ivy.pi, shape=size)
+        v = ivy.random_uniform(low=0, high=1, shape=size)
+
+        condition = v < (1 + ivy.exp(kappa * ivy.cos(u - mu))) / (
+            2 * ivy.pi * ivy.i0(kappa)
+        )
+        selected_samples = u[condition]
+        li.extend(ivy.to_list(selected_samples))
+
+    return ivy.array(li[:size])
+
+
 @to_ivy_arrays_and_back
 @from_zero_dim_arrays_to_scalar
 def wald(mean, scale, size=None):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_random/test_functions.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_random/test_functions.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_random/test_functions.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_random/test_functions.py
@@ -1084,6 +1084,52 @@ def test_numpy_uniform(
     )
 
 
+@handle_frontend_test(
+    fn_tree="numpy.random.vonmises",
+    input_dtypes=helpers.get_dtypes("float"),
+    mu=st.floats(
+        allow_nan=False,
+        allow_infinity=False,
+        width=32,
+        min_value=0,
+        max_value=1,
+        exclude_min=True,
+    ),
+    kappa=st.floats(
+        allow_nan=False,
+        allow_infinity=False,
+        width=32,
+        min_value=0,
+        max_value=10,
+        exclude_min=True,
+    ),
+    size=helpers.get_shape(allow_none=True),
+)
+def test_numpy_vonmises(
+    input_dtypes,
+    frontend,
+    test_flags,
+    backend_fw,
+    fn_tree,
+    on_device,
+    mu,
+    kappa,
+    size,
+):
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=False,
+        mu=mu,
+        kappa=kappa,
+        size=size,
+    )
+
+
 @handle_frontend_test(
     fn_tree="numpy.random.wald",
     input_dtypes=helpers.get_dtypes("float"),
Repository: ivy-llc/ivy

Issue:
swish



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
@@ -245,6 +245,12 @@ def softsign(
     return ivy.divide(x, ivy.add(1, ivy.abs(x)))
 
 
+@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def swish(x, name=None):
+    return ivy.multiply(x, ivy.sigmoid(x))
+
+
 @with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
 @to_ivy_arrays_and_back
 def tanh_(x, name=None):


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
@@ -760,6 +760,34 @@ def test_paddle_softsign(
     )
 
 
+# swish
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.swish",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_paddle_swish(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )
+
+
 # tanh_
 @handle_frontend_test(
     fn_tree="paddle.nn.functional.tanh_",
Repository: ivy-llc/ivy

Issue:
array_equal



Discussion:

Resolving patch:
diff --git a/ivy/data_classes/array/general.py b/ivy/data_classes/array/general.py
--- a/ivy/data_classes/array/general.py
+++ b/ivy/data_classes/array/general.py
@@ -807,6 +807,12 @@ def array_equal(self: ivy.Array, x: Union[ivy.Array, ivy.NativeArray], /) -> boo
         >>> c = a.array_equal(b)
         >>> print(c)
         True
+
+        >>> i = ivy.array([1, 2])
+        >>> j = ivy.array([1, 2, 3])
+        >>> k = i.array_equal(j)
+        >>> print(k)
+        False
         """
         return ivy.array_equal(self, x)
 
diff --git a/ivy/data_classes/container/general.py b/ivy/data_classes/container/general.py
--- a/ivy/data_classes/container/general.py
+++ b/ivy/data_classes/container/general.py
@@ -4031,14 +4031,25 @@ def array_equal(
         >>> b = ivy.array([[-2., 1.], [1. ,2.]])
         >>> c = ivy.array([[0., 1.], [1. ,0.]])
         >>> d = ivy.array([[2., 1.], [1. ,2.]])
-        >>> a0 = ivy.Container(a = a, b = b)
-        >>> a1 = ivy.Container(a = c, b = d)
-        >>> y = a0.array_equal(a1)
+        >>> a1 = ivy.Container(a = a, b = b)
+        >>> a2 = ivy.Container(a = c, b = d)
+        >>> y = a1.array_equal(a2)
         >>> print(y)
         {
             a: True,
             b: False
         }
+
+        >>> x1 = ivy.Container(a=ivy.native_array([1, 0, 0]),
+                               b=ivy.array([1, 2, 3]))
+        >>> x2 = ivy.Container(a=ivy.native_array([1, 0, 1]),
+                               b=ivy.array([1, 2, 3]))
+        >>> y = x1.array_equal(x2)
+        >>> print(y)
+        {
+            a: False,
+            b: True
+        }
         """
         return _ContainerWithGeneral._static_array_equal(
             self,
diff --git a/ivy/functional/backends/tensorflow/general.py b/ivy/functional/backends/tensorflow/general.py
--- a/ivy/functional/backends/tensorflow/general.py
+++ b/ivy/functional/backends/tensorflow/general.py
@@ -37,7 +37,7 @@ def array_equal(
     /,
 ) -> bool:
     x0, x1 = ivy.promote_types_of_inputs(x0, x1)
-    return bool((tf.experimental.numpy.array_equal(x0, x1)))
+    return bool(tf.experimental.numpy.array_equal(x0, x1))
 
 
 def container_types():


Test patch:
Repository: ivy-llc/ivy

Issue:
exponential_



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
@@ -7,6 +7,15 @@
 )
 
 
+@with_supported_dtypes(
+    {"2.5.1 and below": ("float32", "float64")},
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def exponential_(x, lam=1.0, name=None):
+    return ivy.multiply(lam, ivy.exp(ivy.multiply(-lam, x)))
+
+
 @with_supported_dtypes(
     {"2.5.1 and below": ("float32", "float64")},
     "paddle",


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_random.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_random.py
@@ -7,6 +7,37 @@
 from ivy_tests.test_ivy.helpers import handle_frontend_test
 
 
+@handle_frontend_test(
+    fn_tree="paddle.tensor.random.exponential_",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_value=0,
+        max_value=1000,
+        min_num_dims=1,
+        max_num_dims=10,
+        min_dim_size=2,
+        max_dim_size=10,
+    ),
+)
+def test_paddle_exponential_(
+    fn_tree,
+    dtype_and_x,
+    frontend,
+    backend_fw,
+    test_flags,
+):
+    dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        test_values=False,
+        x=x[0],
+    )
+
+
 @handle_frontend_test(
     fn_tree="paddle.normal",
     input_dtypes=st.sampled_from([["float32"], ["float64"]]),
Repository: ivy-llc/ivy

Issue:
invert_permutation



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
@@ -324,6 +324,17 @@ def in_top_k(target, pred, k, name=None):
     return ivy.array([val in top_k.values for val in target])
 
 
+@with_supported_dtypes(
+    {
+        "2.13.0 and below": ("int32", "int64"),
+    },
+    "tensorflow",
+)
+@to_ivy_arrays_and_back
+def invert_permutation(x, name=None):
+    return ivy.invert_permutation(x)
+
+
 @with_supported_dtypes(
     {
         "2.11.0 and below": ("bfloat16", "half", "float32", "float64"),


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
@@ -8,6 +8,12 @@
 from ivy_tests.test_ivy.test_functional.test_core.test_statistical import (
     _statistical_dtype_values,
 )
+# fmt: off
+from ivy_tests.test_ivy.test_functional.test_experimental.test_core.test_sorting \
+    import (
+        _invert_permutation_helper,
+    )
+# fmt: on
 from ivy_tests.test_ivy.helpers import handle_frontend_test
 
 
@@ -1201,6 +1207,33 @@ def test_tensorflow_in_top_k(
     )
 
 
+# invert_permutation
+@handle_frontend_test(
+    fn_tree="tensorflow.math.invert_permutation",
+    dtype_and_perm=_invert_permutation_helper(for_frontend_test=True),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_invert_permutation(
+    *,
+    dtype_and_perm,
+    frontend,
+    test_flags,
+    backend_fw,
+    fn_tree,
+    on_device,
+):
+    input_dtype, perm = dtype_and_perm
+    helpers.test_frontend_function(
+        input_dtypes=[input_dtype],
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=perm,
+    )
+
+
 # is_finite
 
 
diff --git a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_sorting.py b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_sorting.py
--- a/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_sorting.py
+++ b/ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_sorting.py
@@ -12,13 +12,15 @@
 
 
 @st.composite
-def _invert_permutation_helper(draw):
+def _invert_permutation_helper(draw, for_frontend_test=False):
     perm = draw(
         st.permutations(list(range(draw(st.integers(min_value=3, max_value=10)))))
     )
-    if draw(st.booleans()):
+    if for_frontend_test or draw(st.booleans()):
         perm = np.array(perm)
-    dtype = draw(st.sampled_from(["int32", "int64"]))
+    dtype = draw(
+        st.sampled_from(["int32", "int64"] if not for_frontend_test else ["int64"])
+    )
     return dtype, perm
Repository: ivy-llc/ivy

Issue:
gradient



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py
--- a/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py
+++ b/ivy/functional/frontends/numpy/mathematical_functions/miscellaneous.py
@@ -9,7 +9,9 @@
     from_zero_dim_arrays_to_scalar,
     handle_numpy_out,
 )
-from ivy.func_wrapper import with_supported_dtypes
+
+
+from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes
 
 
 # --- Helpers --- #
@@ -331,6 +333,13 @@ def convolve(a, v, mode="full"):
     return result[0, 0, out_order]
 
 
+@with_unsupported_dtypes({"2.0.1 and below": ("bfloat16",)}, "numpy")
+@to_ivy_arrays_and_back
+def gradient(f, *varargs, axis=None, edge_order=None):
+    edge_order = edge_order if edge_order is not None else 1
+    return ivy.gradient(f, spacing=varargs, axis=axis, edge_order=edge_order)
+
+
 @to_ivy_arrays_and_back
 @from_zero_dim_arrays_to_scalar
 def interp(x, xp, fp, left=None, right=None, period=None):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_miscellaneous.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_miscellaneous.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_miscellaneous.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_miscellaneous.py
@@ -370,6 +370,49 @@ def test_numpy_gcd(
     )
 
 
+# gradient
+@handle_frontend_test(
+    fn_tree="numpy.gradient",
+    dtype_input_axis=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_num_dims=1,
+        max_num_dims=3,
+        min_dim_size=2,
+        max_dim_size=4,
+        valid_axis=True,
+        force_int_axis=True,
+    ),
+    varargs=helpers.ints(
+        min_value=-3,
+        max_value=3,
+    ),
+)
+def test_numpy_gradient(
+    dtype_input_axis,
+    varargs,
+    frontend,
+    backend_fw,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    input_dtype, x, axis = dtype_input_axis
+    test_flags.num_positional_args = 2
+    kw = {}
+    kw["varargs"] = varargs
+    kw["axis"] = axis
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        f=x[0],
+        **kw,
+    )
+
+
 # heaviside
 @handle_frontend_test(
     fn_tree="numpy.heaviside",
Repository: ivy-llc/ivy

Issue:
digamma



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
@@ -226,6 +226,11 @@ def cumsum(x, axis, exclusive=False, reverse=False, name=None):
     )
 
 
+@to_ivy_arrays_and_back
+def digamma(x, name=None):
+    return ivy.digamma(x)
+
+
 @to_ivy_arrays_and_back
 def divide(x, y, name=None):
     x, y = check_tensorflow_casting(x, y)
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
@@ -49,6 +49,7 @@
 Cosh = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.cosh))
 Cumprod = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.cumprod))
 Cumsum = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.cumsum))
+Digamma = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.digamma))
 Div = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.divide))
 Einsum = to_ivy_arrays_and_back(
     with_supported_dtypes(


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
@@ -761,6 +761,36 @@ def test_tensorflow_cumsum(  # NOQA
     )
 
 
+# digamma
+@handle_frontend_test(
+    fn_tree="tensorflow.math.digamma",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        num_arrays=1,
+    ),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_digamma(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )
+
+
 # divide
 @handle_frontend_test(
     fn_tree="tensorflow.math.divide",
Repository: ivy-llc/ivy

Issue:
sum



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/math.py b/ivy/functional/frontends/paddle/math.py
--- a/ivy/functional/frontends/paddle/math.py
+++ b/ivy/functional/frontends/paddle/math.py
@@ -503,6 +503,25 @@ def subtract(x, y, name=None):
     return ivy.subtract(x, y)
 
 
+@with_supported_dtypes(
+    {
+        "2.5.1 and below": (
+            "float64",
+            "int64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def sum(x, axis=None, dtype=None, keepdim=False, name=None):
+    return ivy.sum(
+        x,
+        axis=axis,
+        keepdims=keepdim,
+        dtype=dtype,
+    )
+
+
 @with_supported_dtypes(
     {"2.5.1 and below": ("float32", "float64", "int32", "int6")}, "paddle"
 )


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_math.py
@@ -2210,6 +2210,39 @@ def test_paddle_subtract(
     )
 
 
+@handle_frontend_test(
+    fn_tree="paddle.sum",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=2,
+        allow_inf=False,
+        large_abs_safety_factor=2,
+        small_abs_safety_factor=2,
+        safety_factor_scale="log",
+        shared_dtype=True,
+    ),
+)
+def test_paddle_sum(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        test_flags=test_flags,
+        on_device=on_device,
+        x=x[0],
+    )
+
+
 # take
 @handle_frontend_test(
     fn_tree="paddle.take", dtype_and_values=_test_paddle_take_helper()
Repository: ivy-llc/ivy

Issue:
repeat_interleave



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/manipulation.py b/ivy/functional/frontends/paddle/tensor/manipulation.py
--- a/ivy/functional/frontends/paddle/tensor/manipulation.py
+++ b/ivy/functional/frontends/paddle/tensor/manipulation.py
@@ -77,6 +77,15 @@ def gather(params, indices, axis=-1, batch_dims=0, name=None):
     return ivy.gather(params, indices, axis=axis, batch_dims=batch_dims)
 
 
+@with_supported_dtypes(
+    {"2.5.1 and below": ("int32", "int64", "float32", "float64")},
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def repeat_interleave(x, repeats, axis=None, name=None):
+    return ivy.repeat(x, repeats, axis=axis)
+
+
 @to_ivy_arrays_and_back
 def reshape(x, shape):
     return ivy.reshape(x, shape)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_manipulation.py
@@ -8,6 +8,9 @@
 from ivy_tests.test_ivy.test_functional.test_experimental.test_core.test_manipulation import (  # noqa
     _get_dtype_values_k_axes_for_rot90,
 )
+from ivy_tests.test_ivy.test_frontends.test_torch.test_miscellaneous_ops import (
+    _get_repeat_interleaves_args,
+)
 
 
 # --- Helpers --- #
@@ -445,6 +448,40 @@ def test_paddle_gather(
     )
 
 
+# repeat_interleave
+@handle_frontend_test(
+    fn_tree="paddle.repeat_interleave",
+    dtype_values_repeats_axis_output_size=_get_repeat_interleaves_args(
+        available_dtypes=helpers.get_dtypes("numeric"),
+        valid_axis=True,
+        max_num_dims=4,
+        max_dim_size=4,
+    ),
+)
+def test_paddle_repeat_interleave(
+    *,
+    dtype_values_repeats_axis_output_size,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    dtype, values, repeats, axis, _ = dtype_values_repeats_axis_output_size
+
+    helpers.test_frontend_function(
+        input_dtypes=[dtype[0][0], dtype[1][0]],
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=values[0],
+        repeats=repeats[0],
+        axis=axis,
+    )
+
+
 # Tests #
 # ----- #
Repository: ivy-llc/ivy

Issue:
ifft



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/fft.py b/ivy/functional/frontends/jax/numpy/fft.py
--- a/ivy/functional/frontends/jax/numpy/fft.py
+++ b/ivy/functional/frontends/jax/numpy/fft.py
@@ -27,3 +27,10 @@ def fftshift(x, axes=None, name=None):
     roll = ivy.roll(x, shifts, axis=axes)
 
     return roll
+
+
+@to_ivy_arrays_and_back
+def ifft(a, n=None, axis=-1, norm=None):
+    if norm is None:
+        norm = "backward"
+    return ivy.ifft(a, axis, norm=norm, n=n)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_fft.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_fft.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_fft.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_fft.py
@@ -70,3 +70,45 @@ def test_jax_numpy_fftshift(
         x=arr[0],
         axes=None,
     )
+
+
+# ifft
+@handle_frontend_test(
+    fn_tree="jax.numpy.fft.ifft",
+    dtype_values_axis=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("complex"),
+        num_arrays=1,
+        min_value=-1e5,
+        max_value=1e5,
+        min_num_dims=1,
+        max_num_dims=5,
+        min_dim_size=1,
+        max_dim_size=5,
+        allow_inf=False,
+        large_abs_safety_factor=2.5,
+        small_abs_safety_factor=2.5,
+        safety_factor_scale="log",
+        valid_axis=True,
+        force_int_axis=True,
+    ),
+    n=st.integers(min_value=2, max_value=10),
+    norm=st.sampled_from(["backward", "ortho", "forward", None]),
+)
+def test_jax_numpy_ifft(
+    dtype_values_axis, n, norm, frontend, backend_fw, test_flags, fn_tree, on_device
+):
+    dtype, values, axis = dtype_values_axis
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        a=values[0],
+        n=n,
+        axis=axis,
+        norm=norm,
+        atol=1e-02,
+        rtol=1e-02,
+    )