PQMethod Manual
Distributed with the PQMethod package
Location of most recent version:
http://schmolck.org/qmethod/pqmanual.htm 

+---------------------------------------------------+
|                  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) 


Contents


About

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.

Following the tradition originating from the original, mainframe QMethod software, all steps from entering sorts and statements to the analysis and viewing the results can be accomplished without leaving the program. For entering and editing the statements and for viewing the results, external software is required, and therefore the PQMethod distribution package until version 2.33 contained two additional tiny freeware DOS-programs for editing and viewing text files, the editor SSH ED (=ed.com) authored by Sverre H. Huseby, and the text viewer view86.com which originates from the Aldridge Company. Because 64bit versions of Windows 7 and later discontinued all DOS compatibility, the two tools were removed from the PQMethod distribution  version 2.35 (except for the DOSBox version). For more details on editing and viewing statements and the output listing see sections STATES   and VIEWLIST.

PQMethod comes with the 'Lipset' example data set which is identical to the one used in the 'Technique and Method' chapter of Steven Brown's textbook [Brown, S.R. (1980). Political subjectivity: Applications of Q methodology in political science. New Haven: Yale University Press]. The nine sorts -- a very small P sample, even in terms of Q -- were selected by Steven Brown from a larger sample of cases for didactical purposes.

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).


Installing and Launching PQMethod

The present versions of the PQMethod download packages do not automatically self-install the software. At the moment, instructions for installing PQMethod can be found on the PQMethod download page only.



General Flow and Procedure

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.

1 - STATES

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.

 

2 - QENTER

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

The details needed will be:
  1. The total number of statements that were sorted.
  2. The value of the leftmost column of the q-sort. It is assumed that the leftmost column has a lower value than the rightmost column, so that values will range from, say, -4 to +4, or from 1 to 9. The maximal number of columns is 13, with values ranging from either -6 to +6, or from 1 to 13. In general, there should be an unequal number of categories to provide for a neutral midpoint. If that is not the case, PQMethod issues a warning, but accepts the design.
  3. The rightmost column value (see above).
  4. The number of rows in each column, from left to right. This should exactly match your q-sort design. The design itself should be symmetric -- that is, the number of rows on the left should be the same as those of the corresponding columns on the right. In addition, the design must be unimodal -- that is, the number of rows must not decrease from either left or right to the center.

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.
 

3 - QCENT and 4 - QPCA

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.



Horst, P. (1965) Factor Analysis of Data Matrices. Holt, Rinehart and Winston.

 
 

5 - QROTATE

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).

Note
Since version 2.08, PQMethod comes with a separate MS-DOS program, PQROT.EXE, for graphical factor rotation. After choosing QROTATE from the main menu you will be asked (if not so, PQROT.EXE was not found in the pqmethod directory on your disk):

  Do you want to launch the new PQROT program (Y/n)?

If you accept, PQROT is launched, and you can continue with performing hand-rotation using high-resolution graphics. PQROT provides, in addition to much more appropriately displaying the individual sorts in the factor plots, a highly improved interface for rotating axes, highlighting cases, flagging factors etc. The details of using PQROT instead of the old, text-mode QROTATE are not documented in this manual. However, you can easily find your way by following instructions on screen, and requesting help pages by pressing F1 (I highly recommend inspection of the help pages for finding all available features!). One point needs mentioning, though: Most input to the program requires just hitting certain keys on the keyboard, without pressing the <ENTER> key (= CR, carriage return) also. 

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.
 

6 - QVARIMAX

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
n
Performing VARIMAX rotation... How many factors do you wish to rotate? (Press <ENTER> to rotate all 8 unrotated factors) 3 3 Varimax factors will be output to file c:/pqmethod/projects/lipset.rot Next, varimax factors will be displayed for additional rotations [optional] and for adding flags [required] - Do you wish to use the new PQROT program for that (Y/n)?

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.
 

7 - QANALYZE

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

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. 

Factors, Factor Scores, Factor Arrays, and 'Exact' Factor Scores

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.

Factor z scores or simply, factor scores: The individual sorts that were "flagged" by the user as the best representatives of the factor are aggregated or "averaged" into one set of statement scores. The exact computational procedure consists in first z-standardizing every sort, and then applying different weights for every sort depending on the sort's factor loading, and computing the weighted average. Finally, every factor score is z-standardized again, i.e. every  factor score has the same mean (0) and standard deviation (1), and hence scores are directly comparable across factors. The formula for the factor weights, according to Brown (1980) originates from Spearman (1927):
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.

'Exporting' factors

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):

Goldberg, L. R. (2006). Doing it all bass-ackwards: The development of hierarchical factor structures from the top down. Journal of Research in Personality, 40, 347-358.

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/
>.


8 - VIEWLIST

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.



Algorithms and formulas

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).

Among the procedures not included in John Atkinson's original version of QMethod is Principal Component Analysis (PCA), and 'pre-flagging.' The newly (version 2.20) implemented 'exact' factor scores are described in section ' Factors, Factor Scores, Factor Arrays, and 'Exact' Factor Scores '.

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.




APPDX A - File Descriptions

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.

Formats of header lines (files .raw, .cor, .unr, .hro, .rot)

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

 

Files

.sta - Statements

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.
 

.dat - Q-sort data

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.

.raw - Q-sort data, transposed (old) format

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!

.tsv - Q-sort data, tab-separated-values output file

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.

.cor - Correlation matrix

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.
 

.unr - Unrotated factor-loading matrix

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.
 

.hro - Backup of rotated factor-loading matrix

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.
 

.qan - Q-angles

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.
 

.rot - Rotated factor-loading matrix

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).
 

.lis - Listing

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.


APPDX B - Example of Hand Rotation (QROTATE)


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.


Date of last revision: 18 July 2015
Peter@schmolck.org