qr

QR factorization

Syntax

R = qr(A)

[Q,R] = qr(A)

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

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

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

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

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

___ = qr(___,'econ')

___ = qr(___,'real')

Description

R = qr(A) returns the R part of the QR decomposition A = Q*R. Here, A is an m-by-n matrix, R is an m-by-n upper triangular matrix, and Q is an m-by-m unitary matrix.

[Q,R] = qr(A) returns an upper triangular matrix R and a unitary matrix Q, such that A = Q*R.

[Q,R,P] = qr(A) returns an upper triangular matrix R, a unitary matrix Q, and a permutation matrix P, such that A*P = Q*R. If all elements of A can be approximated by the floating-point numbers, then this syntax chooses the column permutation P so that abs(diag(R)) is decreasing. Otherwise, it returns P = eye(n).

[C,R] = qr(A,B) returns an upper triangular matrix R and a matrix C, such that C = Q'*B and A = Q*R. Here, A and B must have the same number of rows.

C and R represent the solution of the matrix equation A*X = B as X = R\C.

[C,R,P] = qr(A,B) returns an upper triangular matrix R, a matrix C, such that C = Q'*B, and a permutation matrix P, such that A*P = Q*R. If all elements of A can be approximated by the floating-point numbers, then this syntax chooses the permutation matrix P so that abs(diag(R)) is decreasing. Otherwise, it returns P = eye(n). Here, A and B must have the same number of rows.

C, R, and P represent the solution of the matrix equation A*X = B as X = P*(R\C).

[Q,R,p] = qr(A,'vector') returns the permutation information as a vector p, such that A(:,p) = Q*R.

[C,R,p] = qr(A,B,'vector') returns the permutation information as a vector p.

C, R, and p represent the solution of the matrix equation A*X = B as X(p,:) = R\C.

___ = qr(___,'econ') returns the "economy size" decomposition. If A is an m-by-n matrix with m > n, then qr computes only the first n columns of Q and the first n rows of R. For m <= n, the syntaxes with 'econ' are equivalent to the corresponding syntaxes without 'econ'.

When you use 'econ', qr always returns the permutation information as a vector p.

You can use 0 instead of 'econ'. For example, [Q,R] = qr(A,0) is equivalent to [Q,R] = qr(A,'econ').

___ = qr(___,'real') assumes that input arguments and intermediate results are real, and therefore, suppresses calls to abs and conj. When you use this flag, qr assumes that all symbolic variables represent real numbers. When using this flag, ensure that all numeric arguments are real numbers.

Use 'real' to avoid complex conjugates in the result.

Examples

R part of QR Factorization

Compute the R part of the QR decomposition of the 4-by-4 Wilkinson's eigenvalue test matrix.

Create the 4-by-4 Wilkinson's eigenvalue test matrix:

A = sym(wilkinson(4))

A =
[ 3/2,   1,   0,   0]
[   1, 1/2,   1,   0]
[   0,   1, 1/2,   1]
[   0,   0,   1, 3/2]

Use the syntax with one output argument to return the R part of the QR decomposition without returning the Q part:

R = qr(A)

R =
[ 13^(1/2)/2,        (4*13^(1/2))/13,            (2*13^(1/2))/13,                              0]
[          0, (13^(1/2)*53^(1/2))/26, (10*13^(1/2)*53^(1/2))/689,       (2*13^(1/2)*53^(1/2))/53]
[          0,                      0,   (53^(1/2)*381^(1/2))/106, (172*53^(1/2)*381^(1/2))/20193]
[          0,                      0,                          0,             (35*381^(1/2))/762]

QR Factorization of Pascal Matrix

Compute the QR decomposition of the 3-by-3 Pascal matrix.

Create the 3-by-3 Pascal matrix:

A = sym(pascal(3))

A =
[ 1, 1, 1]
[ 1, 2, 3]
[ 1, 3, 6]

Find the Q and R matrices representing the QR decomposition of A:

[Q,R] = qr(A)

Q =
[ 3^(1/2)/3, -2^(1/2)/2,  6^(1/2)/6]
[ 3^(1/2)/3,          0, -6^(1/2)/3]
[ 3^(1/2)/3,  2^(1/2)/2,  6^(1/2)/6]
 
R =
[ 3^(1/2), 2*3^(1/2), (10*3^(1/2))/3]
[       0,   2^(1/2),  (5*2^(1/2))/2]
[       0,         0,      6^(1/2)/6]

Verify that A = Q*R using isAlways:

isAlways(A == Q*R)

ans =
  3×3 logical array
     1     1     1
     1     1     1
     1     1     1

Permutation Information

Using permutations helps increase numerical stability of the QR factorization for floating-point matrices. The qr function returns permutation information either as a matrix or as a vector.

Set the number of significant decimal digits, used for variable-precision arithmetic, to 10. Approximate the 3-by-3 symbolic Hilbert matrix by floating-point numbers:

previoussetting = digits(10);
A = vpa(hilb(3))

A =
[          1.0,          0.5, 0.3333333333]
[          0.5, 0.3333333333,         0.25]
[ 0.3333333333,         0.25,          0.2]

First, compute the QR decomposition of A without permutations:

[Q,R] = qr(A)

Q =
[ 0.8571428571, -0.5016049166,  0.1170411472]
[ 0.4285714286,  0.5684855721, -0.7022468832]
[ 0.2857142857,  0.6520863915,  0.7022468832]
 
R =
[ 1.166666667, 0.6428571429,           0.45]
[           0, 0.1017143303,   0.1053370325]
[           0,            0, 0.003901371573]

Compute the difference between A and Q*R. The computed Q and R matrices do not strictly satisfy the equality A*P = Q*R because of the round-off errors.

A - Q*R

ans =
[ -1.387778781e-16, -3.989863995e-16, -2.064320936e-16]
[ -3.469446952e-18, -8.847089727e-17, -1.084202172e-16]
[ -2.602085214e-18, -6.591949209e-17, -6.678685383e-17]

To increase numerical stability of the QR decomposition, use permutations by specifying the syntax with three output arguments. For matrices that do not contain symbolic variables, expressions, or functions, this syntax triggers pivoting, so that abs(diag(R)) in the returned matrix R is decreasing.

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

Q =
[ 0.8571428571, -0.4969293466, -0.1355261854]
[ 0.4285714286,  0.5421047417,  0.7228063223]
[ 0.2857142857,  0.6776309272, -0.6776309272]
R =
[ 1.166666667,         0.45,   0.6428571429]
[           0, 0.1054092553,   0.1016446391]
[           0,            0, 0.003764616262]
P =
     1     0     0
     0     0     1
     0     1     0

Check the equality A*P = Q*R again. QR factorization with permutations results in smaller round-off errors.

A*P - Q*R

ans =
[ -3.469446952e-18, -4.33680869e-18, -6.938893904e-18]
[                0, -8.67361738e-19, -1.734723476e-18]
[                0, -4.33680869e-19, -1.734723476e-18]

Now, return the permutation information as a vector by using the 'vector' argument:

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

Q =
[ 0.8571428571, -0.4969293466, -0.1355261854]
[ 0.4285714286,  0.5421047417,  0.7228063223]
[ 0.2857142857,  0.6776309272, -0.6776309272]
R =
[ 1.166666667,         0.45,   0.6428571429]
[           0, 0.1054092553,   0.1016446391]
[           0,            0, 0.003764616262]
p =
     1     3     2

Verify that A(:,p) = Q*R:

A(:,p) - Q*R

ans =
[ -3.469446952e-18, -4.33680869e-18, -6.938893904e-18]
[                0, -8.67361738e-19, -1.734723476e-18]
[                0, -4.33680869e-19, -1.734723476e-18]

Exact symbolic computations let you avoid roundoff errors:

A = sym(hilb(3));
[Q,R] = qr(A);
A - Q*R

ans =
[ 0, 0, 0]
[ 0, 0, 0]
[ 0, 0, 0]

Restore the number of significant decimal digits to its default setting:

digits(previoussetting)

Use QR Decomposition to Solve Matrix Equation

You can use qr to solve systems of equations in a matrix form.

Suppose you need to solve the system of equations A*X = b, where A and b are the following matrix and vector:

A = sym(invhilb(5))
b = sym([1:5]')

A =
[    25,   -300,    1050,   -1400,    630]
[  -300,   4800,  -18900,   26880, -12600]
[  1050, -18900,   79380, -117600,  56700]
[ -1400,  26880, -117600,  179200, -88200]
[   630, -12600,   56700,  -88200,  44100]
b =
 
 1
 2
 3
 4
 5

Use qr to find matrices C and R, such that C = Q'*B and A = Q*R:

[C,R] = qr(A,b);

Compute the solution X:

X = R\C

X =
        5
    71/20
   197/70
  657/280
 1271/630

Verify that X is the solution of the system A*X = b using isAlways:

isAlways(A*X == b)

ans =
  5×1 logical array
     1
     1
     1
     1
     1

Use QR Decomposition with Permutation Information to Solve Matrix Equation

When solving systems of equations that contain floating-point numbers, use QR decomposition with the permutation matrix or vector.

Suppose you need to solve the system of equations A*X = b, where A and b are the following matrix and vector:

previoussetting = digits(10);
A = vpa([2 -3 -1; 1 1 -1; 0 1 -1]);
b = vpa([2; 0; -1]);

Use qr to find matrices C and R, such that C = Q'*B and A = Q*R:

[C,R,P] = qr(A,b)

C =
  -2.110579412
 -0.2132007164
  0.7071067812
R =
[ 3.31662479, 0.3015113446, -1.507556723]
[          0,  1.705605731, -1.492405014]
[          0,            0, 0.7071067812]
P =
     0     0     1
     1     0     0
     0     1     0

Compute the solution X:

X = P*(R\C)

X =
   1.0
 -0.25
  0.75

Alternatively, return the permutation information as a vector:

[C,R,p] = qr(A,b,'vector')

C =
  -2.110579412
 -0.2132007164
  0.7071067812
R =
[ 3.31662479, 0.3015113446, -1.507556723]
[          0,  1.705605731, -1.492405014]
[          0,            0, 0.7071067812]
p =
     2     3     1

In this case, compute the solution X as follows:

X(p,:) = R\C

X =
   1.0
 -0.25
  0.75

Restore the number of significant decimal digits to its default setting:

digits(previoussetting)

"Economy Size" Decomposition

Use 'econ' to compute the “economy size” QR decomposition.

Create a matrix that consists of the first two columns of the 4-by-4 Pascal matrix:

A = sym(pascal(4));
A = A(:,1:2)

A =
[ 1, 1]
[ 1, 2]
[ 1, 3]
[ 1, 4]

Compute the QR decomposition for this matrix:

[Q,R] = qr(A)

Q =
[ 1/2, -(3*5^(1/2))/10,    (3^(1/2)*10^(1/2))/10,          0]
[ 1/2,     -5^(1/2)/10, -(2*3^(1/2)*10^(1/2))/15,  6^(1/2)/6]
[ 1/2,      5^(1/2)/10,   -(3^(1/2)*10^(1/2))/30, -6^(1/2)/3]
[ 1/2,  (3*5^(1/2))/10,    (3^(1/2)*10^(1/2))/15,  6^(1/2)/6]
 
R =
[ 2,       5]
[ 0, 5^(1/2)]
[ 0,       0]
[ 0,       0]

Now, compute the “economy size” QR decomposition for this matrix. Because the number of rows exceeds the number of columns, qr computes only the first 2 columns of Q and the first 2 rows of R.

[Q,R] = qr(A,'econ')

Q =
[ 1/2, -(3*5^(1/2))/10]
[ 1/2,     -5^(1/2)/10]
[ 1/2,      5^(1/2)/10]
[ 1/2,  (3*5^(1/2))/10]
 
R =
[ 2,       5]
[ 0, 5^(1/2)]

Avoid Complex Conjugates

Use the 'real' flag to avoid complex conjugates in the result.

Create a matrix, one of the elements of which is a variable:

syms x
A = [1 2; 3 x]

A =
[ 1, 2]
[ 3, x]

Compute the QR factorization of this matrix. By default, qr assumes that x represents a complex number, and therefore, the result contains expressions with the abs function.

[Q,R] = qr(A)

Q =
[     10^(1/2)/10, -((3*x)/10 - 9/5)/(abs(x/10 - 3/5)^2...
                          + abs((3*x)/10 - 9/5)^2)^(1/2)]
[ (3*10^(1/2))/10,      (x/10 - 3/5)/(abs(x/10 - 3/5)^2...
                          + abs((3*x)/10 - 9/5)^2)^(1/2)]
 
R =
[ 10^(1/2),                           (10^(1/2)*(3*x + 2))/10]
[        0, (abs(x/10 - 3/5)^2 + abs((3*x)/10 - 9/5)^2)^(1/2)]

When you use 'real', qr assumes that all symbolic variables represent real numbers, and can return shorter results:

[Q,R] = qr(A,'real')

Q =
[     10^(1/2)/10, -((3*x)/10 - 9/5)/(x^2/10 - (6*x)/5...
                                          + 18/5)^(1/2)]
[ (3*10^(1/2))/10,      (x/10 - 3/5)/(x^2/10 - (6*x)/5...
                                          + 18/5)^(1/2)]
 
R =
[ 10^(1/2),         (10^(1/2)*(3*x + 2))/10]
[        0, (x^2/10 - (6*x)/5 + 18/5)^(1/2)]

Input Arguments

A — Input matrix

m-by-n symbolic matrix

Input matrix, specified as an m-by-n symbolic matrix.

B — Input

symbolic vector | symbolic matrix

Input, specified as a symbolic vector or matrix. The number of rows in B must be the same as the number of rows in A.

Output Arguments

R — R part of the QR decomposition

m-by-n upper triangular symbolic matrix

R part of the QR decomposition, returned as an m-by-n upper triangular symbolic matrix.

Q — Q part of the QR decomposition

m-by-m unitary symbolic matrix

Q part of the QR decomposition, returned as an m-by-m unitary symbolic matrix.

P — Permutation information

matrix of double-precision values

Permutation information, returned as a matrix of double-precision values, such that A*P = Q*R.

p — Permutation information

vector of double-precision values

Permutation information, returned as a vector of double-precision values, such that A(:,p) = Q*R.

C — Matrix representing solution of matrix equation A*X = B

symbolic matrix

Matrix representing solution of matrix equation A*X = B, returned as a symbolic matrix, such that C = Q'*B.

More About

QR Factorization of Matrix

The QR factorization expresses an m-by-n matrix A as A = Q*R. Here, Q is an m-by-m unitary matrix, and R is an m-by-n upper triangular matrix. If the components of A are real numbers, then Q is an orthogonal matrix.

Tips

• The upper triangular matrix R satisfies the following condition: R = chol(A'*A).

• The arguments 'econ' and 0 only affect the shape of the returned matrices.

• Calling qr for numeric matrices that are not symbolic objects (not created by sym, syms, or vpa) invokes the MATLAB^® qr function.

• If you use 'matrix' instead of 'vector', then qr returns permutation matrices, as it does by default. If you use 'matrix' and 'econ', then qr throws an error.

• Matrix computations involving many symbolic variables can be slow. To increase the computational speed, reduce the number of symbolic variables by substituting the given values for some variables.