Description Usage Arguments Details Value Author(s) References See Also Examples
This is the main function of the package. It allows to compute many variants of the robust IAT scores all with a single command.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15  RobustScores(IATdata,
P1 = c("none", "fxtrim", "fxwins", "trim10", "wins10", "inve10"),
P2 = c("ignore", "exclude", "recode", "separate", "recode600"),
P3 = c("dscore", "gscore", "wpr90", "minid", "minid_t10", "minid_w10",
"minid_i10"),
P4 = c("nodist", "dist"), maxMemory = 1000,
verbose = TRUE,
autoremove = TRUE)
D2(IATdata, ...)
D5(IATdata, ...)
D6(IATdata, ...)
D2SWND(IATdata, ...)
D5SWND(IATdata, ...)
D6SWND(IATdata, ...)

IATdata 
a dataframe with the following columns:

P1 
(Vector of strings). Determines how the latencies are treated for computing the scores. Can include one or more of the following strings. It is worth noticing that latencies > 10s are excluded by default, independent of P1.

P2 
(Vector of strings). Determines how the error latencies are treated. Can include one or more of the following strings.

P3 
The algorithm for computing the Dscores. Can include one or more of the following strings.

P4 
Distinguish the practice and the critical blocks, as specified by column

maxMemory 
In computing the minidifferences, a very large dataframe is required. 
verbose 
if 
autoremove 
if 
... 
Additional arguments for 
A precise description of the parameters can be found in Richetin et al. (2015, Table 1). The procedure for computing the scores is the following.
First parameter P4 is applied: for "nodist"
the whole dataset is given as input, for "dist"
the dataset is first split in two parts according to column praccrit
and then given in input.
Second, the parameter P1 and P2 are applied: correct and error latencies are treated for each combinations of P1 and P2 and a new column is internally created.
Third, parameter P3 is applied. On each and every vector of latencies defined by a combination of P1 and P2, the IAT scores are computed using all the methods specified in P3.
Finally, for P4 = "dist"
, the scores computed i the practice and critical blocks are averaged.
Functions D2
, D5
, and D6
are simple wrappers around RobustScores that allow computing the D2, D5, and D6 scores shown in Greenwald et al. (2003).
Similarly, D2SWND
, D5SWND
, and D6SWND
allow computing the same D2, D5, and D6 scores with the imrpovements proposed by Richetin et al. (2015): use of statistical winsorizing (SW) and no distinction (ND) between practice and critical blocks.
A dataframe with as many columns as subjects, and as many rows as the possible combinations of the parameters P1, P2, P3 and P4.
subject 
The identifier of the participant 
.
p1342 
The IAT score variants computed. Each number after the p indicates the value of the parameter corresponding to the position. For instance 
... 
other columns in the form 
Giulio Costantini
Greenwald, A. G., Nosek, B. A., & Banaji, M. R. (2003). Understanding and using the Implicit Association Test: I. An improved scoring algorithm. Journal of Personality and Social Psychology, 85(2), 197216. doi:10.1037/00223514.85.2.197
Nosek, B. A., BarAnan, Y., Sriram, N., & Greenwald, A. G. (2013). Understanding and Using the Brief Implicit Association Test: I. Recommended Scoring Procedures. SSRN Electronic Journal. doi:10.2139/ssrn.2196002
Richetin, J., Costantini, G., Perugini, M., Schonbrodt, F. (in press). Should we stop looking for a better scoring algorithm for handling Implicit Association Test data? Test of the role of errors, extreme latencies treatment, scoring formula, and practice trials on reliability and validity. PLOS ONE.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123  #### generate random IAT data ####
set.seed(1234)
rawIATdata < data.frame(
# ID of each participant (N = 10)
ID = rep(1:10, each = 180),
# sevenblock structure, as in Greenwald, Nosek & Banaji (2003)
# block 1 = target discrimination (e.g., Bush vs. Gore items)
# block 2 = attribute discrimination (e.g., Pleasant words vs. unpleasant)
# block 3 = combined practice (e.g., Bush + pleasant vs. Gore + unpleasant)
# block 4 = combined critical (e.g., Bush + pleasant vs. Gore + unpleasant)
# block 5 = reversed target discrimination (e.g., Gore vs. Bush)
# block 6 = reversed combined practice (e.g., Gore + pleasant vs. Bush + unpleasant)
# block 7 = reversed combined critical (e.g., Gore + pleasant vs. Bush + unpleasant)
block = rep(c(rep(1:3, each = 20),
rep(4, 40),
rep(5:6, each = 20),
rep(7, 40)), 10),
# expected proportion of errors = 10 percent
correct = sample(c(0, 1), size = 1800, replace = TRUE, prob = c(.2, .8)),
# reaction times are generated from a mix of two chi2 distributions,
# one centered on 550ms and one on 100ms to simulate fast latencies
latency = round(sample(c(rchisq(1500, df = 1, ncp = 550),
rchisq(300, df = 1, ncp = 100)), 1800)))
# add some IAT effect by making trials longer in block 6 and 7
rawIATdata[rawIATdata$block >= 6, "latency"] <
rawIATdata[rawIATdata$block >= 6, "latency"] + 100
# add some more effect for subjects 1 to 5
rawIATdata[rawIATdata$block >= 6 &
rawIATdata$ID <= 5, "latency"] <
rawIATdata[rawIATdata$block >= 6 &
rawIATdata$ID <= 5, "latency"] + 100
#### pretreat IAT data using function Pretreatment ####
IATdata < Pretreatment(rawIATdata,
label_subject = "ID",
label_latency = "latency",
label_accuracy = "correct",
label_block = "block",
block_pair1 = c(3, 4),
block_pair2 = c(6, 7),
label_praccrit = "block",
block_prac = c(3, 6),
block_crit = c(4, 7))
#### Compute Greenwald et al.'s (2003, Table 3) D2, D5, and D6 measures ####
# All scores are computed both with the RobustScores and with
# the wrappers D2, D5, and D6. Results are identical
# D2 scores
D2(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "fxtrim",
P2 = "ignore",
P3 = "dscore",
P4 = "dist",
verbose = FALSE)
# D5 scores
D5(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "fxtrim",
P2 = "recode",
P3 = "dscore",
P4 = "dist",
verbose = FALSE)
# D6 scores
D6(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "fxtrim",
P2 = "recode600",
P3 = "dscore",
P4 = "dist",
verbose = FALSE)
#### Compute D scores with improvements by Richetin et al. (2015, p. 20) ####
# "In this perspective, we examined whether the D2 for builtin penalty and the
# D5 and D6 for no builtin penalty could benefit from the inclusion of two
# elements that stand out from the results. Within their respective parameter,
# the Statistical Winsorizing as a treatment for extreme latencies and No
# distinction between practice and test trials when computing the difference
# between the two critical blocks seem to lead to the best performances".
# All scores are computed both with the RobustScores and with
# the wrappers D2SWND, D5SWND, and D6SWND. Results are identical
# D2SWND scores
D2SWND(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "wins10",
P2 = "ignore",
P3 = "dscore",
P4 = "nodist",
verbose = FALSE)
# D5_SWND scores
D5SWND(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "wins10",
P2 = "recode",
P3 = "dscore",
P4 = "nodist",
verbose = FALSE)
# D6_SWND scores
D6SWND(IATdata, verbose = FALSE)
RobustScores(IATdata = IATdata,
P1 = "wins10",
P2 = "recode600",
P3 = "dscore",
P4 = "nodist",
verbose = FALSE)
#### Compute all 421 combinations of IAT scores ####
# 421 are the combinations given by parameters P1, P2, P3, and P4. For
# details, see Richetin et al. (2015)
allIATscores < RobustScores(IATdata = IATdata)

Add the following code to your website.
For more information on customizing the embed code, read Embedding Snippets.