Orthogonal-triangular decomposition

`[Q,R] = qr(A)`

[Q,R] = qr(A,0)

[Q,R,E] = qr(A)

[Q,R,E] =
qr(A,'matrix')

[Q,R,e] = qr(A,'vector')

[Q,R,e] = qr(A,0)

X = qr(A)

X = qr(A,0)

R = qr(A)

R = qr(A,0)

[C,R] = qr(A,B)

[C,R,E] = qr(A,B)

[C,R,E]
= qr(A,B,'matrix')

[C,R,e] = qr(A,B,'vector')

[C,R] = qr(A,B,0)

[C,R,e] = qr(A,B,0)

`[Q,R] = qr(A)`

, where `A`

is `m`

-by-`n`

,
produces an `m`

-by-`n`

upper triangular
matrix `R`

and an `m`

-by-`m`

unitary
matrix `Q`

so that `A = Q*R`

.

`[Q,R] = qr(A,0)`

produces the economy-size
decomposition. If `m > n`

, only the first `n`

columns
of `Q`

and the first `n`

rows of `R`

are
computed. If `m<=n`

, this is the same as ```
[Q,R]
= qr(A)
```

.

If A is full:

`[Q,R,E] = qr(A)`

or ```
[Q,R,E] =
qr(A,'matrix')
```

produces unitary `Q`

, upper
triangular `R`

and a permutation matrix `E`

so
that `A*E = Q*R`

. The column permutation `E`

is
chosen so that `abs(diag(R))`

is decreasing.

`[Q,R,e] = qr(A,'vector')`

returns the permutation
information as a vector instead of a matrix. That is, `e`

is
a row vector such that `A(:,e) = Q*R`

.

`[Q,R,e] = qr(A,0)`

produces an economy-size
decomposition in which `e`

is a permutation vector,
so that `A(:,e) = Q*R`

.

`X = qr(A)`

and `X = qr(A,0)`

return
a matrix `X`

such that `triu(X)`

is
the upper triangular factor `R`

.

If A is sparse:

`R = qr(A)`

computes a `Q`

-less `QR`

decomposition
and returns the upper triangular factor `R`

. Note
that `R = chol(A'*A)`

. Since `Q`

is
often nearly full, this is preferred to `[Q,R] = QR(A)`

.

`R = qr(A,0)`

produces economy-size `R`

.
If `m>n`

, `R`

has only `n`

rows.
If `m<=n`

, this is the same as `R = qr(A)`

.

`[Q,R,E] = qr(A)`

or `[Q,R,E] = qr(A,'matrix')`

produces
unitary `Q`

, upper triangular `R`

and
a permutation matrix `E`

so that `A*E = Q*R`

.
The column permutation `E`

is chosen to reduce fill-in
in R.

`[Q,R,e] = qr(A,'vector')`

returns the permutation
information as a vector instead of a matrix. That is, `e`

is
a row vector such that `A(:,e) = Q*R`

.

`[Q,R,e] = qr(A,0)`

produces an economy-size
decomposition in which `e`

is a permutation vector,
so that `A(:,e) = Q*R`

.

`[C,R] = qr(A,B)`

, where `B`

has
as many rows as `A`

, returns `C = Q'*B`

.
The least-squares solution to `A*X = B`

is ```
X
= R\C
```

.

`[C,R,E] = qr(A,B)`

or ```
[C,R,E]
= qr(A,B,'matrix')
```

, also returns a fill-reducing ordering.
The least-squares solution to `A*X = B`

is ```
X
= E*(R\C)
```

.

`[C,R,e] = qr(A,B,'vector')`

returns the
permutation information as a vector instead of a matrix. That is,
the least-squares solution to `A*X = B`

is ```
X(e,:)
= R\C
```

.

`[C,R] = qr(A,B,0)`

produces economy-size
results. If `m>n`

, `C`

and `R`

have
only `n`

rows. If `m<=n`

, this
is the same as `[C,R] = qr(A,B)`

.

`[C,R,e] = qr(A,B,0)`

additionally produces
a fill-reducing permutation vector `e`

. In this
case, the least-squares solution to `A*X = B`

is ```
X(e,:)
= R\C
```

.

Find the least squares approximate solution to ```
A*x
= b
```

with the `Q`

-less `QR`

decomposition
and one step of iterative refinement:

if issparse(A), R = qr(A); else R = triu(qr(A)); end x = R\(R'\(A'*b)); r = b - A*x; err = R\(R'\(A'*r)); x = x + err;

Was this topic helpful?