GPA               package:GPArotation               R Documentation

_R_o_t_a_t_i_o_n _o_p_t_i_m_i_z_a_t_i_o_n

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

     Gradient projection rotation optimization routine used by various
     rotation objective.

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

         GPForth(A, Tmat=diag(ncol(A)), normalize=FALSE, eps=1e-5, maxit=1000, 
            method="varimax", methodArgs=NULL)
         GPFoblq(A, Tmat=diag(ncol(A)), normalize=FALSE, eps=1e-5, maxit=1000, 
            method="quartimin", methodArgs=NULL)
         

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

       A: initial factor loadings matrix for which the rotation 
          criterian is to be optimized.

    Tmat: initial rotation matrix.

  method: rotation objective criterian.

normalize: see details.

     eps: convergence is assumed when the norm of the gradient is
          smaller than eps.

   maxit: maximum number of iterations allowed in the main loop.

methodArgs: a list ofmethodArgs arguments passed to the rotation
          objective

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

     Gradient projection rotation optimization routines developed by
     Coen A. Bernaards and Robert I. Jennrich. These functions can be
     used directly to rotate a loadings matrix, or indirectly through a
     rotation objective passed to a factor estimation routine such as
     'factanal'. For examples of the indirect use see the documention
     for  rotations (such as 'oblimin').

     GPForth is the main GP algorithm for orthogonal rotation. GPFoblq
     is the main GP algorithm for oblique rotation. Both algorithms
     require a loadings matrix 'A' which fixes the  equivalence class
     over which the optimization is done. It must be  the solution to
     the orthogonal factor analysis problem.  A rotation is defined as
     code{A %*% t(solve(Tmat))}. For the  orthogonal case 'Tmat' is
     orthonormal so this simplifies  to code{A %*% Tmat}. The starting
     point for  iterative optimization is given by the 'Tmat' rotation
     of 'A'.  By default the initial rotation is the  identity matrix.
     For some rotation criteria local optima may exist and it is
     recommended to check for this by starting with many different
     initial rotations. The function 'Random.Start' will help to do
     this.

     The argument 'method' can be used to specify a string indicating
     the rotation objective. 'GPFoblq' defaults to '"quartimin"'  and
     'GPForth' defaults to '"varimax"'. Available rotation objectives
     are "oblimin", "quartimin", "target", "pst", "oblimax", "entropy",
      "quartimax", "varimax", "simplimax", "bentler", "tandemI",
     "tandemII",  "geomin", "cf", "infomax" and "mccammon". The string
     is prefixed with  "vgQ." to give the actual function call. The
     'vgQ.*' function call would typically not be used directly, so
     these methods are not exported from the package namespace. You can
     print these functions to see the code for calculating a criterion,
     but since they are not exported the package  name needs to be
     specified. For example, use 'GPArotation:::vgQ.oblimin' to view
     the function 'vgQ.oblimin'.

     Some rotation criteria (including 'simplimax', 'pst', 
     'procrustes') require one or more additional arguments. For
     example, 'simplimax' needs the number of 'close to zero loadings'
     which is given  as the extra argument 'k'. Check the rotation
     methods for details.  (If a new rotation method is implemented and
     needs additional arguments then this is the  way to pass them.)

     The argument 'normalize' gives an indication of if and how any
     normalization should be done before rotation, and then undone
     after rotation. If 'normalize' is 'FALSE' (the default) no
     normalization is done. If 'normalize' is 'TRUE' then Kaiser
     normalization is done. (So squared row entries of normalized 'A'
     sum to 1.0.) If 'normalize' is a vector of length equal to the
     number of indicators (= number of rows of 'A') then the colums are
     divided by 'normalize'  before rotation and multiplied by
     'normalize' after rotation.  If 'normalize' is a function then it
     should take 'A' as an argument and return a vector which is used
     like the vector above.

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

     A GPArotation object which is a list with elements  

      Lh: The rotated loadings, one column for each factor.

      Th: The rotation matrix,  Lh %*% t(Th) = A.

   Table: A matrix recording the iterations of the rotation
          optimization.

  method: A string indicating the rotation objective function.

orthogonal: A logical indicating if the rotation is orthogonal.

convergence: A logical indicating if convergence was obtained.

     Phi: t(Th) %*% Th.  The covariance matrix of the rotated factors.
          This will be the identity matrix for orthogonal rotations so
          is omitted from the result of GPForth.

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

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

_S_o_u_r_c_e:

     code is modified from original source splusfunctions.net available
     at  <URL: http://www.stat.ucla.edu/research/gpa>.

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

     'Random.Start' 'factanal' 'oblimin' 'quartimin' 'targetT'
     'targetQ' 'pstT' 'pstQ' 'oblimax' 'entropy' 'quartimax' 'Varimax'
     'varimax' 'simplimax' 'bentlerT' 'bentlerQ' 'tandemI' 'tandemII'
     'geominT' 'geominQ' 'cfT' 'cfQ' 'infomaxT' 'infomaxQ' 'mccammon'
     'promax'

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

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

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

       GPForth(loadings(fa.unrotated), method="varimax", normalize=TRUE)$Lh

       TV <- GPFoblq(loadings(fa.unrotated), method="oblimin", normalize=TRUE)

       print(TV)
       print(TV, Table=TRUE)
       summary(TV)
       

