Millisecond Forums

Set up a <trial> that presents a single letter. Keep running that trial until you've presented the desired number of letters via /branch. The number of letters to display can be sampled from a <list> at the start of each "round". Once N letters have been displayed, /branch to an <openended> element prompting participants to enter the final 3 or 5 letters in the sequence. Evaluate the response via /iscorrectresponse.

The below example illustrates the above. It will run two sequences of each length (2 x 6 letters, 2 x 7 letters, ..., 2 x 12 letters) in each condition (14 trials or "rounds").

<values>
/ condition = ""
/ easy_n = 3
/ difficult_n = 5
/ n = 0
/ sequencelength = 0
/ lettercount = 0
/ final_n_letters = ""
/ lettersequence = ""
</values>

<expt>
/ blocks = [1=easy; 2=difficult]
</expt>

<block easy>
/ preinstructions = (easyinstructions)
/ onblockbegin = [values.condition = "easy"; values.n = values.easy_n; ]
/ trials = [1-14=starttrial]
</block>

<block difficult>
/ preinstructions = (difficultinstructions)
/ onblockbegin = [values.condition = "difficult"; values.n = values.difficult_n]
/ trials = [1-14=starttrial]
</block>

<trial starttrial>
/ ontrialbegin = [text.lettertext.resetselection();
    values.lettercount = 0; values.lettersequence = ""; values.final_n_letters = "";
    values.sequencelength = list.sequencelengthlist.nextvalue; ]
/ branch = [trial.lettertrial]
/ trialduration = 0
/ recorddata = false
</trial>

<list sequencelengthlist>
/ items = (6,6,7,7,8,8,9,9,10,10,11,11,12,12)
</list>

<trial lettertrial>
/ ontrialend = [values.lettercount += 1;
    values.lettersequence = concat(values.lettersequence, text.lettertext.currentitem); ]
/ stimulusframes = [1=lettertext, debug]
/ trialduration = 2500
/ branch = [if (values.lettercount == values.sequencelength) openended.responsetrial else trial.lettertrial]
/ recorddata = false
</trial>

<openended responsetrial>
/ ontrialbegin = [values.final_n_letters = substring(values.lettersequence, values.sequencelength-values.n, values.n);]
/ stimulusframes = [1=responsetxt, debug]
/ iscorrectresponse = [openended.responsetrial.response == values.final_n_letters]
/ inputdevice = keyboard
</openended>

<text lettertext>
/ items = letteritems
</text>

<text responsetxt>
/ items = ("Enter the final <%values.n%> letters:")
/ position = (50%, 40%)
</text>

<item letteritems>
/ 1 = "B"
/ 2 = "C"
/ 3 = "D"
/ 4 = "F"
/ 5 = "G"
/ 6 = "H"
/ 7 = "J"
/ 8 = "K"
/ 9 = "L"
/ 10 = "M"
/ 12 = "N"
/ 13 = "P"
/ 14 = "Q"
/ 15 = "R"
/ 16 = "S"
/ 17 = "T"
/ 18 = "V"
/ 19 = "W"
/ 20 = "X"
/ 21 = "Y"
/ 22 = "Z"
</item>

<page easyinstructions>
^This is the easy condition.
^You will have to recall the final <%values.easy_n%> letters.
</page>

<page difficultinstructions>
^This is the difficult condition.
^You will have to recall the final <%values.difficult_n%> letters.
</page>

<text debug>
/ items = ("Condition: <%values.condition%> | Length of letter sequence = <%values.sequencelength%> |
~nLetters presented so far: <%values.lettercount%>
~nLetter sequence: <%values.lettersequence%>
~nFinal <%values.n%> letters: <%values.final_n_letters%>")
/ position = (50%, 10%)
/ fontstyle = ("Consolas", 2%)
/ erase = false
</text>

Dave, thank you soooo sooo much! You were an amazing help to my problem. Thanks so much!!!

Dear Dave,

since you helped me so amazingly with my Letter-Memory-Taks, I have a follow-up question for you in the matter of openended attribute and free recall trials.
I want to program similar task to the letter memory, but instead of letters it is words, or at least the first letters of the words that need to be remembered and which category they belong to. It is an adaptation to the Keep Track Task, originally by Yntma (1963). Here is a short decription:

At first participants are presented six target categories in the bottom of the computer screen. Then several words, which are exemplars from each of the
six categories, e.g. “animals”, “colors”, “countries”, “distances”, “metals”, and “relatives”, are presented serially and randomly in the center of the screen for 1,500 ms each, with target categories remaining at the bottom of the screen. During the instruction period, participants are shown all six categories with their exemplars to ensure that participants know to which category each word belongs. The task is to memorize the last word presented in each
target category. At the end of each block of stimuli, each target category is presented individually and in sequence on the computer screen and participants are asked to type as fast as possible the first two letters of the last category exemplar presented. The dependent measure is the average RT for recalling the target words and the proportion of target words recalled correctly. Task difficulty is modified by presenting streams of 18 words, resulting from three target categories and six words per category, in the easy condition, and 36 words, resulting from all six target categories and six words per category, in the difficult condition.

My question now is, can I program this task with the same basic script for the letter-memory task from you and instead of presenting one openended trials, I just present three in the easy condition and six in the difficult condition, one for each category? Is that correct thinking or do I need to approach this task from an different angle?

It would be amazing if you could help me with that one last time.
Kindest regards,
Ulrike Nestler

The basic approach would be the same as in the single-letter recall task, i.e., you can use the script as a basis and extend it as needed.

Instead of using concat() to append the displayed items to a single, global string-variable, you'll probably want to append them to an <item> element, though. That'll make it easier to retrieve the proper item(s) in the recall <openended> element(s) and evaluate the participant's response accordingly.

Dear Dave,

I tried to adapt the script from the letter memory task now for the keep track task. But i still got two issues I dont know how to solve:

A) I have a pool of 6 different categories which contain 6 items each. In the easy condition for each trial I want Inquisit to randomly select 3 out of these 6 categories and run 6 items of each of these 3 categories randomly, so altogether 18 words of totally three categories are presented randomly in a sequence. How do I do that?

<item categories>
/ 1 = "animals"
/ 2 = "colors"
/ 3 = "countries"
/ 4 = "fruits"
/ 5 = "metals"
/ 6 = "relatives"
</item>

<item words>
/ 1 = "fish"
/ 2 = "snail"
/ 3 = "cow"
/ 4 = "lion"
/ 5 = "rabbit"
/ 6 = "dog"
/ 7 = "blue"
/ 8 = "green"
/ 9 = "red"
/ 10 = "black"
/ 11 = "yellow"
/ 12 = "white"
/ 13 = "Sweden"
/ 14 = "France"
/ 15 = "Germany"
/ 16 = "Spain"
/ 17 = "Italy"
/ 18 = "England"
/ 19 = "kiwi"
/ 20 = "apple"
/ 21 = "orange"
/ 22 = "banana"
/ 23 = "melon"
/ 24 = "grapes"
/ 25 = "plumb"
/ 26 = "gold"
/ 27 = "copper"
/ 28 = "iron"
/ 29 = "silver"
/ 30 = "zinc"
/ 31 = "aunt"
/ 32 = "mom"
/ 33 = "dad"
/ 34 = "brother"
/ 35 = "sister"
/ 36 = "uncle"
</item>

B) Dealing with "openended": Since I don't want the last three or six words presented to be recalled by the subject, I would like to know how I can script Inquisit to ask at each end of a trial ...
a) for the exact categories that were chosen for the trial
b) and to recognize the last words for each category as right answers, and NOT the last words of the word sequence?
c) how do I change it then that subjects only have to write the first two letters of each target word and Inquisit recognizes and counts it as correct answer? (since the words have different lenghts and the amount of letters that need to be typed in need to kept equal since their reaction time is essential)
d) and do I need three/six openended pages or can Inquisit ask for the last words of the three / six categories on one page?

Dave, it would be great if you could help me with this. These openended commands are new to me and I have a bit trouble figuring it out.
Kind regards,
Ulrike Nestler

You would work with a number of <list> elements; one for selecting your "target" categories (3 out of 6 in the easy condition) and several others reflecting the *item numbers* for the items making up your respective categories. In short:

<values>
/ condition = ""
/ sequencelength = 18
/ wordcount = 0
/ currentcategory = 0
/ worditem = 0
/ wordsequence = ""
/ correctresponse = ""

/ target_cat_a = 0
/ target_cat_b = 0
/ target_cat_c = 0
/ target_cat_d = 0
/ target_cat_e = 0
/ target_cat_f = 0

/ target_cat_a_name = ""
/ target_cat_b_name = ""
/ target_cat_c_name = ""
/ target_cat_d_name = ""
/ target_cat_e_name = ""
/ target_cat_f_name = ""

/ last_word_in_cat_1 = ""
/ last_word_in_cat_2 = ""
/ last_word_in_cat_3 = ""
/ last_word_in_cat_4 = ""
/ last_word_in_cat_5 = ""
/ last_word_in_cat_6 = ""

/ initials_of_last_word_in_cat_1 = ""
/ initials_of_last_word_in_cat_2 = ""
/ initials_of_last_word_in_cat_3 = ""
/ initials_of_last_word_in_cat_4 = ""
/ initials_of_last_word_in_cat_5 = ""
/ initials_of_last_word_in_cat_6 = ""
</values>

<expt>
/ blocks = [1=easy; 2=difficult]
</expt>

<block easy>
/ preinstructions = (easyinstructions)
/ onblockbegin = [values.condition = "easy"; values.sequencelength = 18; list.categorylist.reset();
    values.target_cat_a = list.categorylist.nextvalue;
    values.target_cat_b = list.categorylist.nextvalue;
    values.target_cat_c = list.categorylist.nextvalue;
    values.target_cat_a_name = item.categories.item(values.target_cat_a);
    values.target_cat_b_name = item.categories.item(values.target_cat_b);
    values.target_cat_c_name = item.categories.item(values.target_cat_c);
    ]
/ trials = [1=starttrial; 2-7=noreplace(cat1_response,cat2_response, cat3_response, cat4_response, cat5_response, cat6_response)]
</block>

<block difficult>
/ preinstructions = (difficultinstructions)
/ onblockbegin = [values.condition = "difficult"; values.sequencelength = 36; list.categorylist.reset();
    values.target_cat_a = list.categorylist.nextvalue;
    values.target_cat_b = list.categorylist.nextvalue;
    values.target_cat_c = list.categorylist.nextvalue;
    values.target_cat_d = list.categorylist.nextvalue;
    values.target_cat_e = list.categorylist.nextvalue;
    values.target_cat_f = list.categorylist.nextvalue;
    values.target_cat_a_name = item.categories.item(values.target_cat_a);
    values.target_cat_b_name = item.categories.item(values.target_cat_b);
    values.target_cat_c_name = item.categories.item(values.target_cat_c);
    values.target_cat_d_name = item.categories.item(values.target_cat_d);
    values.target_cat_e_name = item.categories.item(values.target_cat_e);
    values.target_cat_f_name = item.categories.item(values.target_cat_f);
    ]
/ trials = [1=starttrial; 2-7=noreplace(cat1_response,cat2_response, cat3_response, cat4_response, cat5_response, cat6_response)]
</block>

<trial starttrial>
/ ontrialbegin = [values.wordcount = 0; values.wordsequence = ""; ]
/ branch = [trial.wordtrial]
/ trialduration = 0
/ recorddata = false
</trial>

<trial wordtrial>
/ ontrialbegin = [if (values.condition == "easy") values.currentcategory = list.easycategorylist.nextvalue; ]
/ ontrialbegin = [if (values.condition == "difficult") values.currentcategory = list.difficultcategorylist.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 1) values.worditem = list.cat1items.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 2) values.worditem = list.cat2items.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 3) values.worditem = list.cat3items.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 4) values.worditem = list.cat4items.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 5) values.worditem = list.cat5items.nextvalue; ]
/ ontrialbegin = [if (values.currentcategory == 6) values.worditem = list.cat6items.nextvalue; ]

/ ontrialend = [if (values.currentcategory == 1) {values.last_word_in_cat_1 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_1 = substring(values.last_word_in_cat_1,0,2)}; ]
/ ontrialend = [if (values.currentcategory == 2) {values.last_word_in_cat_2 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_2 = substring(values.last_word_in_cat_2,0,2)}; ]
/ ontrialend = [if (values.currentcategory == 3) {values.last_word_in_cat_3 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_3 = substring(values.last_word_in_cat_3,0,2)}; ]
/ ontrialend = [if (values.currentcategory == 4) {values.last_word_in_cat_4 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_4 = substring(values.last_word_in_cat_4,0,2)}; ]
/ ontrialend = [if (values.currentcategory == 5) {values.last_word_in_cat_5 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_5 = substring(values.last_word_in_cat_5,0,2)}; ]
/ ontrialend = [if (values.currentcategory == 6) {values.last_word_in_cat_6 = text.wordtext.currentitem; values.initials_of_last_word_in_cat_6 = substring(values.last_word_in_cat_6,0,2)}; ]

/ ontrialend = [values.wordcount += 1;
    values.wordsequence = concat(concat(values.wordsequence," "), text.wordtext.currentitem); ]
/ stimulusframes = [1=wordtext, debug]
/ trialduration = 1500
/ branch = [if (values.wordcount != values.sequencelength) trial.wordtrial]
/ recorddata = false
</trial>

<openended cat1_response>
/ skip = [values.last_word_in_cat_1 == ""]
/ ontrialbegin = [values.currentcategory = 1; values.correctresponse = values.initials_of_last_word_in_cat_1; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat1_response == values.correctresponse]
</openended>

<openended cat2_response>
/ skip = [values.last_word_in_cat_2 == ""]
/ ontrialbegin = [values.currentcategory = 2; values.correctresponse = values.initials_of_last_word_in_cat_2; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat2_response == values.correctresponse]
</openended>

<openended cat3_response>
/ skip = [values.last_word_in_cat_3 == ""]
/ ontrialbegin = [values.currentcategory = 3; values.correctresponse = values.initials_of_last_word_in_cat_3; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat3_response == values.correctresponse]
</openended>

<openended cat4_response>
/ skip = [values.last_word_in_cat_4 == ""]
/ ontrialbegin = [values.currentcategory = 4; values.correctresponse = values.initials_of_last_word_in_cat_4; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat4_response == values.correctresponse]
</openended>

<openended cat5_response>
/ skip = [values.last_word_in_cat_5 == ""]
/ ontrialbegin = [values.currentcategory = 5; values.correctresponse = values.initials_of_last_word_in_cat_5; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat5_response == values.correctresponse]
</openended>

<openended cat6_response>
/ skip = [values.last_word_in_cat_6 == ""]
/ ontrialbegin = [values.currentcategory = 6; values.correctresponse = values.initials_of_last_word_in_cat_6; ]
/ stimulusframes = [1=question, debug]
/ inputdevice = keyboard
/ iscorrectresponse = [openended.cat6_response == values.correctresponse]
</openended>

<text question>
/ items = ("Please enter the initial two letters of the last word in the <%item.categories.item(values.currentcategory)%> category:")
/ position = (50%, 40%)
</text>


<text wordtext>
/ items = words
/ select = values.worditem
</text>

<page easyinstructions>
^Instructions for easy condition go here.
</page>

<page difficultinstructions>
^Instructions for difficult condition go here.
</page>

<text debug>
/ items = ("Condition: <%values.condition%> | Length of word sequence = <%values.sequencelength%> | Words presented so far: <%values.wordcount%>
Target categories: <%values.target_cat_a_name%> <%values.target_cat_b_name%> <%values.target_cat_c_name%> <%values.target_cat_d_name%> <%values.target_cat_e_name%> <%values.target_cat_f_name%>
Current category: <%item.categories.item(values.currentcategory)%>

Last word in category <%item.categories.item(1)%>: <%values.last_word_in_cat_1%> Initials: <%values.initials_of_last_word_in_cat_1%>
Last word in category <%item.categories.item(2)%>: <%values.last_word_in_cat_2%> Initials: <%values.initials_of_last_word_in_cat_2%>
Last word in category <%item.categories.item(3)%>: <%values.last_word_in_cat_3%> Initials: <%values.initials_of_last_word_in_cat_3%>
Last word in category <%item.categories.item(4)%>: <%values.last_word_in_cat_4%> Initials: <%values.initials_of_last_word_in_cat_4%>
Last word in category <%item.categories.item(5)%>: <%values.last_word_in_cat_5%> Initials: <%values.initials_of_last_word_in_cat_5%>
Last word in category <%item.categories.item(6)%>: <%values.last_word_in_cat_6%> Initials: <%values.initials_of_last_word_in_cat_6%>

Word sequence: <%values.wordsequence%>")
/ position = (50%, 10%)
/ size = (90%, 20%)
/ hjustify = left
/ fontstyle = ("Consolas", 2%)
/ erase = false
</text>

<list categorylist>
/ items = (1,2,3,4,5,6)
/ selectionrate = always
</list>

<list easycategorylist>
/ items = (values.target_cat_a, values.target_cat_b, values.target_cat_c)
/ poolsize = 18
</list>

<list difficultcategorylist>
/ items = (values.target_cat_a, values.target_cat_b, values.target_cat_c, values.target_cat_d, values.target_cat_e, values.target_cat_f)
/ poolsize = 36
</list>

<list cat1items>
/ items = (1,2,3,4,5,6)
</list>

<list cat2items>
/ items = (7,8,9,10,11,12)
</list>

<list cat3items>
/ items = (13,14,15,16,17,18)
</list>

<list cat4items>
/ items = (19,20,21,22,23,24)
</list>

<list cat5items>
/ items = (25,26,27,28,29,30)
</list>

<list cat6items>
/ items = (31,32,33,34,35,36)
</list>

<item words>
/ 1 = "fish"
/ 2 = "snail"
/ 3 = "cow"
/ 4 = "lion"
/ 5 = "rabbit"
/ 6 = "dog"

/ 7 = "blue"
/ 8 = "green"
/ 9 = "red"
/ 10 = "black"
/ 11 = "yellow"
/ 12 = "white"

/ 13 = "Sweden"
/ 14 = "France"
/ 15 = "Germany"
/ 16 = "Spain"
/ 17 = "Italy"
/ 18 = "England"

/ 19 = "kiwi"
/ 20 = "apple"
/ 21 = "orange"
/ 22 = "banana"
/ 23 = "melon"
/ 24 = "grapes"

/ 25 = "plumb"
/ 26 = "gold"
/ 27 = "copper"
/ 28 = "iron"
/ 29 = "silver"
/ 30 = "zinc"

/ 31 = "aunt"
/ 32 = "mom"
/ 33 = "dad"
/ 34 = "brother"
/ 35 = "sister"
/ 36 = "uncle"
</item>

<item categories>
/ 1 = "animals"
/ 2 = "colors"
/ 3 = "countries"
/ 4 = "fruits"
/ 5 = "metals"
/ 6 = "relatives"
</item>

Dear Dave,

thanks for all the help with the script. I am sorry though to tell you that your script counts right answers as errors, the lines you wrote for the "iscorrectresponse" doesnt seem to work. I just recognized it after I adapted your script to my needs. And then I thought it was my mistake along the adaptation. But then I let your initial script run (from your last post in this forum) and the same happens: The right initials are counted as errors... Why?

a) So it would be great if you could check why correct answers are counted as errors. I can't find the mistake. Even in my script when I let it run and collect raw data it shows the correct answer initials, then my answers, and even though they are the same, they are counted as errors, and not as correct answers.

And 2 more questions now that I extended your original script:

b) In German, usually we start words with a Capital letter. So "aunt" would be "Tante". But I want the participants to type in "ta", not "Ta". Because when using large and lower case, usually too many mistakes are made. Is it possible that Inquisit only registers the letters whether right or wrong and not the writing in large and lower case? For example, "Tante" is presented, they are supposed to write "ta". But even if they type "TA" or "tA", it is still the right letters and I want Inquisit to recognize it and count it as correct answer. Is that possible?

c) If I alternate the easy and difficult blocks (easy, difficult, easy, difficult), then in the second easy block Inquisit asks for 6 instead of 3 categories... Why? And how can I change it?

Thanks a lot.
Kind regards,
Ulrike Nestler

(a) The correct response evaluation failure is due to a stupid, last-minute copy & paste mistake on my part:

<openended cat1_response>
...
/ iscorrectresponse = [openended.cat1_response == values.correctresponse]
</openended>

of course ought to read

<openended cat1_response>
...
/ iscorrectresponse = [openended.cat1_response.response == values.correctresponse]
</openended>

(same for the the other <openended> elements)

(b) Whether you capitalize the initials or not does not matter; I.e., if the final word was "Tante" with the initials "Ta",
"Ta", "TA", "ta", "tA" will all be accepted as correct response.

(c) You need to make sure that the variables representing the selected target categories and the variables holding the final words are reset / emptied at the beginning of a new block. Otherwise they'll still hold entries from the previous block(s) and the script will think it should ask you about those words as well. I.e. you need to do:

/ onblockbegin = [values.last_word_in_cat_1 = ""; values.initials_of_last_word_in_cat_1 = "";
    values.last_word_in_cat_2 = ""; values.initials_of_last_word_in_cat_2 = "";
    values.last_word_in_cat_3 = ""; values.initials_of_last_word_in_cat_3 = "";
    values.last_word_in_cat_4 = ""; values.initials_of_last_word_in_cat_4 = "";
    values.last_word_in_cat_5 = ""; values.initials_of_last_word_in_cat_5 = "";
    values.last_word_in_cat_6 = ""; values.initials_of_last_word_in_cat_6 = "";
    ]
/ onblockbegin = [values.target_cat_a = 0; values.target_cat_a_name = "";
    values.target_cat_b = 0; values.target_cat_b_name = "";
    values.target_cat_c = 0; values.target_cat_c_name = "";
    values.target_cat_d = 0; values.target_cat_d_name = "";
    values.target_cat_e = 0; values.target_cat_e_name = "";
    values.target_cat_f = 0; values.target_cat_f_name = "";
    ]

in both <block> elements.