pcp                 package:hddplot                 R Documentation

_c_o_n_v_e_n_i_e_n_c_e _v_e_r_s_i_o_n _o_f _t_h_e _s_i_n_g_u_l_a_r _v_a_l_u_e _d_e_c_o_m_p_o_s_i_t_i_o_n

_D_e_s_c_r_i_p_t_i_o_n:

     Packages results from an SVD on what can be either a cases by
     variables (features) or variables by cases layout, for use in
     principal component and related calculations

_U_s_a_g_e:

     pcp(x = USArrests, varscores = TRUE, cases = "rows", center = "vars", standardize = FALSE, scale.cases = 1, log = FALSE, sc = 1, reflect = c(1, 1))

_A_r_g_u_m_e_n_t_s:

       x: matrix on which SVD is to be performed

varscores: logical; should scores be returned?

   cases: specify either '"rows"' or '"columns"'

  center: logical: if set to '"vars"', then values of variables will be
          centered

standardize: logical: should values of variables be standardized to
          zero mean and unit deviance.  Takes precedence over the
          setting of  'center'

scale.cases: set to a value in [0,1]. 'scale.cases=0' gives  a pure
          rotation of the variables. 'scale.cases=1' weights a/c the 
          singular values

     log: logical: should logarithms be taken, prior to the
          calculation?

      sc: the variable scores are divided by $\sqrt{sc-1}$. By default,
          'sc' = number of cases

 reflect: a vector of two elements, by default 'c(1,1)'.  Use of -1 in
          one or both positions can be useful in reconciling results
          with output from other software

_D_e_t_a_i_l_s:

_V_a_l_u_e:

       g: case scores

       h: variable scores

     avv: variable means

    sdev: singular values, divides by the square root of one less than
          the number of cases

_N_o_t_e:

_A_u_t_h_o_r(_s):

     John Maindonald

_R_e_f_e_r_e_n_c_e_s:

_S_e_e _A_l_s_o:

     'La.svd'

_E_x_a_m_p_l_e_s:

     USArrests.svd <- pcp(x = USArrests)

     ## The function is currently defined as
     function(x=USArrests,
                varscores=TRUE,
                cases="rows",
                center="vars",
                standardize=FALSE,
                scale.cases=1,
                log=FALSE,
                sc=1,
                reflect=c(1,1))
     {
       x <- as.matrix(x)
       avv <- 0
       sdv <- 1
       casedim <- 2-as.logical(cases=="rows")
       vardim <- 3-casedim
       ## casedim=1 if rows are cases; otherwise casedim=2
       ## scale.cases=0 gives a pure rotation of the variables
       ## scale.cases=1 weights a/c the singular values
       ncases <- dim(x)[casedim]
       nvar <- dim(x)[vardim]
       if(is.null(sc))sc <- dim(x)[casedim]-1
       if(log)x <- log(x, base=2)
       if(standardize){
         avv <- apply(x, vardim, mean)
         sdv <- apply(x, vardim, sd)        
         x <- sweep(x, vardim, avv,"-")
         x <- sweep(x, vardim, sdv,"/")
       }
       else if(as.logical(match("vars", center, nomatch=0))){
         avv <- apply(x,vardim, mean)
         x <- sweep(x, vardim, avv,"-")}

       svdx <- La.svd(x, method = c("dgesdd"))
       h <- NULL
       if(cases=="rows"){
         g <- sweep(svdx$u, 2, svdx$d^scale.cases, "*")*sqrt(sc)
         if(varscores)
           h <- t((svdx$d^(1-scale.cases)* svdx$vt ))/sqrt(sc)
       }
       else if(cases=="columns"){
         g <- sweep(t(svdx$vt), 2, svdx$d^scale.cases, "*")*sqrt(sc)
         if(varscores)
           h <- sweep(svdx$u, 2, svdx$d^(1-scale.cases),"*")/sqrt(sc)
       }
       invisible(list(g=g, rotation=h, av=avv, sdev=svdx$d/sqrt(ncases-1)))
       }

