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

Issue:
clip



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
@@ -81,6 +81,12 @@ def ceil(x, /):
     return ivy.ceil(x)
 
 
+@with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle")
+@to_ivy_arrays_and_back
+def clip(a, a_min=None, a_max=None, out=None):
+    return ivy.array(ivy.clip(a, a_min, a_max), dtype=a.dtype)
+
+
 @to_ivy_arrays_and_back
 def conj(x, /):
     return ivy.conj(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_numpy/test_mathematical_functions.py
@@ -543,6 +543,46 @@ def test_jax_ceil(
     )
 
 
+# clip
+@handle_frontend_test(
+    fn_tree="jax.numpy.clip",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float_and_integer"),
+        min_value=-1e3,
+        max_value=1e3,
+        max_dim_size=10,
+        max_num_dims=4,
+        min_dim_size=1,
+        min_num_dims=1,
+    ),
+    a_min=st.integers(min_value=0, max_value=5),
+    a_max=st.integers(min_value=5, max_value=10),
+)
+def test_jax_clip(
+    *,
+    dtype_and_x,
+    a_min,
+    a_max,
+    on_device,
+    fn_tree,
+    frontend,
+    backend_fw,
+    test_flags,
+):
+    input_dtype, x = dtype_and_x
+    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,
+        a=x[0],
+        a_min=a_min,
+        a_max=a_max,
+    )
+
+
 # conj
 @handle_frontend_test(
     fn_tree="jax.numpy.conj",
Repository: ivy-llc/ivy

Issue:
argmin



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
@@ -658,6 +658,15 @@ def std(self, axis=None, unbiased=True, keepdim=False, name=None):
     def trunc(self, name=None):
         return paddle_frontend.Tensor(ivy.trunc(self._ivy_array))
 
+    @with_supported_dtypes(
+        {"2.5.1 and below": ("float32", "float64", "int16", "int32", "int64", "uint8")},
+        "paddle",
+    )
+    def argmin(self, axis=None, keepdim=False, dtype=None, name=None):
+        return paddle_frontend.argmin(
+            self._ivy_array, axis=axis, keepdim=keepdim, dtype=dtype
+        )
+
     @with_unsupported_dtypes({"2.5.1 and below": ("float16", "bfloat16")}, "paddle")
     def remainder(self, y, name=None):
         return ivy.remainder(self._ivy_array, y)


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
@@ -598,6 +598,50 @@ def test_paddle_tensor_argmax(
     )
 
 
+# argmin
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="argmin",
+    dtype_x_axis=helpers.dtype_values_axis(
+        available_dtypes=st.one_of(helpers.get_dtypes("valid")),
+        min_axis=-1,
+        max_axis=0,
+        min_num_dims=1,
+        force_int_axis=True,
+    ),
+    keep_dims=st.booleans(),
+)
+def test_paddle_tensor_argmin(
+    dtype_x_axis,
+    keep_dims,
+    on_device,
+    backend_fw,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+):
+    input_dtypes, x, axis = dtype_x_axis
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtypes,
+        backend_to_test=backend_fw,
+        init_all_as_kwargs_np={
+            "object": x[0],
+        },
+        method_input_dtypes=input_dtypes,
+        method_all_as_kwargs_np={
+            "axis": axis,
+            "keepdim": keep_dims,
+        },
+        frontend=frontend,
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        on_device=on_device,
+    )
+
+
 # argsort
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
column_stack
- [ ] #9


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py
--- a/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py
+++ b/ivy/functional/frontends/torch/indexing_slicing_joining_mutating_ops.py
@@ -44,6 +44,19 @@ def chunk(input, chunks, dim=0):
                     ),
                     axis=dim,
                 )
+            
+
+@to_ivy_arrays_and_back
+def column_stack(tensors, *, out=None):
+    reshaped_tensors = []
+    for t in tensors:
+        dim_num = ivy.get_num_dims(t, as_array=False)
+        if dim_num <= 1:
+            reshaped_tensor = ivy.reshape(t, (-1, 1))
+        else:
+            reshaped_tensor = t
+        reshaped_tensors.append(reshaped_tensor)
+    return ivy.hstack(reshaped_tensors, out=out)
 
 
 @to_ivy_arrays_and_back
@@ -367,3 +380,5 @@ def where(condition, input=None, other=None):
     if not ivy.exists(input) and not ivy.exists(other):
         return nonzero(condition, as_tuple=True)
     return ivy.where(condition, input, other)
+
+


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_indexing_slicing_joining_mutating_ops.py
@@ -346,6 +346,35 @@ def test_torch_chunk(
     )
 
 
+# columnstack
+@handle_frontend_test(
+    fn_tree="torch.column_stack",
+    dtype_value=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_torch_columnstack(
+    *,
+    dtype_value,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    input_dtype, value = dtype_value
+    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,
+        tensors=value,
+    )
+
+
+
 # concat
 @handle_frontend_test(
     fn_tree="torch.concat",
@@ -1602,3 +1631,6 @@ def test_torch_where(
             other=xs[1],
             backend_to_test=backend_fw,
         )
+
+
+
Repository: ivy-llc/ivy

Issue:
logseries



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
@@ -101,6 +101,19 @@ def lognormal(mean=0.0, sigma=1.0, size=None):
     return ret
 
 
+@to_ivy_arrays_and_back
+@from_zero_dim_arrays_to_scalar
+def logseries(p=0, size=None):
+    if p < 0 or p >= 1:
+        raise ValueError("p value must be in the open interval (0, 1)")
+    r = ivy.log(1 - p)
+    u = ivy.random_uniform(low=0.0, high=1.0, shape=size)
+    v = ivy.random_uniform(low=0.0, high=1.0, shape=size)
+    q = 1 - ivy.exp(r * u)
+    ret = 1 + ivy.log(v) / ivy.log(q)
+    return ret
+
+
 @to_ivy_arrays_and_back
 @from_zero_dim_arrays_to_scalar
 def multinomial(n, pvals, 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
@@ -439,6 +439,42 @@ def test_numpy_lognormal(
     )
 
 
+@handle_frontend_test(
+    fn_tree="numpy.random.logseries",
+    input_dtypes=helpers.get_dtypes("float", index=2),
+    p=st.floats(
+        allow_nan=False,
+        allow_infinity=False,
+        min_value=0,
+        max_value=1,
+        exclude_max=True,
+    ),
+    size=helpers.get_shape(allow_none=True),
+    test_with_out=st.just(False),
+)
+def test_numpy_logseries(
+    input_dtypes,
+    frontend,
+    test_flags,
+    fn_tree,
+    backend_fw,
+    on_device,
+    p,
+    size,
+):
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=False,
+        p=p,
+        size=size,
+    )
+
+
 # multinomial
 @handle_frontend_test(
     fn_tree="numpy.random.multinomial",
Repository: ivy-llc/ivy

Issue:
triu
todo list: #3612


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -1932,6 +1932,24 @@ def unique_consecutive(self, return_inverse, return_counts, dim):
     )
     def cummax(self, dim):
         return torch_frontend.cummax(self, dim)
+    @with_unsupported_dtypes(
+        {
+            "2.0.1 and below": (
+                "bfloat16",
+                "int8",
+                "uint8",
+                "uint32",
+                "uint16",
+                "uint64",
+                "int16",
+                "complex128",
+                "complex64",
+            )
+        },
+        "torch",
+    )
+    def triu(self, diagonal=0):
+        return torch_frontend.triu(self, diagonal)
 
     @with_unsupported_dtypes(
         {"2.0.1 and below": ("bfloat16",)},


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -12861,3 +12861,45 @@ def test_torch_unique_consecutive(
         frontend=frontend,
         on_device=on_device,
     )
+
+
+# triu
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="triu",
+    dtype_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("numeric"),
+        min_num_dims=2,
+        max_num_dims=5,
+        min_dim_size=1,
+        max_dim_size=5,
+    ),
+    diagonal=st.integers(
+        min_value=-4,
+        max_value=4,
+    ),
+)
+def test_torch_triu(
+    dtype_x,
+    diagonal,
+    frontend,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+    backend_fw,
+):
+    input_dtype, x = dtype_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        backend_to_test=backend_fw,
+        init_all_as_kwargs_np={"data": x[0]},
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={"diagonal": diagonal},
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
xlogy
Todo list: #3612


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/tensor.py b/ivy/functional/frontends/torch/tensor.py
--- a/ivy/functional/frontends/torch/tensor.py
+++ b/ivy/functional/frontends/torch/tensor.py
@@ -2036,6 +2036,18 @@ def ne(self, other):
     def unique(self, sorted=True, return_inverse=False, return_counts=False, dim=None):
         return torch_frontend.unique(self, sorted, return_inverse, return_counts, dim)
 
+    @with_unsupported_dtypes(
+        {
+            "2.0.1 and below": (
+                "float16",
+                "bfloat16",
+            )
+        },
+        "torch",
+    )
+    def xlogy(self, *, other, out=None):
+        return torch_frontend.xlogy(self, other, out=out)
+
 
 class Size(tuple):
     def __new__(cls, iterable=()):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_tensor.py
@@ -12741,6 +12741,48 @@ def test_torch_tensor_where(
     )
 
 
+# xlogy
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="xlogy",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        num_arrays=2,
+        min_num_dims=1,
+        min_value=-100,
+        max_value=100,
+        shared_dtype=True,
+    ),
+)
+def test_torch_tensor_xlogy(
+    dtype_and_x,
+    frontend,
+    backend_fw,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    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={
+            "other": x[1],
+        },
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        on_device=on_device,
+    )
+
+
 # xlogy_
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
inner



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
@@ -233,6 +233,17 @@ def heaviside(x, y, name=None):
     return ivy.heaviside(x, y)
 
 
+@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def inner(x, y, name=None):
+    result = ivy.inner(x, y)
+    if (x.shape == () and y.shape == (1,)) or (x.shape == (1,) and y.shape == ()):
+        result = result.reshape((1,))
+    elif x.shape == (1,) and y.shape == (1,):
+        result = result.reshape((1,))
+    return result
+
+
 @with_supported_dtypes(
     {"2.5.1 and below": ("float16", "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
@@ -1003,6 +1003,39 @@ def test_paddle_heaviside(
     )
 
 
+# inner
+@handle_frontend_test(
+    fn_tree="paddle.tensor.math.inner",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        min_value=-10,
+        max_value=10,
+        num_arrays=2,
+        shared_dtype=True,
+    ),
+)
+def test_paddle_inner(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    backend_fw,
+    test_flags,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        backend_to_test=backend_fw,
+        fn_tree=fn_tree,
+        test_flags=test_flags,
+        on_device=on_device,
+        x=x[0],
+        y=x[1],
+    )
+
+
 # isfinite
 @handle_frontend_test(
     fn_tree="paddle.isfinite",
Repository: ivy-llc/ivy

Issue:
nansum



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
@@ -518,3 +518,10 @@ def tanh(x, name=None):
 @to_ivy_arrays_and_back
 def trunc(x, name=None):
     return ivy.trunc(x)
+
+
+@with_supported_dtypes({"2.5.1 and below": ("float32", "float64", "int32", "int64")}, "paddle")
+@to_ivy_arrays_and_back
+def nansum(x, axis=None, dtype=None, name=None):
+    return ivy.nansum(x, axis=axis, dtype=dtype)
+


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
@@ -2212,3 +2212,38 @@ def test_paddle_trunc(
         on_device=on_device,
         x=x[0],
     )
+
+
+#nansum
+@handle_frontend_test(
+    fn_tree="paddle.tensor.math.nansum",
+    dtype_and_x=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("float"),
+        valid_axis=True,
+        force_int_axis=True,
+        min_num_dims=1,
+        allow_nan=True,
+    ),
+)
+def test_paddle_nansum(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    backend_fw,
+    test_flags,
+):
+    input_dtype, x, axis=dtype_and_x
+    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,
+        x=x[0],
+        axis=axis,
+        rtol=1e-04,
+        atol=1e-04,
+    )
Repository: ivy-llc/ivy

Issue:
greater_equal



Discussion:

Resolving patch:
diff --git a/ivy/functional/ivy/elementwise.py b/ivy/functional/ivy/elementwise.py
--- a/ivy/functional/ivy/elementwise.py
+++ b/ivy/functional/ivy/elementwise.py
@@ -3075,8 +3075,8 @@ def greater(
 @handle_array_function
 @handle_device_shifting
 def greater_equal(
-    x1: Union[float, ivy.Array, ivy.NativeArray],
-    x2: Union[float, ivy.Array, ivy.NativeArray],
+    x1: Union[ivy.Array, ivy.NativeArray],
+    x2: Union[ivy.Array, ivy.NativeArray],
     /,
     *,
     out: Optional[ivy.Array] = None,
@@ -3141,30 +3141,6 @@ def greater_equal(
             [1.],
             [0.]]])
 
-    With a mix of :class:`ivy.Array` and :class:`ivy.NativeArray` inputs:
-
-    >>> x = ivy.array([1, 2, 3])
-    >>> y = ivy.native_array([4, 5, 0])
-    >>> z = ivy.greater_equal(x, y)
-    >>> print(z)
-    ivy.array([False, False,  True])
-
-    With a mix of :class:`ivy.Array` and :class:`ivy.Container` inputs:
-
-    >>> x = ivy.array([[5.1, 2.3, -3.6]])
-    >>> y = ivy.Container(a=ivy.array([[4.], [5.], [6.]]),
-    ...                   b=ivy.array([[5.], [6.], [7.]]))
-    >>> z = ivy.greater_equal(x, y)
-    >>> print(z)
-    {
-        a: ivy.array([[True, False, False],
-                      [True, False, False],
-                      [False, False, False]]),
-        b: ivy.array([[True, False, False],
-                      [False, False, False],
-                      [False, False, False]])
-    }
-
     With :class:`ivy.Container` input:
 
     >>> x = ivy.Container(a=ivy.array([4, 5, 6]),b=ivy.array([2, 3, 4]))


Test patch:
Repository: ivy-llc/ivy

Issue:
make_moons



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/sklearn/datasets/_samples_generator.py b/ivy/functional/frontends/sklearn/datasets/_samples_generator.py
--- a/ivy/functional/frontends/sklearn/datasets/_samples_generator.py
+++ b/ivy/functional/frontends/sklearn/datasets/_samples_generator.py
@@ -39,3 +39,31 @@ def make_circles(
         axis=0,
     )
     return X, y
+
+
+def make_moons(n_samples=100, *, shuffle=True, noise=None, random_state=None):
+    if isinstance(n_samples, numbers.Integral):
+        n_samples_out = n_samples // 2
+        n_samples_in = n_samples - n_samples_out
+    elif isinstance(n_samples, tuple):
+        n_samples_out, n_samples_in = n_samples
+
+
+    outer_circ_x = ivy.cos(ivy.linspace(0, ivy.pi, n_samples_out))
+    outer_circ_y = ivy.sin(ivy.linspace(0, ivy.pi, n_samples_out))
+    inner_circ_x = 1 - ivy.cos(ivy.linspace(0, ivy.pi, n_samples_in))
+    inner_circ_y = 1 - ivy.sin(ivy.linspace(0, ivy.pi, n_samples_in)) - 0.5
+
+
+    X = ivy.concat([
+            ivy.stack([outer_circ_x, outer_circ_y], axis=1),
+            ivy.stack([inner_circ_x, inner_circ_y], axis=1),
+        ], axis=0,
+    )
+    y = ivy.concat([
+            ivy.zeros(n_samples_out, dtype=ivy.int32),
+            ivy.ones(n_samples_in, dtype=ivy.int32),
+        ], axis=0,
+    )
+
+    return X, y
\ No newline at end of file


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_datasets/test_samples_generators.py b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_datasets/test_samples_generators.py
--- a/ivy_tests/test_ivy/test_frontends/test_sklearn/test_datasets/test_samples_generators.py
+++ b/ivy_tests/test_ivy/test_frontends/test_sklearn/test_datasets/test_samples_generators.py
@@ -24,3 +24,27 @@ def test_sklearn_make_circles(
         on_device=on_device,
         test_values=False,
     )
+
+
+@handle_frontend_test(
+    fn_tree="sklearn.datasets.make_moons",
+    n_samples=helpers.ints(min_value=1, max_value=5),
+)
+def test_sklearn_make_moons(
+    n_samples,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+    backend_fw,
+):
+    helpers.test_frontend_function(
+        n_samples=n_samples,
+        input_dtypes=["int32"],
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        frontend=frontend,
+        on_device=on_device,
+        test_values=False,
+    )
Repository: ivy-llc/ivy

Issue:
<relu>
- [ ] #22623


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
@@ -124,6 +124,12 @@ def prelu(x, weight, data_format="NCHW", name=None):
     return ivy.add(ivy.maximum(0, x), ivy.multiply(weight, ivy.minimum(0, x)))
 
 
+@with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def relu(x, name=None):
+    return ivy.relu(x)
+
+
 @with_supported_dtypes({"2.5.1 and below": ("float32", "float64")}, "paddle")
 @to_ivy_arrays_and_back
 def relu6(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
@@ -455,6 +455,31 @@ def test_paddle_prelu(
     )
 
 
+# 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,
+    backend_fw,
+    fn_tree,
+):
+    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,
+        x=x[0],
+    )
+
+
 # relu6
 @handle_frontend_test(
     fn_tree="paddle.nn.functional.relu6",