Introduction

R uses the LINPACK dqrdc routine, by default, or the LAPACK DGEQP3 routine, when specified, for computing the QR decomposition. Both routines compute the decomposition using Householder reflections. An m x n matrix A is decomposed into an m x n economy-size orthogonal matrix (Q) and an n x n upper triangular matrix (R) as A = QR, where Q can be computed by the product of t Householder reflection matrices, with t being the lesser of m-1 and n: Q = H₁H₂...H_t.

Each reflection matrix H_i can be represented by a length-(m-i+1) vector. For example, H₁ requires a length-m vector for compact storage. All but one entry of this vector is placed in the first column of the lower triangle of the input matrix (the diagonal is used by the R factor). Therefore, each reflection needs one more scalar of storage, and this is provided by an auxiliary vector (called $qraux in the result from R's qr).

The compact representation used is different between the LINPACK and LAPACK routines.

The LINPACK Way

A Householder reflection is computed as H_i = I - v_iv_i^T/p_i, where I is the identity matrix, p_i is the corresponding entry in $qraux, and v_i is as follows:

• v_i[1..i-1] = 0,
• v_i[i] = p_i
• v_i[i+1:m] = A[i+1..m, i] (i.e., a column of the lower triangle of A after calling qr)

LINPACK Example

Let's work through the example from the QR decomposition article at Wikipedia in R.

The matrix being decomposed is

> A <- matrix(c(12, 6, -4, -51, 167, 24, 4, -68, -41), nrow=3)> A     [,1] [,2] [,3][1,]   12  -51    4[2,]    6  167  -68[3,]   -4   24  -41

We do the decomposition, and the most relevant portions of the result is shown below:

> Aqr = qr(A)> Aqr$qr            [,1]         [,2] [,3][1,] -14.0000000  -21.0000000   14[2,]   0.4285714 -175.0000000   70[3,]  -0.2857143    0.1107692  -35[snip...]$qraux[1]  1.857143  1.993846 35.000000[snip...]

This decomposition was done (under the covers) by computing two Householder reflections and multiplying them by A to get R. We will now recreate the reflections from the information in $qr.

> p = Aqr$qraux   # for convenience> v1 <- matrix(c(p[1], Aqr$qr[2:3,1]))> v1           [,1][1,]  1.8571429[2,]  0.4285714[3,] -0.2857143> v2 <- matrix(c(0, p[2], Aqr$qr[3,2]))> v2          [,1][1,] 0.0000000[2,] 1.9938462[3,] 0.1107692> I = diag(3)   # identity matrix> H1 = I - v1 %*% t(v1)/p[1]   # I - v1*v1^T/p[1]> H2 = I - v2 %*% t(v2)/p[2]   # I - v2*v2^T/p[2]> Q = H1 %*% H2> Q           [,1]       [,2]        [,3][1,] -0.8571429  0.3942857  0.33142857[2,] -0.4285714 -0.9028571 -0.03428571[3,]  0.2857143 -0.1714286  0.94285714

Now let's verify the Q computed above is correct:

> qr.Q(Aqr)           [,1]       [,2]        [,3][1,] -0.8571429  0.3942857  0.33142857[2,] -0.4285714 -0.9028571 -0.03428571[3,]  0.2857143 -0.1714286  0.94285714

Looks good! We can also verify QR is equal to A.

> R = qr.R(Aqr)   # extract R from Aqr$qr> Q %*% R     [,1] [,2] [,3][1,]   12  -51    4[2,]    6  167  -68[3,]   -4   24  -41

The LAPACK Way

A Householder reflection is computed as H_i = I - p_iv_iv_i^T, where I is the identity matrix, p_i is the corresponding entry in $qraux, and v_i is as follows:

• v_i[1..i-1] = 0,
• v_i[i] = 1
• v_i[i+1:m] = A[i+1..m, i] (i.e., a column of the lower triangle of A after calling qr)

There is another twist when using the LAPACK routine in R: column pivoting is used, so the decomposition is solving a different, related problem: AP = QR, where P is a permutation matrix.

LAPACK Example

This section does the same example as before.

> A <- matrix(c(12, 6, -4, -51, 167, 24, 4, -68, -41), nrow=3)> Bqr = qr(A, LAPACK=TRUE)> Bqr$qr            [,1]        [,2]       [,3][1,] 176.2554964 -71.1694118   1.668033[2,]  -0.7348557  35.4388886  -2.180855[3,]  -0.1056080   0.6859203 -13.728129[snip...]$qraux[1] 1.289353 1.360094 0.000000$pivot[1] 2 3 1attr(,"useLAPACK")[1] TRUE[snip...]

Notice the $pivot field; we will come back to that. Now we generate Q from the information the Aqr.

> p = Bqr$qraux   # for convenience> v1 = matrix(c(1, Bqr$qr[2:3,1]))> v1           [,1][1,]  1.0000000[2,] -0.7348557[3,] -0.1056080> v2 = matrix(c(0, 1, Bqr$qr[3,2]))> v2          [,1][1,] 0.0000000[2,] 1.0000000[3,] 0.6859203> H1 = I - p[1]*v1 %*% t(v1)   # I - p[1]*v1*v1^T> H2 = I - p[2]*v2 %*% t(v2)   # I - p[2]*v2*v2^T> Q = H1 %*% H2           [,1]        [,2]       [,3][1,] -0.2893527 -0.46821615 -0.8348944[2,]  0.9474882 -0.01602261 -0.3193891[3,]  0.1361660 -0.88346868  0.4482655

Once again, the Q computed above agrees with the R-provided Q.

> qr.Q(Bqr)           [,1]        [,2]       [,3][1,] -0.2893527 -0.46821615 -0.8348944[2,]  0.9474882 -0.01602261 -0.3193891[3,]  0.1361660 -0.88346868  0.4482655

Finally, let's compute QR.

> R = qr.R(Bqr)> Q %*% R     [,1] [,2] [,3][1,]  -51    4   12[2,]  167  -68    6[3,]   24  -41   -4

Notice the difference? QR is A with its columns permuted given the order in Bqr$pivot above.

I have researched for this same problem as the OP asks and I don't think it is possible. Basically the OP question is whether having the explicitly computed Q, one can recover the H1 H2 ... Ht. I do not think this is possible without computing the QR from scratch but I would also be very interested to know whether there is such solution.

I have a similar issue as the OP but in a different context, my iterative algorithm needs to mutate the matrix A by adding columns and/or rows. The first time, the QR is computed using DGEQRF and thus, the compact LAPACK format. After the matrix A is mutated e.g. with new rows I can quickly build a new set of reflectors or rotators that will annihilate the non-zero elements of the lowest diagonal of my existing R and build a new R but now I have a set of H1_old H2_old ... Hn_old and H1_new H2_new ... Hn_new (and similarly tau's) which can't be mixed up into a single QR compact representation. The two possibilities I have are, and maybe the OP has the same two possibilities:

1. Always maintain Q and R explicitly separated whether when computed the first time or after every update at the cost of extra flops but keeping the required memory well bounded.
2. Stick to the compact LAPACK format but then every time a new update comes in, keep a list of all these mini sets of update reflectors. At the point of solving the system one would do a big Q'*c i.e. H1_u3*H2_u3*...*Hn_u3*H1_u2*H2_u2*...*Hn_u2*H1_u1*H2_u1...*Hn_u1*H1*H2*...*Hn*c where ui is the QR update number and this is potentially a lot of multiplications to do and memory to keep track of but definitely the fastest way.

The long answer from David basically explains what the compact QR format is but not how to get to this compact QR format having the explicit computed Q and R as input.