rotations            package:GPArotation            R Documentation

_R_o_t_a_t_i_o_n_s

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

     Optimize factor loading rotation objective.

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

         oblimin(L, Tmat=diag(ncol(L)), gam=0, normalize=FALSE, eps=1e-5, maxit=1000)
         quartimin(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         targetT(L, Tmat=diag(ncol(L)), Target=NULL, normalize=FALSE, eps=1e-5, maxit=1000)
         targetQ(L, Tmat=diag(ncol(L)), Target=NULL, normalize=FALSE, eps=1e-5, maxit=1000)
         pstT(L, Tmat=diag(ncol(L)), W, Target=NULL, normalize=FALSE, eps=1e-5, maxit=1000)
         pstQ(L, Tmat=diag(ncol(L)), W, Target=NULL, normalize=FALSE, eps=1e-5, maxit=1000)
         oblimax(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         entropy(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         quartimax(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         Varimax(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         simplimax(L, Tmat=diag(ncol(L)), k=nrow(L), normalize=FALSE, eps=1e-5, maxit=1000)
         bentlerT(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         bentlerQ(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         tandemI(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         tandemII(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         geominT(L, Tmat=diag(ncol(L)), delta=.01, normalize=FALSE, eps=1e-5, maxit=1000)
         geominQ(L, Tmat=diag(ncol(L)), delta=.01, normalize=FALSE, eps=1e-5, maxit=1000)
         cfT(L, Tmat=diag(ncol(L)), kappa=0, normalize=FALSE, eps=1e-5, maxit=1000)
         cfQ(L, Tmat=diag(ncol(L)), kappa=0, normalize=FALSE, eps=1e-5, maxit=1000)
         infomaxT(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         infomaxQ(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
         mccammon(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)

         vgQ.oblimin(L, gam=0)
         vgQ.quartimin(L)
         vgQ.target(L, Target=NULL)
         vgQ.pst(L, W, Target=NULL)
         vgQ.oblimax(L)
         vgQ.entropy(L)
         vgQ.quartimax(L)
         vgQ.varimax(L)
         vgQ.simplimax(L, k=nrow(L))
         vgQ.bentler(L)
         vgQ.tandemI(L)
         vgQ.tandemII(L)
         vgQ.geomin(L, delta=.01)
         vgQ.cf(L, kappa=0)
         vgQ.infomax(L)
         vgQ.mccammon(L)

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

       L: a factor loading matrix

    Tmat: initial rotation matrix.

     gam: 0=Quartimin, .5=Biquartimin, 1=Covarimin.

  Target: rotation target for objective calculation.

       W: weighting of each element in target.

       k: number of close to zero loadings.

   delta: constant added to L\^2 in objective calculation.

   kappa: see details.

normalize: parameter passed to optimization routine (GPForth or
          GPFoblq).

     eps: parameter passed to optimization routine (GPForth or
          GPFoblq).

   maxit: parameter passed to optimization routine (GPForth or
          GPFoblq).

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

     These functions optimize a rotation objective. They can be used
     directly or the function name can be passed to factor analysis
     functions like 'factanal'. Several of the function names end in T
     or Q, which indicates if they are orthogonal or oblique rotations
     (called from 'GPForth' or 'GPFoblq' respectively.  

     The 'vgQ.*' versions of the code are called by the optimization
     routine and would typically not be used directly, so these methods
     are not exported from the package namespace. (They simply return
     the function value and gradient for a given rotation matrix.) You
     can print these functions but the package  name needs to be
     specified, since they are not exported. For example, use
     'GPArotation:::vgQ.oblimin' to view the function 'vgQ.oblimin'.
     The T or Q ending on function names should be omitted for the
     'vgQ.*'  versions of the code so, for example, use
     'GPArotation:::vgQ.target' to view the target criterion
     calculation.

     Rotations which are available are 

       oblimin    oblique     oblimin family
       quartimin  oblique     
       targetT    orthogonal  target rotation
       targetQ    oblique     target rotation
       pstT       orthogonal  partially specified target rotation
       pstQ       oblique     partially specified target rotation
       oblimax    oblique     
       entropy    orthogonal  minimum entropy
       quartimax  orthogonal  
       varimax    orthogonal  
       simplimax  oblique     
       bentlerT   orthogonal  Bentler's invariant pattern simplicity criterion
       bentlerQ   oblique     Bentler's invariant pattern simplicity criterion
       tandemI    orthogonal  Tandem Criterion
       tandemII   orthogonal  Tandem Criterion
       geominT    orthogonal  
       geominQ    oblique     
       cfT        orthogonal  Crawford-Ferguson family
       cfQ        oblique     Crawford-Ferguson family
       infomaxT   orthogonal  
       infomaxQ   oblique     
       mccammon   orthogonal  McCammon minimum entropy ratio

     Note that 'Varimax' defined here uses 'vgQ.varimax' and  is not
     'varimax' defined in the 'stats' package. 'stats:::varimax' does
     Kaiser  normalization by default whereas 'Varimax' defined here
     does not.

     The argument 'kappa' parameterizes the family for the
     Crawford-Ferguson  method. If 'm' is the number of factors and 'p'
     is the number of  indicators then 'kappa' values having special
     names are 0=Quartimax,  1/p=Varimax, m/(2*p)=Equamax,
     (m-1)/(p+m-2)=Parsimax, 1=Factor parsimony.

     New rotation methods can be programmed with a name
     "vgQ.newmethod". The  inputs are the matrix L, and optionally any
     additional arguments. The output should be a list with elements 

       'f'       the value of the criterion at L.
       'Gq'      the gradient at L.
       'Method'  a string indicating the criterion.

_V_a_l_u_e:

     A list as needed by 'factanal' with elements 

loadings: Lh from 'GPForth' or 'GPFoblq'.

      Th: Th from 'GPForth' or 'GPFoblq'.

   Table: Table from 'GPForth' or 'GPFoblq'.

 logical: Convergence indicator from 'GPForth' or 'GPFoblq'.

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

     Coen A. Bernaards and Robert I. Jennrich with some R modifications
     by Paul Gilbert.

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

     'GPForth' 'GPFoblq' 'WansbeekMeijer' 'factanal' 'varimax' 'promax'

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

       data(ability.cov)
       factanal(factors = 2, covmat = ability.cov, rotation="oblimin")

       data("Harman", package="GPArotation")
       qHarman  <- GPForth(Harman8, Tmat=diag(2), method="quartimax")
       qHarman2 <- quartimax(Harman8) 

       data("WansbeekMeijer", package="GPArotation")
       fa.unrotated  <- factanal(factors = 2, covmat=NetherlandsTV, rotation="none")

       fa.varimax <- factanal(factors = 2, covmat=NetherlandsTV, 
                     rotation="varimax", control=list(rotate=list(normalize=TRUE)))
       fa.oblimin <- factanal(factors = 2, covmat=NetherlandsTV,
                     rotation="oblimin", control=list(rotate=list(normalize=TRUE)))
       
       cbind(loadings(fa.unrotated), loadings(fa.varimax), loadings(fa.oblimin))

       

