Documentation

# dsp.LUFactor

Factor square matrix into lower and upper triangular matrices

## Description

The `LUFactor` object factors a square matrix into lower and upper triangular matrices.

To factor a square matrix into lower and upper triangular matrices:

1. Define and set up your System object™. See Construction.

2. Call `step` to factor the square matrix according to the properties of `dsp.LUFactor`. The behavior of `step` is specific to each object in the toolbox.

### Note

Starting in R2016b, instead of using the `step` method to perform the operation defined by the System object, you can call the object with arguments, as if it were a function. For example, ```y = step(obj,x)``` and `y = obj(x)` perform equivalent operations.

## Construction

`lu = dsp.LUFactor` returns an `LUFactor` System object, `lu`, which factors a row permutation of a square input matrix `A` as , where `L` is the unit-lower triangular matrix, and `U` is the upper triangular matrix. The row-pivoted matrix Ap contains the rows of A permuted as indicated by the permutation index vector P. The equivalent MATLAB® code is `Ap = A(P,:)`.

`lu = dsp.LUFactor('PropertyName',PropertyValue,...)` returns an `LUFactor` object, `lu`, with each specified property set to the specified value.

## Properties

 `ExceptionOutputPort` Set to `true` to output singularity of input Set this property to `true` to output the singularity of the input as logical data type values of `true` or `false`. An output of `true` indicates that the current input is singular, and an output of `false` indicates the current input is nonsingular.

## Methods

 step Decompose matrix into lower and upper triangular matrices
Common to All System Objects
`release`

Allow System object property value changes

## Examples

expand all

Note: This example runs only in R2016b or later. If you are using an earlier release, replace each call to the function with the equivalent `step` syntax. For example, myObject(x) becomes step(myObject,x).

Decompose a square matrix into the lower and upper components.

```lu = dsp.LUFactor; x = rand(4)```
```x = 4×4 0.8147 0.6324 0.9575 0.9572 0.9058 0.0975 0.9649 0.4854 0.1270 0.2785 0.1576 0.8003 0.9134 0.5469 0.9706 0.1419 ```
```[LU, P] = lu(x); L = tril(LU,-1)+diag(ones(size(LU,1),1)); U = triu(LU); y = L*U```
```y = 4×4 0.9134 0.5469 0.9706 0.1419 0.9058 0.0975 0.9649 0.4854 0.8147 0.6324 0.9575 0.9572 0.1270 0.2785 0.1576 0.8003 ```

Check back whether `y` equals the permuted `x`

`xp = x(P,:)`
```xp = 4×4 0.9134 0.5469 0.9706 0.1419 0.9058 0.0975 0.9649 0.4854 0.8147 0.6324 0.9575 0.9572 0.1270 0.2785 0.1576 0.8003 ```

## Algorithms

This object implements the algorithm, inputs, and outputs described on the LU Factorization block reference page. The object properties correspond to the block parameters.