Millisecond Forums

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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 )

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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.

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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?

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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.

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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.

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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.

+x

 

atgoh - 7/24/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

Dave - 7/23/2024

+x

 

atgoh - 7/23/2024

+x

 

atgoh - 7/22/2024

+x

 

Dave - 7/16/2024

+x

 

atgoh - 7/16/2024

+x

 

Dave - 7/12/2024

+x

 

atgoh - 7/12/2024

Hi 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?