def exact_dev_reps(game):
"""Uses python ints to compute dev reps. Much slower"""
counts = game.profiles
dev_reps = np.empty_like(counts, float)
fcount = [math.factorial(x) for x in game.num_players]
for dev_prof, count_prof in zip(dev_reps, counts):
total = utils.prod(fc // utils.prod(math.factorial(x) for x in cs)
for fc, cs
in zip(fcount, game.role_split(count_prof)))
for dev_role, counts_role, player_count \
in zip(game.role_split(dev_prof), game.role_split(count_prof),
game.num_players):
for s, count in enumerate(counts_role):
rep = total * int(count) // player_count
dev_role[s] = math.log(rep) if rep > 0 else -np.inf
return dev_reps
def test_random_con_bitmask(_):
ndim = random.randint(2, 4)
shape = tuple(random.randint(1, 5) for _ in range(ndim))
total = utils.prod(shape)
mins = tuple(random.randint(1, total // d) for d in shape)
mask = utils.random_con_bitmask(.2, shape, mins)
for dim, min_in in enumerate(mins):
assert np.all(np.rollaxis(mask, dim).reshape(
mask.shape[dim], -1).sum(1) >= min_in)
def test_basegame_function(players, strategies):
game = rsgame.basegame(players, strategies)
assert game.num_players is not None, "num players was None"
assert game.num_strategies is not None, "num strategies was None"
# Test copy constructor
game2 = rsgame.basegame_copy(game)
assert game == game2
assert np.all(game.num_players == game2.num_players)
assert np.all(game.num_strategies == game2.num_strategies)
# Test role indices
expected = game.role_repeat(np.arange(game.num_roles))
actual = game.role_indices[np.arange(game.num_role_strats)]
assert np.all(expected == actual)
# Test that all profiles returns the correct number of things
all_profs = game.all_profiles()
assert all_profs.shape[0] == game.num_all_profiles, \
"size of all profile generation is wrong"
# Test that all subgames returns the correct number
all_subs = game.all_subgames()
assert all_subs.shape[0] == game.num_all_subgames
assert game.role_reduce(all_subs, ufunc=np.bitwise_or).all()
uniques = np.unique(utils.axis_to_elem(all_subs))
assert uniques.size == all_subs.shape[0]
pure_subs = game.pure_subgames()
assert pure_subs.shape[0] == game.num_pure_subgames
assert game.role_reduce(pure_subs, ufunc=np.bitwise_or).all()
uniques = np.unique(utils.axis_to_elem(pure_subs))
assert uniques.size == pure_subs.shape[0]
# Assert that mixture calculations do the right thing
# Uniform
mix = game.uniform_mixture()
assert np.allclose(game.role_reduce(mix), 1), \
"uniform mixture wasn't a mixture"
if game.num_strategies.max() == 1:
assert (mix == 1).all(), "uniform mixtures wasn't uniform"
else:
diff = np.diff(mix)
changes = game.num_strategies[:-1].cumsum() - 1
diff[changes] = 0
assert np.allclose(diff, 0), \
"uniform mixture wasn't uniform"
one_strats = (game.num_strategies.cumsum() - 1)[game.num_strategies
== 1]
assert np.allclose(mix[one_strats], 1), \
"uniform mixture wasn't uniform"
# Random Subgames
assert game.verify_subgame(game.random_subgames())
assert game.verify_subgame(game.random_subgames(20)).all()
# Random
assert np.allclose(game.role_reduce(game.random_mixtures()), 1)
mixes = game.random_mixtures(20)
assert np.allclose(game.role_reduce(mixes, axis=1), 1), \
"random mixtures weren't mixtures"
# Random Sparse
assert np.allclose(game.role_reduce(game.random_sparse_mixtures()), 1)
mixes = game.random_sparse_mixtures(20)
assert np.allclose(game.role_reduce(mixes, axis=1), 1), \
"random mixtures weren't mixtures"
# Biased
bias = 0.6
mixes = game.biased_mixtures(bias)
assert np.prod(game.num_strategies[game.num_strategies > 1]) == \
mixes.shape[0], \
"Didn't generate the proper number of biased mixtures"
saw_bias = (mixes == bias).any(0)
saw_all_biases = (game.role_reduce(saw_bias, ufunc=np.logical_and) |
(game.num_strategies == 1)).all()
assert saw_all_biases, "Didn't bias every strategy"
assert np.allclose(game.role_reduce(mixes, axis=1), 1), \
"biased mixtures weren't mixtures"
# Role Biased
mixes = game.role_biased_mixtures(bias)
assert (game.num_strategies[game.num_strategies > 1].sum()
== mixes.shape[0]), \
"Didn't generate the proper number of role biased mixtures"
saw_bias = (mixes == bias).any(0)
saw_all_biases = (game.role_reduce(saw_bias, ufunc=np.logical_and)
| (game.num_strategies == 1)).all()
assert saw_all_biases, "Didn't bias every strategy"
assert np.allclose(game.role_reduce(mixes, axis=1), 1), \
"biased mixtures weren't mixtures"
# Grid
points = 3
mixes = game.grid_mixtures(points)
expected_num = utils.prod(spm.comb(s, points - 1, repetition=True,
exact=True)
for s in game.num_strategies)
assert expected_num == mixes.shape[0], \
"didn't create the right number of grid mixtures"
assert np.allclose(game.role_reduce(mixes, 1), 1), \
"grid mixtures weren't mixtures"
# Pure
mixes = game.pure_mixtures()
assert np.allclose(game.role_reduce(mixes), 1), \
"pure mixtures weren't mixtures"
assert np.all(game.role_reduce(np.isclose(mixes, 1)) == 1), \
"not all roles in pure mixture had an assignment"
profs = game.pure_profiles()
assert np.all(game.role_reduce(profs > 0) == 1), \
"pure profiles weren't pure"
# Test that various methods can be called
assert repr(game) is not None
assert hash(game) is not None
def num_profiles(subgame, role_counts, **_):
"""Number of profiles in a subgame"""
return utils.prod(utils.game_size(role_counts[role], len(strats)) for role, strats in subgame.items())
