vgQ function

Rotations

vgQ routines to compute value and gradient of the criterion (not exported from NAMESPACE)

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.bigeomin(L, delta=.01)
    vgQ.cf(L, kappa=0)
    vgQ.infomax(L)
    vgQ.mccammon(L)
    vgQ.varimin(L)
    vgQ.bifactor(L)
    vgQ.lp.wls(L,W)

Arguments

• L: a factor loading matrix
• gam: 0=Quartimin, .5=Biquartimin, 1=Covarimin.
• Target: rotation target for objective calculation.
• W: weighting of each element in target and in irls.
• k: number of close to zero loadings.
• delta: constant added to $Lambda^2$ in objective calculation.
• kappa: see details.

Returns

A list (which includes elements used by GPForth and GPFoblq) with: - f: The value of the criterion at L.

• Gq: The gradient at L.

• Method: A string indicating the criterion.

Details

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.) These functions can be printed through,for example, 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 which is used in both orthogonal and oblique rotation.

vgQ.oblimin	orthogonal or oblique	oblimin family
vgQ.quartimin	oblique
vgQ.target	orthogonal or oblique	target rotation
vgQ.pst	orthogonal or oblique	partially specified target rotation
vgQ.oblimax	oblique
vgQ.entropy	orthogonal	minimum entropy
vgQ.quartimax	orthogonal
vgQ.varimax	orthogonal
vgQ.simplimax	oblique
vgQ.bentler	orthogonal or oblique	Bentler's invariant pattern simplicity criterion
vgQ.tandemI	orthogonal	Tandem principle I criterion
vgQ.tandemII	orthogonal	Tandem principle II criterion
vgQ.geomin	orthogonal or oblique
vgQ.bigeomin	orthogonal or oblique
vgQ.cf	orthogonal or oblique	Crawford-Ferguson family
vgQ.cubimax	orthogonal
vgQ.infomax	orthogonal or oblique
vgQ.mccammon	orthogonal	McCammon minimum entropy ratio
vgQ.varimin	orthogonal	varimin criterion
vgQ.bifactor	orthogonal or oblique	bifactor/biquartimin rotation
vgQ.lp.wls	orthoginal or oblique	iterative reweighted least squares for $Lp$ rotation

See rotations for use of arguments.

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, Gq, and Method.

Gradient projection without derivatives can be performed using the GPArotateDF package; type vignette("GPArotateDF", package = "GPArotation")

at the command line.

Examples

GPArotation:::vgQ.oblimin
  getAnywhere(vgQ.oblimax)

See Also

rotations

References

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.

Author(s)

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