Using Circumplex Instruments

Previewing the available instruments

Our goal is to eventually include all circumplex instruments in this package. However, due to time-constraints and copyright issues, this goal may be delayed or even impossible to fully realize. However, you can always preview the list of currently available instruments using the instruments() function. This function will print the abbreviation, name, and (in parentheses) the “code” for each available instrument. We will return to the code in the next section.

instruments()
#> The circumplex package currently includes 13 instruments:
#>  1. CSIE: Circumplex Scales of Interpersonal Efficacy (csie)
#>  2. CSIG: Circumplex Scales of Intergroup Goals (csig)
#>  3. CSIP: Circumplex Scales of Interpersonal Problems (csip)
#>  4. CSIV: Circumplex Scales of Interpersonal Values (csiv)
#>  5. IGI-CR: Interpersonal Goals Inventory for Children, Revised Version (igicr)
#>  6. IIP-32: Inventory of Interpersonal Problems, Brief Version (iip32)
#>  7. IIP-64: Inventory of Interpersonal Problems (iip64)
#>  8. IIP-SC: Inventory of Interpersonal Problems, Short Circumplex (iipsc)
#>  9. IIS-32: Inventory of Interpersonal Strengths, Brief Version (iis32)
#>  10. IIS-64: Inventory of Interpersonal Strengths (iis64)
#>  11. IIT-C: Inventory of Influence Tactics Circumplex (iitc)
#>  12. IPIP-IPC: IPIP Interpersonal Circumplex (ipipipc)
#>  13. ISC: Interpersonal Sensitivities Circumplex (isc)

If there are additional circumplex instruments you would like to have added to the package (especially if you are the author/copyright-holder), please contact me. Note that some information (e.g., item text and normative data) may not be available for all instruments due to copyright issues. However, many instruments are released as open-access and have full item text and normative data included in the package.

Loading a specific instrument

To reduce loading time and memory usage, instrument information is not loaded into R’s memory when the circumplex package is loaded. Instead, instruments should be loaded into memory on an as-needed basis. As demonstrated below, this can be done by passing an instrument’s code (which we saw how to find in the last section) to the instrument() function. We can then examine that instrument data using the print() function.

instrument(csip)
print(csip)
#> CSIP: Circumplex Scales of Interpersonal Problems
#> 64 items, 8 scales, 1 normative data sets
#> Boudreaux, Ozer, Oltmanns, & Wright (2018)
#> <https://doi.org/10.1037/pas0000505>

Note, however, that an error will result if the print() function (or any of the functions to be described later) is called before the instrument() function has loaded the data. Order of operations is important!

print(isc)
#> ISC: Interpersonal Sensitivities Circumplex
#> 64 items, 8 scales, 1 normative data sets
#> Hopwood et al. (2011)
#> <https://doi.org/10.1111/j.1467-6494.2011.00696.x>

instrument(isc)
print(isc)
#> ISC: Interpersonal Sensitivities Circumplex
#> 64 items, 8 scales, 1 normative data sets
#> Hopwood et al. (2011)
#> <https://doi.org/10.1111/j.1467-6494.2011.00696.x>

Examining an instrument in-depth

To examine the information available about a loaded instrument, there are several options. To print a long list of formatted information about the instrument, use the summary() function. This will return the same information returned by print(), followed by information about the instrument’s scales, rating scale anchors, items, and normative data set(s). The summary of each instrument is also available from the package reference page.

instrument("ipipipc")
summary(ipipipc)
#> IPIP-IPC: IPIP Interpersonal Circumplex
#> 32 items, 8 scales, 1 normative data sets
#> Markey & Markey (2009)
#> <https://doi.org/10.1177/1073191109340382>
#> 
#> The IPIP-IPC contains 8 circumplex scales.
#> PA: Assured-Dominant (90 degrees)
#> BC: Arrogant-Calculating (135 degrees)
#> DE: Cold-Hearted (180 degrees)
#> FG: Aloof-Introverted (225 degrees)
#> HI: Unassured-Submissive (270 degrees)
#> JK: Unassuming-Ingenuous (315 degrees)
#> LM: Warm-Agreeable (360 degrees)
#> NO: Gregarious-Extraverted (45 degrees)
#> 
#> The IPIP-IPC is rated using the following 5-point scale.
#> 1. Very Inaccurate
#> 2. Moderately Inaccurate
#> 3. Neither Inaccurate nor Accurate
#> 4. Moderately Accurate
#> 5. Very Accurate
#> 
#> The IPIP-IPC contains 32 items (open-access):
#> 1. Am quiet around strangers
#> 2. Speak softly
#> 3. Tolerate a lot from others
#> 4. Am interested in people
#> 5. Feel comfortable around people
#> 6. Demand to be the center of interest
#> 7. Cut others to pieces
#> 8. Believe people should fend for themselves
#> 9. Am a very private person
#> 10. Let others finish what they are saying
#> 11. Take things as they come
#> 12. Reassure others
#> 13. Start conversations
#> 14. Do most of the talking
#> 15. Contradict others
#> 16. Don't fall for sob-stories
#> 17. Don't talk a lot
#> 18. Seldom toot my own horn
#> 19. Think of others first
#> 20. Inquire about others' well-being
#> 21. Talk to a lot of different people at parties
#> 22. Speak loudly
#> 23. Snap at people
#> 24. Don't put a lot of thought into things
#> 25. Have little to say
#> 26. Dislike being the center of attention
#> 27. Seldom stretch the truth
#> 28. Get along well with others
#> 29. Love large parties
#> 30. Demand attention
#> 31. Have a sharp tongue
#> 32. Am not interested in other people's problems
#> 
#> The IPIP-IPC currently has 1 normative data set(s):
#> 1. 274 American college students
#>   Markey & Markey (2009)
#>   <https://doi.org/10.1177/1073191109340382>

Specific subsections of this output can be returned individually using the scales(), anchors(), items(), and norms() functions. These functions are especially useful when you need to know a specific bit of information about an instrument and don’t want the console to be flooded with unneeded information.

anchors(ipipipc)
#> The IPIP-IPC is rated using the following 5-point scale.
#> 1. Very Inaccurate
#> 2. Moderately Inaccurate
#> 3. Neither Inaccurate nor Accurate
#> 4. Moderately Accurate
#> 5. Very Accurate

norms(ipipipc)
#> The IPIP-IPC currently has 1 normative data set(s):
#> 1. 274 American college students
#>   Markey & Markey (2009)
#>   <https://doi.org/10.1177/1073191109340382>

Some of these functions also have additional arguments to customize their output. For instance, the scales() function has the items argument, which will display the items for each scale when set to TRUE.

scales(ipipipc, items = TRUE)
#> The IPIP-IPC contains 8 circumplex scales.
#> PA: Assured-Dominant (90 degrees)
#>     6. Demand to be the center of interest
#>     14. Do most of the talking
#>     22. Speak loudly
#>     30. Demand attention
#> BC: Arrogant-Calculating (135 degrees)
#>     7. Cut others to pieces
#>     15. Contradict others
#>     23. Snap at people
#>     31. Have a sharp tongue
#> DE: Cold-Hearted (180 degrees)
#>     8. Believe people should fend for themselves
#>     16. Don't fall for sob-stories
#>     24. Don't put a lot of thought into things
#>     32. Am not interested in other people's problems
#> FG: Aloof-Introverted (225 degrees)
#>     1. Am quiet around strangers
#>     9. Am a very private person
#>     17. Don't talk a lot
#>     25. Have little to say
#> HI: Unassured-Submissive (270 degrees)
#>     2. Speak softly
#>     10. Let others finish what they are saying
#>     18. Seldom toot my own horn
#>     26. Dislike being the center of attention
#> JK: Unassuming-Ingenuous (315 degrees)
#>     3. Tolerate a lot from others
#>     11. Take things as they come
#>     19. Think of others first
#>     27. Seldom stretch the truth
#> LM: Warm-Agreeable (360 degrees)
#>     4. Am interested in people
#>     12. Reassure others
#>     20. Inquire about others' well-being
#>     28. Get along well with others
#> NO: Gregarious-Extraverted (45 degrees)
#>     5. Feel comfortable around people
#>     13. Start conversations
#>     21. Talk to a lot of different people at parties
#>     29. Love large parties

An additional, though advanced, option for examining the available information about an instrument is to explore the instrument object itself. This can be done within R using the View() function. Note that the first letter in this function (V) must be capitalized. This will open up a data viewer window like the one shown below; it will give you full access to the information stored by the package, albeit in a “raw” format. Don’t worry if the image below is confusing or overwhelming; you never have to see it again unless you want to!

View(ipipipc)

Ipsatizing item-level data

For some forms of circumplex data analysis (e.g., analysis of circumplex fit) but not others (e.g., structural summary method), it can be helpful to transform item-level responses by subtracting each participant’s mean across all items from his or her response on each item. This practice is called “ipsatizing” or, more precisely, deviation scoring across variables. This practice will attenuate the general factor across all items and recasts the item-level responses as deviations from one’s own mean rather than absolute responses. To perform ipsatizing and create a new set of ipsatized responses to each item, use the ipsatize() function.

ips_iipsc <- ipsatize(.data = raw_iipsc, items = IIP01:IIP32, na.rm = TRUE, overwrite = TRUE)
print(ips_iipsc)
#> # A tibble: 10 x 32
#>      IIP01   IIP02  IIP03  IIP04  IIP05   IIP06  IIP07   IIP08   IIP09   IIP10
#>      <dbl>   <dbl>  <dbl>  <dbl>  <dbl>   <dbl>  <dbl>   <dbl>   <dbl>   <dbl>
#>  1 -1      -1      -1     -1      0     -1       0     -1       1       0     
#>  2  0.0625  0.0625 -0.938 -0.938  2.06   1.06    1.06   0.0625 -0.938   0.0625
#>  3 -0.406  -1.41   -0.406 -1.41  -0.406 -0.406  -0.406  1.59   -1.41   -0.406 
#>  4  0.710  -0.290   0.710 NA     -0.290  0.710  -0.290  0.710  -0.290   0.710 
#>  5 -0.625  -0.625  -0.625  0.375 -0.625 -0.625   0.375  0.375  -0.625   0.375 
#>  6 -0.281  -0.281  -0.281 -0.281 -0.281 -0.281   0.719  0.719  -0.281  -0.281 
#>  7  0.5    -0.5    -0.5   -0.5    1.5    0.5     0.5   -0.5     0.5    -0.5   
#>  8  0.258  -0.742   0.258 -0.742  0.258  0.258   1.26   0.258   0.258  -0.742 
#>  9 -0.969  -0.969   1.03   1.03  -0.969  0.0312  2.03  -0.969   0.0312 -0.969 
#> 10 -0.219  -0.219  -0.219 -0.219 -0.219 -0.219   1.78  -0.219  -0.219  -0.219 
#> # ... with 22 more variables: IIP11 <dbl>, IIP12 <dbl>, IIP13 <dbl>,
#> #   IIP14 <dbl>, IIP15 <dbl>, IIP16 <dbl>, IIP17 <dbl>, IIP18 <dbl>,
#> #   IIP19 <dbl>, IIP20 <dbl>, IIP21 <dbl>, IIP22 <dbl>, IIP23 <dbl>,
#> #   IIP24 <dbl>, IIP25 <dbl>, IIP26 <dbl>, IIP27 <dbl>, IIP28 <dbl>,
#> #   IIP29 <dbl>, IIP30 <dbl>, IIP31 <dbl>, IIP32 <dbl>

Above, we told the function to overwrite the original item variables with their ipsatized versions; new ipsatized variables (ending in _i) could have been appended to the data frame instead by changing the overwrite argument to FALSE. We also told it to calculate the mean for each observation after ignoring any missing values. We could have changed this by setting the na.rm argument to FALSE.

We can check that the ipsatization was successful by calculating the mean of each row (i.e., each participant’s mean response) in the original and ipsatized data frames. We do this below using the rowMeans() function; we also apply the round() function to make the results fit on one row. As expected, we find below that the mean of each participant is zero in the ipsatized data frame but not in the original.

round(rowMeans(raw_iipsc, na.rm = TRUE), 2)
#>  [1] 1.00 0.94 1.41 2.29 0.62 0.28 0.50 0.74 0.97 0.22
round(rowMeans(ips_iipsc, na.rm = TRUE), 2)
#>  [1] 0 0 0 0 0 0 0 0 0 0

Scoring item-level data

For many forms of circumplex data analysis (e.g., structural summary method), it can be very helpful to summarize item-level responses by calculating scale scores. This is typically done by averaging a set of items that all measure the same underlying construct (e.g., location in the circumplex model). For example, the IIP-SC has 32 items in total that measure 8 scales representing octants of the interpersonal circumplex model. Thus, a participant’s score on each scale is calculated as the arithmetic mean of his or her responses to four specific items. Using the aggregate of multiple similar items produces scale scores with higher reliability than would be achieved by using only a single item per scale.

instrument("iipsc")
scales(iipsc)
#> The IIP-SC contains 8 circumplex scales.
#> PA: Domineering (90 degrees)
#> BC: Vindictive (135 degrees)
#> DE: Cold (180 degrees)
#> FG: Socially Avoidant (225 degrees)
#> HI: Nonassertive (270 degrees)
#> JK: Exploitable (315 degrees)
#> LM: Overly Nurturant (360 degrees)
#> NO: Intrusive (45 degrees)

Although calculating the arithmetic mean of a handful of items is not terribly difficult mathematically, doing so manually (e.g., by hand) across multiple scales and multiple participants can be tedious and error-prone. To address these issues, the circumplex package offers the score() function, which automatically calculates scale scores from item-level data.

To demonstrate, let’s return to the raw_iipsc data set. We need to give the score() function a data frame containing the item-level data (i.e., the data set), a list of variables from that data frame that contain the item-level responses to be scored, and an instrument object containing instructions on how to score the data. In order for scoring to work properly, the list of items must be in ascending order from the first to the last item and the ordering of the items must be the same as that assumed by the package. Be sure to check your item numbers against those displayed by the items() function, especially if you shuffle your items.

scale_scores <- score(.data = raw_iipsc, items = IIP01:IIP32, instrument = iipsc)
print(scale_scores)
#> # A tibble: 10 x 40
#>    IIP01 IIP02 IIP03 IIP04 IIP05 IIP06 IIP07 IIP08 IIP09 IIP10 IIP11 IIP12 IIP13
#>    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1     0     0     0     0     1     0     1     0     2     1     0     0     0
#>  2     1     1     0     0     3     2     2     1     0     1     0     1     4
#>  3     1     0     1     0     1     1     1     3     0     1     0     0     2
#>  4     3     2     3    NA     2     3     2     3     2     3     2     4     2
#>  5     0     0     0     1     0     0     1     1     0     1     0     2     1
#>  6     0     0     0     0     0     0     1     1     0     0     0     0     0
#>  7     1     0     0     0     2     1     1     0     1     0     0     0     1
#>  8     1     0     1     0     1     1     2     1     1     0     0     0     1
#>  9     0     0     2     2     0     1     3     0     1     0     1     1     0
#> 10     0     0     0     0     0     0     2     0     0     0     0     0     0
#> # ... with 27 more variables: IIP14 <dbl>, IIP15 <dbl>, IIP16 <dbl>,
#> #   IIP17 <dbl>, IIP18 <dbl>, IIP19 <dbl>, IIP20 <dbl>, IIP21 <dbl>,
#> #   IIP22 <dbl>, IIP23 <dbl>, IIP24 <dbl>, IIP25 <dbl>, IIP26 <dbl>,
#> #   IIP27 <dbl>, IIP28 <dbl>, IIP29 <dbl>, IIP30 <dbl>, IIP31 <dbl>,
#> #   IIP32 <dbl>, PA <dbl>, BC <dbl>, DE <dbl>, FG <dbl>, HI <dbl>, JK <dbl>,
#> #   LM <dbl>, NO <dbl>

The scale_scores data frame contains all the item-level data from item_level_csie, as well as the newly calculated scale scores. Note that the scale score variables were named using the scale abbreviations shown by the scales() function (i.e., two-letter abbreviations from PA to NO). You can customize the naming of these variables by using the prefix and suffix arguments from the score() function. We can select and view just the scale score variables using the select() function.

select(scale_scores, PA:NO)
#> # A tibble: 10 x 8
#>       PA    BC    DE    FG    HI    JK    LM    NO
#>    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1  1.75  2     1.25  0     0.5  0.25   1.5   0.75
#>  2  0.25  0.5   0.25  0.5   2    1.75   1.25  1   
#>  3  1     0.75  0.75  0     2.25 2      2.5   2   
#>  4  1.75  2.25  2.5   2.33  2.5  2      2.5   2.5 
#>  5  0.5   0.75  0     1     0.5  0.25   1.25  0.75
#>  6  0.25  0     0     0     0    0      1     1   
#>  7  1     0     0     0     1    1      0.75  0.25
#>  8  1     0.25  0.75  0     0.5  0.667  1.75  1   
#>  9  0.75  0.5   1.5   0.75  0    1      2.75  0.5 
#> 10  0     0     0     0     0    0.5    1     0.25

Note that the na.rm argument for the score() function defaulted to TRUE, which means that missing values were ignored in calculating the scale scores. This practice is common in the literature, but is technically a form of single imputation and thus can produce biased results when data are not missing completely at random (MCAR). Please examine and report the amount and patterns of missingness in your data.

Standardizing scale-level data

Finally, it can often be helpful to transform scale-level data through reference to a normative or comparison sample. This is often called “standardizing” and involves subtracting the normative sample’s mean score on a scale from each participant’s score on that scale and then dividing this difference by the normative sample’s standard deviation. This rescales the scale scores to be in standard deviation units and to describe the magnitude of each participant’s difference from the normative average.

For many circumplex instruments, the data needed to perform standardization is included in its instrument object. Some instruments even have multiple (e.g., different or overlapping) normative samples for comparisons that are matched in terms of gender, age, or nationality. In selecting a normative sample to compare to, it is important to consider both the size and the appropriateness of the sample.

To demonstrate, let’s examine the normative data sets available for the IIP-SC. Below we see that there are two options: a rather large sample of American college students and a rather small sample of American psychiatric outpatients.

norms(iipsc)
#> The IIP-SC currently has 2 normative data set(s):
#> 1. 872 American college students
#>   Hopwood, Pincus, DeMoor, & Koonce (2011)
#>   <https://doi.org/10.1080/00223890802388665>
#> 2. 106 American psychiatric outpatients
#>   Soldz, Budman, Demby, & Merry (1995)
#>   <https://doi.org/10.1177/1073191195002001006>

Assuming our example data also come from a non-psychiatric community sample of mostly college students, the first normative sample seems like a better choice, especially since it is so much larger and therefore subject to less sampling error. However, there may be times when the second normative sample would be the more appropriate comparison, even despite its smaller sample.

To transform the scale scores we calculated during the last section, we can call the standardize() function and give it the scale_scores object we saved the item-level and scale-level data within. We will save the output of this function to a data frame named z_scales to reflect the idea that standardized scores are often called “z-scores.”

z_scales <- standardize(
  .data = scale_scores, 
  scales = PA:NO, 
  angles = octants(),
  instrument = iipsc,
  sample = 1
)
print(z_scales)
#> # A tibble: 10 x 48
#>    IIP01 IIP02 IIP03 IIP04 IIP05 IIP06 IIP07 IIP08 IIP09 IIP10 IIP11 IIP12 IIP13
#>    <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl> <dbl>
#>  1     0     0     0     0     1     0     1     0     2     1     0     0     0
#>  2     1     1     0     0     3     2     2     1     0     1     0     1     4
#>  3     1     0     1     0     1     1     1     3     0     1     0     0     2
#>  4     3     2     3    NA     2     3     2     3     2     3     2     4     2
#>  5     0     0     0     1     0     0     1     1     0     1     0     2     1
#>  6     0     0     0     0     0     0     1     1     0     0     0     0     0
#>  7     1     0     0     0     2     1     1     0     1     0     0     0     1
#>  8     1     0     1     0     1     1     2     1     1     0     0     0     1
#>  9     0     0     2     2     0     1     3     0     1     0     1     1     0
#> 10     0     0     0     0     0     0     2     0     0     0     0     0     0
#> # ... with 35 more variables: IIP14 <dbl>, IIP15 <dbl>, IIP16 <dbl>,
#> #   IIP17 <dbl>, IIP18 <dbl>, IIP19 <dbl>, IIP20 <dbl>, IIP21 <dbl>,
#> #   IIP22 <dbl>, IIP23 <dbl>, IIP24 <dbl>, IIP25 <dbl>, IIP26 <dbl>,
#> #   IIP27 <dbl>, IIP28 <dbl>, IIP29 <dbl>, IIP30 <dbl>, IIP31 <dbl>,
#> #   IIP32 <dbl>, PA <dbl>, BC <dbl>, DE <dbl>, FG <dbl>, HI <dbl>, JK <dbl>,
#> #   LM <dbl>, NO <dbl>, PA_z <dbl>, BC_z <dbl>, DE_z <dbl>, FG_z <dbl>,
#> #   HI_z <dbl>, JK_z <dbl>, LM_z <dbl>, NO_z <dbl>

Again, the output contains all the item-level, scale-level, and now the standardized scale-level variables. The new variables are named the same as the scale score variables except with a configurable prefix and suffix (by default, they are given only a suffix of _z). We can again use the select() function to view just the newly created standardized variables. These variables are the ones we are most likely to use in subsequent analyses (e.g., the structural summary method).

select(z_scales, PA_z:NO_z)
#> # A tibble: 10 x 8
#>       PA_z    BC_z   DE_z    FG_z   HI_z   JK_z    LM_z    NO_z
#>      <dbl>   <dbl>  <dbl>   <dbl>  <dbl>  <dbl>   <dbl>   <dbl>
#>  1  1.5     1.75    0.409 -1.11   -1.01  -1.33   0.0424 -0.344 
#>  2 -0.773  -0.424  -0.760 -0.578   0.634  0.428 -0.261  -0.0312
#>  3  0.364  -0.0616 -0.175 -1.11    0.907  0.721  1.25    1.22  
#>  4  1.5     2.11    1.87   1.36    1.18   0.721  1.25    1.84  
#>  5 -0.394  -0.0616 -1.05  -0.0501 -1.01  -1.33  -0.261  -0.344 
#>  6 -0.773  -1.15   -1.05  -1.11   -1.55  -1.62  -0.564  -0.0312
#>  7  0.364  -1.15   -1.05  -1.11   -0.459 -0.452 -0.867  -0.969 
#>  8  0.364  -0.786  -0.175 -1.11   -1.01  -0.843  0.345  -0.0312
#>  9 -0.0152 -0.424   0.702 -0.314  -1.55  -0.452  1.56   -0.656 
#> 10 -1.15   -1.15   -1.05  -1.11   -1.55  -1.04  -0.564  -0.969