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

Issue:
ptp



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 ptp(self, *, axis=None, out=None, keepdims=False):
+        return jax_frontend.numpy.ptp(self, axis=axis, keepdims=keepdims)
+
     def min(
         self,
         /,
@@ -298,12 +301,3 @@ def var(
             keepdims=keepdims,
             where=where,
         )
-
-    def ptp(
-        self,
-        *,
-        axis=None,
-        out=None,
-        keepdims=False,
-    ):
-        return jax_frontend.numpy.ptp(self, axis=axis, out=out, 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
@@ -2238,37 +2238,42 @@ def test_jax_array_min(
     class_tree=CLASS_TREE,
     init_tree="jax.numpy.array",
     method_name="ptp",
-    dtype_and_x=helpers.dtype_values_axis(
+    dtype_and_x_axis_dtype=helpers.dtype_values_axis(
         available_dtypes=helpers.get_dtypes("float"),
-        force_int_axis=True,
+        allow_inf=False,
+        num_arrays=1,
+        large_abs_safety_factor=24,
+        small_abs_safety_factor=24,
+        safety_factor_scale="log",
         min_num_dims=1,
         valid_axis=True,
     ),
-    keepdims=st.booleans(),
+    keep_dims=st.booleans(),
 )
 def test_jax_array_ptp(
-    dtype_and_x,
-    keepdims,
-    on_device,
+    dtype_and_x_axis_dtype,
+    keep_dims,
     frontend,
-    backend_fw,
     frontend_method_data,
+    backend_fw,
     init_flags,
     method_flags,
+    on_device,
 ):
-    input_dtype, x, axis = dtype_and_x
+    input_dtypes, x, axis = dtype_and_x_axis_dtype
     helpers.test_frontend_method(
-        init_input_dtypes=input_dtype,
-        backend_to_test=backend_fw,
+        init_input_dtypes=input_dtypes,
         init_all_as_kwargs_np={
             "object": x[0],
         },
-        method_input_dtypes=input_dtype,
+        method_input_dtypes=input_dtypes,
         method_all_as_kwargs_np={
             "axis": axis,
-            "keepdims": keepdims,
+            "out": None,
+            "keepdims": keep_dims,
         },
         frontend=frontend,
+        backend_to_test=backend_fw,
         frontend_method_data=frontend_method_data,
         init_flags=init_flags,
         method_flags=method_flags,
Repository: ivy-llc/ivy

Issue:
view_as_complex



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/miscellaneous_ops.py b/ivy/functional/frontends/torch/miscellaneous_ops.py
--- a/ivy/functional/frontends/torch/miscellaneous_ops.py
+++ b/ivy/functional/frontends/torch/miscellaneous_ops.py
@@ -428,6 +428,24 @@ def view_as_real(input):
     return ivy.stack((re_part, im_part), axis=-1)
 
 
+@to_ivy_arrays_and_back
+@with_supported_dtypes({"2.0.1 and below": ("float32", "float64")}, "torch")
+def view_as_complex(input):
+    if ivy.shape(input)[-1] != 2:
+        raise ivy.exceptions.IvyError("The last dimension must have a size of 2")
+
+    real, imaginary = ivy.split(
+        ivy.stop_gradient(input, preserve_type=False),
+        num_or_size_splits=2,
+        axis=ivy.get_num_dims(input) - 1,
+    )
+    dtype = ivy.complex64 if input.dtype == ivy.float32 else ivy.complex128
+    real = ivy.squeeze(real, axis=ivy.get_num_dims(real) - 1).astype(dtype)
+    imag = ivy.squeeze(imaginary, axis=ivy.get_num_dims(imaginary) - 1).astype(dtype)
+    complex_ = real + imag * 1j
+    return ivy.array(complex_, dtype=dtype)
+
+
 @to_ivy_arrays_and_back
 def corrcoef(input):
     if len(ivy.shape(input)) > 2:


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_miscellaneous_ops.py
@@ -1586,6 +1586,52 @@ def test_torch_view_as_real(
     )
 
 
+
+@st.composite
+def complex_strategy(
+    draw, min_num_dims=0, max_num_dims=5, min_dim_size=1, max_dim_size=10
+):
+    shape = draw(
+        st.lists(
+            helpers.ints(min_value=min_dim_size, max_value=max_dim_size),
+            min_size=min_num_dims,
+            max_size=max_num_dims,
+        )
+    )
+    shape = list(shape)
+    shape.append(2)
+    return tuple(shape)
+
+
+# view_as_complex
+@handle_frontend_test(
+    fn_tree="torch.view_as_complex",
+    dtype_and_values=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        shape=st.shared(complex_strategy()),
+    ),
+)
+def test_torch_view_as_complex(
+    *,
+    dtype_and_values,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    dtype, value = dtype_and_values
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=value[0],
+    )
+
+
 # corrcoef
 @handle_frontend_test(
     fn_tree="torch.corrcoef",
Repository: ivy-llc/ivy

Issue:
bernoulli



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py
--- a/ivy/functional/backends/paddle/experimental/random.py
+++ b/ivy/functional/backends/paddle/experimental/random.py
@@ -1,7 +1,7 @@
 # global
 from typing import Optional, Union, Sequence
 import paddle
-
+from ivy.functional.backends.paddle.device import to_device
 from ivy import with_unsupported_device_and_dtypes
 from ivy.functional.backends.paddle import backend_version
 from ivy.utils.exceptions import IvyNotImplementedException
@@ -9,6 +9,7 @@
 # local
 import ivy
 from paddle.device import core
+from ivy import with_supported_device_and_dtypes
 
 # dirichlet
 
@@ -90,6 +91,23 @@ def poisson(
     raise IvyNotImplementedException()
 
 
+# bernoulli
+@with_supported_device_and_dtypes(
+    {
+        "2.5.0 and above": {
+            "cpu": ("float32", "float64"),
+            "gpu": ("bfloat16", "float16", "float32", "float64"),
+        },
+        "2.4.2 and below": {
+            "cpu": (
+                "float32",
+                "float64",
+            ),
+            "gpu": ("float16", "float32", "float64"),
+        },
+    },
+    backend_version,
+)
 def bernoulli(
     probs: Union[float, paddle.Tensor],
     *,
@@ -100,4 +118,14 @@ def bernoulli(
     seed: Optional[int] = None,
     out: Optional[paddle.Tensor] = None,
 ) -> paddle.Tensor:
-    raise IvyNotImplementedException()
+    if seed is not None:
+        paddle.seed(seed)
+    if probs is not None:
+        probs = probs
+    elif logits is not None:
+        probs = ivy.softmax(logits)
+    probs = paddle.cast(probs, dtype)
+    probs = paddle.unsqueeze(probs, 0) if len(probs.shape) == 0 else probs
+    probs = paddle.maximum(probs, paddle.full_like(probs, 1e-6))
+    sample = paddle.bernoulli(probs)
+    return to_device(sample, device)


Test patch:
Repository: ivy-llc/ivy

Issue:
beta



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/paddle/experimental/random.py b/ivy/functional/backends/paddle/experimental/random.py
--- a/ivy/functional/backends/paddle/experimental/random.py
+++ b/ivy/functional/backends/paddle/experimental/random.py
@@ -1,10 +1,11 @@
 # global
 from typing import Optional, Union, Sequence
 import paddle
-
+from ivy.functional.backends.paddle.device import to_device
 from ivy import with_unsupported_device_and_dtypes
 from ivy.functional.backends.paddle import backend_version
 from ivy.utils.exceptions import IvyNotImplementedException
+from ivy.functional.ivy.random import _check_bounds_and_get_shape
 
 # local
 import ivy
@@ -49,6 +50,7 @@ def dirichlet(
     return res
 
 
+# beta
 def beta(
     alpha: Union[float, paddle.Tensor],
     beta: Union[float, paddle.Tensor],
@@ -60,7 +62,15 @@ def beta(
     seed: Optional[int] = None,
     out: Optional[paddle.Tensor] = None,
 ) -> paddle.Tensor:
-    raise IvyNotImplementedException()
+    if seed is not None:
+        paddle.seed(seed)
+    shape = _check_bounds_and_get_shape(alpha, beta, shape)
+    dtype = paddle.float32 if dtype is None else dtype
+    beta = paddle.cast(beta, alpha.dtype)
+    dist = paddle.distribution.Beta(alpha, beta)
+    sample = dist.sample(shape)
+    sample = paddle.cast(sample, dtype)
+    return to_device(sample, device) if device is not None else sample
 
 
 def gamma(


Test patch:
Repository: ivy-llc/ivy

Issue:
round



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/mathematical_functions/rounding.py b/ivy/functional/frontends/numpy/mathematical_functions/rounding.py
--- a/ivy/functional/frontends/numpy/mathematical_functions/rounding.py
+++ b/ivy/functional/frontends/numpy/mathematical_functions/rounding.py
@@ -117,3 +117,10 @@ def around(a, decimals=0, out=None):
     if ivy.shape(a) == ():
         a = ivy.expand_dims(a, axis=0)
     return ivy.round(a, decimals=decimals, out=out)
+
+
+@handle_numpy_out
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def round(a, decimals=0, out=None):
+    return ivy.round(a, decimals=decimals, out=out)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_rounding.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_rounding.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_rounding.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_mathematical_functions/test_rounding.py
@@ -240,3 +240,34 @@ def test_numpy_around(
         a=x[0],
         decimals=decimals,
     )
+
+
+# round
+@handle_frontend_test(
+    fn_tree="numpy.round",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        max_value=50,
+        min_value=-50,
+    ),
+    decimals=st.integers(min_value=0, max_value=3),
+)
+def test_numpy_round(
+    *,
+    dtype_and_x,
+    decimals,
+    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,
+        a=x[0],
+        decimals=decimals,
+    )
Repository: ivy-llc/ivy

Issue:
atan



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
@@ -591,6 +591,10 @@ def tolist(self):
     def min(self, axis=None, keepdim=False, name=None):
         return ivy.min(self._ivy_array, axis=axis, keepdims=keepdim)
 
+    @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+    def atan(self, name=None):
+        return ivy.atan(self._ivy_array)
+
     @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
     def atanh(self, name=None):
         return ivy.atanh(self._ivy_array)


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
@@ -776,6 +776,41 @@ def test_paddle_tensor_sqrt(
     )
 
 
+# atan
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="atan",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_paddle_instance_atan(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+    backend_fw,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        backend_to_test=backend_fw,
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
+
+
 # tanh
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
maxwell



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
@@ -283,3 +283,23 @@ def pareto(key, b, shape=None, dtype="float64"):
     e = -ivy.log(1 - uniform)
 
     return ivy.exp(e / b)
+
+
+@handle_jax_dtype
+@to_ivy_arrays_and_back
+@with_unsupported_dtypes(
+    {
+        "0.3.14 and below": (
+            "float16",
+            "bfloat16",
+        )
+    },
+    "jax",
+)
+def maxwell(key, shape=None, dtype="float64"):
+    seed = _get_seed(key)
+    # generate uniform random numbers between 0 and 1
+    z = ivy.random_uniform(seed=seed, shape=shape, dtype=dtype)
+    # applying inverse transform sampling
+    x = (z**2) * ivy.exp(-(z**2) / 2)
+    return x


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_random.py
@@ -8,7 +8,8 @@
 from ivy_tests.test_ivy.helpers import handle_frontend_test
 
 
-# ToDo: Find solution around torch and paddle not running with uints 32, 64 and remove xfail fixture
+# ToDo: Find solution around torch and paddle not running with uints 32,
+#  64 and remove xfail fixture
 
 
 @st.composite
@@ -1191,3 +1192,56 @@ def call():
         assert ret_np.shape == shape
     else:
         assert ret_np.shape == b.shape
+
+
+@pytest.mark.xfail
+@handle_frontend_test(
+    fn_tree="jax.random.maxwell",
+    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(),
+    dtype=helpers.get_dtypes("float", full=False),
+)
+def test_jax_maxwell(
+    *,
+    dtype_key,
+    shape,
+    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,
+            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:
column_stack



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/manipulations.py b/ivy/functional/frontends/jax/numpy/manipulations.py
--- a/ivy/functional/frontends/jax/numpy/manipulations.py
+++ b/ivy/functional/frontends/jax/numpy/manipulations.py
@@ -270,6 +270,16 @@ def row_stack(tup):
     return ivy.concat(tup, axis=0)
 
 
+@to_ivy_arrays_and_back
+def column_stack(tup):
+    if len(ivy.shape(tup[0])) == 1:
+        ys = []
+        for t in tup:
+            ys += [ivy.reshape(t, (ivy.shape(t)[0], 1))]
+        return ivy.concat(ys, axis=1)
+    return ivy.concat(tup, axis=1)
+
+
 @to_ivy_arrays_and_back
 def pad(array, pad_width, mode="constant", **kwargs):
     return ivy.pad(array, pad_width, mode=mode, **kwargs)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_manipulations.py
@@ -1451,6 +1451,39 @@ def test_jax_row_stack(
     )
 
 
+# column_stack
+@handle_frontend_test(
+    fn_tree="jax.numpy.column_stack",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_num_dims=1,
+    ),
+    factor=helpers.ints(min_value=2, max_value=6),
+)
+def test_jax_column_stack(
+    dtype_and_x,
+    factor,
+    frontend,
+    backend_fw,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    ys = [x[0]]
+    for i in range(factor):
+        ys += [x[0]]
+    helpers.test_frontend_function(
+        input_dtypes=[dtype[0]] * (factor + 1),
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        tup=ys,
+    )
+
+
 # pad
 @st.composite
 def _pad_helper(draw):
Repository: ivy-llc/ivy

Issue:
LogSoftmax



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
@@ -291,6 +291,18 @@ def Log(*, x, name="Log"):
 
 Log1p = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.log1p))
 
+LogSoftmax = to_ivy_arrays_and_back(
+    with_supported_dtypes(
+        {
+            "2.13.0 and below": (
+                "bfloat16",
+                "float32",
+                "float64",
+            ),
+        },
+        "tensorflow",
+    )(map_raw_ops_alias(tf_frontend.math.log_softmax))
+)
 
 LogicalOr = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.math.logical_or))
 


Test patch:
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
@@ -1650,6 +1650,34 @@ def test_tensorflow_zeros_like(  # NOQA
     )
 
 
+# LogSoftmax
+@handle_frontend_test(
+    fn_tree="tensorflow.raw_ops.LogSoftmax",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        min_num_dims=1,
+    ),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_LogSoftmax(  # NOQA
+    *,
+    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,
+        logits=x[0],
+    )
+
+
 # LogicalOr
 @handle_frontend_test(
     fn_tree="tensorflow.raw_ops.LogicalOr",
Repository: ivy-llc/ivy

Issue:
asinh



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/math.py b/ivy/functional/frontends/paddle/tensor/math.py
--- a/ivy/functional/frontends/paddle/tensor/math.py
+++ b/ivy/functional/frontends/paddle/tensor/math.py
@@ -340,6 +340,12 @@ def frac(x, name=None):
     return x - ivy.sign(x) * ivy.floor(ivy.abs(x))
 
 
+@with_unsupported_dtypes({"2.5.0 and below": ("float16", "bfloat16")}, "paddle")
+@to_ivy_arrays_and_back
+def asinh(x, name=None):
+    return ivy.asinh(x)
+
+
 @with_supported_dtypes(
     {"2.5.0 and below": ("float32", "float64", "int32", "int64")}, "paddle"
 )


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_math.py
@@ -1411,6 +1411,33 @@ def test_paddle_frac(
     )
 
 
+ # asinh
+@handle_frontend_test(
+    fn_tree="paddle.tensor.math.asinh",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_paddle_asinh(
+    *,
+    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,
+        atol=1e-2,
+        x=x[0],
+    )   
+
+
 # max
 @handle_frontend_test(
     fn_tree="paddle.tensor.math.max",
Repository: ivy-llc/ivy

Issue:
gather



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
@@ -96,3 +96,13 @@ def cast(x, dtype):
 @to_ivy_arrays_and_back
 def broadcast_to(x, shape, name=None):
     return ivy.broadcast_to(x, shape)
+
+
+@with_supported_dtypes(
+    {"2.5.0 and below": ("bool", "float32", "float64", "int32", "int64")},
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def gather(params, indices, axis=-1, batch_dims=0, name=None):
+    return ivy.gather(params, indices, axis=axis, batch_dims=batch_dims)
+


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
@@ -450,3 +450,49 @@ def test_paddle_broadcast_to(
         x=x[0],
         shape=shape,
     )
+
+
+@st.composite
+def _gather_helper(draw):
+    dtype_and_param = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes("valid"),
+            min_num_dims=1,
+            max_num_dims=6,
+        )
+    )
+
+    dtype_and_indices = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes("valid"),
+            min_num_dims=1,
+            max_num_dims=6,
+        )
+    )
+    dtype, param = dtype_and_param
+    dtype, indices = dtype_and_indices
+    return dtype, param, indices
+
+
+@handle_frontend_test(
+    fn_tree="paddle.gather",
+    dtype_param_and_indices=_gather_helper(),
+)
+def test_paddle_gather(
+    *,
+    dtype_param_and_indices,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, param, indices = dtype_param_and_indices
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        param=param[0],
+        indices=indices[0],
+    )