The hardware and bandwidth for this mirror is donated by dogado GmbH, the Webhosting and Full Service-Cloud Provider. Check out our Wordpress Tutorial.
If you wish to report a bug, or if you are interested in having us mirror your free-software or open-source project, please feel free to contact us at mirror[@]dogado.de.
This vignette illustrates how to use the
implicitMeasures
package for computing the IAT D
score. The illustration is based on the data set raw_data
that comes with the package.
Labels containing specification .iat
in variable
blockcode
identify IAT blocks.
data("raw_data")
# explore the dataframe
str(raw_data)
#> 'data.frame': 84726 obs. of 6 variables:
#> $ Participant: int 4 4 4 4 4 4 4 4 4 4 ...
#> $ latency : int 2592 628 808 783 2059 1114 608 663 771 676 ...
#> $ correct : int 1 1 1 1 1 1 1 1 1 1 ...
#> $ trialcode : Factor w/ 32 levels "age","alert",..: 31 5 3 20 3 20 5 3 20 3 ...
#> $ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 4 4 4 4 4 4 4 4 4 4 ...
#> $ response : Factor w/ 46 levels "","0","1","19",..: 43 43 43 43 43 43 43 43 43 43 ...
# explore the levels of the blockcode variable to identify the IAT blocks
levels(raw_data$blockcode)
#> [1] "demo" "practice.iat.Milkbad"
#> [3] "practice.iat.Milkgood" "practice.sc_dark.Darkbad"
#> [5] "practice.sc_dark.Darkgood" "practice.sc_milk.Milkbad"
#> [7] "practice.sc_milk.Milkgood" "test.iat.Milkbad"
#> [9] "test.iat.Milkgood" "test.sc_dark.Darkbad"
#> [11] "test.sc_dark.Darkgood" "test.sc_milk.Milkbad"
#> [13] "test.sc_milk.Milkgood"
Once the IAT blocks have been identified, it is possible to clean the
IAT data by using the clean_iat()
function. Since the data
set also includes respondents’ demographic information
(demo
in the blockcode
variable), it is
possible to extract and store these information in a separate data
frame:
iat_cleandata <- clean_iat(raw_data, sbj_id = "Participant",
block_id = "blockcode",
mapA_practice = "practice.iat.Milkbad",
mapA_test = "test.iat.Milkbad",
mapB_practice = "practice.iat.Milkgood",
mapB_test = "test.iat.Milkgood",
latency_id = "latency",
accuracy_id = "correct",
trial_id = "trialcode",
trial_eliminate = c("reminder", "reminder1"),
demo_id = "blockcode",
trial_demo = "demo")
Since also the demographic data has been specified,
clean_iat()
results in a list of 3 elements:
str(iat_cleandata)
#> List of 3
#> $ data_keep :Classes 'iat_clean' and 'data.frame': 19440 obs. of 8 variables:
#> ..$ participant : int [1:19440] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:19440] 1282 1299 1435 1089 967 648 967 615 729 642 ...
#> ..$ correct : int [1:19440] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ block_original: chr [1:19440] "practice.iat.Milkbad" "practice.iat.Milkbad" "practice.iat.Milkbad" "practice.iat.Milkbad" ...
#> ..$ condition : chr [1:19440] "MappingA" "MappingA" "MappingA" "MappingA" ...
#> ..$ block_pool : chr [1:19440] "practice" "practice" "practice" "practice" ...
#> ..$ block : chr [1:19440] "practice_MappingA" "practice_MappingA" "practice_MappingA" "practice_MappingA" ...
#> ..$ trial_id : Factor w/ 32 levels "age","alert",..: 20 6 20 6 20 6 20 6 20 23 ...
#> $ data_eliminate:'data.frame': 64638 obs. of 6 variables:
#> ..$ Participant: int [1:64638] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:64638] 2592 628 808 783 2059 1114 608 663 771 676 ...
#> ..$ correct : int [1:64638] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ trialcode : Factor w/ 32 levels "age","alert",..: 31 5 3 20 3 20 5 3 20 3 ...
#> ..$ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ response : Factor w/ 46 levels "","0","1","19",..: 43 43 43 43 43 43 43 43 43 43 ...
#> $ demo :'data.frame': 3726 obs. of 6 variables:
#> ..$ participant: int [1:3726] 4 4 4 4 4 4 4 4 4 4 ...
#> ..$ latency : int [1:3726] 53047 53047 53047 53047 21554 21554 11266 11266 11266 11266 ...
#> ..$ correct : int [1:3726] 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ trialcode : Factor w/ 32 levels "age","alert",..: 19 1 21 8 22 4 10 11 12 13 ...
#> ..$ blockcode : Factor w/ 13 levels "demo","practice.iat.Milkbad",..: 1 1 1 1 1 1 1 1 1 1 ...
#> ..$ response : Factor w/ 46 levels "","0","1","19",..: 33 15 41 34 16 20 1 1 1 1 ...
data_keep
is a data.frame
with class
iat_clean
. It contains the data set for the
compute_iat()
function.
data_eliminate
is a data.frame
that
contains all the discarded blocks and trials.
demo
is a data.frame
that contains all the
trials identified as demo
in the blockcode
variable.
Store the first data_keep
element in a data frame for
the compute_iat()
function.
iat_data <- iat_cleandata[[1]]
head(iat_data)
#> participant latency correct block_original condition block_pool
#> 60914 4 1282 1 practice.iat.Milkbad MappingA practice
#> 60915 4 1299 1 practice.iat.Milkbad MappingA practice
#> 60916 4 1435 1 practice.iat.Milkbad MappingA practice
#> 60917 4 1089 1 practice.iat.Milkbad MappingA practice
#> 60918 4 967 1 practice.iat.Milkbad MappingA practice
#> 60919 4 648 1 practice.iat.Milkbad MappingA practice
#> block trial_id
#> 60914 practice_MappingA goodright
#> 60915 practice_MappingA darkright
#> 60916 practice_MappingA goodright
#> 60917 practice_MappingA darkright
#> 60918 practice_MappingA goodright
#> 60919 practice_MappingA darkright
Once that IAT data have been cleaned with the
clean_iat()
function, it is possible to compute the
D score by using the compute_iat()
function.
This function only takes two arguments. The first argument is the
data frame with class iat_clean
, the second argument is a
character specifying the D score algorithm for the computation.
To compute multiple D score algorithms at the same time, use
themulti_dscore()
function.
dscore <- compute_iat(iat_data, Dscore = "d3")
str(dscore)
#> Classes 'dscore' and 'data.frame': 162 obs. of 23 variables:
#> $ participant : int 4 6 8 11 14 17 18 19 20 21 ...
#> $ n_trial : int 120 120 120 120 120 120 120 120 120 120 ...
#> $ nslow10000 : num 0 0 0 0 0 0 0 0 0 0 ...
#> $ nfast400 : num 0 0 0 0.01 0.07 0.04 0 0.05 0 0 ...
#> $ nfast300 : num 0 0 0 0 0 0 0 0 0 0 ...
#> $ accuracy.practice_MappingA: num 1 0.95 0.7 0.9 0.95 0.9 0.95 0.95 0.85 0.9 ...
#> $ accuracy.practice_MappingB: num 1 1 0.85 0.95 1 1 1 0.85 1 0.85 ...
#> $ accuracy.test_MappingA : num 1 0.9 1 0.95 0.9 0.925 0.95 0.95 0.8 0.9 ...
#> $ accuracy.test_MappingB : num 1 1 0.85 0.95 1 0.95 1 0.975 0.975 0.9 ...
#> $ accuracy.MappingA : num 1 0.917 0.9 0.933 0.917 ...
#> $ accuracy.MappingB : num 1 1 0.85 0.95 1 ...
#> $ RT_mean.MappingA : num 1037 1179 954 1297 852 ...
#> $ RT_mean.MappingB : num 788 596 926 731 604 ...
#> $ mean_practice_MappingA : num 1070 1224 1504 1608 821 ...
#> $ mean_test_MappingA : num 1021 1157 679 1141 867 ...
#> $ mean_practice_MappingB : num 889 611 1108 702 637 ...
#> $ mean_test_MappingB : num 737 589 836 745 587 ...
#> $ d_practice_d3 : num -0.647 -1.274 -0.584 -1.114 -0.514 ...
#> $ d_test_d3 : num -0.878 -1.226 0.508 -0.816 -0.672 ...
#> $ dscore_d3 : num -0.762 -1.25 -0.038 -0.965 -0.593 ...
#> $ cond_ord : chr "MappingA_First" "MappingB_First" "MappingB_First" "MappingA_First" ...
#> $ legendMappingA : chr "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" "practice.iat.Milkbad_and_test.iat.Milkbad" ...
#> $ legendMappingB : chr "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" "practice.iat.Milkgood_and_test.iat.Milkgood" ...
The compute_iat()
function results in a
data.frame
with class dscore
containing a
number of rows equal to the number of participants. The columns contain
the D score and otehr useful information on the performance of
each respondent (see the documentation of the compute_iat()
function for further details). The IAT_rel()
,
descript_d()
, d_point()
, and
d_density()
functions require the object resulting from
function compute_iat()
.
The IAT D is computed as such that positive scores indicate slower response times in condition identified by Mapping B.
The descriptive statistics of the D scores computed on the
practice and test blocks, and the actual D scores can be easily
obtained with the descript_d()
function:
descript_d(dscore) # Data frame containing IAT Ds
#> Mean SD Min Max
#> D-score -0.56 0.54 -1.59 1.29
#> D-practice -0.59 0.64 -1.59 1.26
#> D-test -0.54 0.56 -1.59 1.32
By specifying latex = TRUE
, function
descript_d()
print the results in LaTeX code:
descript_d(dscore, # Data frame containing IAT Ds
latex = TRUE) # obtain the code for latex tables
#> % latex table generated in R 4.5.1 by xtable 1.8-4 package
#> % Thu Jul 10 16:37:45 2025
#> \begin{table}[ht]
#> \centering
#> \begin{tabular}{rrrrr}
#> \hline
#> & Mean & SD & Min & Max \\
#> \hline
#> D-score & -0.56 & 0.54 & -1.59 & 1.29 \\
#> D-practice & -0.59 & 0.64 & -1.59 & 1.26 \\
#> D-test & -0.54 & 0.56 & -1.59 & 1.32 \\
#> \hline
#> \end{tabular}
#> \end{table}
The IAT_rel()
function computes the reliability of the
IAT by correlating the D score obtained from practice blocks
with the D score obtained from test blocks (see Gawronski et al. 2017 for further
details):
The implicitMeasures
package comes with several
functions for obtaining clear representations of the results at both
individual respondent and sample levels. Additionally, it includes a
function for computing and plotting multiple IAT D score
algorithms at the same time.
The d_point()
function plots the IAT D score
for each respondent.
d_point() function with default settings
In case of large sample size, the label identifying each respondent
is difficult to read. It can be eliminated by setting
x_values = FALSE
.
Respondents can be arranged by increasing or decreasing D
scores by setting argument order_sbj
equal to
"D-increasing"
or "D-decreasing"
,
respectively. Descriptive statistics (\(M_{\text{D}}\pm 2sd\)) can be added by
setting include_stats = TRUE
. Finally, the color of the
points can be changed by using argument col_point
.
d_point(dscore, # dataframe containing IAT Ds
order_sbj = "D-decreasing", # change respondents order
x_values = FALSE, # remove respondents' labels
include_stats = TRUE, # include descriptive statistics
col_point = "lightskyblue") # change points color
d_point() function with settings change
The d_density()
function plots the distribution of the
IAT D scores. It allows for choosing the most appropriate
representation.
d_density() function with default settings
The number of bins can be changed with argument n_bin
.
Argument graph
can be used for changing the graphical
representation of the data. It is possible to choose an histogram
representation (graph = "histogram"
, default), a
representation of the density distribution
(graph = "density"
), or a boxplot
(graph = "boxplot"
). Argument col_fill
can be
used to change the color of the points representing each respondent’s
score in the violin plot. Descriptive statistics (i.e., \(M_{\text{D}} \pm 2sd\)) can be added to
the graph by setting argument include_stats = TRUE
.
d_density(dscore, # dataframe containing IAT Dscores
graph = "boxplot", # change graphical representation
include_stats = TRUE) # include descriptive statistics
d_density() function with settings change
The multi_dscore()
function computes and plot multiple
D score algorithms. The D score algorithms that can be
computed depend on the IAT administration. If the IAT administration
included a feedback strategy (i.e., built-in correction), only
D1 and D2 algorithms should be computed. If the IAT
administration did not include a feedback strategy, then algorithms
D3, D4, D5, and D6 should be
computed. An exhaustive and detailed illustration of the D
score algorithms is provided in the “Implicit Measures” vignette. To
specify the algorithms that can be computed, argument ds
must be set equal to either "built-in"
(for the computation
of D1 and D2) or error-inflation
(for the
computation of all other algorithms).
multi_scores <- multi_dscore(iat_data, # object with class "iat_clean"
ds = "error-inflation") # string specifying the
# algorithms to compute
The multi_dscore()
function results in a
list
containing two objects. The first object is a
data.frame
that contains all the computed algorithms and
the respondent IDs.
multi_d <- multi_scores[[1]]
head(multi_d)
#> participant dscore_d3 dscore_d4 dscore_d5 dscore_d6
#> 1 4 -0.76242699 -0.76242699 -0.76242699 -0.76242699
#> 2 6 -1.24976744 -1.26905702 -1.24976744 -1.26905702
#> 3 8 -0.03801459 0.02021915 -0.03801459 0.02021915
#> 4 11 -0.96488057 -0.97207623 -0.95538961 -0.96294963
#> 5 14 -0.59341709 -0.57385144 -0.59236921 -0.57213017
#> 6 17 -1.30474798 -1.27140694 -1.27997040 -1.26676628
str(multi_d)
#> 'data.frame': 162 obs. of 5 variables:
#> $ participant: int 4 6 8 11 14 17 18 19 20 21 ...
#> $ dscore_d3 : num -0.762 -1.25 -0.038 -0.965 -0.593 ...
#> $ dscore_d4 : num -0.7624 -1.2691 0.0202 -0.9721 -0.5739 ...
#> $ dscore_d5 : num -0.762 -1.25 -0.038 -0.955 -0.592 ...
#> $ dscore_d6 : num -0.7624 -1.2691 0.0202 -0.9629 -0.5721 ...
The second object is a ggplot
graph displaying the
distribution of the D scores computed with each algorithm in
violin plots.
Multiple IAT D scores representation
These binaries (installable software) and packages are in development.
They may not be fully stable and should be used with caution. We make no claims about them.
Health stats visible at Monitor.