GPA: Rotation Optimization
In GPArotation: GPA Factor Rotation

Description Usage Arguments Details Value Author(s) References See Also Examples

Gradient projection rotation optimization routine used by various rotation objective.

    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`	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

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 A %*% t(solve(Tmat)). For the orthogonal case Tmat is orthonormal so this simplifies to 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. This is sometimes called Horst normalization.) 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.

A GPArotation object which is a list with elements

`loadings`	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 (NULL) for the result from GPForth.
`Gq`	The gradient of the objective function at the rotated loadings.

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

Additional information is available at http://www.stat.ucla.edu/research or http://www.stat.ucla.edu/research/gpa The software reference is

Bernaards, C.A. and Jennrich, R.I. (2005) Gradient Projection Algorithms and Software for Arbitrary Rotation Criteria in Factor Analysis. Educational and Psychological Measurement, 65, 676–696.

Theory of gradient projection algorithms may be found in:

Jennrich, R.I. (2001). A simple general procedure for orthogonal rotation. Psychometrika, 66, 289–306.

Jennrich, R.I. (2002). A simple general method for oblique rotation. Psychometrika, 67, 7–19.

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

  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)$loadings

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

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