lu

ivy/data_classes/array/experimental/linear_algebra.py

@@ -110,6 +110,29 @@ def diagflat(
             out=out,
         )
 
+    def lu(
+        self: ivy.Array,
+        /,
+        *,
+        out: Optional[ivy.Array] = None,
+    ) -> ivy.Array:
+        """ivy.Array instance method variant of ivy.lu. This method simply
+        wraps the function, and so the docstring for ivy.lu also applies to
+        this method with minimal changes.
+
+        Examples
+        --------
+               >>> x = ivy.array([[1.0,2.0],[3.0,4.0]])
+               >>> ivy.lu(x)
+               ivy.array([[0., 1.],
+               [1., 0.]]),
+        ivy.array([[1.        , 0.        ],
+               [0.33333334, 1.        ]]),
+        ivy.array([[3.        , 4.        ],
+               [0.        , 0.66666663]])
+        """
+        return ivy.lu(self._data, out=out)
+
     def kron(
         self: ivy.Array,
         b: ivy.Array,

ivy/data_classes/container/experimental/linear_algebra.py

@@ -349,6 +349,54 @@ def kron(
             out=out,
         )
 
+    @staticmethod
+    def static_lu(
+        x: Union[ivy.Array, ivy.NativeArray, ivy.Container],
+        /,
+        *,
+        key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
+        to_apply: Union[bool, ivy.Container] = True,
+        out: Optional[ivy.Container] = None,
+    ) -> ivy.Container:
+        return ContainerBase.cont_multi_map_in_function(
+            "lu",
+            x,
+            out=out,
+            key_chains=key_chains,
+            to_apply=to_apply,
+        )
+
+    def lu(
+        self: ivy.Container,
+        /,
+        *,
+        key_chains: Optional[Union[List[str], Dict[str, str], ivy.Container]] = None,
+        to_apply: Union[bool, ivy.Container] = True,
+        out: Optional[ivy.Container] = None,
+    ) -> ivy.Container:
+        """ivy.Container instance method variant of ivy.diagflat. This method
+        simply wraps the function, and so the docstring for ivy.diagflat also
+        applies to this method with minimal changes.
+
+        Examples
+        --------
+        >>> x = ivy.array([[[1., 0.],
+                            [0., 1.]],
+                            [[2., 0.],
+                            [0., 2.]]])
+        >>> ivy.matrix_exp(x)
+        ivy.array([[[2.7183, 1.0000],
+                    [1.0000, 2.7183]],
+                    [[7.3891, 1.0000],
+                    [1.0000, 7.3891]]])
+        """
+        return self.static_lu(
+            self,
+            key_chains=key_chains,
+            to_apply=to_apply,
+            out=out,
+        )
+
     @staticmethod
     def static_matrix_exp(
         x: Union[ivy.Array, ivy.NativeArray, ivy.Container],

ivy/functional/backends/jax/experimental/linear_algebra.py

@@ -13,6 +13,15 @@
 from . import backend_version
 
 
+def lu(
+    x: JaxArray,
+    /,
+    *,
+    out: Optional[JaxArray] = None,
+) -> JaxArray:
+    return jla.lu(x)
+
+
 def diagflat(
     x: JaxArray,
     /,

ivy/functional/backends/mxnet/experimental/linear_algebra.py

@@ -49,6 +49,15 @@ def kron(
     raise IvyNotImplementedException()
 
 
+def lu(
+    x: Union[(None, mx.ndarray.NDArray)],
+    /,
+    *,
+    out: Optional[Union[(None, mx.ndarray.NDArray)]] = None,
+) -> Union[(None, mx.ndarray.NDArray)]:
+    raise IvyNotImplementedException()
+
+
 def matrix_exp(
     x: Union[(None, mx.ndarray.NDArray)],
     /,

ivy/functional/backends/numpy/experimental/linear_algebra.py

@@ -1,6 +1,7 @@
 import math
 from typing import Optional, Tuple, Sequence, Union, Any
 import numpy as np
+import scipy.linalg as sla
 
 import ivy
 from ivy.func_wrapper import with_supported_dtypes, with_unsupported_dtypes
@@ -10,6 +11,15 @@
 from ivy.functional.ivy.experimental.linear_algebra import _check_valid_dimension_size
 
 
+def lu(
+    x: np.ndarray,
+    /,
+    *,
+    out: Optional[np.ndarray] = None,
+) -> np.ndarray:
+    return sla.lu(x)
+
+
 def diagflat(
     x: np.ndarray,
     /,

ivy/functional/backends/paddle/experimental/linear_algebra.py

@@ -59,6 +59,16 @@ def kron(
     return paddle.kron(a, b)
 
 
+def lu(
+    x: paddle.Tensor,
+    /,
+    *,
+    out: Optional[paddle.Tensor] = None,
+) -> paddle.Tensor:
+    # return paddle.lu(x)
+    raise IvyNotImplementedException()
+
+
 def matrix_exp(
     x: paddle.Tensor,
     /,

ivy/functional/backends/tensorflow/experimental/linear_algebra.py

@@ -75,6 +75,15 @@ def diagflat(
     return ret
 
 
+def lu(
+    x: Union[tf.Tensor, tf.Variable],
+    /,
+    *,
+    out: Optional[Union[tf.Tensor, tf.Variable]] = None,
+) -> Union[tf.Tensor, tf.Variable]:
+    return tf.linalg.lu(x)
+
+
 def kron(
     a: Union[tf.Tensor, tf.Variable],
     b: Union[tf.Tensor, tf.Variable],

ivy/functional/backends/torch/experimental/linear_algebra.py

@@ -100,6 +100,15 @@ def diagflat(
 diagflat.support_native_out = False
 
 
+def lu(
+    x: torch.Tensor,
+    /,
+    *,
+    out: Optional[torch.Tensor] = None,
+) -> torch.tensor:
+    return torch.linalg.lu(x)
+
+
 def kron(
     a: torch.Tensor,
     b: torch.Tensor,

ivy/functional/ivy/experimental/linear_algebra.py

@@ -228,6 +228,33 @@ def diagflat(
     )
 
 
+@handle_exceptions
+@handle_backend_invalid
+@handle_nestable
+@handle_array_like_without_promotion
+@handle_out_argument
+@to_native_arrays_and_back
+@handle_device
+def lu(
+    x: Union[ivy.Array, ivy.NativeArray],
+    /,
+    *,
+    out: Optional[ivy.Array] = None,
+) -> ivy.Array:
+    """Perform LU decomposition of a square matrix using Doolittle's method.
+
+    Args:
+    ----
+    - x: a square numpy array representing the input matrix
+
+    Returns:
+    -------
+    - L: Lower triangular matrix
+    - U: Upper triangular matrix
+    """
+    return current_backend(x).lu(x, out=out)
+
+
 @handle_exceptions
 @handle_backend_invalid
 @handle_nestable

ivy_tests/test_ivy/test_functional/test_experimental/test_core/test_linalg.py

@@ -1380,6 +1380,33 @@ def test_kronecker(*, data, test_flags, backend_fw, fn_name, on_device):
     )
 
 
+@handle_test(
+    fn_tree="functional.ivy.experimental.lu",
+    dtype_x=helpers.dtype_and_values(
+        available_dtypes=helpers.get_dtypes("valid"),
+        min_num_dims=2,
+        max_num_dims=2,
+        min_dim_size=2,
+        max_dim_size=2,
+        min_value=-100,
+        max_value=100,
+        allow_nan=False,
+        shared_dtype=True,
+    ),
+    test_gradients=st.just(False),
+)
+def test_lu(dtype_x, test_flags, backend_fw, fn_name, on_device):
+    dtype, x = dtype_x
+    helpers.test_function(
+        input_dtypes=dtype,
+        test_flags=test_flags,
+        on_device=on_device,
+        backend_to_test=backend_fw,
+        fn_name=fn_name,
+        x=x[0],
+    )
+
+
 @handle_test(
     fn_tree="functional.ivy.experimental.make_svd_non_negative",
     data=_make_svd_nn_data(),