solve                  package:base                  R Documentation

_S_o_l_v_e _a _S_y_s_t_e_m _o_f _E_q_u_a_t_i_o_n_s

_D_e_s_c_r_i_p_t_i_o_n:

     This generic function solves the equation 'a %*% x = b' for 'x',
     where 'b' can be either a vector or a matrix.

_U_s_a_g_e:

     solve(a, b, ...)

     ## Default S3 method:
     solve(a, b, tol, LINPACK = FALSE, ...)

_A_r_g_u_m_e_n_t_s:

       a: a square numeric or complex matrix containing the
          coefficients of the linear system.

       b: a numeric or complex vector or matrix giving the right-hand
          side(s) of the linear system.  If missing, 'b' is taken to be
          an identity matrix and 'solve' will return the inverse of
          'a'.

     tol: the tolerance for detecting linear dependencies in the
          columns of 'a'.  If 'LINPACK' is 'TRUE' the default is
          '1e-7', otherwise it is '.Machine$double.eps'. Future
          versions of R may use a tighter tolerance. Not presently used
          with complex matrices 'a'.

 LINPACK: logical. Should LINPACK be used (for compatibility with R <
          1.7.0)?  Otherwise LAPACK is used.

     ...: further arguments passed to or from other methods

_D_e_t_a_i_l_s:

     'a' or 'b' can be complex, but this uses double complex arithmetic
     which might not be available on all platforms and LAPACK will
     always be used.

     The row and column names of the result are taken from the column
     names of 'a' and of 'b' respectively.  If 'b' is missing the
     column names of the result are the row names of 'a'.  No check is
     made that the column names of 'a' and the row names of 'b' are
     equal.

     For back-compatibility 'a' can be a (real) QR decomposition,
     although 'qr.solve' should be called in that case. 'qr.solve' can
     handle non-square systems.

_R_e_f_e_r_e_n_c_e_s:

     Becker, R. A., Chambers, J. M. and Wilks, A. R. (1988) _The New S
     Language_. Wadsworth & Brooks/Cole.

_S_e_e _A_l_s_o:

     'solve.qr' for the 'qr' method, 'chol2inv' for inverting from the
     Choleski factor 'backsolve', 'qr.solve'.

_E_x_a_m_p_l_e_s:

     hilbert <- function(n) { i <- 1:n; 1 / outer(i - 1, i, "+") }
     h8 <- hilbert(8); h8
     sh8 <- solve(h8)
     round(sh8 %*% h8, 3)

     A <- hilbert(4)
     A[] <- as.complex(A)
     ## might not be supported on all platforms
     try(solve(A))