Randomization of Lists with Sequential Trials

David McFarlane mcfarla9 at msu.edu
Thu May 8 20:55:56 UTC 2014


David,

Thanks for all the new detail, but I am even more confused now 
:).  At first it looks like you just want E-Prime to randomize the 
order of blocks, without randomizing the order of stimuli within each 
block, which should not pose a big problem.  But then it looks like 
you use some inline code so that the stimulus for each trial is 
contingent upon the response to earlier trials, which changes everything.

Just in case you really mean only to randomize the order of blocks 
without randomizing stimulus order within each block, here is how you 
might do that.  Make a separate nested List for the fixed stimulus 
order of each block, e.g., Block1StimList, Block2StimList, etc.  Each 
of these contains all the trial attributes for that block; set each 
of these to run in Sequential order.

Then make a BlockList that looks like

Weight  Nested  Procedure  StimList
      1          BlockProc  Block1StimList
      1          BlockProc  Block2StimList
      1          BlockProc  Block3StimList
    ...          ...        ...

Set this to run in Random order, so block order gets 
randomized.  BlockProc contains a TrialList, and TrialList looks like

Weight  Nested      Procedure
      3  [StimList]  TrialProc

So TrialList gets its stimulus List as an attribute reference 
supplied by the BlockList.  It should not matter in this case what 
order TrialList runs in, because each StimList is already set to run 
in Sequential order.  Make sure that the Weight value here matches 
the number of trials in each StimList.

You will see some "?" markers in your Structure this way, and your 
Block#StimLists will end up in Unreferenced E-Objects (this is why I 
am so emphatic about not leaving a mess in Unreferenced E-Objects; 
there are also advanced techniques for getting these Lists to show up 
back in the Structure).

Yes, you could do all this with a separate BlockProc for each 
stimulus order, which may seem simpler at first but I think that gets 
unwieldy.  The method above keeps down the number of "moving parts".

I doubt that I answered your question, but I will be away until 
Monday and so may not pick this up again.  Maybe someone else here 
can weigh in.  Sorry.

-- David McFarlane

/----
Stock reminder:  1) I do not work for PST.  2) PST's trained staff 
take any and all questions at https://support.pstnet.com , and they 
strive to respond to all requests in 24-48 hours, so make full use of 
it.  3) In addition, PST offers several instructional videos on their 
YouTube channel (http://www.youtube.com/user/PSTNET ).  4) If you do 
get an answer from PST staff, please extend the courtesy of posting 
their reply back here for the sake of others.
\----


At 5/8/2014 02:46 PM Thursday, David Ruvolo wrote:
>Thanks for your help.  I have provided more information about the 
>task.  See the attached pdf for more information about the list structure.
>
>
>This is quite a poor example, but hopefully the idea is there.
>
>Now for the randomization part.  When the erun file is loaded and 
>the instructions/practice are through, I would like the task to 
>randomize the order of the lists. So using the same example as 
>before, let's say the first list administered is list 2 and all the 
>trials within this list are administered. The second list 
>administered is list 1 and all the trials within this list are 
>administered.  Then to list 3 and so forth.  However, that is not 
>what happens.  See below for where I am at now.  I am using the same 
>example.  The total number of trials is 15 (3 lists, 5 trials per list).
>
>The task correctly displays the stimuli and keeps track of the 
>adjusted value (left stimuli), but the blocks are varied. 
>Interestingly the trials are administered in order but not one after 
>another (Oops, I think I left this part out in my first post).
>
>Here is how the actual task runs:
># Trial 1
>Left Stimuli = 1 ; Right stimuli = 2; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 2 x 2 = 4
>
># Trial 2
>Left Stimuli = 1 ; Right stimuli = 3; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 2 x 2 = 4
>
># Trial 3
>Left Stimuli = 1 ; Right stimuli = 1; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 2 x 2 = 4
>
># Trial 4
>Left Stimuli = 4 ; Right stimuli = 3; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 4 x 8 = 32
>
># Trial 5
>Left Stimuli = 4 ; Right stimuli = 2; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 4 x 8 = 32
>
># Trial 6
>Left Stimuli = 32 ; Right stimuli = 3; Response= "yes" Then multiply 
>the left stimuli by the value the reaction: 32 ^ 14 = a long number
>
>.... # and so forth
>
>I have tried choosing the Order in the list properties and varying 
>the Reset/Exit options.  The sequential option addresses fixes the 
>one after another issue, but not the randomization of the blocks 
>issue.  The randomization option displays the lists randomly and the 
>trials are not one after another. I have a feeling this is a simply 
>fix. I am not sure if it an experiment structure issue, a missing 
>presentation option, or I need to add another in-line script to 
>control the order (which might be the best option).  I wanted to see 
>if anyone had experience with a task structure like this and what 
>they have done in the past to address this issue.
>
>Hopefully this has made the task and the issue a little clearer.
>
>Thanks for your help,
>
>- David
>
>On Thursday, May 8, 2014 10:47:38 AM UTC-5, McFarlane, David wrote:
>David,
>
>I hope someone smarter than me will weigh in, I feel that a solution
>exists but I
>am still having trouble following this.  Could you give an even more
>concrete example, maybe simplified to 3 Lists with 3 trials each,
>with actual stimulus items, etc., showing first what you might like
>one complete run of this hypothetical sequence of 9 trials total to
>look like, and then one run of what might really happen under your
>current setup?
>
>Thanks,
>-- David McFarlane
>
>
>At 5/8/2014 10:59 AM Thursday, David Ruvolo wrote:
> >There was a thread on this topic a while ago, but it appears there
> >wasn't an update if the suggests worked or if the issue was resolved.
> >
> >I am working on building an experiment that has several lists, where
> >each list has the same number of trials. The order of the lists do
> >not matter, but the trials do. The order of the lists should be
> >randomized (list 4, list2, list8,list1, etc.) and the trials must be
> >presented in sequential order. The reason is the stimuli presented
> >in subsequent trials depend on the response of the first trial.
> >
> >I have the main task proc set to random and each list set to
> >sequential. I have each list nested under a main procedure list and
> >the order set to random. As of now, when the task is run everything
> >is randomized (pure chaos!).
> >
> ># It looks like
> >this:                                               #  It should 
> look like this
> ># Current: (random everything)                          # Ideal:
> >(random lists, sequential trials)
> >      List 8, trial
> > x                                                          List 8, trial 1
> >      List 1, trial
> > x                                                          List 8, trial 2
> >      List 3, trial x
> > ...                                                      List 8, trial 3
> >      ...
> >                ...
> >      ...
> >                List 2, trial 1
> >      ...
> >                List 2, trial 2
> >      ...
> >               ...
> >
> >I am not sure where the issue lies.  The structure of the experiment
> >can be found below.  Any information or suggestions with this issue
> >would be greatly appreciated.
> >
> >- David
> >
> >#
> >------------------------------------------------------------------- 
> -----------------------------------------
> >
> ># Experiment structure
> >- main
> >      - [initial parameters, instructions, etc.]
> >      - practice
> >      - taskproc #each list is nested in the main taskproc and order
> > set to random
> >             - list1
> >             - list2
> >             - list3
> >             - list4
> >             - list5
> >             - list6
> >             - list7
> >             - ...
> >
> ># List structure
> >- main
> >      - [initial parameters, instructions, etc.]
> >      - practice
> >      - taskprocedure
> >             - list1
> >                   - Trial 1
> >                   - Trial 2
> >                   - Trial 3
> >                   - Trial 4
> >                   - ...
> >             - list2
> >                   - Trial 1
> >                   - Trial 2
> >                   - Trial 3
> >                   - Trial 4
> >                   - ...

-- 
You received this message because you are subscribed to the Google Groups "E-Prime" group.
To unsubscribe from this group and stop receiving emails from it, send an email to e-prime+unsubscribe at googlegroups.com.
To post to this group, send email to e-prime at googlegroups.com.
To view this discussion on the web visit https://groups.google.com/d/msgid/e-prime/536bef79.8770320a.3b5e.065dSMTPIN_ADDED_MISSING%40gmr-mx.google.com.
For more options, visit https://groups.google.com/d/optout.



More information about the Eprime mailing list