code: def test_LUdecomp():
      testmat = Matrix(
          [[0, 2, 5, 3], [3, 3, 7, 4], [8, 4, 0, 2], [-2, 6, 3, 4]]
      )
      L, U, p = testmat.LUdecomposition()
      assert L.is_lower
      assert U.is_upper
      assert (L * U).permute_rows(p, "backward") - testmat == zeros(4)
  
      testmat = Matrix(
          [[6, -2, 7, 4], [0, 3, 6, 7], [1, -2, 7, 4], [-9, 2, 6, 3]]
      )
      L, U, p = testmat.LUdecomposition()
      assert L.is_lower
      assert U.is_upper
      assert (L * U).permute_rows(p, "backward") - testmat == zeros(4)
  
      # non-square
      testmat = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
      L, U, p = testmat.LUdecomposition(rankcheck=False)
      assert L.is_lower
      assert U.is_upper
      assert (L * U).permute_rows(p, "backward") - testmat == zeros(
          4, 3
      )
  
      # square and singular
      testmat = Matrix([[1, 2, 3], [2, 4, 6], [4, 5, 6]])
      L, U, p = testmat.LUdecomposition(rankcheck=False)
      assert L.is_lower
      assert U.is_upper
      assert (L * U).permute_rows(p, "backward") - testmat == zeros(3)
  
      M = Matrix(((1, x, 1), (2, y, 0), (y, 0, z)))
      L, U, p = M.LUdecomposition()
      assert L.is_lower
      assert U.is_upper
      assert (L * U).permute_rows(p, "backward") - M == zeros(3)
  
      mL = Matrix(
          (
              (1, 0, 0),
              (2, 3, 0),
          )
      )
      assert mL.is_lower is True
      assert mL.is_upper is False
      mU = Matrix(
          (
              (1, 2, 3),
              (0, 4, 5),
          )
      )
      assert mU.is_lower is False
      assert mU.is_upper is True
  
      # test FF LUdecomp
      M = Matrix([[1, 3, 3], [3, 2, 6], [3, 2, 2]])
      P, L, Dee, U = M.LUdecompositionFF()
      assert P * M == L * Dee.inv() * U
  
      M = Matrix(
          [[1, 2, 3, 4], [3, -1, 2, 3], [3, 1, 3, -2], [6, -1, 0, 2]]
      )
      P, L, Dee, U = M.LUdecompositionFF()
      assert P * M == L * Dee.inv() * U
  
      M = Matrix([[0, 0, 1], [2, 3, 0], [3, 1, 4]])
      P, L, Dee, U = M.LUdecompositionFF()
      assert P * M == L * Dee.inv() * U
  
      # issue 15794
      M = Matrix([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
      raises(
          ValueError, lambda: M.LUdecomposition_Simple(rankcheck=True)
      )
  
imports: from sympy.core.function import expand_mul
  from sympy.core.numbers import I, Rational
  from sympy.core.singleton import S
  from sympy.core.symbol import Symbol
  from sympy.functions.elementary.miscellaneous import sqrt
  from sympy.functions.elementary.complexes import Abs
  from sympy.simplify.simplify import simplify
  from sympy.matrices.exceptions import NonSquareMatrixError
  from sympy.matrices import Matrix, zeros, eye, SparseMatrix
  from sympy.abc import x, y, z
  from sympy.testing.pytest import raises, slow
  from sympy.testing.matrices import allclose
label_desc: Use image node_id 1 for calling a global function with example usage: test_LUdecomp() without return types