Rotations
Optimize factor loading rotation objective.
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=NULL, Target=NULL,
normalize=FALSE, eps=1e-5, maxit=1000)
pstQ(L, Tmat=diag(ncol(L)), W=NULL, 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)
bifactorT(L, Tmat=diag(ncol(L)), normalize=FALSE, eps=1e-5, maxit=1000)
bifactorQ(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=NULL, 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)
vgQ.bifactor(L)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). |
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 (using 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 |
| bifactorT | orthogonal | Jennrich and Bentler bifactor rotation |
| bifactorQ | oblique | Jennrich and Bentler biquartimin rotation |
Also included for convenience are two analytic rotations eiv
and echelon which do not require GPForth or GPFoblq.
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. |
A list (which includes elements used by factanal) with:
loadings |
Lh from |
Th |
Th from |
Table |
Table from |
method |
A string indicating the rotation objective function. |
orthogonal |
A logical indicating if the rotation is orthogonal. |
convergence |
Convergence indicator from |
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. |
Coen A. Bernaards and Robert I. Jennrich with some R modifications by Paul Gilbert.
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.
Bifactor rotation, bifactorT and bifactorQ are called bifactor and biquartimin in Jennrich, R.I. and Bentler, P.M. (2011) Exploratory bi-factor analysis. Psychometrika, 76.
A discussion of rotation objectives can be found in many references, for example,
Tom Wansbeek and Erik Meijer (2000) Measurement Error and Latent Variables in Econometrics, Amsterdam: North-Holland.
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))Please choose more modern alternatives, such as Google Chrome or Mozilla Firefox.