Esempio n. 1
0
def test_lex_big():

    criteria = [(0, 1, 2)] * 3
    alts = [
        # I think I got these items from a paper, but now I've forgotten
        # which. D'oh.
        (0, 1, 1),
        (1, 1, 0),
        (2, 0, 1),
        (0, 2, 0),
        (1, 0, 2),
        (2, 1, 1),
        (2, 1, 0),
        (2, 2, 0),
        (1, 0, 1)
    ]

    def p(find_best, max_dev, a):
        return vda(criteria=criteria,
                   alts=alts,
                   asker=a,
                   find_best=find_best,
                   max_dev=max_dev)

    prefs = p(1, 3, lambda a, b: Relation.cmp(a[::-1], b[::-1]))
    assert prefs.maxes() == {(2, 2, 2)}
    assert prefs.maxes(among=alts) == {(1, 0, 2)}

    prefs = p(1, 3, lambda a, b: Relation.cmp(a, b))
    assert prefs.maxes() == {(2, 2, 2)}
    assert prefs.maxes(among=alts) == {(2, 2, 0)}

    prefs = p(3, 4, lambda a, b: Relation.cmp(a, b))
    assert prefs.extreme(3, among=alts) == {(2, 2, 0), (2, 1, 1), (2, 1, 0)}
Esempio n. 2
0
def test_simple_strings():

    criteria = [['bad', 'good'], ['expensive', 'cheap']]
    alts = [('bad', 'cheap'), ('good', 'expensive'), ('bad', 'expensive')]

    def asker(a, b):
        # We prefer good to bad, but when that criterion is the same,
        # we prefer cheap to expensive.
        if a[0] == b[0]:
            if a[1] == b[1]:
                return EQ
            elif a[1] == 'cheap':
                return GT
            else:
                return LT
        elif a[0] == 'good':
            return GT
        else:
            return LT

    for find_best in (1, 2, None):
        prefs = vda(criteria=criteria,
                    alts=alts if find_best else None,
                    asker=asker,
                    find_best=find_best)
        assert prefs.maxes(among=alts) == {('good', 'expensive')}
        if find_best == 2:
            assert prefs.extreme(2, among=alts) == {('good', 'expensive'),
                                                    ('bad', 'cheap')}
        elif not find_best:
            assert prefs.maxes() == {('good', 'cheap')}
            ranking = (('bad', 'expensive'), ('bad', 'cheap'),
                       ('good', 'expensive'), ('good', 'cheap'))
            for (ai, a), (bi, b) in choose2(enumerate(ranking)):
                assert prefs.cmp(a, b) == Relation.cmp(ai, bi)
Esempio n. 3
0
def test_appendixD():
    '''Appendix D of Larichev and Moshkovich (1995).'''

    criteria = [(3, 2, 1)] * 3
    # 3 is worst and 1 is best.
    alts = [(1, 2, 3), (2, 3, 1), (3, 1, 2)]
    dm_ranking = [(2, 1, 1), (1, 1, 2), (1, 2, 1), (1, 3, 1), (3, 1, 1),
                  (1, 1, 3)]

    # The first element is the best, so we negate `cmp` in the
    # asker.
    def asker(a, b):
        return -Relation.cmp(dm_ranking.index(a), dm_ranking.index(b))

    Proposal1, Proposal2, Proposal3 = alts

    for goal in ('find_best', 'rank_alts', 'rank_space'):
        prefs = vda(criteria=criteria,
                    alts=(None if goal == 'rank_alts' else alts),
                    asker=asker,
                    find_best=goal == 'find_best' and 1)
        assert prefs.maxes(among=alts) == {Proposal2}
        if goal == 'rank_alts':
            for v1, v2 in choose2(dm_ranking):
                assert prefs.cmp(v1, v2) == -Relation.cmp(
                    dm_ranking.index(v1), dm_ranking.index(v2))
        if goal != 'find_best':
            assert prefs.cmp(Proposal2, Proposal1) == GT
            assert prefs.cmp(Proposal2, Proposal3) == GT
            assert prefs.cmp(Proposal3, Proposal1) == GT
Esempio n. 4
0
def test_lex_generalized(criteria,
                         R,
                         n_questions=(15, 34, 33, 35, 30, 75, 86, 463)):
    '''Artiruno should be able to reproduce lexicographic preferences,
    in which the criteria have a defined order of importance.'''
    criterion_order = R.sample(range(len(criteria)), len(criteria))
    return lambda a, b: Relation.cmp(*(tuple(v[i] for i in criterion_order)
                                       for v in (a, b)))
Esempio n. 5
0
def test_value_function(criteria,
                        R,
                        n_questions=(15, 34, 53, 35, 33, 86, 76, 652)):
    '''Artiruno should be able to reproduce preferences defined by an
    additive value function, in which each criterion increment adds a
    certain positive amount of utility.'''
    values = tuple(
        tuple(0 if i == 0 else R.randint(1, 4) for i in range(len(c)))
        for c in criteria)
    return lambda a, b: Relation.cmp(*(sum(
        sum(values[ci][:cl + 1]) for ci, cl in enumerate(item))
                                       for item in (a, b)))
Esempio n. 6
0
def test_extreme_n():
    x = PreorderedSet(l + str(i)
        for l in "wxyz"
        for i in range(3))
    for a, b in choose2(x.elements):
        x.learn(a, b, Relation.cmp(a[0], b[0]))

    assert (x.maxes() == x.extreme(2) == x.extreme(3) ==
        {"z0", "z1", "z2"})
    assert (x.extreme(4) == x.extreme(5) == x.extreme(6) ==
        {"z0", "z1", "z2", "y0", "y1", "y2"})
    def xb(n):
        return x.extreme(n, bottom = True)
    assert (x.mins() == xb(2) == xb(3) ==
        {"w0", "w1", "w2"})
    assert (xb(4) == xb(5) == xb(6) ==
        {"w0", "w1", "w2", "x0", "x1", "x2"})
Esempio n. 7
0
 def asker(a, b):
     return -Relation.cmp(dm_ranking.index(a), dm_ranking.index(b))
Esempio n. 8
0
def test_lex_small():
    'A scenario with lexicographic preferences.'
    criteria = [(0, 1)] * 3
    alts = [(1, 0, 0), (0, 1, 1)]
    prefs = vda(criteria=criteria, alts=alts, asker=Relation.cmp, max_dev=3)
    assert prefs.cmp(*alts) == Relation.cmp(*alts)
Esempio n. 9
0
 async def asker(a, b):
     l.append('start')
     queue.put_nowait(1)
     await queue.join()
     l.append('done')
     return Relation.cmp(a, b)