ff.rotationsDF: Rotations

Description

Optimize factor loading rotation objective.

Usage

ff.bentler(L)
	ff.cf(L, kappa=0)
	ff.cubimax(L)
	ff.entropy(L)
	ff.geomin(L, delta=0.01)
	ff.infomax(L) 
	ff.oblimax(L)
	ff.pst(L, W=NULL, Target=NULL)
	ff.quartimax(L)
	ff.quartimin(L)
	ff.simplimax(L, k=nrow(L))
	ff.fss(L, kij=2)
	ff.target(L, Target=NULL) 
	ff.varimax(L)

Value

f: criterion function value.
method: A string indicating the rotation objective function.

Arguments

L: a factor loading matrix
kappa: see details.
delta: constant added to Lambda^2 in objective calculation.
Target: rotation target for objective calculation.
W: weighting of each element in target.
k: number of close to zero loadings.
kij: minimum additional number of forced simple structure loadings in a pair of factors.

Author

Coen A. Bernaards and Robert I. Jennrich

Details

These functions are used to optimize a rotation objective. The name need to be included in a call to GPForth.df or GPFoblq. Calling the functions itself computes the values but no rotation is performed.

Functions listed here are all exported through NAMESPACE, and primarily serve as examples for programming new rotation methods. New rotation methods can be programmed with a name ff.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.
`Method`	a string indicating the criterion.

Please note that the function value f has to be minimized. If the rotation criterion is supposed to maximize, then use the negative of the criterion to miniize. Functions which are available are

`ff.bentler`	orthogonal or oblique	Bentler's invariant pattern simplicity criterion
`ff.cf`	orthogonal or oblique	Crawford-Ferguson family
`ff.cubimax`	orthogonal
`ff.entropy`	orthogonal	minimum entropy
`ff.fss`	orthogonal or oblique	Forced Simple Structure (see Vignette)
`ff.geomin`	orthogonal or oblique
`ff.infomax`	orthogonal or oblique
`ff.oblimax`	oblique
`ff.pst`	orthogonal or oblique	partially specified target rotation
`ff.quartimax`	orthogonal
`ff.quartimin`	oblique
`ff.simplimax`	oblique
`ff.target`	orthogonal or oblique	target rotation
`ff.varimax`	orthogonal

The argument kappa parameterizes the family for the Crawford-Ferguson method. If m is the number of factors and p is the number of items 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.

For the argument kij for Forced Simple Structure see rotationsDF.

References

Jennrich, R.I. (2004) Derivative free gradient projection algorithms for rotation, Psychometrika: 69(3), 475--480.

Examples

Run this code

  # Example from Mulaik, S.A. (2018) Fundamentals of Common Analysis in 
  # Irwing, P., Booth, T., Hughes, D. J.  (20180314). The Wiley Handbook of 
  # Psychometric Testing, 2 Volume Set: A Multidisciplinary Reference on Survey, 
  # Scale and Test Development. [VitalSource Bookshelf 10.2.0]. 
  # Retrieved from vbk://9781118489703
  # See Part II, Table 8.5 (p.225) and Table 8.6 (p.235)

  ff.absolmin <- function(L)
  {
    f <- sum(abs(L))
    list(f = f, Method = "DF-Absolmin")
  }
  absolmin.df <- function(A, Tmat = diag(ncol(A)), normalize = FALSE, eps = 1e-5, maxit = 1000){
   GPFoblq.df(A, Tmat=Tmat, method = "absolmin", normalize = normalize, eps = eps, maxit = maxit)	
  }
  # absolmin.df(fa.unrotated$loadings, normalize = TRUE)
  
  # See GPArotation vignette for a bug in factanal with oblique rotation.

  data("Griffith")  
  fa.unrotated <- factanal(covmat = Griffith, factors = 6, rotation = "none")
  GPFoblq.df(fa.unrotated$loadings, method = "quartimin", normalize = TRUE)
  
  absolmin.df(fa.unrotated$loadings, normalize = TRUE)
  
  data("Harman", package="GPArotation")
  qHarman  <- GPForth.df(Harman8, Tmat=diag(2), method="quartimax")
  
  # define a new function as ff.newname orthogonal rotation for use with factanal
  ff.expomax <- function(L)
  {
    f <- -sum(expm1(abs(L)))
    list(f = f, Method = "DF-Expomax")
  }
  GPForth.df(Harman8, method ="expomax")

  expomax.df <- function(L, Tmat = diag(ncol(L)), normalize = FALSE, eps = 1e-5, maxit = 1000){
   GPForth.df(L, Tmat=Tmat, method = "expomax", normalize = normalize, eps= eps, maxit = maxit)	
  }
  expomax.df(Harman8, normalize = TRUE)
  factanal(factors = 2, covmat = ability.cov, rotation = "expomax.df", 
      control = list(rotate =c(normalize = TRUE)))

Run the code above in your browser using DataLab