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

Issue:
addr_



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
@@ -920,6 +920,10 @@ def is_complex(self):
 
     def addr(self, vec1, vec2, *, beta=1, alpha=1, out=None):
         return torch_frontend.addr(self, vec1, vec2, beta=beta, alpha=alpha, out=out)
+    
+    def addr_(self, vec1, vec2, *, beta=1, alpha=1):
+        self.ivy_array = self.addr(vec1, vec2, beta=beta, alpha=alpha).ivy_array
+        return self
 
     # Special Methods #
     # -------------------#


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
@@ -8771,3 +8771,56 @@ def test_torch_greater(
         frontend=frontend,
         on_device=on_device,
     )
+
+
+# addr_
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="addr_",
+    dtype_and_vecs=_get_dtype_input_and_vectors(with_input=True),
+    beta=st.floats(
+        min_value=-5,
+        max_value=5,
+        allow_nan=False,
+        allow_subnormal=False,
+        allow_infinity=False,
+    ),
+    alpha=st.floats(
+        min_value=-5,
+        max_value=5,
+        allow_nan=False,
+        allow_subnormal=False,
+        allow_infinity=False,
+    ),
+)
+def test_torch_instance_addr_(
+    dtype_and_vecs,
+    beta,
+    alpha,
+    frontend,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    on_device,
+):
+    dtype, input, vec1, vec2 = dtype_and_vecs
+    helpers.test_frontend_method(
+        init_input_dtypes=dtype,
+        init_all_as_kwargs_np={
+            "data": input,
+        },
+        method_input_dtypes=dtype,
+        method_all_as_kwargs_np={
+            "vec1": vec1,
+            "vec2": vec2,
+            "beta": beta,
+            "alpha": alpha,
+        },
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        atol_=1e-02,
+        on_device=on_device,
+    )
\ No newline at end of file
Repository: ivy-llc/ivy

Issue:
acosh



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
@@ -96,6 +96,10 @@ def dim(self):
     def abs(self):
         return paddle_frontend.abs(self)
 
+    @with_unsupported_dtypes({"2.5.0 and below": ("float16", "bfloat16")}, "paddle")
+    def acosh(self, name=None):
+        return ivy.acosh(self._ivy_array)
+
     @with_unsupported_dtypes({"2.5.0 and below": ("float16", "bfloat16")}, "paddle")
     def ceil(self):
         return paddle_frontend.ceil(self)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
@@ -2429,3 +2429,36 @@ def test_paddle_sign(
         frontend=frontend,
         on_device=on_device,
     )
+
+
+# acosh
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="acosh",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_paddle_acosh(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
Repository: ivy-llc/ivy

Issue:
cosine_similarity
#15051 


Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/nn/functional/common.py b/ivy/functional/frontends/paddle/nn/functional/common.py
--- a/ivy/functional/frontends/paddle/nn/functional/common.py
+++ b/ivy/functional/frontends/paddle/nn/functional/common.py
@@ -1 +1,25 @@
 # local
+import ivy
+from ivy.functional.frontends.paddle.func_wrapper import to_ivy_arrays_and_back
+from ivy.func_wrapper import with_unsupported_dtypes
+
+
+@with_unsupported_dtypes({"2.0.1 and below": ("float16", "bfloat16")}, "torch")
+@to_ivy_arrays_and_back
+def cosine_similarity(x1, x2, *, axis=1, eps=1e-08):
+    if len(x1.shape) == len(x2.shape) and len(x2.shape) >= 2:
+        numerator = ivy.sum(x1 * x2, axis=axis)
+        x1_squared_norm = ivy.sum(ivy.square(x1), axis=axis)
+        x2_squared_norm = ivy.sum(ivy.square(x2), axis=axis)
+    else:
+        numerator = ivy.sum(x1 * x2)
+        x1_squared_norm = ivy.sum(ivy.square(x1))
+        x2_squared_norm = ivy.sum(ivy.square(x2))
+
+    x1_norm = ivy.sqrt(x1_squared_norm)
+    x2_norm = ivy.sqrt(x2_squared_norm)
+    norm_mm = x1_norm * x2_norm
+    denominator = ivy.maximum(norm_mm, eps)
+
+    cosine = numerator / denominator
+    return cosine


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_paddle_common.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_paddle_common.py
new file mode 100644
--- /dev/null
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_nn/test_paddle_common.py
@@ -0,0 +1,43 @@
+# global
+from hypothesis import strategies as st
+
+# local
+import ivy_tests.test_ivy.helpers as helpers
+from ivy_tests.test_ivy.helpers import handle_frontend_test
+
+
+# Cosine Similarity
+@handle_frontend_test(
+    fn_tree="paddle.nn.functional.common.cosine_similarity",
+    d_type_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        num_arrays=2,
+        shared_dtype=True,
+        min_value=2,
+        max_value=5,
+        min_dim_size=2,
+        shape=(4, 4),
+    ),
+    axis=st.integers(min_value=-1, max_value=1),
+)
+def test_paddle_cosine_similarity(
+    *,
+    d_type_and_x,
+    axis,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    dtype, x = d_type_and_x
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        rtol=1e-01,
+        x1=x[0],
+        x2=x[1],
+        axis=axis,
+    )
Repository: ivy-llc/ivy

Issue:
cholesky



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/linalg.py b/ivy/functional/frontends/paddle/tensor/linalg.py
--- a/ivy/functional/frontends/paddle/tensor/linalg.py
+++ b/ivy/functional/frontends/paddle/tensor/linalg.py
@@ -104,3 +104,10 @@ def eigh(x, UPLO="L", name=None):
 def pinv(x, rcond=1e-15, hermitian=False, name=None):
     # TODO: Add hermitian functionality
     return ivy.pinv(x, rtol=rcond)
+
+
+# cholesky
+@with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
+@to_ivy_arrays_and_back
+def cholesky(x, /, *, upper=False, name=None):
+    return ivy.cholesky(x, upper=upper)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_linalg.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_linalg.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_linalg.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_linalg.py
@@ -376,3 +376,37 @@ def test_paddle_pinv(
         x=x[0],
         rcond=rcond,
     )
+
+
+# cholesky
+@handle_frontend_test(
+    fn_tree="paddle.tensor.linalg.cholesky",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        min_value=0,
+        max_value=10,
+        shape=helpers.ints(min_value=2, max_value=5).map(lambda x: tuple([x, x])),
+    ),
+    upper=st.booleans(),
+)
+def test_paddle_cholesky(
+    dtype_and_x,
+    upper,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    x = x[0]
+    x = np.matmul(x.T, x) + np.identity(x.shape[0])  # make symmetric positive-definite
+
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x,
+        upper=upper,
+    )
Repository: ivy-llc/ivy

Issue:
partition



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/sorting_searching_counting/sorting.py b/ivy/functional/frontends/numpy/sorting_searching_counting/sorting.py
--- a/ivy/functional/frontends/numpy/sorting_searching_counting/sorting.py
+++ b/ivy/functional/frontends/numpy/sorting_searching_counting/sorting.py
@@ -33,3 +33,31 @@ def sort_complex(a):
 @to_ivy_arrays_and_back
 def lexsort(keys, /, *, axis=-1):
     return ivy.lexsort(keys, axis=axis)
+
+
+@to_ivy_arrays_and_back
+def partition(a, kth, axis=-1, kind="introselect", order=None):
+    sorted_arr = ivy.sort(a, axis=axis)
+    for k in kth:
+        index_to_remove = ivy.argwhere(a == sorted_arr[k])[0, 0]
+        if len(a) == 1:
+            a = ivy.array([], dtype=a.dtype)
+        else:
+            a = ivy.concat((a[:index_to_remove], a[index_to_remove + 1 :]))
+        left = ivy.array([], dtype=a.dtype)
+        right = ivy.array([], dtype=a.dtype)
+        equal = ivy.array([], dtype=a.dtype)
+        for i in range(len(a)):
+            if a[i] < sorted_arr[k]:
+                left = ivy.concat((left, ivy.array([a[i]], dtype=a.dtype)))
+            elif a[i] > sorted_arr[k]:
+                right = ivy.concat((right, ivy.array([a[i]], dtype=a.dtype)))
+            else:
+                equal = ivy.concat((equal, ivy.array([a[i]], dtype=a.dtype)))
+        for j in range(len(equal)):
+            if len(left) == len(sorted_arr[:k]):
+                right = ivy.concat((right, ivy.array([equal[j]], dtype=a.dtype)))
+            else:
+                left = ivy.concat((left, ivy.array([equal[j]], dtype=a.dtype)))
+        a = ivy.concat((left, ivy.array([sorted_arr[k]], dtype=a.dtype), right))
+    return a


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_sorting_searching_counting/test_sorting.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_sorting_searching_counting/test_sorting.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_sorting_searching_counting/test_sorting.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_sorting_searching_counting/test_sorting.py
@@ -160,3 +160,39 @@ def test_numpy_lexsort(
         keys=x[0],
         axis=axis,
     )
+
+
+@handle_frontend_test(
+    fn_tree="numpy.partition",
+    dtype_x_axis=helpers.array_indices_axis(
+        array_dtypes=helpers.get_dtypes("numeric"),
+        indices_dtypes=["int64"],
+        min_dim_size=1,
+        max_num_dims=1,
+        indices_same_dims=False,
+        disable_random_axis=False,
+        axis_zero=False,
+        valid_bounds=True,
+    ),
+    test_with_out=st.just(False),
+)
+def test_numpy_partition(
+    *,
+    dtype_x_axis,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtypes, x, kth, axis, _ = dtype_x_axis
+    helpers.test_frontend_function(
+        input_dtypes=dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=False,
+        a=x,
+        kth=kth,
+        axis=axis,
+    )
Repository: ivy-llc/ivy

Issue:
logical_xor



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/logic.py b/ivy/functional/frontends/paddle/tensor/logic.py
--- a/ivy/functional/frontends/paddle/tensor/logic.py
+++ b/ivy/functional/frontends/paddle/tensor/logic.py
@@ -99,3 +99,23 @@ def less_equal(x, y, /, *, name=None):
 @handle_out_argument
 def logical_or(x, y, /, *, name=None, out=None):
     return ivy.logical_or(x, y, out=out)
+
+
+@with_supported_dtypes(
+    {
+        "2.4.2 and below": (
+            "bool",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "float32",
+            "float64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+@handle_out_argument
+def logical_xor(x, y, /, *, name=None, out=None):
+    return ivy.logical_xor(x, y, out=out)


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

Issue:
rfftfreq



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py
--- a/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py
+++ b/ivy/functional/frontends/numpy/fft/discrete_fourier_transform.py
@@ -85,3 +85,16 @@ def fftfreq(n, d=1.0):
     results[N:] = p2
 
     return results * val
+
+
+@to_ivy_arrays_and_back
+def rfftfreq(n, d=1.0):
+    if not isinstance(
+        n, (int, type(ivy.int8), type(ivy.int16), type(ivy.int32), type(ivy.int64))
+    ):
+        raise ValueError("n should be an integer")
+
+    val = 1.0 / (n * d)
+    N = n // 2 + 1
+    results = ivy.arange(0, N, dtype=int)
+    return results * val


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py b/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py
--- a/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py
+++ b/ivy_tests/test_ivy/test_frontends/test_numpy/test_fft/test_discrete_fourier_transform.py
@@ -138,3 +138,22 @@ def test_numpy_fftfreq(n, sample_rate, frontend, test_flags, fn_tree, on_device)
         n=n,
         d=d,
     )
+
+
+@handle_frontend_test(
+    fn_tree="numpy.fft.rfftfreq",
+    n=st.integers(min_value=10, max_value=100),
+    sample_rate=st.integers(min_value=1, max_value=10),
+)
+def test_numpy_rfftfreq(n, sample_rate, frontend, test_flags, fn_tree, on_device):
+    d = 1 / sample_rate
+    helpers.test_frontend_function(
+        input_dtypes=[int],
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=True,
+        n=n,
+        d=d,
+    )
Repository: ivy-llc/ivy

Issue:
is_complex



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/attribute.py b/ivy/functional/frontends/paddle/tensor/attribute.py
--- a/ivy/functional/frontends/paddle/tensor/attribute.py
+++ b/ivy/functional/frontends/paddle/tensor/attribute.py
@@ -1 +1,10 @@
 # global
+import ivy
+from ivy.functional.frontends.paddle.func_wrapper import (
+    to_ivy_arrays_and_back,
+)
+
+
+@to_ivy_arrays_and_back
+def is_complex(x):
+    return ivy.is_complex_dtype(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_attribute.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_attribute.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_attribute.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_attribute.py
@@ -1,3 +1,30 @@
 # global
 
 # local
+import ivy_tests.test_ivy.helpers as helpers
+from ivy_tests.test_ivy.helpers import handle_frontend_test
+
+
+@handle_frontend_test(
+    fn_tree="paddle.tensor.attribute.is_complex",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+)
+def test_paddle_is_complex(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, input = 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=input[0],
+    )
Repository: ivy-llc/ivy

Issue:
logical_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
@@ -119,3 +119,23 @@ def logical_or(x, y, /, *, name=None, out=None):
 @handle_out_argument
 def logical_xor(x, y, /, *, name=None, out=None):
     return ivy.logical_xor(x, y, out=out)
+
+
+@with_supported_dtypes(
+    {
+        "2.4.2 and below": (
+            "bool",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "float32",
+            "float64",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+@handle_out_argument
+def logical_not(x, /, *, name=None, out=None):
+    return ivy.logical_not(x, out=out)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_logic.py
@@ -269,3 +269,27 @@ def test_paddle_logical_xor(
         x=x[0],
         y=x[1],
     )
+
+
+@handle_frontend_test(
+    fn_tree="paddle.logical_not",
+    dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")),
+    test_with_out=st.just(True),
+)
+def test_paddle_logical_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],
+    )
Repository: ivy-llc/ivy

Issue:
cumprod



Discussion:
- [ ] #16125

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
@@ -210,6 +210,24 @@ def exp(x, name=None):
     return ivy.exp(x)
 
 
+@with_supported_dtypes(
+    {
+        "2.4.2 and below": (
+            "float32",
+            "float64",
+            "int32",
+            "int64",
+            "complex64",
+            "complex128",
+        )
+    },
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def cumprod(x, dim=None, dtype=None, name=None):
+    return ivy.cumprod(x, axis=dim, dtype=dtype)
+ 
+
 @with_unsupported_dtypes({"2.5.0 and below": ("float16", "bfloat16")}, "paddle")
 @to_ivy_arrays_and_back
 def reciprocal(x, name=None):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_math.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_math.py
@@ -938,6 +938,41 @@ def test_paddle_reciprocal(
         x=x[0],
     )
 
+    
+# cumprod
+@handle_frontend_test(
+    fn_tree="paddle.tensor.math.cumprod",
+    dtype_and_x=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("valid"),
+        safety_factor_scale="log",
+        large_abs_safety_factor=6,
+        small_abs_safety_factor=5,
+        min_num_dims=1,
+        valid_axis=True,
+        force_int_axis=True,
+    ),
+)
+def test_paddle_cumprod(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, x, axis = 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],
+        dim=axis,
+        rtol=1e-01,
+        atol=1e-01,
+    )
+
 
 # gcd
 @handle_frontend_test(
Repository: ivy-llc/ivy

Issue:
sin



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
@@ -105,3 +105,7 @@ def asinh(self, name=None):
     @with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
     def asin(self, name=None):
         return ivy.asin(self._ivy_array)
+
+    @with_supported_dtypes({"2.4.2 and below": ("float32", "float64")}, "paddle")
+    def sin(self, name=None):
+        return ivy.sin(self._ivy_array)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_paddle_tensor.py
@@ -278,6 +278,39 @@ def test_torch_instance_abs(
     )
 
 
+# sin
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="paddle.to_tensor",
+    method_name="sin",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+    ),
+)
+def test_paddle_sin(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=input_dtype,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        method_input_dtypes=input_dtype,
+        method_all_as_kwargs_np={},
+        frontend_method_data=frontend_method_data,
+        init_flags=init_flags,
+        method_flags=method_flags,
+        frontend=frontend,
+        on_device=on_device,
+    )
+
+
 # asin
 @handle_frontend_method(
     class_tree=CLASS_TREE,