lufact

``````..  lufact(A [,pivot=Val{true}]) -> F

Compute the LU factorization of ``A``. The return type of ``F`` depends on the type of ``A``. In most cases, if ``A`` is a subtype ``S`` of AbstractMatrix with an element type ``T`` supporting ``+``, ``-``, ``*`` and ``/`` the return type is ``LU{T,S{T}}``. If pivoting is chosen (default) the element type should also support ``abs`` and ``<``. When ``A`` is sparse and have element of type ``Float32``, ``Float64``, ``Complex{Float32}``, or ``Complex{Float64}`` the return type is ``UmfpackLU``. Some examples are shown in the table below.

======================= ========================= ========================================
Type of input ``A``     Type of output ``F``      Relationship between ``F`` and ``A``
======================= ========================= ========================================
:func:`Matrix`           ``LU``                   ``F[:L]*F[:U] == A[F[:p], :]``
:func:`Tridiagonal`      ``LU{T,Tridiagonal{T}}`` ``F[:L]*F[:U] == A[F[:p], :]``
:func:`SparseMatrixCSC`  ``UmfpackLU``            ``F[:L]*F[:U] == (F[:Rs] .* A)[F[:p], F[:q]]``
======================= ========================= ========================================

The individual components of the factorization ``F`` can be accessed by indexing:

=========== ======================================= ====== ======================== =============
Component   Description                             ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
=========== ======================================= ====== ======================== =============
``F[:L]``   ``L`` (lower triangular) part of ``LU``    âœ“            âœ“                        âœ“
``F[:U]``   ``U`` (upper triangular) part of ``LU``    âœ“            âœ“                        âœ“
``F[:p]``   (right) permutation ``Vector``             âœ“            âœ“                        âœ“
``F[:P]``   (right) permutation ``Matrix``             âœ“            âœ“
``F[:q]``   left permutation ``Vector``                                                      âœ“
``F[:Rs]``  ``Vector`` of scaling factors                                                    âœ“
``F[:(:)]`` ``(L,U,p,q,Rs)`` components                                                      âœ“
=========== ======================================= ====== ======================== =============

================== ====== ======================== =============
Supported function ``LU`` ``LU{T,Tridiagonal{T}}`` ``UmfpackLU``
================== ====== ======================== =============
``/``            âœ“
``\``            âœ“                       âœ“             âœ“
``cond``         âœ“                                     âœ“
``det``          âœ“                       âœ“             âœ“
``logdet``       âœ“                       âœ“
``logabsdet``    âœ“                       âœ“
``size``         âœ“                       âœ“
================== ====== ======================== =============``````

Examples

The `lufact` function in Julia computes the LU factorization of a given matrix `A`. The return type of `F` depends on the type of `A`. Here are some examples of its usage:

1. LU factorization of a matrix:

``````julia> A = [1 2; 3 4];
julia> F = lufact(A);``````

In this example, the LU factorization of the matrix `A` is computed, and the result is stored in `F`.

2. LU factorization of a tridiagonal matrix:

``````julia> T = Tridiagonal([1, 2, 3], [4, 5, 6], [7, 8, 9]);
julia> F = lufact(T);``````

Here, the LU factorization of a tridiagonal matrix `T` is computed.

3. LU factorization of a sparse matrix:
``````julia> using SparseArrays
julia> S = sprand(5, 5, 0.5);
julia> F = lufact(S);``````

In this example, the LU factorization of a sparse matrix `S` is computed using the UMFPACK library.

You can access the individual components of the factorization `F` using indexing. Here are some examples:

• Accessing the lower triangular part:

``julia> F[:L]``
• Accessing the upper triangular part:

``julia> F[:U]``
• Accessing the permutation vector `p`:

``julia> F[:p]``
• Accessing the left permutation vector `q` (only applicable for `UmfpackLU`):

``julia> F[:q]``
• Accessing the scaling factors `Rs` (only applicable for `UmfpackLU`):
``julia> F[:Rs]``

Note that the availability of these components depends on the type of `F`.

Supported operations and functions for the different factorization types are as follows:

• Division: `F / b`
• Conditioning: `cond(F)`
• Determinant: `det(F)`
• Log-determinant: `logdet(F)`
• Log-absolute-determinant: `logabsdet(F)`
• Size: `size(F)`

Please note that the specific functionality may vary depending on the factorization type.

That covers the basic usage and components of the `lufact` function in Julia.