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

Issue:
signbit
- [ ] signbit
atleast_2d



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/paddle/experimental/elementwise.py b/ivy/functional/backends/paddle/experimental/elementwise.py
--- a/ivy/functional/backends/paddle/experimental/elementwise.py
+++ b/ivy/functional/backends/paddle/experimental/elementwise.py
@@ -282,13 +282,17 @@ def diff(
     return paddle.diff(x, n=n, axis=axis, prepend=prepend, append=append)
 
 
+@with_unsupported_device_and_dtypes(
+    {"2.4.2 and below": {"cpu": ("uint16", "bfloat16")}}, backend_version
+)
 def signbit(
     x: Union[paddle.Tensor, float, int, list, tuple],
     /,
     *,
     out: Optional[paddle.Tensor] = None,
 ) -> paddle.Tensor:
-    raise IvyNotImplementedException()
+    with ivy.ArrayMode(False):
+        return ivy.less_equal(x, 0)
 
 
 def hypot(


Test patch:
Repository: ivy-llc/ivy

Issue:
double



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/creation.py b/ivy/functional/frontends/jax/numpy/creation.py
--- a/ivy/functional/frontends/jax/numpy/creation.py
+++ b/ivy/functional/frontends/jax/numpy/creation.py
@@ -186,6 +186,11 @@ def single(x):
     return ivy.astype(x, ivy.float32)
 
 
+@to_ivy_arrays_and_back
+def double(x):
+    return ivy.astype(x, ivy.float64)
+
+
 @to_ivy_arrays_and_back
 def geomspace(start, stop, num=50, endpoint=True, dtype=None, axis=0):
     cr = ivy.log(stop / start) / (num - 1 if endpoint else num)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_creation.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_creation.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_creation.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_creation.py
@@ -757,6 +757,29 @@ def test_jax_numpy_single(
     )
 
 
+# double
+@handle_frontend_test(
+    fn_tree="jax.numpy.double",
+    dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
+)
+def test_jax_numpy_double(
+    dtype_and_x,
+    test_flags,
+    frontend,
+    fn_tree,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )
+
+
 @handle_frontend_test(
     fn_tree="jax.numpy.geomspace",
     dtype_start_stop=_get_dtype_and_range(),
Repository: ivy-llc/ivy

Issue:
meshgrid



Discussion:

Resolving patch:
diff --git a/ivy/functional/ivy/creation.py b/ivy/functional/ivy/creation.py
--- a/ivy/functional/ivy/creation.py
+++ b/ivy/functional/ivy/creation.py
@@ -1302,6 +1302,7 @@ def meshgrid(
     *arrays: Union[ivy.Array, ivy.NativeArray],
     sparse: bool = False,
     indexing: str = "xy",
+    out: Optional(ivy.Array) = None
 ) -> List[ivy.Array]:
     """Returns coordinate matrices from coordinate vectors.
 
@@ -1404,7 +1405,9 @@ def meshgrid(
             [4, 4]])
 
     """
-    return current_backend().meshgrid(*arrays, sparse=sparse, indexing=indexing)
+    return current_backend().meshgrid(
+        *arrays, sparse=sparse, indexing=indexing, out=out
+    )
 
 
 @infer_device


Test patch:
Repository: ivy-llc/ivy

Issue:
take



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
@@ -335,3 +335,9 @@ def index_copy(input, dim, index, source, *, out=None):
 @to_ivy_arrays_and_back
 def masked_select(input, mask, out=None):
     return ivy.flatten(input[mask], out=out)
+  
+  
+@to_ivy_arrays_and_back
+def take(input, index):
+    input = ivy.reshape(input, (-1,))
+    return ivy.gather(input, index, axis=0)  
\ No newline at end of file


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
@@ -1383,3 +1383,29 @@ def test_torch_masked_select(
         input=x[0],
         mask=mask,
     )
+    
+    
+@handle_frontend_test(
+    fn_tree="torch.take",
+    dtype_and_x=helpers.array_indices_axis(
+        array_dtypes=helpers.get_dtypes(), indices_dtypes=["int64"]
+    ),
+)
+def test_torch_take(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    dtypes, xs, indices, _, _ = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=xs,
+        index=indices,
+    )    
\ No newline at end of file
Repository: ivy-llc/ivy

Issue:
unique



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/reduction_ops.py b/ivy/functional/frontends/torch/reduction_ops.py
--- a/ivy/functional/frontends/torch/reduction_ops.py
+++ b/ivy/functional/frontends/torch/reduction_ops.py
@@ -230,3 +230,24 @@ def logsumexp(input, dim, keepdim=False, *, out=None):
         c = ivy.squeeze(c, axis=dim)
     ret = ivy.add(ret, c, out=out)
     return ret
+
+
+@to_ivy_arrays_and_back
+def unique(input, sorted=True, return_inverse=False, return_counts=False, dim=None):
+    results = ivy.unique_all(input, axis=dim)
+
+    fields = ["values"]
+    if return_inverse:
+        fields.append("inverse_indices")
+    if return_counts:
+        fields.append("counts")
+
+    Results = namedtuple("Results", fields)
+
+    values = [results.values]
+    if return_inverse:
+        values.append(results.inverse_indices)
+    if return_counts:
+        values.append(results.counts)
+
+    return Results(*values)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_reduction_ops.py
@@ -797,3 +797,40 @@ def test_torch_logsumexp(
         dim=axis,
         keepdim=keepdims,
     )
+
+
+@handle_frontend_test(
+    fn_tree="torch.unique",
+    dtype_x_axis=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("numeric"),
+        force_int_axis=True,
+        valid_axis=True,
+    ),
+    return_inverse=st.booleans(),
+    return_counts=st.booleans(),
+    test_with_out=st.just(False),
+)
+def test_torch_unique(
+    *,
+    dtype_x_axis,
+    return_inverse,
+    return_counts,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtypes, x, axis = dtype_x_axis
+    
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        input=x[0],
+        sorted=True,
+        return_inverse=return_inverse,
+        return_counts=return_counts,
+        dim=axis,
+    )
Repository: ivy-llc/ivy

Issue:
searchsorted



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/searching_sorting.py b/ivy/functional/frontends/jax/numpy/searching_sorting.py
--- a/ivy/functional/frontends/jax/numpy/searching_sorting.py
+++ b/ivy/functional/frontends/jax/numpy/searching_sorting.py
@@ -153,6 +153,10 @@ def sort_complex(a):
 
 
 @to_ivy_arrays_and_back
+def searchsorted(a, v, side='left', sorter=None, *, method='scan'):
+    return ivy.searchsorted(a, v, side=side, sorter=sorter, ret_dtype='int32')
+
+
 def where(condition, x=None, y=None, size=None, fill_value=0):
     if x is not None and y is not None:
         return ivy.where(condition, x, y)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/.ivy/key.pem b/ivy_tests/test_ivy/test_frontends/test_jax/.ivy/key.pem
new file mode 100644
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_searching_sorting.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_searching_sorting.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_searching_sorting.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_searching_sorting.py
@@ -1,6 +1,6 @@
 # global
 from hypothesis import strategies as st
-
+import numpy as np
 # local
 import ivy_tests.test_ivy.helpers as helpers
 from ivy_tests.test_ivy.helpers import handle_frontend_test
@@ -339,6 +339,60 @@ def test_jax_numpy_sort_complex(
     )
 
 
+# searchsorted
+@st.composite
+def _searchsorted(draw):
+    dtype_x, x = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes(
+                "numeric", full=False, key="searchsorted"
+            ),
+            shape=(draw(st.integers(min_value=1, max_value=10)),),
+        ),
+    )
+    dtype_v, v = draw(
+        helpers.dtype_and_values(
+            available_dtypes=helpers.get_dtypes(
+                "numeric", full=False, key="searchsorted"
+            ),
+            min_num_dims=1,
+        )
+    )
+
+    input_dtypes = dtype_x + dtype_v
+    xs = x + v
+    side = draw(st.sampled_from(["left", "right"]))
+    sorter = None
+    xs[0] = np.sort(xs[0], axis=-1)
+    return input_dtypes, xs, side, sorter
+
+
+@handle_frontend_test(
+    fn_tree="jax.numpy.searchsorted",
+    dtype_x_v_side_sorter=_searchsorted(),
+    test_with_out=st.just(False),
+)
+def test_numpy_searchsorted(
+    dtype_x_v_side_sorter,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    input_dtypes, xs, side, sorter = dtype_x_v_side_sorter
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        a=xs[0],
+        v=xs[1],
+        side=side,
+        sorter=sorter,
+    )
+
+
 # where
 @handle_frontend_test(
     fn_tree="jax.numpy.where",
Repository: ivy-llc/ivy

Issue:
rfft



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
@@ -56,3 +56,12 @@ def fftshift(x, axes=None):
     roll = ivy.roll(x, shift, axis=axes)
 
     return roll
+
+
+@with_unsupported_dtypes({"1.9.0 and below": ("float16",)}, "torch")
+@to_ivy_arrays_and_back
+def rfft(a, n=None, axis=-1, norm=None):
+    if norm is None:
+        norm = "backward"
+    a = ivy.array(a, dtype=ivy.float64)
+    return ivy.dft(a, axis=axis, inverse=False, onesided=True, dft_length=n, norm=norm)


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
@@ -90,3 +90,32 @@ def test_numpy_fttshift(dtype_and_x, frontend, test_flags, fn_tree, on_device):
         x=arr[0],
         axes=None,
     )
+
+
+@handle_frontend_test(
+    fn_tree="numpy.fft.rfft",
+    dtype_input_axis=helpers.dtype_values_axis(
+        available_dtypes=helpers.get_dtypes("float_and_complex"),
+        shape=(2,),
+        min_axis=-1,
+        force_int_axis=True,
+    ),
+    norm=st.sampled_from(["backward", "ortho", "forward"]),
+    n=st.integers(min_value=2, max_value=5),
+)
+def test_numpy_rfft(
+    dtype_input_axis, norm, n, frontend, test_flags, fn_tree, on_device
+):
+    input_dtype, x, axis = dtype_input_axis
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        test_values=True,
+        a=x[0],
+        n=n,
+        axis=axis,
+        norm=norm,
+    )
Repository: ivy-llc/ivy

Issue:
exp
- [ ] #761 


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
@@ -1832,7 +1832,7 @@ def equal(
 @handle_nestable
 @handle_exceptions
 def exp(
-    x: Union[ivy.Array, ivy.NativeArray],
+    x: Union[ivy.Array, ivy.NativeArray, Number],
     /,
     *,
     out: Optional[ivy.Array] = None,
@@ -1867,13 +1867,57 @@ def exp(
         in ``x``. The returned array must have a floating-point data type determined by
         :ref:`type-promotion`.
 
+    This method conforms to the
+    `Array API Standard <https://data-apis.org/array-api/latest/>`_.
+    This docstring is an extension of the
+    `docstring <https://data-apis.org/array-api/latest/API_specification/generated/signatures.elementwise_functions.exp.html>`_  # noqa
+    in the standard.
+
+    Both the description and the type hints above assumes an array input for simplicity,
+    but this function is *nestable*, and therefore also accepts :class:`ivy.Container`
+    instances in place of any of the arguments.
+
     Examples
     --------
+    With :class:Number:
+
+    >>> x = 3
+    >>> y = ivy.exp(x)
+    >>> print(y)
+    ivy.array(20.08553692)
+
+    With :class:`ivy.Array` input:
+
     >>> x = ivy.array([1., 2., 3.])
     >>> y = ivy.exp(x)
     >>> print(y)
-    ivy.array([2.72,7.39,20.1])
+    ivy.array([ 2.71828175,  7.38905621, 20.08553696])
+
+    With nested inputs in :class:`ivy.Array`:
+
+    >>> x = ivy.array([[-5.67], [ivy.nan], [0.567]])
+    >>> y = ivy.exp(x)
+    >>> print(y)
+    ivy.array([[0.00344786],
+           [       nan],
+           [1.76297021]])
+
+    With :class:`ivy.NativeArray` input:
 
+    >>> x = ivy.native_array([0., 4., 2.])
+    >>> y = ivy.exp(x)
+    >>> print(y)
+    ivy.array([ 1.        , 54.59814835,  7.38905621])
+
+    With :class:`ivy.Container` input:
+
+    >>> x = ivy.Container(a=3.1, b=ivy.array([3.2, 1.]))
+    >>> y = ivy.exp(x)
+    >>> print(y)
+    {
+        a: ivy.array(22.197948),
+        b: ivy.array([24.53253174, 2.71828175])
+    }
     """
     return ivy.current_backend(x).exp(x, out=out)
 


Test patch:
Repository: ivy-llc/ivy

Issue:
imag



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
@@ -49,6 +49,10 @@ def dtype(self):
     def shape(self):
         return self.ivy_array.shape
 
+    @property
+    def imag(self):
+        return self.ivy_array.imag()
+
     # Setters #
     # --------#
 


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
@@ -114,6 +114,20 @@ def test_torch_tensor_property_shape(dtype_x):
     ivy.utils.assertions.check_equal(x.ivy_array.shape, ivy.Shape(shape))
 
 
+@given(
+    dtype_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("complex", prune_function=False)
+    ),
+)
+def test_torch_tensor_property_imag(
+    dtype_x,
+):
+    _, data = dtype_x
+    x = Tensor(data[0])
+    x.ivy_array = data[0]
+    ivy.utils.assertions.check_equal(x.imag, ivy.imag(data[0]))
+
+
 # chunk
 @pytest.mark.skip("Testing takes a lot of time")
 @handle_frontend_method(
Repository: ivy-llc/ivy

Issue:
gumbel



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
@@ -89,3 +89,26 @@ def poisson(key, lam, shape=None, dtype=None):
 def gamma(key, a, shape=None, dtype="float64"):
     seed = _get_seed(key)
     return ivy.gamma(a, 1.0, shape=shape, dtype=dtype, seed=seed)
+
+
+@handle_jax_dtype
+@to_ivy_arrays_and_back
+@with_unsupported_dtypes(
+    {
+        "0.3.14 and below": (
+            "float16",
+            "bfloat16",
+        )
+    },
+    "jax",
+)
+def gumbel(key, shape=(), dtype="float64"):
+    seed = _get_seed(key)
+    uniform_x = ivy.random_uniform(
+        low=0.0,
+        high=1.0,
+        shape=shape,
+        dtype=dtype,
+        seed=seed,
+    )
+    return -ivy.log(-ivy.log(uniform_x))


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
@@ -1,4 +1,5 @@
 # global
+import pytest
 from hypothesis import strategies as st
 import ivy
 
@@ -388,3 +389,59 @@ def call():
     for (u, v) in zip(ret_np, ret_from_np):
         assert u.dtype == v.dtype
         assert u.shape == v.shape
+
+
+# TODO Update the test by fixing the uint32 unsupported problem
+@pytest.mark.xfail
+@handle_frontend_test(
+    fn_tree="jax.random.gumbel",
+    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(
+        min_dim_size=1, max_num_dims=6, max_dim_size=6, min_num_dims=1, allow_none=False
+    ),
+    dtype=helpers.get_dtypes("float", full=False),
+)
+def test_jax_gumbel(
+    *,
+    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:
t



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
@@ -112,3 +112,22 @@ def gumbel(key, shape=(), dtype="float64"):
         seed=seed,
     )
     return -ivy.log(-ivy.log(uniform_x))
+
+
+@handle_jax_dtype
+@to_ivy_arrays_and_back
+@with_unsupported_dtypes(
+    {
+        "0.3.14 and below": (
+            "float16",
+            "bfloat16",
+        )
+    },
+    "jax",
+)
+def t(key, df, shape=(), dtype="float64"):
+    seed = _get_seed(key)
+    n = ivy.random_normal(shape=shape, dtype=dtype, seed=seed)
+    half_df = df / 2.0
+    g = ivy.gamma(half_df, 1.0, shape=shape, dtype=dtype, seed=seed)
+    return n * ivy.sqrt(ivy.divide(half_df, g))


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_random.py
@@ -445,3 +445,63 @@ def call():
     for (u, v) in zip(ret_np, ret_from_np):
         assert u.dtype == v.dtype
         assert u.shape == v.shape
+
+
+# TODO Update the test by fixing the uint32 unsupported problem
+@pytest.mark.xfail
+@handle_frontend_test(
+    fn_tree="jax.random.t",
+    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,
+    ),
+    df=st.floats(min_value=0, max_value=5, exclude_min=True),
+    shape=helpers.get_shape(
+        min_num_dims=1, max_num_dims=6, min_dim_size=1, max_dim_size=6
+    ),
+    dtype=helpers.get_dtypes("float", full=False),
+    test_with_out=st.just(False),
+)
+def test_jax_t(
+    *,
+    dtype_key,
+    df,
+    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],
+            df=df,
+            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:
conj



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/lax/operators.py b/ivy/functional/frontends/jax/lax/operators.py
--- a/ivy/functional/frontends/jax/lax/operators.py
+++ b/ivy/functional/frontends/jax/lax/operators.py
@@ -620,3 +620,8 @@ def real(x):
 @to_ivy_arrays_and_back
 def nextafter(x1, x2):
     return ivy.nextafter(x1, x2)
+
+
+@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_jax_lax_operators.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_lax_operators.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_lax_operators.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_lax_operators.py
@@ -2553,3 +2553,29 @@ def test_jax_lax_nextafter(
         x1=x[0],
         x2=x[0],
     )
+
+
+# conj
+@handle_frontend_test(
+    fn_tree="jax.lax.conj",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=["complex64"],
+    ),
+)
+def test_jax_lax_conj(
+    *,
+    dtype_and_x,
+    test_flags,
+    on_device,
+    fn_tree,
+    frontend,
+):
+    input_dtype, x = dtype_and_x
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        test_flags=test_flags,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+    )