help rotatemat dialog: rotatemat
also see: rotate
-------------------------------------------------------------------------------
Title
[MV] rotatemat -- Orthogonal and oblique rotations of a Stata matrix
Syntax
rotatemat matrix_L [, options]
options description
-------------------------------------------------------------------------
Main
orthogonal restrict to orthogonal rotations; the default,
except with promax()
oblique allow oblique rotations
rotation_methods rotation criterion
normalize rotate Kaiser normalized matrix
Reporting
format(%fmt) display format for matrices; default is
format(%9.5f)
blanks(#) display numbers as blanks when |loadings| < #;
default is blanks(0)
nodisplay suppress all output except log and trace
noloading suppress display of rotated loadings
norotation suppress display of rotation matrix
matname(str) descriptive label of the matrix to be rotated
colnames(str) descriptive name for columns of the matrix to be
rotated
Optimization
optimize_options control the maximization process; seldom used
-------------------------------------------------------------------------
rotation_methods description
-------------------------------------------------------------------------
Main
* varimax varimax (orthogonal only); the default
vgpf varimax via the GPF algorithm (orthogonal only)
quartimax quartimax (orthogonal only)
equamax equamax (orthogonal only)
parsimax parsimax (orthogonal only)
entropy minimum entropy (orthogonal only)
tandem1 Comrey's tandem 1 principle (orthogonal only)
tandem2 Comrey's tandem 2 principle (orthogonal only)
* promax[(#)] promax power # (implies oblique); default is
promax(3)
oblimin[(#)] oblimin with gamma=#; default is oblimin(0)
cf(#) Crawford-Ferguson family with kappa=#, 0<=#<=1
bentler Bentler's invariant pattern simplicity
oblimax oblimax
quartimin quartimin
target(Tg) rotate toward matrix Tg
partial(Tg W) rotate toward matrix Tg, weighted by matrix W
-------------------------------------------------------------------------
* varimax and promax ignore all optimize_options.
Menu
Statistics > Multivariate analysis > Orthogonal and oblique rotations of
a matrix
Description
rotatemat applies a linear transformation T to the matrix matrix_L, which
we will call A, so that the result c(A*inv(T')) minimizes some criterion
function c() over all matrices T in a class of feasible transformations.
Two classes are supported: orthogonal (orthonormal) and oblique.
orthonormal rotations comprise all orthonormal matrices T, such that T'*T
= T*T' = I; here A*inv(T') simplifies to A*T. Oblique rotations are
characterized by diag(T'*T) = 1. A wide variety of criteria c() is
available, representing different ways to measure the "simplicity" of a
matrix. Most of these criteria can be applied with both orthogonal and
oblique rotations.
If you are interested in rotation after factor, factormat, pca, or
pcamat, see [MV] factor postestimation, [MV] pca postestimation, and the
general description of rotate as a postestimation facility in [MV]
rotate.
This entry describes the computation engine for orthogonal and oblique
transformations of Stata matrices. This command may be used directly on
any Stata matrix.
Options
+------+
----+ Main +-------------------------------------------------------------
orthogonal specifies that an orthogonal rotation be applied. This is the
default.
See Rotation criteria below for details on the rotation_methods
available with orthogonal.
oblique specifies that an oblique rotation be applied. This often yields
more interpretable factors with a simpler structure than obtained
with an orthogonal rotation. In many applications (e.g., after
factor and pca) the factors before rotation are orthogonal
(uncorrelated), whereas the oblique rotated factors are correlated.
See Rotation criteria below for details on the rotation_methods
available with oblique.
normalize requests that the rotation be applied to the Kaiser
normalization of the matrix A, so that the rowwise sums of squares r
equal 1.
+-----------+
----+ Reporting +--------------------------------------------------------
format(%fmt) specifies the display format for matrices. The default is
format(%9.5f).
blanks(#) specifies that small values of the rotated matrix -- i.e.,
those elements of A (T')^{-1} that are less than # in absolute value
-- are displayed as spaces.
nodisplay suppresses all output except the log and trace.
noloading suppresses the display of the rotated matrix.
norotation suppresses the display of the optimal rotation matrix.
matname(str) is a rarely used output option; it specifies a descriptive
label of the matrix to be rotated.
colnames(str) is a rarely used output option; it specifies a descriptive
name to refer to the columns of the matrix to be rotated. For
instance, colnames(components) specifies that the output labels the
columns as "components". The default is "factors".
+--------------+
----+ Optimization +-----------------------------------------------------
optimize_options control the iterative optimization process. These
options are seldom used.
iterate(#) is a rarely used option; it specifies the maximum number
of iterations. The default is iterate(1000).
log specifies that an iteration log be displayed.
trace is a rarely used option; it specifies that the rotation be
displayed at each iteration.
tolerance(#) is one of three criteria for declaring convergence and
is rarely used. The tolerance() convergence criterion is
satisfied when the relative change in the rotation matrix T from
one iteration to the next is less than or equal to #. The
default is tolerance(1e-6).
ltolerance(#) is one of three criteria for declaring convergence and
is rarely used. The ltolerance() convergence criterion is
satisfied when the relative change in the minimization criterion
c() from one iteration to the next is less than or equal to #.
The default is ltolerance(1e-6).
protect(#) requests that # optimizations with random starting values
be performed and that the best of the solutions be reported. The
output also indicates whether all starting values converged to
the same solution. When specified with a large number, such as
protect(50), this provides reasonable assurance that the solution
found is the global maximum and not just a local maximum. If
trace is also specified, the rotation matrix and rotation
criterion value of each optimization will be reported.
maxstep(#) is a rarely used option; it specifies the maximum number
of step-size halvings. The default is maxstep(20).
init(matname) is a rarely used option; it specifies the initial
rotation matrix. matname should be square and regular
(nonsingular) and have the same number of columns as matrix
matrix_L to be rotated. It should be orthogonal (T'*T = T*T' =
I) or normal (diag(T'*T) = 1), depending on whether orthogonal or
oblique rotations are performed. init() cannot be combined with
random. If neither init() nor random is specified, the identity
matrix is used as the initial rotation.
random is a rarely used option; it specifies that a random orthogonal
or random normal matrix is to be used as the initial rotation
matrix. random cannot be combined with init(). If neither
init() nor random is specified, the identity matrix is used as
the initial rotation.
Rotation criteria
In the descriptions below, the matrix to be rotated is denoted as A, p
denotes the number of rows of A, and f denotes the number of columns of A
(factors or components). If A is a loading matrix from factor or pca, p
is the number of variables, and f the number of factors or components.
Criteria suitable only for orthogonal rotations
varimax and vgpf apply the orthogonal varimax rotation. varimax
maximizes the variance of the squared loadings within factors
(columns of A). It is equivalent to cf(1/p) and to oblimin(1).
varimax, the most popular rotation, is implemented with a
dedicated fast algorithm and ignores all optimize_options.
Specify vgpf to switch to the general GPF algorithm used for the
other criteria.
quartimax uses the quartimax criterion. quartimax maximizes the
variance of the squared loadings within the variables (rows of
A). For orthogonal rotations, quartimax is equivalent to cf(0)
and to oblimax.
equamax specifies the orthogonal equamax rotation. equamax maximizes
a weighted sum of the varimax and quartimax criteria, reflecting
a concern for simple structure within variables (rows of A) as
well as within factors (columns of A). equamax is equivalent to
oblimin(p/2) and cf(f/(2p)).
parsimax specifies the orthogonal parsimax rotation. parsimax is
equivalent to cf((f-1)/(p+f-2)).
entropy applies the minimum entropy rotation criterion.
tandem1 specifies that the first principle of Comrey's tandem be
applied. According to Comrey (1967), this principle should be
used to judge which "small" factors should be dropped.
tandem2 specifies that the second principle of Comrey's tandem be
applied. According to Comrey (1967), tandem2 should be used for
"polishing".
Criteria suitable only for oblique rotations
promax[(#)] specifies the oblique promax rotation. The optional
argument specifies the promax power. Not specifying the argument
is equivalent to specifying promax(3). Values less than 4 are
recommended, but the choice is yours. Larger promax powers
simplify the loadings (generate numbers closer to zero and one)
but at the cost of additional correlation between factors.
Choosing a value is a matter of trial and error, but most sources
find values in excess of 4 undesirable in practice. The power
must be greater than 1 but is not restricted to integers.
Promax rotation is an oblique rotation method that was developed
before the "analytical methods" (based on criterion optimization)
became computationally feasible. Promax rotation comprises an
oblique Procrustean rotation of the original loadings A toward
the elementwise #-power of the orthogonal varimax rotation of A.
Criteria suitable for orthogonal and oblique rotations
oblimin[(#)] specifies that the oblimin criterion with gamma = # be
used. When restricted to orthogonal transformations, the
oblimin() family is equivalent to the orthomax criterion
function. Special cases of oblimin() include
+------------------------------------+
| gamma Special case |
|------------------------------------|
| 0 quartimax / quartimin |
| 1/2 biquartimax / biquartimin |
| 1 varimax / covarimin |
| p/2 equamax |
+------------------------------------+
p = number of rows of A.
gamma defaults to zero. gamma < 0 is recommended for oblique
rotations. For gamma > 0 it is possible that optimal oblique
rotations do not exist; the iterative procedure used to compute
the solution will wander off to a degenerate solution.
cf(#) specifies that a criterion from the Crawford-Ferguson family be
used with kappa = #. cf(kappa) can be seen as (1-kappa)cf_1(A) +
kappa cf_2(A), where cf_1(A) is a measure of row parsimony and
cf_2(A) is a measure of column parsimony. cf_1(A) attains its
greatest lower bound when no row of A has more than one nonzero
element, whereas cf_2(A) reaches zero if no column of A has more
than one nonzero element.
For orthogonal rotations, the Crawford-Ferguson family is
equivalent to the oblimin() family. For orthogonal rotations,
special cases include the following:
+----------------------------------------+
| kappa Special case |
|----------------------------------------|
| 0 quartimax / quartimin |
| 1/p varimax / covarimin |
| f/(2p) equamax |
| (f-1)/(p+f-2) parsimax |
| 1 factor parsimony |
+----------------------------------------+
p = number of rows of A.
f = number of columns of A.
bentler specifies that Bentler's "invariant pattern simplicity"
criterion be used.
oblimax specifies the oblimax criterion. oblimax maximizes the
number of high and low loadings. oblimax is equivalent to
quartimax for orthogonal rotations.
quartimin specifies that the quartimin criterion be used. For
orthogonal rotations, quartimin is equivalent to quartimax.
target(Tg) specifies that A be rotated as near as possible to the
conformable matrix Tg. Nearness is expressed by the Frobenius
matrix norm.
partial(Tg W) specifies that A be rotated as near as possible to the
conformable matrix Tg. Nearness is expressed by a weighted (by
W) Frobenius matrix norm. W should be nonnegative, and usually
is zero-one valued, with ones identifying the target values to be
reproduced as closely as possible by the factor loadings, whereas
zeros identify loadings to remain unrestricted.
Remark on identification
All supported criteria are invariant with respect to permutations of the
columns and change of signs of the columns. rotatemat returns the
solution with positive column sums and with columns sorted by the L2
norm; columns are ordered with respect to the L1 norm if the columns have
the same L2 norm.
Examples
. rotatemat L
. rotatemat X, oblique
. rotatemat L, entropy protect(20)
Saved results
rotatemat saves the following in r():
Scalars
r(f) criterion value
r(iter) number of GPF iterations
r(rc) return code
r(nnconv) number of nonconvergent trials; protect() only
Macros
r(cmd) rotatemat
r(ctitle) descriptive label of rotation method
r(ctitle12) version of r(ctitle) at most 12 characters long
r(criterion) criterion name (e.g., oblimin)
r(class) orthogonal or oblique
r(normalization) kaiser or none
r(carg) criterion argument
Matrices
r(T) optimal transformation T
r(AT) optimal AT = A(T')^-1
r(fmin) minimums found; protect() only
Also see
Manual: [MV] rotatemat
Help: [MV] rotate;
[MV] procrustes
