コード例 #1
0
def test_bad_heterogeneity():
    main_structure = [
        ('participant',
         Design(ivs={
             'a': [1, 2],
             'b': [1, 2]
         }, ordering=Shuffle(3))),
        ('session',
         Design(ivs={'design': ['practice', 'test']},
                design_matrix=[[0], [1], [1]])),
    ]
    other_structures = {
        'practice': [
            ('block', Design()),
            ('trial', Design(ivs={'difficulty': [1, 2]},
                             ordering=Shuffle(20))),
        ],
        'test': [
            ('block', Design(ordering=CompleteCounterbalance(2))),
            ('trial',
             Design(ivs={'difficulty': [1, 3, 5, 7]}, ordering=Shuffle(5))),
        ],
    }
    with pytest.raises(ValueError):
        DesignTree.new(main_structure, **other_structures)
コード例 #2
0
def make_heterogeneous_tree():
    main_structure = [
        ('participant',
         Design(ivs={
             'a': [1, 2],
             'b': [1, 2]
         }, ordering=Shuffle(3))),
        ('session',
         Design(ivs={'design': ['practice', 'test']},
                design_matrix=[[0], [1], [1]])),
    ]
    other_structures = {
        'practice': [
            ('block', Design()),
            ('trial', Design(ivs={'difficulty': [1, 2]},
                             ordering=Shuffle(20))),
        ],
        'test': [
            ('block', Design(ordering=Ordering(2))),
            ('trial',
             Design(ivs={'difficulty': [1, 3, 5, 7]}, ordering=Shuffle(5))),
        ],
    }

    return DesignTree.new(main_structure, **other_structures)
コード例 #3
0
def make_manual_exp():
    tree = DesignTree.new([('participant', [Design(ordering=Shuffle(2))]),
                           ('block', [Design(ivs={'b': [0, 1, 2]}, ordering=CompleteCounterbalance())]),
                           ('trial', [Design({'a': [False, True]}, ordering=Shuffle(4))]),
                           ])
    exp = Experiment.new(tree)
    exp.add_callback('trial', trial)
    return exp
コード例 #4
0
def make_standard_exp():
    exp = Experiment.basic(('participant', 'block', 'trial'),
                           {'block': [('b', [0, 1, 2])],
                            'trial': [('a', [False, True])]},
                           ordering_by_level={'trial': Shuffle(4),
                                              'block': CompleteCounterbalance(),
                                              'participant': Shuffle(2)})
    exp.add_callback('trial', trial)
    return exp
コード例 #5
0
def test_design_from_spec():
    spec = {
        'name': 'test1',
        'order': 'Shuffle',
        'n': 2,
        'ivs': {
            'a': [True, False],
            'b': [1, 2, 3]
        },
    }
    assert Design.from_dict(spec) == ('test1',
                                      Design(
                                          {
                                              'a': [True, False],
                                              'b': [1, 2, 3]
                                          },
                                          ordering=Shuffle(2)))

    spec = {
        'name': 'test2',
        'some_extra_field': ['blah'],
        'number': 3,
    }
    assert Design.from_dict(spec) == ('test2',
                                      Design(extra_data={
                                          'some_extra_field': ['blah']
                                      },
                                             ordering=Shuffle(3)))

    spec = {
        'name': 'test3',
        'ordering': {
            'class': 'Sorted',
            'order': 'ascending',
        },
        'ivs': {
            'a': [1, 2, 3]
        },
    }
    assert Design.from_dict(spec) == ('test3',
                                      Design(
                                          ivs={'a': [1, 2, 3]},
                                          ordering=Sorted(order='ascending')))

    spec = {
        'name': 'test4',
        'order': ['CompleteCounterbalance', 3],
    }
    assert Design.from_dict(spec) == ('test4',
                                      Design(
                                          ordering=CompleteCounterbalance(3)))

    spec.pop('name')
    assert Design.from_dict(spec) == Design(ordering=CompleteCounterbalance(3))
コード例 #6
0
def test_shuffle_generator_condition():
    n = 3
    o = Shuffle(number=n)
    o.first_pass(c for c in CONDITIONS_3)
    yield check_shuffle, o, len(CONDITIONS_3)

    o = Shuffle(n, avoid_repeats=True)
    o.first_pass(c for c in CONDITIONS_3)
    yield check_shuffle, o, len(CONDITIONS_3)
    yield check_repeats, o.get_order()
コード例 #7
0
def test_shuffle():
    for n in range(1, 6, 2):
        for conditions in (CONDITIONS_6, CONDITIONS_2_3, CONDITIONS_2_3_2):
            o = Shuffle(number=n)
            o.first_pass(conditions)
            yield check_shuffle, o, len(conditions)

            o = Shuffle(n, avoid_repeats=True)
            o.first_pass(conditions)
            yield check_shuffle, o, len(conditions)
            yield check_repeats, o.get_order()
コード例 #8
0
def test_shuffle_generator_condition():
    n = 3
    o = Shuffle(number=n)
    o.first_pass(c for c in CONDITIONS_3)
    yield check_shuffle, o, len(CONDITIONS_3)

    o = Shuffle(n, avoid_repeats=True)
    o.first_pass(c for c in CONDITIONS_3)
    yield check_shuffle, o, len(CONDITIONS_3)
    yield check_repeats, o.get_order()
コード例 #9
0
def test_shuffle():
    for n in range(1, 6, 2):
        for conditions in (CONDITIONS_6, CONDITIONS_2_3, CONDITIONS_2_3_2):
            o = Shuffle(number=n)
            o.first_pass(conditions)
            yield check_shuffle, o, len(conditions)

            o = Shuffle(n, avoid_repeats=True)
            o.first_pass(conditions)
            yield check_shuffle, o, len(conditions)
            yield check_repeats, o.get_order()
コード例 #10
0
def make_blocked_exp():
    exp = Experiment.blocked({'a': [False, True]}, 2,
                             block_ivs={'b': [0, 1, 2]},
                             orderings={'trial': Shuffle(4), 'block': CompleteCounterbalance()})
    exp.add_callback('trial', trial)
    return exp
コード例 #11
0
def make_simple_exp():
    ivs = {'a': [False, True], 'b': [0, 1, 2]}
    exp = Experiment.within_subjects(ivs, 10, ordering=Shuffle(4))
    exp.add_callback('trial', trial)
    return exp
コード例 #12
0
def test_schema_list():
    assert OrderSchema.from_any(['Shuffle', 2]) == Shuffle(2)
コード例 #13
0
def test_bizarre_inequality():
    assert (Shuffle() == 1) is False
コード例 #14
0
def test_reprs():
    for ord in (CompleteCounterbalance(), Shuffle(), LatinSquare(), Ordering(),
                Sorted()):
        yield check_repr, ord
コード例 #15
0
def test_design_tree():
    trial_matrix = np.array(
        [[-1, -1], [1, -1], [-1, 1], [1, 1], [0, 0], [0, 0], [0, 0], [0, 0],
         [-1.41421356, 0.1],
         [1.41421356, 0.1], [0, -1.41421356], [0,
                                               1.41421356],
         [0, 0], [0, 0], [0,
                          0], [0, 0]]
    )  # pyDOE.ccdesign(2) with two 0.1 elements to prevent symmetry in the IVs.
    trial_iv_names = ['a', 'b']
    trial_iv_values = [None, None]
    block_ivs = {'block': [1, 2]}
    participant_iv_names = ('A', 'B')
    participant_iv_values = [[1, 2], [1, 2, 3]]

    trial_design = Design(ivs=zip(trial_iv_names, trial_iv_values),
                          ordering=Shuffle(3),
                          design_matrix=trial_matrix)
    block_design = Design(block_ivs, ordering=CompleteCounterbalance())
    practice_block_design = Design()
    participant_design = Design(dict(
        zip(participant_iv_names, participant_iv_values)),
                                ordering=Ordering(10))

    levels_and_designs = OrderedDict([('participant', participant_design),
                                      ('block',
                                       [practice_block_design, block_design]),
                                      ('trial', trial_design)])

    tree = DesignTree.new(levels_and_designs)
    tree.add_base_level()

    levels, designs = zip(*tree.levels_and_designs)

    yield check_identity, designs[1][0], participant_design
    yield check_identity, designs[2][0], practice_block_design
    yield check_identity, designs[2][1], block_design
    yield check_identity, designs[3][0], trial_design

    yield check_equality, len(tree), 4
    yield check_equality, tree[3], ('trial', [trial_design])

    yield check_equality, next(tree).levels_and_designs, next(
        tree).levels_and_designs, tree.levels_and_designs[1:]
    tree_with_participant_base = next(tree)
    tree_with_block_base = next(tree_with_participant_base)
    yield (check_equality, tree_with_block_base.levels_and_designs,
           next(next(tree)).levels_and_designs,
           [('block', [practice_block_design, block_design]),
            ('trial', [trial_design])])
    tree_with_trial_base = next(tree_with_block_base)
    yield (check_equality, tree_with_trial_base.levels_and_designs, [
        ('trial', [trial_design])
    ], next(tree_with_block_base).levels_and_designs)
    with pytest.raises(StopIteration):
        next(tree_with_trial_base)

    for design, iv_names, iv_values, n, data, matrix in zip(
        [designs[1][0], designs[2][0], designs[2][1], designs[3][0]],
        [['A', 'B', CompleteCounterbalance.iv_name], [], ['block'], ['a', 'b']
         ], [[[1, 2], [1, 2, 3], [0, 1]], [], [[1, 2]], [None, None]],
        [10 * 2 * 2 * 3, 1, 2, 3 * len(trial_matrix)],
        [{}, {}, {
            CompleteCounterbalance.iv_name: 0
        }, {}], [None, None, None, trial_matrix]):
        yield check_design, design, iv_names, iv_values, n, data, matrix

    yield check_design_matrix, designs[3][0].get_order(), ['a', 'b'
                                                           ], [None, None
                                                               ], trial_matrix