ordering                package:spam                R Documentation

_E_x_t_r_a_c_t _t_h_e _p_e_r_m_u_t_a_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     Extract the (inverse) permutation used by the Cholesky
     decomposition

_U_s_a_g_e:

     ordering( x, inv=FALSE)

_A_r_g_u_m_e_n_t_s:

       x: object of class 'spam.chol.'_method_ returned by the function
          'chol'.

     inv: Return the permutation (default) or inverse thereof.

_D_e_t_a_i_l_s:

     Recall that calculating a Cholesky factor from a sparse matrix
     consists of finding a permutation first, then calculating the
     factors of the permuted matrix. The ordering is important when
     working with the factors themselves.

     The ordering from a full/regular matrix is '1:n'.

     Note that there exists many different algorithms to find
     orderings.   

     See the examples, they speak more than 10 lines.

_A_u_t_h_o_r(_s):

     Reinhard Furrer

_S_e_e _A_l_s_o:

     'chol', 'solve'.

_E_x_a_m_p_l_e_s:

     # Construct a pd matrix S to work with (size n)
     n <- 100    # dimension
     S <- .25^abs(outer(1:n,1:n,"-"))
     S <- as.spam( S, eps=1e-4)
     I <- diag(n)  # Identity matrix

     cholS <- chol( S)
     ord <- ordering(cholS)
     iord <- ordering(cholS, inv=TRUE)

     R <- as.spam( cholS ) # R'R = P S P', with P=I[ord,],
       # a permutation matrix (rows permuted).
     RtR <- t(R) %*% R

     # the following are equivalent:
     as.spam( RtR -            S[ord,ord] )
     as.spam( RtR[iord,iord] - S )
     as.spam( t(R[,iord]) %*% R[,iord] - S )

     # trivially:
     as.spam( t(I[iord,]) - I[ord,])  # (P^-1)' = P  
     as.spam( t(I[ord,]) - I[,ord])  # 
     as.spam( I[iord,] - I[,ord])
     as.spam( I[ord,]%*%S%*%I[,ord] - S[ord,ord] )
        # pre and post multiplication with P and P' is ordering

