eigen                  package:base                  R Documentation

_S_p_e_c_t_r_a_l _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:

     This function computes eigenvalues and eigenvectors by providing
     an interface to the EISPACK routines `RS', `RG', `CH' and `CG'.

_U_s_a_g_e:

     eigen(x, symmetric, only.values=FALSE)

_A_r_g_u_m_e_n_t_s:

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

symmetric: if `TRUE', the matrix is assumed to be symmetric (or
          Hermitian if complex) and only its lower triangle is used. If
          `symmetric' is not specified, the matrix is inspected for
          symmetry.

only.values: if `TRUE', only the eigenvalues are computed and returned,
          otherwise both eigenvalues and eigenvectors are returned.

_V_a_l_u_e:

     The spectral decomposition of `x' is returned as components of a
     list. 

  values: a vector containing the p eigenvalues of `x', sorted in
          decreasing order, according to `Mod(values)' if they are
          complex. Complex conjugate pairs have the eigenvalue with the
          positive imaginary part first. 

 vectors: a p * p matrix whose columns contain the eigenvectors of `x',
          or `NULL' if `only.values' is `TRUE'.  When `symmetric =
          TRUE' the vectors are normalized to unit length.  Otherwise
          the choice of length of the eigenvectors is not defined in
          the underlying Fortran code.

_R_e_f_e_r_e_n_c_e_s:

     Smith, B. T, Boyle, J. M., Dongarra, J. J., Garbow, B. S.,
     Ikebe,Y., Klema, V., and  Moler, C. B. (1976). Matrix Eigensystems
     Routines - EISPACK Guide. Springer-Verlag Lecture Notes in
     Computer Science.

_S_e_e _A_l_s_o:

     `svd', a generalization of `eigen'; `qr', and `chol' for related
     decompositions.

     To compute the determinant of a matrix, the `qr' decomposition is
     much more efficient: `det'.

_E_x_a_m_p_l_e_s:

     eigen(cbind(c(1,-1),c(-1,1)))
     eigen(cbind(c(1,-1),c(-1,1)), symmetric = FALSE)# same (different algorithm).

     eigen(cbind(1,c(1,-1)), only.values = TRUE)
     eigen(cbind(-1,2:1)) # complex values
     eigen(print(cbind(c(0,1i), c(-1i,0))))# Hermite ==> real Eigen values
     ## 3 x 3:
     eigen(cbind( 1,3:1,1:3))
     eigen(cbind(-1,c(1:2,0),0:2)) # complex values

     Meps <- .Alias(.Machine$double.eps)
     m <- matrix(round(rnorm(25),3), 5,5)
     sm <- m + t(m) #- symmetric matrix
     em <- eigen(sm); V <- em$vect
     print(lam <- em$values) # ordered DEcreasingly

     stopifnot(
      abs(sm %*% V - V %*% diag(lam))          < 60*Meps,
      abs(sm       - V %*% diag(lam) %*% t(V)) < 60*Meps)

     ##------- Symmetric = FALSE:  -- different to above : ---

     em <- eigen(sm, symmetric = FALSE); V2 <- em$vect
     print(lam2 <- em$values) # ordered decreasingly in ABSolute value !
                              # and V2 is not normalized (where V is):
     print(i <- rev(order(lam2)))
     stopifnot(abs(1 - lam2[i] / lam) < 60 * Meps)

     zapsmall(Diag <- t(V2) %*% V2) # orthogonal, but not normalized
     print(norm2V <- apply(V2 * V2, 2, sum))
     stopifnot( abs(1- norm2V / diag(Diag)) < 60*Meps)

     V2n <- sweep(V2,2, STATS= sqrt(norm2V), FUN="/")## V2n are now Normalized EV
     apply(V2n * V2n, 2, sum)
     ##[1] 1 1 1 1 1

     ## Both are now TRUE:
     stopifnot(abs(sm %*% V2n - V2n %*% diag(lam2))            < 60*Meps,
               abs(sm         - V2n %*% diag(lam2) %*% t(V2n)) < 60*Meps)

     ## Re-ordered as with symmetric:
     sV <- V2n[,i]
     slam <- lam2[i]
     all(abs(sm %*% sV -  sV %*% diag(slam))             < 60*Meps)
     all(abs(sm        -  sV %*% diag(slam) %*% t(sV)) < 60*Meps)
     ## sV  *is* now equal to V  -- up to sign (+-) and rounding errors
     all(abs(c(1 - abs(sV / V)))       <     1000*Meps) # TRUE (P ~ 0.95)

