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

Issue:
max_pool3d



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/mindspore/ops/function/nn_func.py b/ivy/functional/frontends/mindspore/ops/function/nn_func.py
--- a/ivy/functional/frontends/mindspore/ops/function/nn_func.py
+++ b/ivy/functional/frontends/mindspore/ops/function/nn_func.py
@@ -403,6 +403,52 @@ def log_softmax(input, axis=-1):
     return ivy.log_softmax(input)
 
 
+@with_supported_dtypes(
+    {
+        "2.0.0 and below": (
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64",
+            "float16",
+            "float32",
+            "float64",
+        )
+    },
+    "mindspore",
+)
+@to_ivy_arrays_and_back
+def max_pool3d(
+    input,
+    kernel_size,
+    stride=None,
+    padding=0,
+    dilation=1,
+    ceil_mode=False,
+    return_indices=False,
+):
+    # ToDo: Add return_indices once superset in implemented
+
+    if not stride:
+        stride = kernel_size
+
+    data_format = "NCDHW"
+
+    return ivy.max_pool3d(
+        input,
+        kernel_size,
+        stride,
+        padding,
+        data_format=data_format,
+        dilation=dilation,
+        ceil_mode=ceil_mode,
+    )
+
+
 @with_supported_dtypes(
     {
         "2.0 and below": (


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py
--- a/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py
+++ b/ivy_tests/test_ivy/test_frontends/test_mindspore/test_ops/test_function/test_mindspore_nn_func.py
@@ -665,6 +665,52 @@ def test_mindspore_log_softmax(
 #     )
 
 
+# max_pool3d
+@pytest.mark.skip("Testing pipeline not yet implemented")
+@handle_frontend_test(
+    fn_tree="mindspore.ops.function.nn_func.max_pool3d",
+    x_k_s_p=helpers.arrays_for_pooling(
+        min_dims=5,
+        max_dims=5,
+        min_side=1,
+        max_side=4,
+        only_explicit_padding=True,
+        return_dilation=True,
+        data_format="channel_first",
+    ),
+    test_with_out=st.just(False),
+    ceil_mode=st.sampled_from([True, False]),
+)
+def test_mindspore_max_pool3d(
+    x_k_s_p,
+    ceil_mode,
+    *,
+    test_flags,
+    frontend,
+    backend_fw,
+    fn_tree,
+    on_device,
+):
+    input_dtypes, x, kernel_size, stride, padding, dilation = x_k_s_p
+
+    padding = (padding[0][0], padding[1][0], padding[2][0])
+
+    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,
+        input=x[0],
+        kernel_size=kernel_size,
+        stride=stride,
+        padding=padding,
+        dilation=dilation,
+        ceil_mode=ceil_mode,
+    )
+
+
 # pad
 @pytest.mark.skip("Testing pipeline not yet implemented")
 @handle_frontend_test(
Repository: ivy-llc/ivy

Issue:
Tile



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
@@ -590,10 +590,6 @@ def GreaterEqual(*, x, y, name="GreaterEqual"):
     return ivy.greater_equal(x, y)
 
 
-@with_supported_dtypes(
-    {"2.13.0 and below": ("complex64", "complex128")},
-    "tensorflow",
-)
 @to_ivy_arrays_and_back
 def Imag(
     *,
@@ -793,6 +789,9 @@ def TanhGrad(*, y, dy, name="TanhGrad"):
     return ivy.multiply(dy, ivy.subtract(1, ivy.multiply(y, y)))
 
 
+Tile = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.general_functions.tile))
+
+
 @to_ivy_arrays_and_back
 def Transpose(*, x, perm, name="Transpose"):
     ret = ivy.permute_dims(x, axes=perm)


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
@@ -4335,6 +4335,60 @@ def test_tensorflow_roll(
     )
 
 
+# Tile
+@st.composite
+def _multiple_shape_helper(draw):
+    input_dtype, input_array, input_shape = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes("valid"), ret_shape=True
+        )
+    )
+    input_dims = len(input_shape)
+
+    dt_n_multiples = draw(
+        helpers.dtype_and_values(
+            available_dtypes=["int32", "int64"],
+            min_value=0,
+            max_value=10,
+            shape=draw(
+                helpers.get_shape(
+                    min_num_dims=1,
+                    max_num_dims=1,
+                    min_dim_size=input_dims,
+                    max_dim_size=input_dims,
+                )
+            ),
+        )
+    )
+
+    return input_dtype, input_array, dt_n_multiples
+
+@handle_frontend_test(
+    fn_tree="tensorflow.raw_ops.Tile", all_arguments=_multiple_shape_helper()
+)
+def test_tensorflow_Tile(
+    *,
+    all_arguments,
+    test_flags,
+    frontend,
+    fn_tree,
+    on_device,
+    backend_fw,
+):
+    input_dtype, input_matrix, dt_and_multiples = all_arguments
+    dt_mul, multiples = dt_and_multiples
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype + dt_mul,
+        input=input_matrix[0],
+        multiples=multiples[0],
+        test_flags=test_flags,
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        on_device=on_device,
+    )
+
+
 # Transpose
 @handle_frontend_test(
     fn_tree="tensorflow.raw_ops.Transpose",
Repository: ivy-llc/ivy

Issue:
negative



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
@@ -891,7 +891,7 @@ def cumsum_(self, dim, *, dtype=None):
     def inverse(self):
         return torch_frontend.inverse(self)
 
-    @with_unsupported_dtypes({"2.0.1 and below": ("bool",)}, "torch")
+    @with_unsupported_dtypes({"2.0.1 and below": ("bool", "bfloat16")}, "torch")
     def neg(self):
         return torch_frontend.negative(self)
 
@@ -902,6 +902,10 @@ def neg_(self):
 
     __neg__ = neg
 
+    @with_unsupported_dtypes({"2.0.1 and below": ("bool", "bfloat16")}, "torch")
+    def negative(self):
+        return torch_frontend.negative(self)
+
     def int(self, memory_format=None):
         self.ivy_array = ivy.astype(self.ivy_array, ivy.int32, copy=False)
         return self


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
@@ -6626,6 +6626,44 @@ def test_torch_tensor_flip(
     )
 
 
+# negative
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="negative",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_value=-1e04,
+        max_value=1e04,
+        allow_inf=False,
+    ),
+)
+def test_torch_tensor_negative(
+    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,
+        backend_to_test=backend_fw,
+        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,
+    )
+
+
 # fliplr
 @handle_frontend_method(
     class_tree=CLASS_TREE,
@@ -12436,7 +12474,7 @@ def test_torch_tensor_vsplit(
         on_device=on_device,
     )
 
-
+ 
 # where
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
Fix sums_products_differences.test_numpy_prod
|   |   |
|---|---|
|numpy|<a href="https://github.com/unifyai/ivy/actions/runs/6408093971"><img src=https://img.shields.io/badge/-failure-red></a>
|jax|<a href="https://github.com/unifyai/ivy/actions/runs/6408093971"><img src=https://img.shields.io/badge/-failure-red></a>
|tensorflow|<a href="https://github.com/unifyai/ivy/actions/runs/6408093971"><img src=https://img.shields.io/badge/-failure-red></a>
|torch|<a href="https://github.com/unifyai/ivy/actions/runs/6408093971"><img src=https://img.shields.io/badge/-failure-red></a>
|paddle|<a href="https://github.com/unifyai/ivy/actions/runs/6408093971"><img src=https://img.shields.io/badge/-failure-red></a>



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/tensorflow/creation.py b/ivy/functional/backends/tensorflow/creation.py
--- a/ivy/functional/backends/tensorflow/creation.py
+++ b/ivy/functional/backends/tensorflow/creation.py
@@ -93,6 +93,9 @@ def asarray(
     try:
         ret = tf.convert_to_tensor(obj, dtype)
     except (TypeError, ValueError):
+        obj = (
+            obj if isinstance(obj, tf.Tensor) else tf.convert_to_tensor(obj, tf.float64)
+        )
         ret = tf.cast(obj, dtype)
     return tf.identity(ret) if copy else ret
 
diff --git a/ivy/functional/frontends/numpy/mathematical_functions/sums_products_differences.py b/ivy/functional/frontends/numpy/mathematical_functions/sums_products_differences.py
--- a/ivy/functional/frontends/numpy/mathematical_functions/sums_products_differences.py
+++ b/ivy/functional/frontends/numpy/mathematical_functions/sums_products_differences.py
@@ -8,6 +8,7 @@
     from_zero_dim_arrays_to_scalar,
     handle_numpy_out,
 )
+import ivy.functional.frontends.numpy as np_frontend
 
 
 @handle_numpy_out
@@ -114,9 +115,10 @@ def prod(
     initial=None,
     where=True,
 ):
-    if ivy.is_array(where):
+    if where is not True:
         x = ivy.where(where, x, ivy.default(out, ivy.ones_like(x)), out=out)
     if initial is not None:
+        initial = np_frontend.array(initial, dtype=dtype).tolist()
         if axis is not None:
             s = ivy.to_list(ivy.shape(x, as_array=True))
             s[axis] = 1


Test patch:
Repository: ivy-llc/ivy

Issue:
conv_general_transpose



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/paddle/layers.py b/ivy/functional/backends/paddle/layers.py
--- a/ivy/functional/backends/paddle/layers.py
+++ b/ivy/functional/backends/paddle/layers.py
@@ -435,4 +435,62 @@ def conv_general_transpose(
     bias: Optional[paddle.Tensor] = None,
     out: Optional[paddle.Tensor] = None,
 ):
-    raise IvyNotImplementedException()
+    if data_format == "channel_last":
+        x = x.transpose(x, (0, dims + 1, *range(1, dims + 1)))
+    strides = [strides] * dims if isinstance(strides, int) else strides
+    dilations = [dilations] * dims if isinstance(dilations, int) else dilations
+    filters = filters.transpose(dims, dims + 1, *range(dims))
+    not_valid_pad, padding_list, output_padding = _pad_before_conv_tranpose(
+        x, filters, strides, padding, dims, dilations, output_shape, filters.shape[2:]
+    )
+    if dims == 1:
+        res = paddle.nn.functional.conv1d_transpose(
+            x,
+            filters,
+            bias=bias,
+            stride=strides,
+            padding=padding_list,
+            output_padding=output_padding,
+            groups=feature_group_count,
+            dilation=dilations,
+            data_format="NCL",
+        )
+        if not_valid_pad[0]:
+            res = res[:, :, 0:-1]
+    elif dims == 2:
+        res = paddle.nn.functional.conv2d_transpose(
+            x,
+            filters,
+            bias=bias,
+            stride=strides,
+            padding=padding_list,
+            output_padding=output_padding,
+            groups=feature_group_count,
+            dilation=dilations,
+            data_format="NCHW",
+        )
+        if not_valid_pad[0]:
+            res = res[:, :, 0:-1, :]
+        if not_valid_pad[1]:
+            res = res[:, :, :, 0:-1]
+    else:
+        res = paddle.nn.functional.conv3d_transpose(
+            x,
+            filters,
+            bias=bias,
+            stride=strides,
+            padding=padding_list,
+            output_padding=output_padding,
+            groups=feature_group_count,
+            dilation=dilations,
+            data_format="NCDHW",
+        )
+        if not_valid_pad[0]:
+            res = res[:, 0:-1, :, :]
+        if not_valid_pad[1]:
+            res = res[:, :, 0:-1, :]
+        if not_valid_pad[2]:
+            res = res[:, :, :, 0:-1]
+    if data_format == "channel_last":
+        res = res.transpose(0, *range(2, dims + 2), 1)
+    return res


Test patch:
Repository: ivy-llc/ivy

Issue:
ldexp



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/pointwise_ops.py b/ivy/functional/frontends/torch/pointwise_ops.py
--- a/ivy/functional/frontends/torch/pointwise_ops.py
+++ b/ivy/functional/frontends/torch/pointwise_ops.py
@@ -565,6 +565,14 @@ def igamma(input, other, *, out=None):
     return ivy.igamma(input, x=other, out=out)
 
 
+@with_supported_dtypes({"2.0.1 and below": ("float16", "float32", "float64")}, "torch")
+@to_ivy_arrays_and_back
+def ldexp(input, other, *, out=None):
+    value = ivy.pow(2, other, out=out)
+    value = ivy.multiply(input, value, out=out)
+    return value
+
+
 @with_unsupported_dtypes({"2.0.1 and below": ("float16",)}, "torch")
 @to_ivy_arrays_and_back
 def lgamma(input, *, out=None):


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_pointwise_ops.py
@@ -2834,6 +2834,39 @@ def test_torch_igamma(
     )
 
 
+# ldexp
+@handle_frontend_test(
+    fn_tree="torch.ldexp",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=2,
+        min_value=-1e04,
+        max_value=1e04,
+        allow_inf=False,
+    ),
+)
+def test_torch_ldexp(
+    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,
+        rtol=1e-03,
+        input=x[0],
+        other=x[1],
+    )
+
+
 @handle_frontend_test(
     fn_tree="torch.lgamma",
     dtype_and_input=helpers.dtype_and_values(
Repository: ivy-llc/ivy

Issue:
kron



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
@@ -454,3 +454,8 @@ def corrcoef(input):
             f" input with {ivy.shape(input)} dimansions"
         )
     return ivy.corrcoef(input, y=None, rowvar=True)
+
+
+@to_ivy_arrays_and_back
+def kron(input, other, *, out=None):
+    return ivy.kron(input, other, out=out)


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
@@ -1655,3 +1655,32 @@ def test_torch_corrcoef(
         backend_to_test=backend_fw,
         input=x[0],
     )
+
+
+# kron
+@handle_frontend_test(
+    fn_tree="torch.kron",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"), num_arrays=2
+    ),
+)
+def test_torch_kron(
+    dtype_and_x,
+    frontend,
+    fn_tree,
+    test_flags,
+    backend_fw,
+    on_device,
+):
+    input_dtypes, x = dtype_and_x
+    input, label = x[0], x[1]
+    helpers.test_frontend_function(
+        input_dtypes=["float32"],
+        backend_to_test=backend_fw,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=input,
+        other=label,
+    )
Repository: ivy-llc/ivy

Issue:
isfinite



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/tensorflow/elementwise.py b/ivy/functional/backends/tensorflow/elementwise.py
--- a/ivy/functional/backends/tensorflow/elementwise.py
+++ b/ivy/functional/backends/tensorflow/elementwise.py
@@ -337,6 +337,7 @@ def greater_equal(
     return tf.math.greater_equal(x1, x2)
 
 
+@with_unsupported_dtypes({"2.13.0 and below": ("bool",)}, backend_version)
 def isfinite(
     x: Union[tf.Tensor, tf.Variable],
     /,
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
@@ -1091,6 +1091,9 @@ def fix_(self):
         self.ivy_array = self.fix().ivy_array
         return self
 
+    def isfinite(self):
+        return torch_frontend.isfinite(self._ivy_array)
+
     def isinf(self):
         return torch_frontend.isinf(self._ivy_array)
 


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
@@ -9706,6 +9706,39 @@ def test_torch_tensor_norm(
     )
 
 
+# isfinite
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="isfinite",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+    ),
+)
+def test_torch_tensor_isfinite(
+    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,
+        backend_to_test=backend_fw,
+        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,
+    )
+
+
 # isinf
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
max_pool3d



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py
--- a/ivy/functional/frontends/torch/nn/functional/pooling_functions.py
+++ b/ivy/functional/frontends/torch/nn/functional/pooling_functions.py
@@ -274,3 +274,28 @@ def max_pool2d(
         dilation=dilation,
         ceil_mode=ceil_mode,
     )
+
+
+@with_unsupported_dtypes({"2.0.1 and below": ("float16",)}, "torch")
+@to_ivy_arrays_and_back
+def max_pool3d(
+    input,
+    kernel_size,
+    stride=None,
+    padding=0,
+    dilation=1,
+    ceil_mode=False,
+    return_indices=False,
+):
+    if stride is None:
+        stride = kernel_size
+
+    return ivy.max_pool3d(
+        input,
+        kernel_size,
+        stride,
+        padding,
+        data_format="NCDHW",
+        dilation=dilation,
+        ceil_mode=ceil_mode,
+    )


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_nn/test_functional/test_pooling_functions.py
@@ -479,3 +479,46 @@ def test_torch_max_pool2d(
         dilation=dilation,
         ceil_mode=ceil_mode,
     )
+
+
+# max_pool3d
+@handle_frontend_test(
+    fn_tree="torch.nn.functional.max_pool3d",
+    x_k_s_p=helpers.arrays_for_pooling(
+        min_dims=5,
+        max_dims=5,
+        min_side=1,
+        max_side=5,
+        only_explicit_padding=True,
+        return_dilation=True,
+        data_format="channel_first",
+    ),
+    test_with_out=st.just(False),
+    ceil_mode=st.booleans(),
+)
+def test_torch_max_pool3d(
+    x_k_s_p,
+    ceil_mode,
+    *,
+    test_flags,
+    frontend,
+    backend_fw,
+    fn_tree,
+    on_device,
+):
+    dtype, x, kernel, stride, pad, dilation = x_k_s_p
+    padding = (pad[0][0], pad[1][0], pad[2][0])
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        backend_to_test=backend_fw,
+        test_flags=test_flags,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=x[0],
+        kernel_size=kernel,
+        stride=stride,
+        padding=padding,
+        dilation=dilation,
+        ceil_mode=ceil_mode,
+    )
Repository: ivy-llc/ivy

Issue:
std



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/paddle/tensor/stat.py b/ivy/functional/frontends/paddle/tensor/stat.py
--- a/ivy/functional/frontends/paddle/tensor/stat.py
+++ b/ivy/functional/frontends/paddle/tensor/stat.py
@@ -69,3 +69,17 @@ def nanmedian(x, axis=None, keepdim=True, name=None):
         else ivy.astype(x, ivy.float32)
     )
     return ivy.median(x, axis=axis, keepdims=keepdim)
+
+
+@with_supported_dtypes(
+    {"2.5.1 and below": ("float32", "float64", "uint16")},
+    "paddle",
+)
+@to_ivy_arrays_and_back
+def std(x, axis=None, unbiased=True, keepdim=False, name=None):
+    x = (
+        ivy.astype(x, ivy.float64)
+        if ivy.dtype(x) == "float64"
+        else ivy.astype(x, ivy.float32)
+    )
+    return ivy.std(x, axis=axis, correction=int(unbiased), keepdims=keepdim)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_stat.py b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_stat.py
--- a/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_stat.py
+++ b/ivy_tests/test_ivy/test_frontends/test_paddle/test_tensor/test_stat.py
@@ -193,3 +193,34 @@ def test_paddle_nanmedian(
         axis=axis,
         keepdim=keepdim,
     )
+
+
+# std
+@handle_frontend_test(
+    fn_tree="paddle.std",
+    dtype_and_x=_statistical_dtype_values(function="std"),
+    unbiased=st.booleans(),
+    keepdim=st.booleans(),
+)
+def test_paddle_std(
+    *,
+    unbiased,
+    dtype_and_x,
+    keepdim,
+    fn_tree,
+    frontend,
+    backend_fw,
+    test_flags,
+):
+    input_dtype, x, axis, _ = 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],
+        axis=axis,
+        unbiased=unbiased,
+        keepdim=keepdim,
+    )