By agt - 7/7/2024
Hi there, may I find out if it is possible to limit same-key correct responses for IAT in combined tasks to less than four consecutive times?
|
By Dave - 7/8/2024
+xHi there, may I find out if it is possible to limit same-key correct responses for IAT in combined tasks to less than four consecutive times?
The short answer is no, there is no easy or straightforward way to do this.
The long answer is anything is possible if you're willing to make deep and major changes to the code.
|
By agt - 7/8/2024
Hi Dave. I would like to make the change. May I find out how to do this?
|
By Dave - 7/8/2024
+xHi Dave. I would like to make the change. May I find out how to do this?
Look at the combined blocks as they exist now and understand how they work. That's step one.
Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint.
Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial.
|
By agt - 7/8/2024
+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial.
Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task.
|
By Dave - 7/8/2024
+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task.
That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this.
|
By agt - 7/8/2024
+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this.
Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you.
|
By Dave - 7/8/2024
+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you.
You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code.
|
By agt - 7/8/2024
+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code.
There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses.
|
By Dave - 7/8/2024
+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses.
Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand.
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work?
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work?
You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for:
Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint.
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint.
Do you mean the blocks or trials?
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials?
You spell out the trial sequence in the <block> elements' /trials attribute.
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute.
Do you mean this?
<block compatibletest1>
/ postinstructions = (compatibletest1feedback)
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block>
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block>
The /trials attribute in the blocks, yes.
Instead of
/ trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)]
you need to spell out a trial sequence that does what you want. So
/ trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
]
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
]
I would like my sequence to be randomised. Just not more than 4 consecutive same key response.
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response.
I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences.
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences.
I would like to integrate the following to the script:
consecutiveCorrectResponses = 0;
maxConsecutiveCorrectResponses = 3;
however, i am unsure which section to include this.
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences. I would like to integrate the following to the script: consecutiveCorrectResponses = 0; maxConsecutiveCorrectResponses = 3; however, i am unsure which section to include this.
Adding a bunch of variables will not do a single thing, so the question is beside the point, I'm afraid
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences. I would like to integrate the following to the script: consecutiveCorrectResponses = 0; maxConsecutiveCorrectResponses = 3; however, i am unsure which section to include this. Adding a bunch of variables will not do a single thing, so the question is beside the point, I'm afraid
Thanks for the information. Is there a user manual i can refer to on limiting the consecutive response key?
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences. I would like to integrate the following to the script: consecutiveCorrectResponses = 0; maxConsecutiveCorrectResponses = 3; however, i am unsure which section to include this. Adding a bunch of variables will not do a single thing, so the question is beside the point, I'm afraid Thanks for the information. Is there a user manual i can refer to on limiting the consecutive response key?
There is a programmer's manual. It does not deal specifically with limiting consecutive response keys. There's no reason why it should. It's a generic programming problem like any other. https://www.millisecond.com/support
|
By agt - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+xHi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences. I would like to integrate the following to the script: consecutiveCorrectResponses = 0; maxConsecutiveCorrectResponses = 3; however, i am unsure which section to include this. Adding a bunch of variables will not do a single thing, so the question is beside the point, I'm afraid Thanks for the information. Is there a user manual i can refer to on limiting the consecutive response key? There is a programmer's manual. It does not deal specifically with limiting consecutive response keys. There's no reason why it should. It's a generic programming problem like any other. https://www.millisecond.com/support
Is there anyone I can consult on setting the consecutive response keys limit? and also understanding the basic math and algorithm so that i am able to come up with the right script.
|
By Dave - 7/8/2024
+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x+x[quote]Hi Dave. I would like to make the change. May I find out how to do this? Look at the combined blocks as they exist now and understand how they work. That's step one. Note down the <trial> elements that have the same correct response key in each combined block. Note down how many trials there are of each type. Note, too, that combined blocks always alternate between attribute and target trials. Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Otherwise you need to come up with an algorithm that produces random trial sequences that satisfy all the properties above and implement it. This is not trivial. Thanks Dave. I have noted on the number of trials for each combined blocks. It would be ideal to come up with a script to produce random trial sequence that limit not more than 4 times the same response key in each combined task. That is what you should work on then. What you have on your hands there is a constraint satisfaction problem (cf. https://forums.millisecond.com/Topic6419.aspx ), so be prepared to spend some time on this. Thanks for the information. Is there a starting script or section where I can work on? I have no background on computer science/scripts so it will be great to get some advice from you. You should not start with any code. You should start with doing the math and spelling out an algorithm -- i.e. a series of precisely defined steps that will yield the desired result -- that produces trial sequences in the way you want them to. You don't need a script for that, you need a piece of paper. Once you have your algorithm worked out, you can start thinking about implementing it. It's only then that you need to concern yourself with any code. There’s a total of 7 blocks, of which 4 blocks are combined tasks consisting of 32 and 64 trials. Within each ofthe 4 blocks, there should be not more than 4 consecutive same key responses. Yes. That is not an algorithm. That is a statement of the desired end state. You need to work out the steps that get you to that end state. If you can't do that, my advice is go for the easy option and use a fixed trial sequence, which you can construct by hand. Unfortunately I am unsure how an algorithm works. How would a fixed trial sequence work? You simplly write down an order of trials that satisfies the constraints you want. That's what this exercise was for: Note down the <trial> elements that have the same correct response key in each combined block.
Note down how many trials there are of each type.
Note, too, that combined blocks always alternate between attribute and target trials.
Your easiest option is to simply spell out a fixed trial sequence that satisfiies your added constraint. Do you mean the blocks or trials? You spell out the trial sequence in the <block> elements' /trials attribute. Do you mean this? <block compatibletest1> / postinstructions = (compatibletest1feedback) / bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright) / trials = [1=instructions; 3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright); 2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] / errormessage = true(error,200) / responsemode = correct / ontrialend = [ if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1; if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency); if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct; ] </block> The /trials attribute in the blocks, yes. Instead of / trials = [1=instructions;
3,5,7,9,11,13,15,17,19,21,23,25,27,29,31,33= random(targetAleft, targetBright);
2,4,6,8,10,12,14,16,18,20,22,24,26,28,30,32 = random(attributeA, attributeB)] you need to spell out a trial sequence that does what you want. So / trials = [1=instructions;
2=sequence(attributeA, argetAleft, ...);
] I would like my sequence to be randomised. Just not more than 4 consecutive same key response. I've already explained to you that that's not trivial to do and what you'd have to work out to do this. You can either do that and read up on the things you don't know or you go for the easier option and use fixed trial sequences. I would like to integrate the following to the script: consecutiveCorrectResponses = 0; maxConsecutiveCorrectResponses = 3; however, i am unsure which section to include this. Adding a bunch of variables will not do a single thing, so the question is beside the point, I'm afraid Thanks for the information. Is there a user manual i can refer to on limiting the consecutive response key? There is a programmer's manual. It does not deal specifically with limiting consecutive response keys. There's no reason why it should. It's a generic programming problem like any other. https://www.millisecond.com/support Is there anyone I can consult on setting the consecutive response keys limit? and also understanding the basic math and algorithm so that i am able to come up with the right script.
There is no "the" algorithm. You need to develop one. Then and only then will you be able to come up with the right script.
Maybe start with some basics:
- What is an algorithm: https://www.geeksforgeeks.org/introduction-to-algorithms/
- Ds some tutorials to learn at leas the basics of Inquisit syntax: https://www.millisecond.com/support/docs/v5/html/tutorials/tutorials.htm
- Then re-read all the information already contained in this thread.
|
By agt - 7/11/2024
Hi Dave, may I find out what is the fee to engage your team to develop the script?
|
By Dave - 7/12/2024
+xHi Dave, may I find out what is the fee to engage your team to develop the script?
The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is:
- It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more.
- Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random).
|
By agt - 7/15/2024
+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random).
Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create?
|
By Dave - 7/15/2024
+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create?
You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject.
|
By agt - 7/22/2024
+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject.
Hi Dave,
I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here:
Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft)
Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB)
I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1.
|
By agt - 7/22/2024
+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1.
My apologies, I have updated my sequence A and B below:
Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright )
Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft )
|
By Dave - 7/22/2024
+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft )
You need to put every sequence in a separate <list>, like so:
<list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list>
Then you make a list of lists:
<list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list>
You define a variable which will store the sequence number you administer.
<values>
/ sequencenumber = 1
</values>
At the start of the block, you select one of the sequences at random.
<block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block>
That's it. Do the same for all the other sequences and combined blocks.
|
By agt - 7/22/2024
+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks.
Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically?
|
By Dave - 7/22/2024
+x+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks. Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically?
Then obviously you need to construct sequences with lenghts of 64 trials for that.
|
By agt - 7/22/2024
+x+x+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks. Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically? Then obviously you need to construct sequences with lenghts of 64 trials for that.
I understand. I am just wondering if each item won't repeat more than twice for 64 trials.
|
By Dave - 7/22/2024
+x+x+x+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks. Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically? Then obviously you need to construct sequences with lenghts of 64 trials for that. I understand. I am just wondering if each item won't repeat more than twice for 64 trials.
Items are sampled without replacement. You can work out the answer on your own. Or just look at the data files, where everything is recorded.
|
By agt - 7/23/2024
+x+x+x+x+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks. Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically? Then obviously you need to construct sequences with lenghts of 64 trials for that. I understand. I am just wondering if each item won't repeat more than twice for 64 trials. Items are sampled without replacement. You can work out the answer on your own. Or just look at the data files, where everything is recorded.
Thanks Dave. May I know how do I include a column in the raw summary to know which sequence the participant was assigned?
|
By Dave - 7/24/2024
+x+x+x+x+x+x+x+x+x+x+x+xHi Dave, may I find out what is the fee to engage your team to develop the script? The standard fee for script development is $100 per hour. I can't tell you how many hours this particular project would take, but what I can tell you is: - It's not a small change, the IAT script would require comparably extensive additions and modifications, since changes have downstream effects. It isn't as simple as adding a line of code or two, so it's probably not a matter of only one or two hours. It could be substantially more. - Given the amount of work involved, consider whether the pay-off is worth the investment. There is a simple, robust, and cheap alternative: Using fixed trial sequences (you can construct several and then pick one at random). Thanks for the information. After much consideration, I will go with fixed trail sequence. Is there an ideal number of fixed trail sequences that I have to create? You can create as few or as many as you deem appropriate for your purposes. Offhand, I'd aim at somewhere around 4 to 5 per type of block (compatibletest1, compatibletest2, incompatibletest1, incompatibletest2). Put each sequence in a separete <list>. Once you have these constructed, I can show you how to select one per block at random for each subject. Hi Dave, I have created 5 randomised sequences for compatibletest1 (32 trials). Showing 2 of them here: Sequence A (attributeB, targetAleft, attributeA, targetBright, attribute, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attribute, targetBright, targetBright, targetAleft, attribute, attributeA, attribute, targetAleft, attributeA, attributeA, targetBright, targetBright, attributeA, attribute, attribute, targetAleft, targetBright, targetAleft, targetBright, targetBright, targetAleft) Sequence B (attributeA, targetAleft, attributeB, targetBright, targetAleft, targetBright, targetBright, attributeA, targetBright, targetAleft, attributeB, attributeB, targetAleft, targetBright, attributeA, targetAleft, targetBright, targetAleft, targetBright, attributeB, attributeA, targetBright, attributeB, attributeB, attributeA, targetAleft, targetAleft, attributeB, attributeA, attributeA, attributeA, attributeB) I have 8 items for attribute A and 8 items for attribute B. The number of items is similar for targets. Each item will appear once for compatibletest1. My apologies, I have updated my sequence A and B below: Sequence A (attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright, attributeA, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetBright ) Sequence B (attributeA, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeB, targetAleft, attributeB, targetBright, attributeA, targetAleft, attributeB, targetBright, attributeA, targetBright, attributeB, targetAleft, attributeA, targetBright, attributeA, targetBright, attributeA, targetAleft, attributeB, targetAleft ) You need to put every sequence in a separate <list>, like so: <list compatibletest1_sequence_a>
/ items = (
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetBright)
/ selectionmode = sequence
</list>
<list compatibletest1_sequence_b>
/ items = (
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeB, trial.targetAleft, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft, trial.attributeB, trial.targetBright,
trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeB, trial.targetAleft,
trial.attributeA, trial.targetBright, trial.attributeA, trial.targetBright, trial.attributeA, trial.targetAleft, trial.attributeB, trial.targetAleft)
/ selectionmode = sequence
</list> Then you make a list of lists: <list compatibletest1_trialsequence>
/ items = (list.compatibletest1_sequence_a.nextvalue, list.compatibletest1_sequence_b.nextvalue)
/ selectionmode = values.sequencenumber
</list> You define a variable which will store the sequence number you administer. <values>
/ sequencenumber = 1
</values> At the start of the block, you select one of the sequences at random. <block compatibletest1>
/ onblockbegin = [
values.sequencenumber = noreplace(1,2);
]
/ bgstim = (targetAleftmixed, orleft, attributeAleft, targetBrightmixed, orright, attributeBright)
/ trials = [1=instructions;
2-33 = list.compatibletest1_trialsequence]
/ errormessage = true(error,200)
/ responsemode = correct
/ ontrialend = [
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.sum1a = values.sum1a + block.compatibletest1.latency;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n1a += 1;
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.ss1a = values.ss1a + (block.compatibletest1.latency * block.compatibletest1.latency);
if(block.compatibletest1.latency <= 10000 && block.compatibletest1.currenttrialnumber != 1 ) values.n_correct += block.compatibletest1.correct;
]
</block> That's it. Do the same for all the other sequences and combined blocks. Thank you. I would like my each item to appear twice for compatibletest2, i.e. 64 trials. May I know if i just have to extend my sequence and the script will run automatically? Then obviously you need to construct sequences with lenghts of 64 trials for that. I understand. I am just wondering if each item won't repeat more than twice for 64 trials. Items are sampled without replacement. You can work out the answer on your own. Or just look at the data files, where everything is recorded. Thanks Dave. May I know how do I include a column in the raw summary to know which sequence the participant was assigned?
Add values.sequencenumber to the /columns attribute in the <data> element
|
|