Millisecond Forums

> I'm not sure if there is a way to do this in Inquisit.

I'm not sure how this is a question about Inquisit. It seems to me, this is a question of whether you can work out the math, entirely independently of Inquisit.

The math, by the way, would seem pretty straightforward to me. You calculate three sums:

sum_orig = max_orig + mid_orig + min_orig
sum_a = max _a + mid_a + min_a
sum_b = max_b + mid_b + min_b

All of these values are known and you have them readily available in your code.

Then you simply rescale to sum_orig:

max_a_r = max_a/sum_a * sum_orig
mid_a_r = mid_a/sum_a * sum_orig
min_a_r = min_a/sum_a * sum_orig

max_b_r = max_b/sum_b * sum_orig
mid_b_r = mid_b/sum_b * sum_orig
min_b_r = min_b/sum_b * sum_orig

Numerical example:

Original: 1000,800,100 (sum_orig = 1900)
Option A: 600,500,400 (sum_a = 1500)
Option B: 4500,4400,2000 (sum_b = 10900)

For A_r: (600/1500)*1900, (500/1500)*1900, (400/1500)*1900
-> A_r: 760, 633.33, 506.67 (sum: 1900)

For B_r: (4500/10900)*1900, (4400/10900)*1900, (2000/10900)*1900
-> B_r: 784.40, 766.97, 348.62 (sum: 1899.99)

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. 

 
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

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

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

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.

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.

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;
}

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.