+---------------------------------------------------+ | PQMethod - 2.35 | | (Mar 2014) | +---------------------------------------------------+ | by Peter.Schmolck@web.de | | Adapted from Mainframe-Program QMethod | | by John Atkinson at KSU | +---------------------------------------------------+ | The QMethod Page: | | http://schmolck.org/qmethod/ | +---------------------------------------------------+
New in 2.35: In the context of securing compatibility with 64bit versions of Windows as well as with Linux,
STATES and VIEWLIST (replaces: 'View project files') were updated
New in 2.33 & 2.32 : minor bugs cleared
New in 2.31: Additional data output format .tsv
New in 2.30: Option of an alternative Centroid method (Horst 5.5)
New in 2.20: 'Exact' factor scores (á la SPSS)
PQMethod is a statistical program tailored to the requirements of Q studies. Specifically, it allows to easily enter data (Q-Sorts) the way they are collected, i.e. as 'piles' of statement numbers. It computes intercorrelations among Q-Sorts, which are then factor-analysed with either the Centroid or Principal Component method. Resulting factors can be rotated either analytically (Varimax), or judgmentally with the help of two-dimensional plots. Finally, after selecting the relevant factors and 'flagging' the entries that shall define the factors, the analysis step produces an extensive report with a variety of tables on factor loadings, statement factor scores, discriminating statements for each of the factors as well as consensus statements across factors, etc.
PQMethod was adapted, revised and is maintained by Peter
Schmolck. The FORTRAN-77 code on which it is based was originally
written for the mainframe by John Atkinson under the guidance of
Steven Brown at Kent State University. PQMethod is free, with all
the usual legal disclaimers, of course. The most recent version
can be downloaded from the QMethod
Page.
The seemingly antiquated programming language FORTRAN is quite
useful still for implementing mathematical-statistical algorithms, and
additionally,
PQMethod's FORTRAN-77 source code can easily be ported to all types of
computers. But FORTRAN is not itself designed for graphic user interface
with mouse support, and it has no built-in possibilities for displaying
results in graphic form. PQMethod users have learned to accept that
PQMethod is no point-and-click Windows program, but graphic rotation and
flagging of factors in the original, text-only mode (can be invoked
still as the "old" version of QROTATE) was actually worse than
just awkward to use. Fortunately, in 1999 Andreas Zollorsch, a student
assistant at that time, created a user friendly software for that
purpose as a separate program (PQROT) that can automatically be
launched from within PQMethod. Unfortunately, however, PQROT, written in
Turbo-Pascal, cannot easily be ported to platforms that do not fully
support MS-DOS, like Windows Vista and later. Therefore, beginning in
May 2008, PQMethod for Windows was provided as a package bundled with
the free DOS emulator software DOSBox.
In the same vein, a DOSBox version of PQMethod has also been created
for Mac OS X. In February 2012 I eventually managed to port the PQROT
Turbo Pascal code to the windows version of free pascal, and since version 2.3x there exist windows versions of PQMethod.exe and PQROT.exe that do not require DOSBox anymore.
This manual itself originates from the QMethod-Help file which is part of the original QMethod system for the mainframe, and authored by John Atkinson (and / or Steven Brown).
Requirements: PQMethod for
Windows now runs on all versions of Windows. There also exists an MS-DOS
version of PQMethod that can be run with the free MS-DOS emulator DOSBox
which is available for Mac OS X and Linux (and Windows). For both, Mac
and Windows, exist PQMethod download packages that are bundled together
with the DOSBox emulator. The PQMethod.exe executable for MS-DOS
contained in the package may not be the latest release, but can be
updated by downloading a separate zip file with the latest release of
the executable (and accompanying PQManual).
Limitations: The maximum
values allowed in PQMethod are 299 sorts (subjects) and 200
statements. The maximal number of factors that will be
extracted is 8 factors. The Q-Sort design may have a
maximum of 13 piles or columns, with a maximal pile
size of 50. The maximal length of statements displayed in the
output listing is 60 characters (excess of text will be
truncated).
The system is composed of several pieces which lead from the
individual Q-Sorts which you collect to a final analysis of the
data. The first option, STATES, allows you to edit a file where
you will enter the text of the q-sort statements. These are not
used again until the QANALYZE routine at the end. Next is a
routine called QENTER which allows you to enter the data directly
from the sorts that you have collected. The next step consists in
creating a correlation matrix from the raw sorts, and performing
a factor analysis on the correlation matrix. This is the first
point where you have to choose between two alternatives: Select
QCENT for a Centroid factor analysis, or QPCA for Principal
Component analysis. After that, you need to choose a rotation
method, and PQMethod gives you the choice of QROTATE, which
allows you to manually rotate the factors, or QVARIMAX, which
performs a varimax rotation on the factors. Finally, the rotated
factor matrix is input to the QANALYZE routine, which
differentiates the factors based on the original q-sort
statements.
Now, let's look at the overall procedure and then the individual routines in more detail.
For any study, you need to establish one name. This name will be the file name of all files associated with the project, so it must conform to the standards of MS-DOS filenames: from 1 to 8 characters. For the example that follows, we will use the name mystudy. Note: Using the name lipset instead would give access to the ready-to-use example data set. You can skip routines 1 and 2 and start with 3 - QCENT or 4 - QPCA for an analysis of the 'Lipset study' example.
When you start PQMethod you will be asked for the project
name, and after entering the name ('mystudy') you will see Screen
1:
Enter [Path and] Project Name:
mystudy
Current Project is ... c:/pqmethod/projects/mystudy
Choose the number of the routine you want to run and enter it.
1 - STATES - Enter (or edit) the file of statements
2 - QENTER - Enter q sorts (new or continued)
3 - QCENT - Perform a Centroid factor analysis
4 - QPCA - Perform a Principal Components factor analysis
5 - QROTATE - Perform a manual rotation of the factors
6 - QVARIMAX - Perform a varimax rotation of the factors
7 - QANALYZE - Perform the final Q analysis of the rotated factors
8 - VIEWLIST - View output file mystudy.lis
X - Exit from PQMethod
Last Routine Run Successfully - (Initial)
|
Screen 1
From this point, we simply choose the routine we want to run,
starting with STATES.
Though STATES is #1 in the main menu, you can as well postpone execution until you are ready to perform the final QANALYZE routine.
Choosing option #1 provides the possibility to enter the
statements: For this purpose PQMethod opens an external editor program
for you (Notepad.exe in the Windows version of PQMethod). Every
statement must be typed as a single line (without empty
lines between them). Note that all records will get truncated to
60 characters in the final output listing, since that is the
maximum for statement text in PQMethod. You might think about
appropriately abbreviating longer statements, instead of having
them truncated by the program.
It is essential that the
statements are in the correct order (the same as the numbers that
were used to enter in the q-sorts). You do not need to number
each statement, however, as they will be labeled on the output in
the QANALYZE module. Just be sure to enter the statements in the
correct order. When you are finished with
editing (dont't forget the final hard return after the
last statement!), exit the editor program for returning to
PQMethod. As a matter of fact, you can also create your statements file with the name <project>.sta (e.g., mystudy.sta) on your own, and copy it into the projects folder where your other <projects>.* files are.
Since version 2.35 of PQMethod the somewhat awkward alternatives of 'importing' statements from an existing file or entering statements without an editor program were discarded, as well as the automatic cutting of the statements to 60 characters. As mentioned above, the QANALYZE module cannot print more than 60 characters of statement text. But there is no such limit in statement length for the pair of little tools, PQM2HTM / PQM2MHTM that can be used to visualize every sort of your project's .dat file in a q-sort format.
QENTER is used to enter data directly from the q-sorts you have administered. The file that is created by QENTER can be created by another source, but it must be modified for entry to factor analysis, etc. See the appendix for details about record formats.
When you run QENTER, you don't have to enter all of the q-sorts at one time. You can quit whenever you like and continue data entry the next time you run QENTER. This is the first question QENTER asks you. However, if this is the beginning of data entry, you will need to enter a title for the study (up to 68 characters), and all of the details of the q-sort design used.
The screen you see at first will be as in Screen 2. Note that
you will only enter the title if you are not continuing
data entry.
Last Routine Run Successfully - (Initial) 2 Checking old input data file .... Enter the title of your study to a max of 68 characters. ____________________________________________________________________ MYSTUDY My first attempt to do a Q analysis |
Screen 2
Screen 3 shows what this detail entry would look like.
Remember, this is only entered the first time for any design. A
file containing this data is created so you can continue entering
data later or go back and modify or delete previously entered
sorts.
How many q statements are there? 33 Enter the leftmost column value (e.g. -5): -4 Enter the rightmost column value (e.g. 5): 4 Enter the Number of Rows for each Column from -4 to 4. For Example: 2 3 3 4 4 4 3 3 2 : 2 3 4 5 5 5 4 3 2 |
Screen 3
Now you are ready to begin entering q-sorts. The first screen you will see is the main menu, from which you can also change, delete, or show any sort, as well as query the current Q design. The first time through, of course, we will choose to add a new sort, as shown in Screen 4 (note that the request can be a lower case letter).
On many of the following screens, you are asked to enter
information at various prompts. On virtually any of those
screens, you can always abort the current process by entering the
the words QUIT or STOP.
Ready to process another sort. Enter one of the following codes: A - to add a new sort C - to change a previous sort D - to delete a sort S - to show a previous sort Q - to query status of this study X - to exit QENTER (stop entering/changing sorts) a |
Screen 4
When you add a sort, you will be asked at first to enter an
identification code (Sort Id) for the sort or person you are
going to enter next.
Then you will be prompted for the values for a single person
one column at a time, starting from the left (lowest value)
column. Although the design has to be symmetrical, the individual
q-sorts do not, so you can enter 3 values, for example, even if
the design says the column only contains 2. The entries do not
need to be in any order, such as ascending, but there must be a
space between each number. An example of data entry is shown in
Screens 5 and 6.
Enter identification code for subject no. 1 (A case label consisting of max. 8 characters) MySt01F Enter the Sort Values for Subject 1 MySt01F Enter the Statement Numbers, Separated by Spaces, for Column -4: 16 20 Enter the Statement Numbers, Separated by Spaces, for Column -3: 18 17 30 Enter the Statement Numbers, Separated by Spaces, for Column -2: 3 5 31 32 Enter the Statement Numbers, Separated by Spaces, for Column -1: 1 15 19 8 10 Enter the Statement Numbers, Separated by Spaces, for Column 0: 26 2 4 7 9 Enter the Statement Numbers, Separated by Spaces, for Column 1: 11 6 12 25 24 |
Screen 5
(Continuation of Subject 1 MySt01F ) Enter the Statement Numbers, Separated by Spaces, for Column 2: 13 22 28 29 Enter the Statement Numbers, Separated by Spaces, for Column 3: 14 21 23 Enter the Statement Numbers, Separated by Spaces, for Column 4: 27 33 |
Screen 6
When you have entered all of the values, you will be shown a
picture of what this q-sort looks like. If there are mistakes,
such as numbers too large or appearing more than once, you will
have to make corrections. You can also make any changes you want
even if the sort is OK. Any corrections are made one column at a
time, so you may have to go through this process a couple of
times to make changes. An example is shown in Screen 7.
-4 -3 -2 -1 0 1 2 3 4
!----!----!----!----!----!----!----!----!----!
! 16 ! 18 ! 3 ! 1 ! 26 ! 11 ! 13 ! 14 ! 27 !
!----!----!----!----!----!----!----!----!----!
! 20 ! 17 ! 5 ! 15 ! 2 ! 6 ! 22 ! 21 ! 33 !
!----!----!----!----!----!----!----!----!----!
! 30 ! 31 ! 19 ! 4 ! 12 ! 28 ! 23 !
!----!----!----!----!----!----!----!
! 32 ! 8 ! 7 ! 25 ! 29 !
!----!----!----!----!----!
! 10 ! 9 ! 24 !
!----!----!----!
SubjNo: 1 ID: MySt01F
The Sum is 0.00, and the Mean is 0.00, for Subject 1 MySt01F
The Sort is OK, Do You Want to Change It Anyway? (y/N):
|
Screen 7
If you just hit the enter key in response to the above questions, the default answer will be, NO, no changes, and YES, enter another sort. If you do say you want to change the sort anyway, or if there is some problem, such as a missing number or a number entered twice (there is no provision for missing data at this time), then you will enter the change process.
In the example above, suppose you wanted to exchange the statements 13 and 14 in the sort. When asked which row to change, you could give either '2' or '3'. If you first changed column 2 to contain the numbers 14, 22, 28, & 29, you would then have two 14's and no 13. So you could then change column 3 to contain 13, 21, & 23. Most changes will require a couple of iterations such as this.
When you are done entering q-sorts, you would answer 'N' to the second question:
Do you want to enter another sort? (Y/n)
n
(If you've inadvertently hit the enter key for Yes
instead of answering No, keep inputting empty inputs until the
question appears again.)
This will take you back to the QENTER menu where you can choose other options if you wish. If you choose option X from that menu, then the standard data file will still be written out, so you can move on to the next stage (either QCENT or QPCA), but also have the option of going back and adding, deleting, or modifying sorts later.
When you exit QENTER, control returns to the menu.
Note on PQMethod's three raw data file formats. There are
essentially two formats of the Q-sort data matrix that are supported,
and
automatically generated by QENTER: (a) the regular form with
sorts as rows and items as columns, and (b) the old inverted form
(used by mainframe QMethod and PQMethod 1.xx) with items as rows
and sorts as columns. The file <project>.dat, which is
required as input to QCENT / QPCA and to QANALYZE contains the
data matrix in the regular format (a). The file
<project>.raw which is of the form (b) might be useful if
you wish to analyse your Q-sort data with another statistical
software package. QENTER always outputs the data entered in both
file versions, and it also converts between file formats
automatically. If only either one of the two files exists, the
other one will be created. For instance, if you have got the file
oldstudy.raw that you once created with a former version of
QMethod software, all you need to do for creating the
oldstudy.dat file is to start QENTER once, and e(X)it it
immediately again. Since version 2.31, an additional, output only,
tab-separated, format was added that might prove useful in the future
for importing the PQMethod generated data into another, modern Q
software. For further details see Appendix
A.
QCENT (Centroid analysis) and QPCA (PCA, Principal Components analysis) are alternative options for extracting (unrotated) factors. Centroid analysis, the method of choice for Stephenson and his followers, is not much used outside the Q community nowadays, whereas Principal Components analysis is the default method of factor extraction in statistical packages like SPSS.
Both, QCENT and QPCA first take the rawdata file created by
QENTER and compute and output a correlation matrix into a file
with file-name extension .cor. Then, an unrotated factor loadings
file (.unr) is created by the application of the respective
method of factor analysis.
Since version 2.30, QCENT offers the option of choosing between two
methods of Centroid extraction, the customary method described in Brown (1980), and Horst's (1965) method with iterative solutions for communalities.
Brown Centroids: As a default, it suggests the 'magical number' of
seven Centroids to extract. However, you can change that; the
maximal number of factors PQMethod can handle is eight. In fact,
under normal conditions, there is no good reason for selecting
less than 7 factors, since upon rotation of factors you can
choose how many of the unrotated factors to use. QPCA
always computes eight factors, which is the maximum number
of factors PQMethod can process. This does not mean that you have
to take into account all factors up to the eighth for either
judgmental or Varimax rotation which follow later. Note:
In "Brown-Centroid" as well as PCA, but not in "Horst-Centroid", the composition of the 1st, 2nd, 3rd, etc. factors
extracted do not depend in any way on how many (additional)
factors are extracted altogether.
Horst's Centroid method
uses a somewhat more refined approach in the way the diagonal entries
in the correlation matrix are estimated, and it was implemented in
PQMethod because it did not show certain irregularities that were found
with several data sets when analyzed with the customary Centroid method.
You can either determine how many factors to be extracted (max. 8)
or let the program determine when to stop extracting factors
according to what Horst suggested as the limiting level of residual
correlations (average r2 < 1/NITEMS). Since in this method
the final communalities are iteratively entered as diagonal entries in
the initial correlation matrix, all factors in a solution depend on the
number of factors the user asks to extract. The final average residual
correlation is displayed on screen, and the iterated series of
communality estimates and the residual correlation matrix are written
after the factor loading matrix in the unrotated-factors file (.unr).
QPCA computes and outputs all Eigenvalues (and
corresponding percentage figures) on screen as well as to the
unrotated-factors file (.unr). The absolute and relative sizes of
the Eigenvalues are of some importance when deciding on how many
factors to keep for rotation.
Now it is time to rotate the factors. You have two options: you can rotate the factors by hand, or you can perform a Varimax rotation (as described in the next section). You would not normally do both, unless you wanted to compare the methods. If you choose QROTATE to rotate the factors yourself, you are first asked if this is a continuation. If you say 'no', then the file output by QCENT or QPCA, respectively, the unrotated factors file (.unr), will be the only input. If you say this is a continuation, then an intermediate file (.hro) created the last time you ran QROTATE is used instead. In either case, at the end of this session, a new intermediate file is written out, and you always have the option of running QROTATE again and using either this file or the original file of unrotated factors (if you want to start over).
First, QROTATE will list the factor loadings for you, and you must then choose which factors you would like to rotate. You will work on just one pair of factors at a time, but you can always go back to a pair later. Once you establish an appropriate angle between factors 1 and 2, you can then rotate 1 and 3, or 2 and 3, for instance, without affecting the angle between 1 and 2. Once you have rotated the axes to your satisfaction, the current array of factor loadings will be displayed again.
You rotate factors simply by giving a number of degrees. A positive number rotates the axes clockwise, and a negative number counter-clockwise. Your goal is to get clusters of subjects close to an axis. This would generate the highest possible loadings on that factor for those subjects. In addition, it is advisable to attempt to load subjects positively, so you want to do rotations which leave subjects close to the positive axes (the ones at 12 o'clock and 3 o'clock). A rotation of 180 would reverse the orientation of both axes, for example. Reversing the orientation of one factor only without affecting other factors is possible with a little trick: Plot this factor against itself, and then rotate the axes 180 degrees. -- The new PQROT provides a special function for inverting a factor!
If you press <ENTER> without entering a rotation, you can then choose another set of factors to rotate.
When you are done rotating, simply press <ENTER> instead of the numbers of two factors to rotate.
'Flagging' factors: Now you can choose to associate particular subjects with factors. This is necessary for input to the QANALYZE routine that will come next, so you want to do this if you are ready to move on. You can pass if you are going to come back and do more rotating later. If you choose to flag factors now, press <ENTER>. However, if you wish the program to 'pre-flag' factors first, press <p>.
The flags provided automatically by PQMethod may not be exactly what you want, but at least you can see how the result of flagging the factors might look like, and thereafter you can go over each factor in turn, and make your own selections -- or accept the pre-flagging for a first test run of QANALYZE. (The QANALYZE module calculates a synthetic Q-sort, or factor prototype sort, for each factor consisting of a weighted average of the sorts of those subjects that were flagged for the factor.)
To flag specific subjects, simply enter the number of the factor when asked, and then enter the subjects (sorts) to be associated with that factor. After you have done this, the matrix is displayed again for you, and you can flag another factor.
When you are done flagging factors, you choose which factors you want to write to the output file, the file that will be the input to QANALYZE. The type of this file will be 'rotated factor matrix' (file extension .rot). The factors are written to the file in the order you specify, so you can choose the order that is most natural (first write out the factor associated with the first subject, etc.).
At least one of the factors written to the output file (.rot) must be flagged for at least one subject, 'unflagged' factors are automatically dropped by QANALYZE.
If you change your mind later about the subjects flagged, you can edit the .rot file and change any flags desired. -- The new PQROT provides an easier an secure interface for editing flags!!
See Appendix B for an example of hand rotation.
If you choose not to rotate the factors yourself, you can
choose a varimax rotation. QVARIMAX takes in the unrotated matrix
file (.unr) created by QCENT or QPCA, and asks for the number of
factors you wish to rotate. If you just press the <ENTER>
key, all unrotated factors will be rotated to the Varimax
criterion (not usually to be recommended!). After the VARIMAX
rotation is performed, you are then given the option to do
further rotating by hand if you want, or you can simply flag the
factors and write them out, just as you would if you had done the
entire rotation by hand.
Last Routine Run Successfully - QPCA 66 |
Screen 8
Whether you only want to flag factors (which is required
before running the final QANALYZE step) or do further hand
rotating, the new PQROT program can be used for both. See section
(5) QROTATE for details.
Finally, you need to choose QANALYZE (#7 from the main menu)
to give you a complete analysis of the q-sorts you collected.
7
PQMethod is going to write the report into the file
c:/pqmethod/projects/lipset.lis
with max. 132 chars/line and 52 lines/page
Do you want to change no. lines/page? (y/N):
|
Screen 9
You may simply press <ENTER> at this point, and accept the default of 52 lines/page, since you can repeat this step later again. Considerations regarding printing the report listing will be discussed later in this section.
QANALYZE uses the statement file (extension .sta) that contains the text of all the statements, the raw-data file (.dat) that is generated by the QENTER routine (or provided beforehand as a plain text file) and the rotated factor loadings (.rot) file that was created by QROTATE or QVARIMAX. In addition, just for display purposes, it uses the correlations file (.cor), and the unrotated factor matrix file (.unr).
QANALYZE stops processing with an error message if any of the
required files either is not found or is incomplete (e.g., factor
loadings in the .rot file not flagged, see section 5-QROTATE).
When run, QANALYZE creates a written report in a listing file
(.lis) that is actually sent to disk, just like all the other
files in this system. You can view this file with option #8 (see next section) and look at it on-line, and, after
finishing PQMethod, (edit and) print it out with your favorite
text program.
Printing the listing file (.lis) is best accomplished with the help of a text program (like Word or Wordpad). Having loaded the file, choose either landscape or portrait orientation for page setup, and select the entire text for formatting type and size of font. Be sure to choose a fixed-pitch font (e.g., Courier New) and a font size small enough such that lines would not be broken. The QANALYZE default for the number of lines/page, 52, corresponds to landscape page orientation, and a font size of 8 (15 pitch, characters per inch). Printing in portrait page orientation would allow double the number of lines per page, but requires a tiny font size of 6 or 5 (20 or 24 pitch) and somewhat reduced margins. Note: Usuallly, not all of the tables produced by QANALYZE are required for interpretations; for printing only parts of the report, simply delete the remainder.
In the PQMethod output factors are referred to in a confusing number
of different ways. And because version 2.20 introduces an additional
variant, the 'exact' factor scores, it seems appropriate for the updated
PQManual to provide a reasonably comprehensive account on the meaning details of factors and their scores.
In Q factor analysis persons (or, more generally: sorts) load on factors, statements have scores on factors.
A factor is defined basically
by a selection of persons who unambiguously load highly on the
factor, as shown in the factor (loading) matrix. For the interpretation of
the factors knowing these persons and their factor loading coefficients
is of comparably little value. Of more relevance are the perspectives of these
persons as revealed in their individual q-sorts, and the common themes
running through their individual views which as a generalized,
shared perspective make their sorts correlate highly with one and the
same factor. The central goal of the analysis consists in the
creation of one idealized, prototype sort
for each factor as the best possible, intrinsically coherent,
representation of what is general in the individual views associated
with the factor.
wij = aij / (1 - a2ij)
where aij is the factor loading of the ith individual on the jth factor, and wij is
the weight. Compared to the regression approach for the
computation of exact factor scores (á la SPSS, see below), this
is a very simple formula. In effect the weights overproportionally
increase the impact of higher loadings on the respective factor.
The way factor scores are computed in Q methodology accomodates the
fact that the groupings of persons that are selected as factor
representatives do not usually fall into orthogonal positions in factor
space, as do the factor axes themselves which are located for
representing the configuration of sorts with maximal parsimony. Factor
scores therefore usually are correlated to at least a small to medium
degree, with the size of the correlations reflecting the relative degree
of similarity vs. distinctiveness.
Over-factoring, i.e., rotating more factors than there exist distinct
perspectives, results in conspicuously high factor score
intercorrelations. A reasonable rule of thumb would not, except for well
founded reasons, accept a factor solution with factor score
intercorrelations in the order of magnitude of the factor loadings of those sorts that appear suited to represent a factor.
Ranks: As
an intermediate step the factor scores are rank-ordered, and the
statements' factor scores with their associated ranks are reported
in a synoptic table.
Factor Arrays with Q-Sort Values:
Based on the rank orderings of their factor Z scores, the statements
are "sorted" for each factor into the q-sort "slots" from, e.g., -4 to
+4. It may be noted here that this (non linear) transformation of
the factor scores is nothing but a matter of convenience. An array of
weighted averages of q-sort arrays that each follows a forced-choice
distribution does not naturally fall into the same form of distribution.
'Exact' Factor Scores:
What I, for the sake of clarity, call 'exact' factor scores here
is the normal version of factor scores outside the Q methodology
context. In the case of principal component extraction these factor
scores are not estimates only but identical with the factors. They are
uncorrelated, and the sorts' correlations with the factor scores
do not differ from their factor loadings (except for small rounding
deviations). The exact factor scores are not computed if Centroid extraction was selected.
They are printed in two different scales, the z- and the T-scale.
Compared to the z-scale (mean 0, std dev 1) the T-scale (mean 50, std
dev 10) simply has the advantage of non-negative numbers without
decimals. This format was chosen because it allows to write the scores
out with sufficient precision in the PQMethod data format that allows
for two digits only (see next section).
I did not implement the exact factor scores as an alternative to be
used for factor interpretation. In my view the orthogonal factors as
operationalized by their exact scores are artificial composites
incorporating the views of all persons
with varying positive and negative (!) weights. The main application I
had in mind for which the exact factor scores are better suited than the
conventional factor arrays lies at the interface between Q methodology
and psychometric or survey research applications: If the Q factor
loadings shall be used as measures of a person's relative affinities to
the perspectives associated with the factors, then the q-sorts of new
persons or new samples of persons can be projected into the factor space
of the derivation sample by correlating their q-sorts with the exact
factor scores from this original sample. For this purpose the exact
factor scores are preferable to the conventional Q factor scores
(either z-scores or q-sort values) for two reasons: They make use
of all available information for explaining the maximal possible
amount of variance (in the oiginal sample), and due to their orthogonality they avoid mutual
confounding of the factor measures as a consequence of built-in overlap.
Another potential application consists in the systematic comparison of
the factors from factor analysis solutions with differing numbers of
factors. This offers the possibility to see how factors at consecutive
steps of analysis (1, 2, 3 ... factors rotated) may appear again with
little change or split in two, etc. before dwelling on the detailed
interpretation of all the factors from every solution.
Important note: There is a trick of the trade for splitting a bipolar
factor that amounts to saving the same factor, with reversed signs,
twice. PQMethod does not check for that irregularity in the factor
loading matrix (.rot) and outputs faulty results in the Exact Factor Scores table this case.
Both versions of factor scores are written into files for using the
scores as data input for separate analyses. The conventional, q-sort
value 'factor arrays' are output into the file fax.dat, the 'exact' factor scores (in T-scale values) into the file xfax.dat.
PQMethod does not overwrite these output files with every new run, the
new data are appended instead at the end of the existing files, every
time QANALYZE is run. Every entry in the files is formatted like a
PQMethod raw-data
file, with the first header line containing project name, and
date and time of the QANALYZE run that produced it. Importing
factors from fax.dat or from xfax.dat into a PQMethod raw-data file
(.dat) requires manual editing; see Appendix A
for details on how a .dat file has to be set up.
The most typical applications for the conventional factor scores are secondary factor analysis and 'spiking':
Secondary or second-order factors in the strict sense are
higher-order, or simply: more general, factors that result from a
second-step factor analysis of 'primary' factors extracted and
obliquely rotated in a first step. This kind of analysis, though
technically possible using PQMethod, does not appear to be particularly
useful in Q methodology. Q researchers, however, use the term more
loosely, when they analyze how factors from different P
samples relate to each other. Another technical variant of relating
types of perspectives found in one P sample to those of another P sample
consists in 'spiking' the data set of the one sample with the factor
arrays of the other.
The 'exact' factor scores
are new in PQMethod, and future will show whether they will be found
useful in applied settings where Q methodology based measurement
instruments are sought for. The second kind of application suggested
above, correlating factors from consecutive factor solutions with one,
two, three, four, etc., was introduced as a practical way for
structuring the interpretation process. Actually, from there it's only
a small step to the intriguing 'bass-ackwards' method for "examining the
hierarchical structure of a set of variables, based on factor
scores
from rotated solutions involving one to many factors" introduced to
personality psychology by Lew Goldberg (2006). It's not the place here
for giving an introduction to the bass-ackwards method. If I could
arouse your curiosity, though, get the Goldberg (2006) paper that
contains several examples of graphical displays of hierarchical factor
structures, and the tool for creating such diagrams (Levine, Schaaf,
& Goldberg, 2005):
Levitin, D. J., Schaaf, A., & Goldberg, L. R. (2005). Factor
diagrammer (Version 1.1b). Montreal: McGill University (computer
software) <http://
www.psych.mcgill.ca/labs/levitin/software/factor_diagrammer/>.
Choosing option #8 transfers control to an external 'viewer program'
that opens the output listing, <project>.lis, which was created
with QANALYZE. In the Windows version of PQMethod, the default 'viewer program' is the Windows Editor, notepad.exe. After
exiting the viewer program, PQMethod resumes control again.
VIEWLIST replaces the former 'View project files
<project>.*' as implemented until version 2.34, which was meant to
allow browsing through all the project's files not only the output
listing. In the course of discarding the former little DOS tools for
editing and viewing PQMethod files, no suitable free Windows software
for browsing multiple files was found, and since this functionality
deemed not really demanded in a Windows environment, the option #8
was redefined.
The standard viewer program, VIEW86, has its own help page accessed by pressing F1, but the most important key functions will be given here as well:
Note: Newer versions of Windows may not support MS-DOS programs like VIEW86 any
more. But you can always view a PQMethod project file by loading it in a
text program like Notepad Editor. Files are free for external access
not only after PQMethod is finished but also everytime you stop at the
main menu.
Most computations performed in PQMethod are designed after concepts and formulas that are described in
Brown, S.R. (1980). Political subjectivity: Applications of Q methodology in political science. New Haven: Yale University Press
For instance, the algorithm used for Centroid
extraction, is fully documented in Brown (1980).
PCA is a standard, and mathematically unambiguous procedure, that can be found in standard textbooks on factor analysis. I have double-checked its implementation in PQMethod against SPSS for several data sets. (The same is true for Varimax rotation.)
The pre-flagging algorithm is designed to flag 'pure' cases only, according to the rule: Flag loading a
if (1) a2 > h2/2 (factor 'explains' more than half of the common variance)
and (2) a > 1.96 / SQRT(nitems) (loading 'significant at p<.05').
Please note that the selection of factor-defining sorts is a matter of reasoned judgment, and as indicated by the prefix 'pre-', this algorithm is not meant as a definitive statistical solution for that -- notwithstanding the possibility that your own judgment turns out to greatly coincide with what the program suggests.
Since version 2.11, an additional
table, "Cumulative Communalities Matrix",
is provided right after the unrotated factor matrix. The
communality, h2, of a sort assesses
the proportion of its variance accounted for by the factors. h2
is computed as the sum of the squared factor loadings (a2)
, and therefore increases with the number of factors extracted.
Communality coefficients are not affected by factor rotation,
i.e., rotation of a given number of extracted (unrotated)
factors, does not change any sort's h2.
The Cumulative Communalities Matrix is a synoptical table that
displays the h2 coefficients for any
number of extracted factors one might decide to keep for
rotation.
All files have the filename of the project that is entered when PQMethod is first run. The file extension identifies each individual file. The only files required for a new run of the statistical analyses are the raw-data file (.dat) and the statements file (.sta).
File formats are (upwards) compatible with all versions of QMethod software, or can be converted with QENTER (old to new raw-data formats). The .ent / $HLDENT$ file of version 1.x which contained redundant information only, is obsolete since version 2.0.
The first two records are maintained in all project files
except .sta, .qan, .tsv, and .lis throughout the PQMethod routines.
| Record | Columns* | Description |
| 1 | 1-3 | number of factors (not used before QCENT / QPCA) |
| 4-6 | number of sorts (subjects) | |
| 7-9 | number of statements | |
| 10 | blank | |
| 11-78 | title of the study | |
| 2 | 1-3 | leftmost column value for q-sort (e.g., '-04') |
| 4-6 | rightmost column value for q-sort (e.g., ' 04') | |
| 7-66 | 20 three-digit numbers, column ('pile') sizes for each possible value from -6 to 13 | |
| *Note | All numbers must be right-justified within their column ranges |
Each record contains the text of one statement. In text
programs, a record may be referred to as a 'paragraph',
and a record is finished with a 'hard return' or paragraph
mark. Though the records in this file may be longer, only up to
60 characters of every record are read in. There must be exactly
as many records (without empty lines between them) in the file as
there are statements in the q-sort, and they must agree with the
numbers assigned to the statements in the sorts given. This file is
normally created with option #1. Note that statements in an
existing .sta file will be truncated to 60 characters when
running the STATES module.
The first two records are standard. Thereafter, each record contains the case label (the Sort Id) in columns 1-8 and, starting at column 11, the values assigned for that sort for each statement. Every response value is a 2-digit (right-justified) number. The values of the data will range from the leftmost column value to the rightmost column value.
The .dat file is normally created by manually entering q-sorts
in QENTER. It is required as input for QCENT/QPCA and for
QANALYZE. As described below, the .dat file can be created by
QENTER also by way of converting a .raw file.
PQMethod does not check any formal properties of the data read from
the .dat file, e.g. it does not care whether or not a sort violated the
prescribed forced-distribution. In fact, the calculations performed with
the data, i.e., computation of intercorrelations between the sorts and
computation of factor scores, do not depend
on any specific formal properties of the data. It's entirely up to the
user to decide whether whatever kind of questionnaire data can be
subjected to Q factor analysis with PQMethod.
This is the old-format raw data file used in versions before PQMethod 2.0. It is, however, still supported for input by the new version, as well as output in addition to the new format .dat file. The first two records are standard and each record after that contains the values assigned by each sort for the statement in I2 format (2-digits, right-justified) up to a maximal record lenght of 80 (40 sorts), continuing on the next record(s) in case there are more than 40 (80, ...) sorts. Sort Ids are appended after the last record of the data matrix, every Sort Id (consisting of max. 8 characters) on a separate record, and in the same order as the sorts they designate. If an existing .raw file is used as input to QENTER for file conversion, adding the Sort Ids at the end of the file is optional --if not provided, QENTER generates automatic Sort Ids.
The .raw file is created as output, and may be read as input
by QENTER according to the following logic: When started, QENTER
first tries to open the <project>.dat. If that does not
exist, it next tries to open the <project>.raw. In either
case, upon exiting, QENTER always writes out both versions
of the data, the .dat file and the .raw file. Therefore, both
directions of file conversion work, depending on which data-file
version exists or does not exist. However, note that QENTER does
not care for recency or comprehensiveness of the two files: if
both exist, it is always the .dat which is read in, and the .raw
which is overwritten!
This additional data output file is new in version 2.31 to
allow for more easily importing PQMethod data into Excel and other
modern software. For creating a .tsv file for an existing project with
its .dat file, one only needs to select QENTER from the main menue, and eXit again.
Contains the two standard records followed by a correlation matrix in '(8(F9.5,1X))' FORTRAN-type format. (This format will be used by all the matrices in PQMethod.)
Output from QCENT/QPCA, read by QANALYZE for display purposes
only.
Normally this file is created by QCENT or QPCA, although it can come from another source (e.g., you can compute Principal Axes factors for your sorts with SPSS instead of PQMethod's Centroids or Principal Components; be sure to create the .unr file in the same format as used by PQMethod). Again, the first two records are standard, but for the first time the field for number of factors is used. The remainder of the file is the matrix of factor loadings in '(8(F9.5,1X))' FORTRAN format. Normally, there will be one record for every subject and seven or eight factors across the file, although the number of factors specified in the first record can be anywhere from 2 to 8.
Output from QCENT / QPCA, required as input for QROTATE /
PQROT, QVARIMAX, and QANALYZE.
This is a temporary file created by QROTATE / PQROT. It keeps
the latest (intermediate) state of the rotated factors, even if
you did not explicitely flag and save the rotated factors. In
this way, you can run QROTATE / PQROT for a second (or third ...)
time and take in this file which will reflect rotations made
previously.
Following a header, the records indicate the factors and the
angle of rotation for each hand rotation made. Up to PQMethod version
2.11, the content of this file was echoed also in the listing file
(.lis). Since
QROTATE / PQROT cannot always keep track of all rotations that
may have been performed in more than one session, the .qan rotation
history can be misleading, e.g., if after manual rotations a Varimax
solution was finally kept for the QANALYZE report. Therefore the
rotation history is dropped from the report since version 2.20.
The rotated factor matrix file created by QROTATE / PQROT or
VARIMAX will look very similar to the .hro file, except that
first, only those factors that have been specified will be
written to it, and second, factors are flagged, or should be
flagged, before you run QANALYZE. There must be at least one flag
('X' immediately behind the factor loading) for every factor
(column), and there should rather be no more than one flag for
any sort (row).
The final report of the Q analysis, the matrix of intercorrelations among the sorts, unrotated and rotated factor-loading matrices, factor scores, comparing the factors, listing the statements that differentiate the factors, etc.
Note: What follows is the original Appdx B from the QMethod-Help of the mainframe QMethod package. Maybe, some time somebody might volunteer to write a hand-rotation tutorial for PQROT. For the time being I'd suggest to consult the tutorial for PCQ for Windows (commercial Q-software by Mike Stricklin & Ricardo Almeida) which is based on the same 'Lipset example' data set, which is packaged with PQMethod. When following the rotational steps in that tutorial with PQMethod / PQROT you should be aware, however, that PQMethod and PCQ do not use the same algorithm for Centroid extraction. The most notable differences for the Lipset data set are found for the higher factor numbers. Specifically, factors 6 and 7 change positions (6 in PCQ is most similar to 7 in PQMethod and vice versa), and factors 8 (and in PCQ, no. 9) show no similarity at all between the two programs.
Following is an example of how QROTATE is used to perform a hand rotation of factors. You simply choose this option from the main menu of PQMethod and answer the query of whether this is a continuation of a rotation or not. If you say "no", then the original unrotated factor matrix that was output by the factor routine will be used. If you have already run QROTATE, however, you can choose to continue that rotation instead, as the (partially) rotated factor matrix is always kept when you exit from QROTATE. Even if you have tried to rotate some factors, if you say that this is not a continuation, then you will start with the original unrotated matrix.
When the routine starts, it will present a listing of the factor matrix with the entries truncated to fit easily on the screen. In the following example, only six sorts were entered, so there could be only six possible factors to rotate.
In this first rotation, factors 1 and 2 are chosen. At this stage it is likely that we will want to view all of the points on the graph so we ask to see all of the variables:
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 47 69 43 21 -1 9 | | 2 57 50 19 9 3 6 | | 3 39 47 16 -6 -17 35 | | 4 44 -61 30 -57 1 16 | | 5 55 -65 35 -1 62 13 | | 6 77 -42 12 6 5 -1 | |PLEASE ENTER YOUR CHOICE OF FACTORS (TWO ONLY) | |? | | | |1 2 | |PLEASE ENTER YOUR CHOICE OF VARIABLES (* FOR ALL) | |* | | | +----------------------------------------------------------------------+
At this point we are then asked if we want each point represented as the number of the subject or just use asterisks for all. Since we have a small number, we ask for the actuall numbers:
+----------------------------------------------------------------------+ | | |PLEASE ENTER CHOICE OF GRAPH REPRESENTATION | |1 -- USING STARS, 2 -- USING NUMBERS | |? | |2 | | | +----------------------------------------------------------------------+
Now, we will see factors 1 and 2 graphed against each other in the standard way, with each subject labeled. At this point, we will probably want to rotate the factors to locate clusters of variables near one factor. In this case, (an unnaturally clear example, by the way), it should be obvious that a counterclockwise rotation of around 40 degrees would put subjects 1, 2, and 3 close to the axis of factor 2, and 4, 5, and 6 close to that of factor 1. (Remember that there is 90 degrees between orthogonal factors, hence the midline would be a 45 degree angle.)
+----------------------------------------------------------------------+ | | | 1 | | | | | 6 | | | | | | 5 | 2 | | | 1 | | 4 | 3 | | | | | | | | | | | -----------------------+----------------------2 | | | | | | | | | | | | | | | | | | | | | | | | | | | | |PLEASE ENTER ROTATION ANGLE | |? | |-40 | +----------------------------------------------------------------------+
We enter the "-40" to indicate a negative, or counterclockwise rotation, and the new graph is immediately printed on the screen (probably after we have used the "clear" key for the "MORE. . ." condition).
+----------------------------------------------------------------------+ | | | 1 | | | 6 | | 5 | | | 4 | | | | | | | | | | | | | | | | | | | 2 | | -----------------------+-------------3----1---2 | | | | | | | | | | | | | | | | | | | | | | | | | | | | |PLEASE ENTER ROTATION ANGLE | |? | | | +----------------------------------------------------------------------+
It turns out in this case that the "-40" seems to have been a very good estimate, and so we need no more rotation of these factors. If we wanted to fine tune the rotation a little here, we could easily continue to rotate the axes to and fro with smaller rotations. (In this case, maybe another "-5" would be appropriate.)
Instead, in this case, we just press the enter key, which returns us to the factor matrix, but now it reflects the rotation we have just made.
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 -8 84 43 21 -1 9 | | 2 11 75 19 9 3 6 | | 3 -1 61 16 -6 -17 35 | | 4 73 -19 30 -57 1 16 | | 5 84 -14 35 -1 62 13 | | 6 86 18 12 6 5 -1 | |PLEASE ENTER YOUR CHOICE OF FACTORS (TWO ONLY) | |? | | | +----------------------------------------------------------------------+
Here, we see that the loadings have been greatly affected by our rotation, and that the first three subjects load heavily on factor two, while the last three load on factor one.
Looking at the matrix, we see that there is still quite a bit of variance accounted for by factor three, so perhaps another rotation can pick up some of that.
In the same way that we rotated the two factors above, we could now choose factors 1 & 3, for example, and rotate them. In this particular instance, we would probably choose to look only at subjects 4, 5, and 6, however, since those are the three that we are interested in loading on factor one. Obviously, this process becomes more complicated when there are more than two factors to be extracted for analysis.
After several rotations, we arrive at the matrix shown below, and now we want to flag the entries that define the factors that interest us. In this case, enter a null return to the question of which factors to rotate. Just to ensure that we are done, we are asked if we are done rotating. Another null return or an explicit "N" will then allow us to mark entries.
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 7 92 20 21 0 -7 | | 2 17 76 -5 9 3 -7 | | 3 5 68 0 -5 -16 24 | | 4 79 -13 8 -56 1 19 | | 5 91 -9 8 0 62 15 | | 6 85 12 -21 6 5 -2 | |PLEASE ENTER YOUR CHOICE OF FACTORS (TWO ONLY) | |? | | | |MORE ROTATING? (Y/N) | | | |YOU CAN NOW ASSOCIATE INDIVIDUAL SORTS WITH FACTORS | |FOR USE BY THE QANALYZE PROGRAM COMING UP NEXT. | |DO YOU WISH TO FLAG FACTORS? (ENTER N TO BYPASS) | | | +----------------------------------------------------------------------+
Again, a null return will be taken to mean that we do wish to flag factors, in which the matrix will be repainted and we will be asked to state which factor we wish to flag.
We are then asked which subjects (sorts) are to be flagged, that is, which sorts define that factor.
In this example, we first choose factor one, and assign 4, 5, and 6 to be defining sorts:
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 7 92 20 21 0 -7 | | 2 17 76 -5 9 3 -7 | | 3 5 68 0 -5 -16 24 | | 4 79 -13 8 -56 1 19 | | 5 91 -9 8 0 62 15 | | 6 85 12 -21 6 5 -2 | |ENTER THE NUMBER OF THE FACTOR | | (ENTER A NULL RETURN WHEN YOU | | ARE FINISHED MARKING FACTORS) | |? | |1 | |ENTER THE NUMBERS OF THE SORTS TO BE FLAGGED, | |ONE AT A TIME, SEPARATED BY SPACES (E.G. 3 4 8) | |4 5 6 | | | +----------------------------------------------------------------------+
At this point, the matrix is repainted, and we can flag any factor in a similar fashion (or change the one we just did). In this example, we now flag factor two.
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 7 92 20 21 0 -7 | | 2 17 76 -5 9 3 -7 | | 3 5 68 0 -5 -16 24 | | 4 79X -13 8 -56 1 19 | | 5 91X -9 8 0 62 15 | | 6 85X 12 -21 6 5 -2 | |ENTER THE NUMBER OF THE FACTOR | | (ENTER A NULL RETURN WHEN YOU | | ARE FINISHED MARKING FACTORS) | |? | |2 | |ENTER THE NUMBERS OF THE SORTS TO BE FLAGGED, | |ONE AT A TIME, SEPARATED BY SPACES (E.G. 3 4 8) | |1 2 3 | | | +----------------------------------------------------------------------+
When the matrix is repainted this time, we are finished rotating and flagging and are ready to write out the factors to be analysed. Thus, we enter a null return to the first question to indicate that we do not wish to mark any more factors.
We then decide to write out just the first two factors (since these are the only ones that have been flagged), and we can write these in any order we wish. In this case, we probably want to renumber the two factors so that factor one is defined by the first three subjects, so we write out the factors as "2 1". However, this order is completely optional and will not affect the analysis.
+----------------------------------------------------------------------+ | | |SUBJ 1 2 3 4 5 6 | | 1 7 92X 20 21 0 -7 | | 2 17 76X -5 9 3 -7 | | 3 5 68X 0 -5 -16 24 | | 4 79X -13 8 -56 1 19 | | 5 91X -9 8 0 62 15 | | 6 85X 12 -21 6 5 -2 | |ENTER THE NUMBER OF THE FACTOR | | (ENTER A NULL RETURN WHEN YOU | | ARE FINISHED MARKING FACTORS) | |? | | | |WHICH FACTORS WOULD YOU LIKE TO WRITE OUT? (PUT | | THEM IN THE ORDER YOU WANT THEM IN THE OUTPUT FILE) | |2 1 | | | +----------------------------------------------------------------------+
We are now finished, QROTATE will end, and we will be back at the main menu ready to run QANALYZE.