LUDecompositionQuick (Colt 1.2.0 - API Specification)
Keywords: cern.colt.matrix.linalg.LUDecompositionQuick class

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Colt 1.2.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## cern.colt.matrix.linalg
Class LUDecompositionQuick

    java.lang.Object
      cern.colt.matrix.linalg.LUDecompositionQuick

All Implemented Interfaces:
  Serializable

public class LUDecompositionQuick
extends Object
implements Serializable

A low level version of `LUDecomposition`, avoiding unnecessary memory allocation and copying. The input to `decompose` methods is overriden with the result (LU). The input to `solve` methods is overriden with the result (X). In addition to `LUDecomposition`, this class also includes a faster variant of the decomposition, specialized for tridiagonal (and hence also diagonal) matrices, as well as a solver tuned for vectors. Its disadvantage is that it is a bit more difficult to use than `LUDecomposition`. Thus, you may want to disregard this class and come back later, if a need for speed arises.

An instance of this class remembers the result of its last decomposition. Usage pattern is as follows: Create an instance of this class, call a decompose method, then retrieve the decompositions, determinant, and/or solve as many equation problems as needed. Once another matrix needs to be LU-decomposed, you need not create a new instance of this class. Start again by calling a decompose method, then retrieve the decomposition and/or solve your equations, and so on. In case a `LU` matrix is already available, call method `setLU` instead of `decompose` and proceed with solving et al.

If a matrix shall not be overriden, use `matrix.copy()` and hand the the copy to methods.

For an `m x n` matrix `A` with `m >= n`, the LU decomposition is an `m x n` unit lower triangular matrix `L`, an `n x n` upper triangular matrix `U`, and a permutation vector `piv` of length `m` so that `A(piv,:) = L*U`; If `m < n`, then `L` is `m x m` and `U` is `m x n`.

The LU decomposition with pivoting always exists, even if the matrix is singular, so the decompose methods will never fail. The primary use of the LU decomposition is in the solution of square systems of simultaneous linear equations. Attempting to solve such a system will throw an exception if `isNonsingular()` returns false.

See Also:
  Serialized Form

Constructor Summary
`LUDecompositionQuick()` Constructs and returns a new LU Decomposition object with default tolerance `1.0E-9` for singularity detection.
`LUDecompositionQuick(double tolerance)` Constructs and returns a new LU Decomposition object which uses the given tolerance for singularity detection;

Method Summary
`void` | `decompose(DoubleMatrix2D A)` Decomposes matrix `A` into `L` and `U` (in-place).
`void` | `decompose(DoubleMatrix2D A, int semiBandwidth)` Decomposes the banded and square matrix `A` into `L` and `U` (in-place).
`double` | `det()` Returns the determinant, `det(A)`.
`DoubleMatrix2D` | `getL()` Returns the lower triangular factor, `L`.
`DoubleMatrix2D` | `getLU()` Returns a copy of the combined lower and upper triangular factor, `LU`.
`int[]` | `getPivot()` Returns the pivot permutation vector (not a copy of it).
`DoubleMatrix2D` | `getU()` Returns the upper triangular factor, `U`.
`boolean` | `isNonsingular()` Returns whether the matrix is nonsingular (has an inverse).
`void` | `setLU(DoubleMatrix2D LU)` Sets the combined lower and upper triangular factor, `LU`.
`void` | `solve(DoubleMatrix1D B)` Solves the system of equations `A*X = B` (in-place).
`void` | `solve(DoubleMatrix2D B)` Solves the system of equations `A*X = B` (in-place).
`String` | `toString()` Returns a String with (propertyName, propertyValue) pairs.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Constructor Detail

### LUDecompositionQuick

    public LUDecompositionQuick()

  Constructs and returns a new LU Decomposition object with default tolerance `1.0E-9` for singularity detection.

### LUDecompositionQuick

    public LUDecompositionQuick(double tolerance)

  Constructs and returns a new LU Decomposition object which uses the given tolerance for singularity detection;

Method Detail

### decompose

    public void decompose(DoubleMatrix2D A)

  Decomposes matrix `A` into `L` and `U` (in-place). Upon return `A` is overridden with the result `LU`, such that `L*U = A`. Uses a "left-looking", dot-product, Crout/Doolittle algorithm.

  Parameters:
    `A` - any matrix.

### decompose

    public void decompose(DoubleMatrix2D A,
                          int semiBandwidth)

  Decomposes the banded and square matrix `A` into `L` and `U` (in-place). Upon return `A` is overridden with the result `LU`, such that `L*U = A`. Currently supports diagonal and tridiagonal matrices, all other cases fall through to `decompose(DoubleMatrix2D)`.

  Parameters:
    `semiBandwidth` - == 1 --> A is diagonal, == 2 --> A is tridiagonal.
    `A` - any matrix.

### det

    public double det()

  Returns the determinant, `det(A)`.

  Throws:
    `IllegalArgumentException` - if `A.rows() != A.columns()` (Matrix must be square).

### getL

    public DoubleMatrix2D getL()

  Returns the lower triangular factor, `L`.

  Returns:
    `L`

### getLU

    public DoubleMatrix2D getLU()

  Returns a copy of the combined lower and upper triangular factor, `LU`.

  Returns:
    `LU`

### getPivot

    public int[] getPivot()

  Returns the pivot permutation vector (not a copy of it).

  Returns:
    piv

### getU

    public DoubleMatrix2D getU()

  Returns the upper triangular factor, `U`.

  Returns:
    `U`

### isNonsingular

    public boolean isNonsingular()

  Returns whether the matrix is nonsingular (has an inverse).

  Returns:
    true if `U`, and hence `A`, is nonsingular; false otherwise.

### setLU

    public void setLU(DoubleMatrix2D LU)

  Sets the combined lower and upper triangular factor, `LU`. The parameter is not checked; make sure it is indeed a proper LU decomposition.

### solve

    public void solve(DoubleMatrix1D B)

  Solves the system of equations `A*X = B` (in-place). Upon return `B` is overridden with the result `X`, such that `L*U*X = B(piv)`.

  Parameters:
    `B` - A vector with `B.size() == A.rows()`.
  Throws:
    `IllegalArgumentException` - if B.size() != A.rows().
    `IllegalArgumentException` - if A is singular, that is, if `!isNonsingular()`.
    `IllegalArgumentException` - if `A.rows() < A.columns()`.

### solve

    public void solve(DoubleMatrix2D B)

  Solves the system of equations `A*X = B` (in-place). Upon return `B` is overridden with the result `X`, such that `L*U*X = B(piv,:)`.

  Parameters:
    `B` - A matrix with as many rows as `A` and any number of columns.
  Throws:
    `IllegalArgumentException` - if B.rows() != A.rows().
    `IllegalArgumentException` - if A is singular, that is, if `!isNonsingular()`.
    `IllegalArgumentException` - if `A.rows() < A.columns()`.

### toString

    public String toString()

  Returns a String with (propertyName, propertyValue) pairs. Useful for debugging or to quickly get the rough picture. For example,

      rank          : 3
      trace         : 0

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
| Colt 1.2.0
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Jump to the Colt Homepage