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

Issue:
atleast_2d



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
@@ -331,3 +331,8 @@ def diff(input, n=1, dim=-1, prepend=None, append=None):
 @to_ivy_arrays_and_back
 def broadcast_shapes(*shapes):
     return ivy.broadcast_shapes(*shapes)
+
+
+@to_ivy_arrays_and_back
+def atleast_2d(*tensors):
+    return ivy.atleast_2d(*tensors)


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
@@ -1115,3 +1115,35 @@ def test_torch_broadcast_shapes(
         test_values=False,
     )
     assert ret == frontend_ret
+
+
+# atleast_2d
+@handle_frontend_test(
+    fn_tree="torch.atleast_2d",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        num_arrays=helpers.ints(min_value=1, max_value=10),
+    ),
+    test_with_out=st.just(False),
+)
+def test_torch_atleast_2d(
+    *,
+    dtype_and_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    input_dtype, arrays = dtype_and_x
+    arys = {}
+    for i, (array, idtype) in enumerate(zip(arrays, input_dtype)):
+        arys["arrs{}".format(i)] = array
+    test_flags.num_positional_args = len(arys)
+    helpers.test_frontend_function(
+        input_dtypes=input_dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        **arys,
+    )
Repository: ivy-llc/ivy

Issue:
einsum



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/tensorflow/linalg.py b/ivy/functional/frontends/tensorflow/linalg.py
--- a/ivy/functional/frontends/tensorflow/linalg.py
+++ b/ivy/functional/frontends/tensorflow/linalg.py
@@ -238,3 +238,8 @@ def lu_matrix_inverse(lower_upper, perm, validate_args=False, name=None):
     return ivy.lu_matrix_inverse(
         ivy.lu_reconstruct(lower_upper, perm), validate_args=validate_args, name=name
     )
+
+
+@to_ivy_arrays_and_back
+def einsum(equation, *inputs, **kwargs):
+    return tf_frontend.einsum(equation, *inputs, **kwargs)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_linalg.py
@@ -298,7 +298,8 @@ def test_tensorflow_logdet(
 @handle_frontend_test(
     fn_tree="tensorflow.linalg.slogdet",
     dtype_and_x=_get_dtype_and_matrix(),
-    test_with_out=st.just(False))
+    test_with_out=st.just(False),
+)
 def test_tensorflow_slogdet(
     *,
     dtype_and_x,
@@ -768,3 +769,43 @@ def test_tensorflow_svd(
         atol=1e-2,
         ground_truth_backend=frontend,
     )
+
+
+# einsum
+@handle_frontend_test(
+    fn_tree="tensorflow.linalg.einsum",
+    eq_n_op_n_shp=st.sampled_from(
+        [
+            ("ii", (np.arange(25).reshape(5, 5),), ()),
+            ("ii->i", (np.arange(25).reshape(5, 5),), (5,)),
+            ("ij,j", (np.arange(25).reshape(5, 5), np.arange(5)), (5,)),
+        ]
+    ),
+    dtype=helpers.get_dtypes("float", full=False),
+)
+def test_tensorflow_linalg_einsum(
+    *,
+    eq_n_op_n_shp,
+    dtype,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    eq, operands, _ = eq_n_op_n_shp
+    kw = {}
+    i = 0
+    for x_ in operands:
+        kw["x{}".format(i)] = x_
+        i += 1
+    # len(operands) + 1 because of the equation
+    test_flags.num_positional_args = len(operands) + 1
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        equation=eq,
+        **kw,
+    )
Repository: ivy-llc/ivy

Issue:
expm1



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/tensorflow/math.py b/ivy/functional/frontends/tensorflow/math.py
--- a/ivy/functional/frontends/tensorflow/math.py
+++ b/ivy/functional/frontends/tensorflow/math.py
@@ -34,6 +34,11 @@ def exp(x, name=None):
     return ivy.exp(x)
 
 
+@to_ivy_arrays_and_back
+def expm1(x, name=None):
+    return ivy.expm1(x)
+
+
 @to_ivy_arrays_and_back
 def sqrt(x, name=None):
     return ivy.sqrt(x)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_math.py
@@ -176,6 +176,31 @@ def test_tensorflow_exp(
     )
 
 
+# expm1
+@handle_frontend_test(
+    fn_tree="tensorflow.math.expm1",
+    dtype_and_x=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("float")),
+    test_with_out=st.just(False),
+)
+def test_tensorflow_expm1(
+    *,
+    dtype_and_x,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    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],
+    )
+
+
 # sqrt
 @handle_frontend_test(
     fn_tree="tensorflow.math.sqrt",
@@ -2104,6 +2129,7 @@ def test_tensorflow_floormod(
         on_device=on_device,
         x=x[0],
         y=x[1],
+
     )
Repository: ivy-llc/ivy

Issue:
searchsorted



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
@@ -336,3 +336,28 @@ def broadcast_shapes(*shapes):
 @to_ivy_arrays_and_back
 def atleast_2d(*tensors):
     return ivy.atleast_2d(*tensors)
+
+
+@to_ivy_arrays_and_back
+def searchsorted(
+    sorted_sequence,
+    values,
+    /,
+    *,
+    out_int32=False,
+    right=False,
+    side="left",
+    out=None,
+    sorter=None,
+):
+    if right and side == "left":
+        raise ivy.exceptions.IvyError(
+            "side and right can't be set to opposites,\
+            got side of left while right was True"
+        )
+    if right:
+        side = "right"
+    ret = ivy.searchsorted(sorted_sequence, values, side=side, out=out, sorter=sorter)
+    if out_int32:
+        ret = ivy.astype(ret, "int32")
+    return ret


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
@@ -1147,3 +1147,50 @@ def test_torch_atleast_2d(
         on_device=on_device,
         **arys,
     )
+
+
+@handle_frontend_test(
+    fn_tree="torch.searchsorted",
+    dtype_x_v=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        shared_dtype=True,
+        min_num_dims=1,
+        max_num_dims=1,
+        num_arrays=2,
+    ),
+    side=st.sampled_from(["left", "right"]),
+    out_int32=st.booleans(),
+    right=st.just(False),
+    test_with_out=st.just(False),
+)
+def test_torch_searchsorted(
+    dtype_x_v,
+    side,
+    out_int32,
+    right,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    input_dtypes, xs = dtype_x_v
+    use_sorter = st.booleans()
+    if use_sorter:
+        sorter = np.argsort(xs[0])
+        sorter = np.array(sorter, dtype=np.int64)
+    else:
+        xs[0] = np.sort(xs[0])
+        sorter = None
+    helpers.test_frontend_function(
+        input_dtypes=input_dtypes + ["int64"],
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        sorted_sequence=xs[0],
+        values=xs[1],
+        side=side,
+        out_int32=out_int32,
+        right=right,
+        sorter=sorter,
+    )
Repository: ivy-llc/ivy

Issue:
corrcoef



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/statistical.py b/ivy/functional/frontends/jax/numpy/statistical.py
--- a/ivy/functional/frontends/jax/numpy/statistical.py
+++ b/ivy/functional/frontends/jax/numpy/statistical.py
@@ -400,3 +400,8 @@ def std(a, axis=None, dtype=None, out=None, ddof=0, keepdims=False, *, where=Non
             where, std_a, ivy.default(out, ivy.zeros_like(std_a)), out=out
         )
     return ivy.astype(std_a, ivy.as_ivy_dtype(dtype), copy=False)
+
+
+@to_ivy_arrays_and_back
+def corrcoef(x, y=None, rowvar=True):
+    return ivy.corrcoef(x, y=y, rowvar=rowvar)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_statistical.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_statistical.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_statistical.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_statistical.py
@@ -729,3 +729,41 @@ def test_jax_numpy_std(
         atol=1e-3,
         rtol=1e-3,
     )
+
+
+@handle_frontend_test(
+    fn_tree="jax.numpy.corrcoef",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=["float32", "float64"],
+        num_arrays=2,
+        shared_dtype=True,
+        abs_smallest_val=1e-5,
+        min_num_dims=2,
+        max_num_dims=2,
+        min_dim_size=3,
+        max_dim_size=3,
+        min_value=-100,
+        max_value=100,
+        allow_nan=False,
+    ),
+    rowvar=st.booleans(),
+)
+def test_jax_numpy_corrcoef(
+    dtype_and_x,
+    rowvar,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    input_dtypes, x = dtype_and_x
+    np_helpers.test_frontend_function(
+        input_dtypes=input_dtypes,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x=x[0],
+        y=x[1],
+        rowvar=rowvar,
+    )
Repository: ivy-llc/ivy

Issue:
fliplr



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
@@ -651,6 +651,9 @@ def squeeze(self, dim):
     def flip(self, dims):
         return torch_frontend.flip(self._ivy_array, dims)
 
+    def fliplr(self):
+        return torch_frontend.fliplr(self._ivy_array)
+
     def sort(self, dim=-1, descending=False):
         return torch_frontend.sort(self._ivy_array, dim=dim, descending=descending)
 


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
@@ -4940,6 +4940,40 @@ def test_torch_instance_flip(
     )
 
 
+# fliplr
+@handle_frontend_method(
+    class_tree=CLASS_TREE,
+    init_tree="torch.tensor",
+    method_name="fliplr",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("float"),
+        min_num_dims=2,
+    ),
+)
+def test_torch_instance_fliplr(
+    dtype_and_x,
+    frontend_method_data,
+    init_flags,
+    method_flags,
+    frontend,
+    on_device,
+):
+    dtype, x = dtype_and_x
+    helpers.test_frontend_method(
+        init_input_dtypes=dtype,
+        init_all_as_kwargs_np={
+            "data": x[0],
+        },
+        method_input_dtypes=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,
+    )
+
+
 # tril
 @handle_frontend_method(
     class_tree=CLASS_TREE,
Repository: ivy-llc/ivy

Issue:
Slice



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
@@ -686,3 +686,6 @@ def DebugGradientIdentity(input, name="DebugGradientIdentity"):
 @to_ivy_arrays_and_back
 def Real(input, Tout=ivy.float32, name="Real"):
     return ivy.Real(input, Tout=Tout)
+
+
+Slice = to_ivy_arrays_and_back(map_raw_ops_alias(tf_frontend.slice))


Test patch:
Repository: ivy-llc/ivy

Issue:
Fix random.test_tensorflow_shuffle
|   |   |
|---|---|
|numpy|<a href="https://github.com/unifyai/ivy/actions/runs/5641192365/job/15278865591"><img src=https://img.shields.io/badge/-success-success></a>
|tensorflow|<a href="https://github.com/unifyai/ivy/actions/runs/5641192365/job/15278865591"><img src=https://img.shields.io/badge/-success-success></a>
|torch|<a href="https://github.com/unifyai/ivy/actions/runs/5641192365/job/15278865591"><img src=https://img.shields.io/badge/-success-success></a>
|jax|<a href="https://github.com/unifyai/ivy/actions/runs/5641192365/job/15278865591"><img src=https://img.shields.io/badge/-success-success></a>
|paddle|<a href="https://github.com/unifyai/ivy/actions/runs/5641192365/job/15278865591"><img src=https://img.shields.io/badge/-failure-red></a>



Discussion:

Resolving patch:
diff --git a/ivy/functional/backends/numpy/random.py b/ivy/functional/backends/numpy/random.py
--- a/ivy/functional/backends/numpy/random.py
+++ b/ivy/functional/backends/numpy/random.py
@@ -119,4 +119,6 @@ def shuffle(
 ) -> np.ndarray:
     if seed:
         np.random.seed(seed)
+    if len(x.shape) == 0:
+        return x
     return np.random.permutation(x)
diff --git a/ivy/functional/backends/torch/random.py b/ivy/functional/backends/torch/random.py
--- a/ivy/functional/backends/torch/random.py
+++ b/ivy/functional/backends/torch/random.py
@@ -126,6 +126,8 @@ def shuffle(
     seed: Optional[int] = None,
     out: Optional[torch.Tensor] = None,
 ) -> torch.Tensor:
+    if len(x.shape) == 0:
+        return x
     batch_size = x.shape[0]
     if seed:
         torch.manual_seed(seed)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_random.py b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_random.py
--- a/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_random.py
+++ b/ivy_tests/test_ivy/test_frontends/test_tensorflow/test_random.py
@@ -95,9 +95,7 @@ def test_tensorflow_normal(
 # random_shuffle
 @handle_frontend_test(
     fn_tree="tensorflow.random.shuffle",
-    dtype_value=helpers.dtype_and_values(
-        available_dtypes=helpers.get_dtypes("integer")
-    ),
+    dtype_value=helpers.dtype_and_values(available_dtypes=helpers.get_dtypes("valid")),
     seed=helpers.ints(min_value=0, max_value=10),
     test_with_out=st.just(False),
 )
@@ -109,7 +107,7 @@ def test_tensorflow_shuffle(
     seed,
     test_flags,
 ):
-    input_dtypes, value = dtype_value
+    input_dtypes, values = dtype_value
     helpers.test_frontend_function(
         input_dtypes=input_dtypes,
         frontend=frontend,
@@ -117,6 +115,6 @@ def test_tensorflow_shuffle(
         fn_tree=fn_tree,
         on_device=on_device,
         test_values=False,
-        value=value,
+        value=values[0],
         seed=seed,
     )
Repository: ivy-llc/ivy

Issue:
multi_dot



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/torch/linalg.py b/ivy/functional/frontends/torch/linalg.py
--- a/ivy/functional/frontends/torch/linalg.py
+++ b/ivy/functional/frontends/torch/linalg.py
@@ -236,3 +236,9 @@ def vander(x, N=None):
     output = ivy.reshape(output, (*original_shape, N))
     output = ivy.astype(output, x.dtype)
     return output
+
+
+@to_ivy_arrays_and_back
+@with_unsupported_dtypes({"1.11.0 and below": ("bfloat16", "float16")}, "torch")
+def multi_dot(tensors, *, out=None):
+    return ivy.multi_dot(tensors, out=out)


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
--- a/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
+++ b/ivy_tests/test_ivy/test_frontends/test_torch/test_linalg.py
@@ -1147,3 +1147,66 @@ def test_torch_vander(
         test_flags=test_flags,
         x=x[0], N=N
     )
+    
+    
+@st.composite
+def _generate_multi_dot_dtype_and_arrays(draw):
+    input_dtype = [draw(
+        st.sampled_from(draw(helpers.get_dtypes("numeric")))
+    )]
+    matrices_dims = draw(
+        st.lists(st.integers(min_value=2, max_value=10), min_size=4, max_size=4)
+    )
+    shape_1 = (matrices_dims[0], matrices_dims[1])
+    shape_2 = (matrices_dims[1], matrices_dims[2])
+    shape_3 = (matrices_dims[2], matrices_dims[3])
+
+    matrix_1 = draw(
+        helpers.dtype_and_values(
+            shape=shape_1,
+            dtype=input_dtype,
+            min_value=-10,
+            max_value=10,
+        )
+    )
+    matrix_2 = draw(
+        helpers.dtype_and_values(
+            shape=shape_2,
+            dtype=input_dtype,
+            min_value=-10,
+            max_value=10,
+        )
+    )
+    matrix_3 = draw(
+        helpers.dtype_and_values(
+            shape=shape_3,
+            dtype=input_dtype,
+            min_value=-10,
+            max_value=10,
+        )
+    )
+
+    return input_dtype, [matrix_1[1][0], matrix_2[1][0], matrix_3[1][0]]
+
+
+@handle_frontend_test(
+    fn_tree="torch.linalg.multi_dot",
+    dtype_x=_generate_multi_dot_dtype_and_arrays(),
+)
+def test_torch_multi_dot(
+    dtype_x,
+    on_device,
+    fn_tree,
+    frontend,
+    test_flags,
+):
+    dtype, x = dtype_x
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        test_flags=test_flags,
+        on_device=on_device,
+        frontend=frontend,
+        fn_tree=fn_tree,
+        test_values=True,
+        tensors=x,
+    )
Repository: ivy-llc/ivy

Issue:
real



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
@@ -534,3 +534,8 @@ def top_k(operand, k):
     values, indices = ivy.top_k(operand, k, axis=-1)
     indices = ivy.astype(indices, ivy.int32, copy=False)
     return [values, indices]
+
+
+@to_ivy_arrays_and_back
+def real(x):
+    return ivy.real(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
@@ -2307,3 +2307,30 @@ def test_jax_lax_top_k(
         k=k,
         # test_values=False,
     )
+
+
+# real
+@handle_frontend_test(
+    fn_tree="jax.lax.real",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("complex")
+    ),
+)
+def test_jax_lax_real(
+    *,
+    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,
+        test_values=True,
+        x=x[0],
+    )
Repository: ivy-llc/ivy

Issue:
isrealobj



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py
--- a/ivy/functional/frontends/jax/numpy/logic.py
+++ b/ivy/functional/frontends/jax/numpy/logic.py
@@ -194,3 +194,8 @@ def isreal(x, out=None):
 def logical_xor(x1, x2, /):
     x1, x2 = promote_jax_arrays(x1, x2)
     return ivy.logical_xor(x1, x2)
+
+
+@to_ivy_arrays_and_back
+def isrealobj(x: any):
+    return not ivy.is_complex_dtype(ivy.dtype(x))


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
@@ -853,3 +853,29 @@ def test_jax_numpy_logical_xor(
         x1=x[0],
         x2=x[1],
     )
+
+
+@handle_frontend_test(
+    fn_tree="jax.numpy.isrealobj",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"), min_num_dims=1
+    ),
+    test_with_out=st.just(False),
+)
+def test_jax_numpy_isrealobj(
+    dtype_and_x,
+    frontend,
+    on_device,
+    *,
+    fn_tree,
+    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:
right_shift



Discussion:

Resolving patch:
diff --git a/ivy/functional/frontends/jax/numpy/logic.py b/ivy/functional/frontends/jax/numpy/logic.py
--- a/ivy/functional/frontends/jax/numpy/logic.py
+++ b/ivy/functional/frontends/jax/numpy/logic.py
@@ -196,6 +196,12 @@ def logical_xor(x1, x2, /):
     return ivy.logical_xor(x1, x2)
 
 
+@to_ivy_arrays_and_back
+def right_shift(x1, x2, /):
+    return ivy.bitwise_right_shift(x1, x2)
+
+
 @to_ivy_arrays_and_back
 def isrealobj(x: any):
     return not ivy.is_complex_dtype(ivy.dtype(x))
+


Test patch:
diff --git a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
--- a/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
+++ b/ivy_tests/test_ivy/test_frontends/test_jax/test_jax_numpy_logic.py
@@ -855,6 +855,38 @@ def test_jax_numpy_logical_xor(
     )
 
 
+@handle_frontend_test(
+    fn_tree="jax.numpy.right_shift",
+    dtype_and_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("integer"),
+        num_arrays=2,
+        shared_dtype=True,
+    ),
+    test_with_out=st.just(False),
+)
+def test_jax_numpy_right_shift(
+    *,
+    dtype_and_x,
+    frontend,
+    test_flags,
+    fn_tree,
+    on_device,
+):
+    dtype, xs = dtype_and_x
+
+    xs[1] = np.asarray(np.clip(xs[1], 0, np.iinfo(dtype[1]).bits - 1), dtype=dtype[1])
+
+    helpers.test_frontend_function(
+        input_dtypes=dtype,
+        frontend=frontend,
+        test_flags=test_flags,
+        fn_tree=fn_tree,
+        on_device=on_device,
+        x1=xs[0],
+        x2=xs[1],
+    )
+
+
 @handle_frontend_test(
     fn_tree="jax.numpy.isrealobj",
     dtype_and_x=helpers.dtype_and_values(