User Manual for Inquisit's Experiential Discounting Task



Script Author: Katja Borchert, Ph.D. ( for Millisecond Software, LLC
Date: 05-06-2013
last updated:  02-21-2022 by K. Borchert ( for Millisecond Software, LLC

Script Copyright © 02-21-2022 Millisecond Software

This script implements the Experiential Discounting Task, a type of Delay Discounting task that assesses
the degree to which the subjective value of a commodity decreases as a function of a delay.
In contrast to more traditional Delay Discounting Tasks, the Experientiel Discounting Task provides participants
with actual experiences of delays as consequences of their choices.

The implemented procedure is based on:

Reynolds, B. & Schiffbauer, R. (2004). Measuring state changes in human delay discounting:
an experiential discounting task. Behavioural Processes, 67, 343–356.


Smits,R.R, Stein,J.S., Johnson, P.S., Odum, A.L., & Madden, G.J. (2013). Test–Retest Reliability and Construct Validity 
of the Experiential Discounting Task. Experimental and Clinical Psychopharmacology, 21, 155–163.

Millisecond Software thanks Dr. Fillmore and Nicholas Van Dyke for collaborating on this script. 
Millisecond Software further thanks Dr. Madden for answering procedural questions pertaining to the EDT.

The goal of the game is to win as much money as one can. In order to win money, participants choose between 2 options: 
the Standard option (on the right) and the Adjust option (on the left). When choosing the Standard option participants
can win a fixed amount of money (higher than with the adjust option) but it is more uncertain whether they will win it 
(probabilistic reward, default probability p = 0.35) and they may have to wait to find out whether or not they won (4 different delay periods).
With the Adjust option, participants can immediately add the advertised amount of money to their winnings.
Choosing the Standard option will increase the amount that can be won with the Adjust option for the next round (up to a
point); choosing the Adjust option will decrease the amount that can be won with the Adjust option for the next round.
After choosing the same option consecutively for 4 (default) times in a row, participants will be forced to choose the opposite
option. Forced trials in this script do not influence the amount that can be won with the adjust options.
The game is over if either an Indifference Point for the two options can be determined or a predetermined time period
has passed.

the default set-up of the script takes appr. XXX minutes to complete
(if no task duration is provided, please contact Millisecond Software

The default data stored in the data files are:

(1) Raw data file: 'experientialdiscountingtask_raw*.iqdat' (a separate file for each participant)

build:								The specific Inquisit version used (the 'build') that was run
computer.platform:					the platform the script was run on (win/mac/ios/android)
date, time: 						date and time script was run 
subject, group: 					with the current subject/groupnumber
session:							with the current session id

blockcode, blocknum:				the name and number of the current block (built-in Inquisit variable)
trialcode, trialnum: 				the name and number of the currently recorded trial (built-in Inquisit variable)
										Note: trialnum is a built-in Inquisit variable; it counts all trials run; even those
										that do not store data to the data file such as feedback trials. Thus, trialnum 
										may not reflect the number of main trials run per block)
delay:								contains the current delay duration for finding out whether standard option wins or loses
countstart:							counts the number of rounds started per block
count_standard:						counts the number of standard options chosen (choice selections only)
count_adjust:						counts the number of adjust options chosen (choice selections only)
countchoice:						counts the choice trials (excluding force trials) in a block 

forced:								1 = forced option trial; 
									0 = choice trial
responseCategory:					participant's response (selection)

selection_rt:						response latency (in ms) of selection trial (either choice or forced: how long did it take to make selection?)

lateny:								latency (in ms) of the currently recorded trial
											NOTE: by default only trial.intertrialinterval/trial.interblockinterval record data to raw data file (therefore latency is 0)
											If other trials should record data, go to section TRIALS and set /recorddata = true in the
											trials of interest
standardamount:						the default standard amount (default: $0.30)
current_adjustamount:				contains the adjustamount that could be won for the current trial sequence
percentchange_adjust:				the factor with with parameters.startadjustamount gets multiplied to calculate values.change

reversal:							0 = the trial is a forced reversal (no adjustments are made to values.percentchange_adjust)
									1 = the selected option should reverse previous adjustments (e.g. if standard is chosen after adjust)
									2 = the selected option does not need to reverse any previous adjustments
win:								1 = promised amount is won; 0 = promised amount is not won

totalamount:						contains the total amount won per block

remaininggameduration:				the remaining time for the block (updated in trial.delayinterval_standard)

ipeval:								calculates the sum of the last 6 choices (1 = standard; 2 = adjust)
										the last six choices are stored in list.iplist on index positions 1 (last added) to 6.
										If the last 6 choices add up to 9 => an equal number of 1 (standard) and 2 (adjust) choices have been made
										and therefore the IP can be determined.
IP_found: 							0 = Indifference Point (IP) has not been established for this block; 
									1 = IP has been established	
ip:									indifference point; once IPeval == 9 is found (equal number of standard and adjust choices)
									this expression calculates IP = the (rounded) mean of the last 6 adjustamounts.
(2) Summary data file: 'experientialdiscountingtask_summary*.iqdat' (a separate file for each participant)

inquisit.version: 						Inquisit version run
computer.platform:					the platform the script was run on (win/mac/ios/android)
startdate:							date script was run
starttime:							time script was started
subjectid:							assigned subject id number
groupid:							assigned group id number
sessionid:							assigned session id number
elapsedtime:						time it took to run script (in ms); measured from onset to offset of script
completed:							0 = script was not completed (prematurely aborted); 
									1 = script was completed (all conditions run)

delayD:								delays for block A-D

ip_delayD:							contains the IP point for delay A-D (if established)

totalamountA -
totalamountD:						contains the total amount won in block A, B, C, D

winamount:							the total amount won

* 2 choices: standard vs. adjust (NO choice is given if the same option was chosen 4 times in a row => forced choice)
* 4 delay periods: 0, 7s, 14s, 28s (Smits et al, 2013; editable parameters); tested in blocked format
* The 4 delay periods are run in sequence of ascending delays (Smits et al, 2013)
-> more info under section EXPERIMENT
* win probability: p = 0.35, fixed (can be edited under EDITABLE CODE -> Editable Lists)
* Standard Option: set win amount of $0.30 (does not change)
* Adjust Option: start win amount of $0.15; can increase (up to 24 cents) or decrease (down to 6cents) depending on selected option

(1) 'Adjust Win Amount' Adjustment Rules:
Selecting the Standard Choice will increase the Adjust Win Amount, selecting the Adjust Choice will
decrease the Adjust Win Amount
* The INITIAL change amount to increase or decrease is calculated as follows: change = round(0.15*original Adjust Amount) = round(0.15*0.15) = round(0.0225) = 0.02  
* If the same choice is made consecutively, 0.15 is reduced consecutively by 0.02 until it reaches 0.03, after that it changes to 0.02 and stays there
=> Example: Participant chooses Standard Option 4 times in a row
1. change = round(0.15*0.15) = 0.02   	(Adjust Amount = 0.15 + 0.02 = 0.17; after choosing Standard option, participant could now add 17 cents to winnings when choosing Adjust option next)
2. change = round(0.13*0.15) = 0.02  	(Adjust Amount = 0.17 + 0.02 = 0.19)
3. change = round (0.11*0.15) = 0.02 	(Adjust Amount = 0.19 + 0.02 = 0.21) 
4. change = round (0.09*0.15) = 0.01 	(Adjust Amount = 0.21 + 0.01 = 0.22)
5. change = round (0.07*0.15) = 0.01 	(Adjust Amount = 0.22 + 0.01 = 0.23)
6. change = round (0.05*0.15) = 0.01 	(Adjust Amount = 0.23 + 0.01 = 0.24)
7. change = round (0.03*0.15) = 0.00 	(Adjust Amount = 0.24 + 0.00 = 0.24)
8. change = round (0.02*0.15) = 0.00 	(Adjust Amount = 0.24 + 0.00 = 0.24)

* Choosing the opposite option will undo the previous adjustments in the reversed order*
Example: if participant were now to choose the Adjust Option for 8 times in a row the Adjust Amount would change
1. 0.24 - 0.00 = 0.24
2. 0.24 - 0.00 = 0.24
3. 0.24 - 0.01 = 0.23
4. 0.23 - 0.01 = 0.22
(forced standard)
5. 0.22 - 0.01 = 0.21
6. 0.21 - 0.02 = 0.19
7. 0.19 - 0.02 = 0.17
8. 0.17 - 0.02 = 0.15
=> back to start conditions 

*Note: this script offers the option to set via parameters.reversaloption whether to
a) reverse in the exact same order (that is if participant has reached parameters.min_adjustvalue (0.02)- and 
continues with same choice the reversal would take into account how many times participant was at 0.02)
Example: 0.15, 0.13, 0.11, 0.09, 0.07, 0.05, 0.03, 0.02, 0.02, 0.02
Reversal: 0.02, 0.02, 0.02, 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15
b) reverse in the same order but start reversing immediately after participant reaches values.minadjustvalue (0.02)
(reversal starts with 0.03 regardless how many times participants had chosen a particular button with
with values.adjustamount = 0.02)
Example: 0.15, 0.13, 0.11, 0.09, 0.07, 0.05, 0.03, 0.02, 0.02, 0.02
Reversal: 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15

(2) Indifference Point 
After 16 mandatory choice trials (default), the program checks whether the Indifference Point can be determined.
The Indifference Point can be determined if participant chose the same number of Adjust and Standard options for the last
6 choice trials. If this condition is met, the Indifference Point = average of the last 6 adjust amounts.
If this condition is not met, the block continues and the program checks after each new choice trial if the
Indifference condition is met at this point (or if predetermined time for block has expired, see (3)).

(3) Duration of Game/Block
* at least 16 (default) choice trials per game/block
* Game/block quits if 
a) the participant chose the same number of Standard options as Adjust options during the last 6 rounds => Indifference Point
can be established (see above)
b) the predetermined time for the game/block is up.

Determination of Predetermined Time:
* The predetermined time of a block = 20 (standard option trials) * values.delay
=> each block allows the selection of 20 choice standard option trials
(!!!Note: for values.delay = 0; the predetermined time of a block = 20 and not 0 to allow for the selection
of 20 choice standard option trials)
* The game duration decreases by values.delay in trial.delayinterval_standard for choice standard option trials only
* if the game ends before predetermined time is up (because IP has been found) the remaining time is added to an interblock trial
Note: in the unlikely even that participant chooses only Adjust option, an endless loop is created.
For this particular reason, the script has a built-in time to quit after 2h (editable parameter)

provided by Millisecond Software - can be edited under section Editable Stimuli


Instructions are not original to the task. They are provided by Millisecond Software
as htm/html pages and can be edited by changing the provided htm/html files.
To edit htm/html-files: open the respective documents in simple Text Editors such as TextEdit (Mac)
or Notepad (Windows).

Original instructions from Reynolds & Schiffbauer (2004) are provided under section Editable Instructions
for comparisons.

check below for (relatively) easily editable parameters, stimuli, instructions etc. 
Keep in mind that you can use this script as a template and therefore always "mess" with the entire code 
to further customize your experiment.

The parameters you can change are:

/standardamount:							the default standard amount (default: $0.30)
/startadjustamount:							the default starting adjust amount (default: $0.15)
/max_adjustvalue:							maximum/start adjusting proportion (default: 0.15)
/min_adjustvalue:							minimum adjusting proportion (default: 0.02)
/adjustvalue:								the default adjust value increase/decrease  (default: 0.02)

/min_choicetrials:							the minimum number of choice trials (default: 16)
											Note: needs to be >=6
/maxsameoption:								the max number of consecutive trials of the same option
											before a forced trial is initiated (default: 4)
/nr_practicerounds:							number of practice rounds run, regardless of choice or forced rounds (default: 16)

Delay Options: in ms
/delay_practice:							delay used in practice session (default: 7000ms = 7s)
/delayD:									delays for block A-D (in ms)
/durationadjustmentfactor:					the number of standard option trials used (default: 20) to calculate the
											max. blockduration = values.delay * parameters.durationadjustmentfactor
											(-> the time allows 20 standard option trial sequences)
/intertrialinterval:							sets the intertrialinterval duration (default: 0)

/reversaloption:							1 = reversal of parameters.adjustvalue follows exactly the previous pattern even if
											participant was operating at parameters.min_adjustvalue for a while
											(e.g. 0.15, 0.13, 0.11, 0.09, 0.07, 0.05, 0.03, 0.02, 0.02, 0.02
											-> reversal: 0.02, 0.02, 0.02, 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15) (default)
											2 = reversal of parameters.adjustvalue follows the previous pattern unless participant was 
											operating at parameters.min_adjustvalue for a while - in that case the
											reversal process picks up right away once the opposite option is chosen.
											(e.g. 0.15, 0.13, 0.11, 0.09, 0.07, 0.05, 0.03, 0.02, 0.02, 0.02
											-> reversal: 0.03, 0.05, 0.07, 0.09, 0.11, 0.13, 0.15) (default)

/maxtimeofscript:							maximum time this script runs in ms if potential endless loop of procedure is hit ( default: 7200000ms, 2 hours)