Millisecond Forums

If you want to ensure that all 80 combinations occur with equal frequency -- either all within a single participant or split across multiple participants (you talked of sets of 20 split across 4 consecutive participants before) -- then you need explicitly define the combinations and sample from those combinations. If you don't link the lists / don't explicitly define the combinations, you will have no guarantee whatsoever that all combinations occur across participants or that they occur with equal frequency across participants. Some will occur more often than others just by chance, in the extreme some might not occur at all.

As I've explained before: Take your 80 combinations as defined here https://www.millisecond.com/forums/FindPost27573.aspx and split them into four sets of 20 unique combinations each (in whichever way you want). Those four sets of linked lists go into different files -- then you just <include> one out of the four sets as a between-subjects factor.

Hi Dave, 

Thank you for letting me know. To clarify, I cannot have Option A and B set to the original values, plus the manipulations that were selected (mentioned below)? 


 I understand that you are indicating I need to have the <include> to do the combinations. 

<list manipulations_a>
/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = random
/ not = (values.manip_b)
</list>

<list manipulations_b>
/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = random
/ not = (values.manip_a)
</list>

<list distributions_orig>
/ items = (1,2,3,4)
/ selectionmode = random
/ replace = true
</list>

This makes no sense. You need to link the lists if you want to sample from *combinations*. Exactly as here:

https://www.millisecond.com/forums/FindPost27573.aspx

Only the first list is set to random selection. The selection in all the other lists *depends on* and is locked to the item randomly sampled from the 1st list. That's how the combinations are defined to begin with.

Hi Dave,

Thank you so much for all of your help. I want to test that all combination happen without splitting up the participants. I want to test that all participants could complete all 80 combinations, without repeats of combinations. Is there a way to do this with selection mode within lists? If I say noreplace within the list, it presents issues since it only restricts one of the list combinations, not all of them.

I have changed my code since we last spoke. Now I use the original values (distrib_orig) randomly selected for a trial and use them to define both the max_a, mid_a, min_a (option a) and max_b, mid_b, min_b, (option b) and then I have the values manipulated randomly for each (manip_a, manip_b). Before they were randomizing their own values, separate from the selected original values).

I have pasted two relevant sections of code for background:

// we have 5 manipulation options to select from

/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = random
/ not = (values.manip_b)



/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = random
/ not = (values.manip_a)


// only four original distributions to select from

/ items = (1,2,3,4)
/ selectionmode = random
/ replace = true

/ not = (values.dist_a)


/// original values


/ items = (1000, 1000, 1000, 600)
/ select = values.dist_orig



/ items = (200, 800, 500, 500)
/ select = values.dist_orig



/ items = (100, 100, 400, 400)
/ select = values.dist_orig


/ expression applies the selected manipulation to the original values of the chosen distribution



// expression applies the selected manipulation to the original values of the chosen distribution - option A

/ apply_manipulation_a = if (values.manip_a == 1) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue/0.75);
list.sort.appenditem(list.list_mid_orig.nextvalue);
list.sort.appenditem(list.list_min_orig.nextvalue + (list.list_max_orig.nextvalue/0.75));
list.sort.sort(true, false);
values.max_a = list.sort.item(3);
values.mid_a = list.sort.item(2);
values.min_a = list.sort.item(1);
} else if (values.manip_a == 2) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue/0.50);
list.sort.appenditem(list.list_mid_orig.nextvalue + (list.list_max_orig.nextvalue/0.25));
list.sort.appenditem(list.list_min_orig.nextvalue + (list.list_max_orig.nextvalue/0.25));
list.sort.sort(true, false);
values.max_a = list.sort.item(3);
values.mid_a = list.sort.item(2);
values.min_a = list.sort.item(1);
} else if (values.manip_a == 3) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue + (0.50 * list.list_min_orig.nextvalue));
list.sort.appenditem(list.list_mid_orig.nextvalue + (0.50 * list.list_min_orig.nextvalue));
list.sort.appenditem(0 * list.list_min_orig.nextvalue);
list.sort.sort(true, false);
values.max_a = list.sort.item(3);
values.mid_a = list.sort.item(2);
values.min_a = list.sort.item(1);
} else if (values.manip_a == 4) {
values.max_a = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
values.mid_a = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
values.min_a = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
} else if (values.manip_a == 5) {
values.max_a = list.list_max_orig.nextvalue;
values.mid_a = list.list_mid_orig.nextvalue;
values.min_a = list.list_min_orig.nextvalue;
};



/ apply_manipulation_b = if (values.manip_b == 1 && values.manip_a != 1) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue/0.75);
list.sort.appenditem(list.list_mid_orig.nextvalue);
list.sort.appenditem(list.list_min_orig.nextvalue + (list.list_max_orig.nextvalue/0.75));
list.sort.sort(true, false);
values.max_b = list.sort.item(3);
values.mid_b = list.sort.item(2);
values.min_b = list.sort.item(1);
} else if (values.manip_b == 2 && values.manip_a != 2) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue/0.50);
list.sort.appenditem(list.list_mid_orig.nextvalue + (list.list_max_orig.nextvalue/0.25));
list.sort.appenditem(list.list_min_orig.nextvalue + (list.list_max_orig.nextvalue/0.25));
list.sort.sort(true, false);
values.max_b = list.sort.item(3);
values.mid_b = list.sort.item(2);
values.min_b = list.sort.item(1);
} else if (values.manip_b == 3 && values.manip_a != 3) {
list.sort.reset();
list.sort.appenditem(list.list_max_orig.nextvalue + (0.50 * list.list_min_orig.nextvalue));
list.sort.appenditem(list.list_mid_orig.nextvalue + (0.50 * list.list_min_orig.nextvalue));
list.sort.appenditem(0 * list.list_min_orig.nextvalue);
list.sort.sort(true, false);
values.max_b = list.sort.item(3);
values.mid_b = list.sort.item(2);
values.min_b = list.sort.item(1);
} else if (values.manip_b == 4 && values.manip_b != 4) {
values.max_b = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
values.mid_b = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
values.min_b = (list.list_max_orig.nextvalue + list.list_mid_orig.nextvalue + list.list_min_orig.nextvalue)/3;
} else if (values.manip_b == 5 && values.manip_a != 5) {
values.max_b = list.list_max_orig.nextvalue;
values.mid_b = list.list_mid_orig.nextvalue;
values.min_b = list.list_min_orig.nextvalue;
} else if (values.manip_b == 1 && values.manip_a ==1) {
values.manip_a == list.manipulations_a.nextvalue;
} else if (values.manip_b == 2 && values.manip_a ==2) {
values.manip_a == list.manipulations_a.nextvalue;
} else if (values.manip_a == 3 && values.manip_a ==3) {
values.manip_a == list.manipulations_a.nextvalue;
} else if (values.manip_a == 4 && values.manip_a ==4) {
values.manip_a == list.manipulations_a.nextvalue;
} else if (values.manip_a == 5 && values.manip_a ==5) {
values.manip_a == list.manipulations_a.nextvalue;
}

Look at your script at https://www.millisecond.com/forums/FindPost27477.aspx (I have no way of knowing how current that is). You have your 80 options / combinations encoded in a bunch of <list> elements. These:

// we have 4 distributions to select from
<list distributions_a>
/ items = (
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
</list>

<list distributions_b>
/ items = (
1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,3,
4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4,4)
</list>

// we have 5 manipulation options to select from
<list manipulations_a>
/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = list.distributions_a.currentindex
</list>

<list manipulations_b>
/ items = (
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,
1,2,3,4,5,1,2,3,4,5,1,2,3,4,5,1,2,3,4,5)
/ selectionmode = list.distributions_b.currentindex
</list>


<list potentialSelfInterests>
/ items = (
1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,
1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,
1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4,
1,1,1,1,1,2,2,2,2,2,3,3,3,3,3,4,4,4,4,4)
/ selectionmode = list.distributions_a.currentindex
</list>

Now,  just create four files containing those lists, but in each file the lists have only 20 options / combinations. I.e. split things into four sets of 20 different combinations.

Then you just <include> the applicable set of 20 combinations as illustrated before.

I have no idea what this is supposed to mean.

You said:

"I have three options of different numbers presented on the screen. I want to make sure all possible 80 options occur, but I want to split them up between subjects, such that the first subject does the first 1-20, the next does 20-40, the next does 40-60, and finally 60-80."

That sounds to me like you have four sets of 20 "options" each. I don't understand what this has to do with if-statements.

You ask:

"How could I go about listing the items with the combinations below?"

Where do the numbers 1, 2, 3, 4 and 5 in your listing

values.manip_a = 1 && values.manip_b ==2 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==3 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==4 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==5 && values.dist_orig == 1
[...]

come from? Those are your combinations, right? So put them in <list>s and <include> different lists.

Thanks, Dave. I am a bit confused based on the example you provided with the different .txt files that were used to define different sets of items. 

I wrote out all of the possible options (as though they were if statements...). How could I go about listing the items with the combinations below? I'm unsure based on the example. I would really appreciate any help. 

values.manip_a = 1 && values.manip_b ==2 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==3 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==4 && values.dist_orig == 1
values.manip_a = 1 && values.manip_b ==5 && values.dist_orig == 1

values.manip_a = 1 && values.manip_b ==2 && values.dist_orig == 2
values.manip_a = 1 && values.manip_b ==3 && values.dist_orig == 2
values.manip_a = 1 && values.manip_b ==4 && values.dist_orig == 2
values.manip_a = 1 && values.manip_b ==5 && values.dist_orig == 2

values.manip_a = 1 && values.manip_b ==2 && values.dist_orig == 3
values.manip_a = 1 && values.manip_b ==3 && values.dist_orig == 3
values.manip_a = 1 && values.manip_b ==4 && values.dist_orig == 3
values.manip_a = 1 && values.manip_b ==5 && values.dist_orig == 3

values.manip_a = 1 && values.manip_b ==2 && values.dist_orig == 4
values.manip_a = 1 && values.manip_b ==3 && values.dist_orig == 4
values.manip_a = 1 && values.manip_b ==4 && values.dist_orig == 4
values.manip_a = 1 && values.manip_b ==5 && values.dist_orig == 4

values.manip_a = 2 && values.manip_b ==1 && values.dist_orig == 1
values.manip_a = 2 && values.manip_b ==3 && values.dist_orig == 1
values.manip_a = 2 && values.manip_b ==4 && values.dist_orig == 1
values.manip_a = 2 && values.manip_b ==5 && values.dist_orig == 1

values.manip_a = 2 && values.manip_b ==1 && values.dist_orig == 2
values.manip_a = 2 && values.manip_b ==3 && values.dist_orig == 2
values.manip_a = 2 && values.manip_b ==4 && values.dist_orig == 2
values.manip_a = 2 && values.manip_b ==5 && values.dist_orig == 2

values.manip_a = 2 && values.manip_b ==1 && values.dist_orig == 3
values.manip_a = 2 && values.manip_b ==3 && values.dist_orig == 3
values.manip_a = 2 && values.manip_b ==4 && values.dist_orig == 3
values.manip_a = 2 && values.manip_b ==5 && values.dist_orig == 3

values.manip_a = 2 && values.manip_b ==1 && values.dist_orig == 4
values.manip_a = 2 && values.manip_b ==3 && values.dist_orig == 4
values.manip_a = 2 && values.manip_b ==4 && values.dist_orig == 4
values.manip_a = 2 && values.manip_b ==5 && values.dist_orig == 4

values.manip_a = 3 && values.manip_b ==1 && values.dist_orig == 1
values.manip_a = 3 && values.manip_b ==2 && values.dist_orig == 1
values.manip_a = 3 && values.manip_b ==4 && values.dist_orig == 1
values.manip_a = 3 && values.manip_b ==5 && values.dist_orig == 1

values.manip_a = 3 && values.manip_b ==1 && values.dist_orig == 2
values.manip_a = 3 && values.manip_b ==2 && values.dist_orig == 2
values.manip_a = 3 && values.manip_b ==4 && values.dist_orig == 2
values.manip_a = 3 && values.manip_b ==5 && values.dist_orig == 2

values.manip_a = 3 && values.manip_b ==1 && values.dist_orig == 3
values.manip_a = 3 && values.manip_b ==2 && values.dist_orig == 3
values.manip_a = 3 && values.manip_b ==4 && values.dist_orig == 3
values.manip_a = 3 && values.manip_b ==5 && values.dist_orig == 3

values.manip_a = 3 && values.manip_b ==1 && values.dist_orig == 4
values.manip_a = 3 && values.manip_b ==2 && values.dist_orig == 4
values.manip_a = 3 && values.manip_b ==4 && values.dist_orig == 4
values.manip_a = 3 && values.manip_b ==5 && values.dist_orig == 4

values.manip_a = 4 && values.manip_b ==1 && values.dist_orig == 1
values.manip_a = 4 && values.manip_b ==2 && values.dist_orig == 1
values.manip_a = 4 && values.manip_b ==3 && values.dist_orig == 1
values.manip_a = 4 && values.manip_b ==5 && values.dist_orig == 1

values.manip_a = 4 && values.manip_b ==1 && values.dist_orig == 2
values.manip_a = 4 && values.manip_b ==2 && values.dist_orig == 2
values.manip_a = 4 && values.manip_b ==3 && values.dist_orig == 2
values.manip_a = 4 && values.manip_b ==5 && values.dist_orig == 2

values.manip_a = 4 && values.manip_b ==1 && values.dist_orig == 3
values.manip_a = 4 && values.manip_b ==2 && values.dist_orig == 3
values.manip_a = 4 && values.manip_b ==3 && values.dist_orig == 3
values.manip_a = 4 && values.manip_b ==5 && values.dist_orig == 3

values.manip_a = 4 && values.manip_b ==1 && values.dist_orig == 4
values.manip_a = 4 && values.manip_b ==2 && values.dist_orig == 4
values.manip_a = 4 && values.manip_b ==3 && values.dist_orig == 4
values.manip_a = 4 && values.manip_b ==5 && values.dist_orig == 4

values.manip_a = 5 && values.manip_b ==1 && values.dist_orig == 1
values.manip_a = 5 && values.manip_b ==2 && values.dist_orig == 1
values.manip_a = 5 && values.manip_b ==3 && values.dist_orig == 1
values.manip_a = 5 && values.manip_b ==4 && values.dist_orig == 1

values.manip_a = 5 && values.manip_b ==1 && values.dist_orig == 2
values.manip_a = 5 && values.manip_b ==2 && values.dist_orig == 2
values.manip_a = 5 && values.manip_b ==3 && values.dist_orig == 2
values.manip_a = 5 && values.manip_b ==4 && values.dist_orig == 2

values.manip_a = 5 && values.manip_b ==1 && values.dist_orig == 3
values.manip_a = 5 && values.manip_b ==2 && values.dist_orig == 3
values.manip_a = 5 && values.manip_b ==3 && values.dist_orig == 3
values.manip_a = 5 && values.manip_b ==4 && values.dist_orig == 3

values.manip_a = 5 && values.manip_b ==1 && values.dist_orig == 4
values.manip_a = 5 && values.manip_b ==2 && values.dist_orig == 4
values.manip_a = 5 && values.manip_b ==3 && values.dist_orig == 4
values.manip_a = 5 && values.manip_b ==4 && values.dist_orig == 4

You can define sets of items (or whatever else) and conditionally <include> them in a between-subjects manner: https://www.millisecond.com/forums/Topic15639.aspx

 
Hello Dave,

Thank you again for your help. I am wondering if you would be able to help with one last question of mine:

I have three options of different numbers presented on the screen. I want to make sure all possible 80 options occur, but I want to split them up between subjects, such that the first subject does the first 1-20, the next does 20-40, the next does 40-60, and finally 60-80.

One of the issues is that each of the options occur randomly and independently of one another, and are not yet connected to one another. I assume I would need to define each of the 80 combinations? 

 How would I go about splitting these combinations up across subjects, as mentioned above? Any links to other posts would be helpful.
Thank you

Thank you so much, Dave. You have really helped to get the basic components of this experiment running. I really appreciate all of your time.