qr                   package:base                   R Documentation

_T_h_e _Q_R _D_e_c_o_m_p_o_s_i_t_i_o_n _o_f _a _M_a_t_r_i_x

_D_e_s_c_r_i_p_t_i_o_n:

     `qr' computes the QR decomposition of a matrix.  It provides an
     interface to the techniques used in the LINPACK routine DQRDC or
     (for complex matrices) the LAPACK routine ZGEQP3.

_U_s_a_g_e:

     qr(x, tol=1e-07)
     qr.coef(qr, y)
     qr.qy(qr, y)
     qr.qty(qr, y)
     qr.resid(qr, y)
     qr.fitted(qr, y, k = qr$rank)
     qr.solve(a, b, tol = 1e-7)

     is.qr(x)
     as.qr(x)

_A_r_g_u_m_e_n_t_s:

       x: a matrix whose QR decomposition is to be computed.

     tol: the tolerance for detecting linear dependencies in the
          columns of `x'.

      qr: a QR decomposition of the type computed by `qr'.

    y, b: a vector or matrix of right-hand sides of equations.

       a: A matrix or QR decomposition.

       k: effective rank.

_D_e_t_a_i_l_s:

     The QR decomposition plays an important role in many statistical
     techniques.  In particular it can be used to solve the equation Ax
     = b for given matrix A, and vector b.  It is useful for computing
     regression coefficients and in applying the Newton-Raphson
     algorithm.

     The functions `qr.coef', `qr.resid', and `qr.fitted' return the
     coefficients, residuals and fitted values obtained when fitting
     `y' to the matrix with QR decomposition `qr'. `qr.qy' and `qr.qty'
     return `Q %*% y' and `t(Q) %*% y', where `Q' is the Q matrix.

     All the above functions keep `dimnames' (and `names') of `x' and
     `y' if there are.

     `qr.solve' solves systems of equations via the QR decomposition.

     `is.qr' returns `TRUE' if `x' is a `list' with components named
     `qr', `rank' and `qraux' and `FALSE' otherwise.

     It is not possible to coerce objects to mode `"qr"'.  Objects
     either are QR decompositions or they are not.

_V_a_l_u_e:

     The QR decomposition of the matrix as computed by LINPACK or
     LAPACK. The components in the returned value correspond directly
     to the values returned by DQRDC/ZGEQP3. 

      qr: a matrix with the same dimensions as `x'. The upper triangle
          contains the R of the decomposition and the lower triangle
          contains information on the Q of the decomposition (stored in
          compact form).

   qraux: a vector of length `ncol(x)' which contains additional
          information on Q.

    rank: the rank of `x' as computed by the decomposition: always full
          rank in the complex case.

   pivot: information on the pivoting strategy used during the
          decomposition.

_N_o_t_e:

     To compute the determinant of a matrix (do you really need it?),
     the QR decomposition is much more efficient than using Eigen
     values (`eigen').  See `det'.

     The complex case uses column pivoting and does not attempt to
     detect rank-deficient matrices.

_R_e_f_e_r_e_n_c_e_s:

     Dongarra, J. J., Bunch, J. R., Moler, C. B. and Stewart, G. W.
     (1978) LINPACK Users Guide.  Philadelphia: SIAM Publications.

     Anderson. E. and ten others (1999) LAPACK Users' Guide. Third
     Edition. SIAM.
     Available on-line at <URL:
     http://www.netlib.org/lapack/lug/lapack_lug.html>.

_S_e_e _A_l_s_o:

     `qr.Q',  `qr.R',  `qr.X' for reconstruction of the matrices.
     `solve.qr',  `lsfit', `eigen', `svd'.

     `det' (using `qr') to compute the determinant of a matrix.

_E_x_a_m_p_l_e_s:

     hilbert <- function(n) { i <- 1:n; 1 / outer(i - 1, i, "+") }
     h9 <- hilbert(9); h9
     qr(h9)$rank           #--> only 7
     qrh9 <- qr(h9, tol = 1e-10)
     qrh9$rank             #--> 9
     ##-- Solve linear equation system  H %*% x = y :
     y <- 1:9/10
     x <- qr.solve(h9, y, tol = 1e-10) # or equivalently :
     x <- qr.coef(qrh9, y) #-- is == but much better than
                           #-- solve(h9) %*% y
     h9 %*% x              # = y

