class TestNormalFormGame_3p: """Test the methods of NormalFormGame with three players""" def setUp(self): """Setup a NormalFormGame instance""" payoffs_2opponents = [[[3, 6], [4, 2]], [[1, 0], [5, 7]]] player = Player(payoffs_2opponents) self.g = NormalFormGame([player for i in range(3)]) def test_getitem(self): assert_array_equal(self.g[0, 0, 1], [6, 4, 1]) def test_delete_action(self): action_to_delete = 0 for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, action_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), action_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i)) def test_is_nash_pure(self): ok_(self.g.is_nash((0, 0, 0))) ok_(not self.g.is_nash((0, 0, 1))) def test_is_nash_mixed(self): p = (1 + np.sqrt(65)) / 16 ok_(self.g.is_nash(([1 - p, p], [1 - p, p], [1 - p, p])))
class TestNormalFormGame_Asym2p: """Test the methods of NormalFormGame with asymmetric two players""" def setUp(self): """Setup a NormalFormGame instance""" self.BoS_bimatrix = np.array([[(3, 2), (1, 1)], [(0, 0), (2, 3)]]) self.g = NormalFormGame(self.BoS_bimatrix) def test_getitem(self): action_profile = (1, 0) assert_array_equal(self.g[action_profile], self.BoS_bimatrix[action_profile]) def test_is_nash_pure(self): ok_(not self.g.is_nash((1, 0))) def test_is_nash_mixed(self): ok_(self.g.is_nash(([3/4, 1/4], [1/4, 3/4]))) def test_payoff_arrays(self): assert_array_equal( self.g.payoff_arrays[0], self.BoS_bimatrix[:, :, 0] ) assert_array_equal( self.g.payoff_arrays[1], self.BoS_bimatrix[:, :, 1].T )
def setUp(self): self.game_dicts = [] # Example from Abreu and Sannikov (2014) bimatrix = [[(16, 9), (3, 13), (0, 3)], [(21, 1), (10, 4), (-1, 0)], [(9, 0), (5, -4), (-5, -15)]] vertices = np.array([[7.33770472e+00, 1.09826253e+01], [1.12568240e+00, 2.80000000e+00], [7.33770472e+00, 4.44089210e-16], [7.86308964e+00, 4.44089210e-16], [1.97917977e+01, 2.80000000e+00], [1.55630896e+01, 9.10000000e+00]]) d = {'sg': NormalFormGame(bimatrix), 'delta': 0.3, 'vertices': vertices, 'u': np.zeros(2)} self.game_dicts.append(d) # Prisoner's dilemma bimatrix = [[(9, 9), (1, 10)], [(10, 1), (3, 3)]] vertices = np.array([[3. , 3.], [9.75, 3. ], [9. , 9. ], [3. , 9.75]]) d = {'sg': NormalFormGame(bimatrix), 'delta': 0.9, 'vertices': vertices, 'u': np.array([3., 3.])} self.game_dicts.append(d)
def test_normalformgame_constant_payoffs(): g = NormalFormGame((2, 2)) ok_(g.is_nash((0, 0))) ok_(g.is_nash((0, 1))) ok_(g.is_nash((1, 0))) ok_(g.is_nash((1, 1)))
class TestNormalFormGame_3p: """Test the methods of NormalFormGame with three players""" def setUp(self): """Setup a NormalFormGame instance""" payoffs_2opponents = [[[3, 6], [4, 2]], [[1, 0], [5, 7]]] player = Player(payoffs_2opponents) self.g = NormalFormGame([player for i in range(3)]) def test_getitem(self): assert_array_equal(self.g[0, 0, 1], [6, 4, 1]) def test_delete_action(self): action_to_delete = 0 for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, action_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), action_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i) ) def test_is_nash_pure(self): ok_(self.g.is_nash((0, 0, 0))) ok_(not self.g.is_nash((0, 0, 1))) def test_is_nash_mixed(self): p = (1 + np.sqrt(65)) / 16 ok_(self.g.is_nash(([1 - p, p], [1 - p, p], [1 - p, p])))
class TestNormalFormGame_1p: """Test for trivial NormalFormGame with a single player""" def setUp(self): """Setup a NormalFormGame instance""" data = [[0], [1], [1]] self.g = NormalFormGame(data) def test_construction(self): """Trivial game: construction""" ok_(self.g.N == 1) assert_array_equal(self.g.players[0].payoff_array, [0, 1, 1]) def test_getitem(self): """Trivial game: __getitem__""" eq_(self.g[0], 0) def test_delete_action(self): actions_to_delete = [1, 2] for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, actions_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), actions_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i)) def test_is_nash_pure(self): """Trivial game: is_nash with pure action""" ok_(self.g.is_nash((1, ))) ok_(not self.g.is_nash((0, ))) def test_is_nash_mixed(self): """Trivial game: is_nash with mixed action""" ok_(self.g.is_nash(([0, 1 / 2, 1 / 2], )))
class TestNormalFormGame_1p: """Test for trivial NormalFormGame with a single player""" def setUp(self): """Setup a NormalFormGame instance""" data = [[0], [1], [1]] self.g = NormalFormGame(data) def test_construction(self): """Trivial game: construction""" ok_(self.g.N == 1) assert_array_equal(self.g.players[0].payoff_array, [0, 1, 1]) def test_getitem(self): """Trivial game: __getitem__""" eq_(self.g[0], 0) def test_is_nash_pure(self): """Trivial game: is_nash with pure action""" ok_(self.g.is_nash((1,))) ok_(not self.g.is_nash((0,))) def test_is_nash_mixed(self): """Trivial game: is_nash with mixed action""" ok_(self.g.is_nash(([0, 1/2, 1/2],)))
def setup(self): self.game_dicts = [] # Matching Pennies game with no pure nash equilibrium MP_bimatrix = [[(1, -1), (-1, 1)], [(-1, 1), (1, -1)]] MP_NE = [] # Prisoners' Dilemma game with one pure nash equilibrium PD_bimatrix = [[(1, 1), (-2, 3)], [(3, -2), (0, 0)]] PD_NE = [(1, 1)] # Battle of the Sexes game with two pure nash equilibria BoS_bimatrix = [[(3, 2), (1, 0)], [(0, 1), (2, 3)]] BoS_NE = [(0, 0), (1, 1)] # Unanimity Game with more than two players N = 4 a, b = 1, 2 g_Unanimity = NormalFormGame((2, ) * N) g_Unanimity[(0, ) * N] = (a, ) * N g_Unanimity[(1, ) * N] = (b, ) * N Unanimity_NE = [(0, ) * N] for k in range(2, N - 2 + 1): for ind in itertools.combinations(range(N), k): a = np.ones(N, dtype=int) a[list(ind)] = 0 Unanimity_NE.append(tuple(a)) Unanimity_NE.append((1, ) * N) for bimatrix, NE in zip([MP_bimatrix, PD_bimatrix, BoS_bimatrix], [MP_NE, PD_NE, BoS_NE]): d = {'g': NormalFormGame(bimatrix), 'NEs': NE} self.game_dicts.append(d) self.game_dicts.append({'g': g_Unanimity, 'NEs': Unanimity_NE})
class TestNormalFormGame_1p: """Test for trivial NormalFormGame with a single player""" def setUp(self): """Setup a NormalFormGame instance""" data = [[0], [1], [1]] self.g = NormalFormGame(data) def test_construction(self): """Trivial game: construction""" ok_(self.g.N == 1) assert_array_equal(self.g.players[0].payoff_array, [0, 1, 1]) def test_getitem(self): """Trivial game: __getitem__""" eq_(self.g[0], 0) def test_is_nash_pure(self): """Trivial game: is_nash with pure action""" ok_(self.g.is_nash((1,))) ok_(not self.g.is_nash((0,))) def test_is_nash_mixed(self): """Trivial game: is_nash with mixed action""" ok_(self.g.is_nash(([0, 1 / 2, 1 / 2],)))
class TestNormalFormGame_Asym2p: """Test the methods of NormalFormGame with asymmetric two players""" def setUp(self): """Setup a NormalFormGame instance""" self.BoS_bimatrix = np.array([[(3, 2), (1, 1)], [(0, 0), (2, 3)]]) self.g = NormalFormGame(self.BoS_bimatrix) def test_getitem(self): action_profile = (1, 0) assert_array_equal(self.g[action_profile], self.BoS_bimatrix[action_profile]) def test_delete_action(self): action_to_delete = 0 for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, action_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), action_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i)) def test_is_nash_pure(self): ok_(not self.g.is_nash((1, 0))) def test_is_nash_mixed(self): ok_(self.g.is_nash(([3 / 4, 1 / 4], [1 / 4, 3 / 4]))) def test_payoff_arrays(self): assert_array_equal(self.g.payoff_arrays[0], self.BoS_bimatrix[:, :, 0]) assert_array_equal(self.g.payoff_arrays[1], self.BoS_bimatrix[:, :, 1].T)
def setUp(self): """Setup a NormalFormGame instance""" payoffs_2opponents = [[[3, 6], [4, 2]], [[1, 0], [5, 7]]] player = Player(payoffs_2opponents) self.g = NormalFormGame([player for i in range(3)])
def test_normalformgame_payoff_profile_array(): nums_actions = (2, 3, 4) for N in range(1, len(nums_actions) + 1): payoff_arrays = [ np.arange(np.prod(nums_actions[0:N])).reshape(nums_actions[i:N] + nums_actions[0:i]) for i in range(N) ] players = [Player(payoff_array) for payoff_array in payoff_arrays] g = NormalFormGame(players) g_new = NormalFormGame(g.payoff_profile_array) for player_new, payoff_array in zip(g_new.players, payoff_arrays): assert_array_equal(player_new.payoff_array, payoff_array)
class TestNormalFormGame_Asym2p: """Test the methods of NormalFormGame with asymmetric two players""" def setUp(self): """Setup a NormalFormGame instance""" matching_pennies_bimatrix = [[(1, -1), (-1, 1)], [(-1, 1), (1, -1)]] self.g = NormalFormGame(matching_pennies_bimatrix) def test_getitem(self): assert_array_equal(self.g[1, 0], [-1, 1]) def test_is_nash_against_pure(self): ok_(not self.g.is_nash((0, 0))) def test_is_nash_against_mixed(self): ok_(self.g.is_nash(([1 / 2, 1 / 2], [1 / 2, 1 / 2])))
def test_random_matrix(self): seed = 12345 rng = np.random.default_rng(seed) size = (10, 15) A = rng.normal(size=size) v, x, y = minmax(A) for z in [x, y]: assert_((z >= 0).all()) assert_allclose(z.sum(), 1) g = NormalFormGame((Player(A), Player(-A.T))) NE = lemke_howson(g) assert_allclose(v, NE[0] @ A @ NE[1]) assert_(g.is_nash((x, y)))
class TestNormalFormGame_Sym2p: """Test the methods of NormalFormGame with symmetric two players""" def setUp(self): """Setup a NormalFormGame instance""" coordination_game_matrix = [[4, 0], [3, 2]] self.g = NormalFormGame(coordination_game_matrix) def test_getitem(self): assert_array_equal(self.g[0, 1], [0, 3]) def test_is_nash_pure(self): ok_(self.g.is_nash((0, 0))) def test_is_nash_mixed(self): ok_(self.g.is_nash(([2 / 3, 1 / 3], [2 / 3, 1 / 3])))
def setup(self): # From von Stengel 2007 in Algorithmic Game Theory bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] g = NormalFormGame(bimatrix) # Original best response polytope for player 0 vertices_P = np.array([ [0, 0, 0], # 0 [1 / 3, 0, 0], # a [2 / 7, 1 / 14, 0], # b [0, 1 / 6, 0], # c [0, 1 / 8, 1 / 4], # d [0, 0, 1 / 3] # e ]) labelings_P = np.array([ [0, 1, 2], # 0 [1, 2, 3], # a [2, 3, 4], # b [0, 2, 4], # c [0, 3, 4], # d [0, 1, 3] # e ]) # Sort rows lexicographically K = labelings_P.shape[1] ind = np.lexsort([labelings_P[:, K - k - 1] for k in range(K)]) self.labelings_P = labelings_P[ind] self.vertices_P = vertices_P[ind] # Translated best response polytope for player 0 self.brp0 = _BestResponsePolytope(g.players[1], idx=0)
def test_normalformgame_setitem_1p(): g = NormalFormGame(2) eq_(g.N, 1) # Number of players g[0] = 10 # Set payoff 10 for action 0 eq_(g.players[0].payoff_array[0], 10)
def test_lemke_howson_capping(): bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] g = NormalFormGame(bimatrix) m, n = g.nums_actions max_iter = 10**6 # big number for k in range(m + n): NE0, res0 = lemke_howson(g, init_pivot=k, max_iter=max_iter, capping=None, full_output=True) NE1, res1 = lemke_howson(g, init_pivot=k, max_iter=max_iter, capping=max_iter, full_output=True) for action0, action1 in zip(NE0, NE1): assert_allclose(action0, action1) eq_(res0.init, res1.init) init_pivot = 1 max_iter = m + n NE, res = lemke_howson(g, init_pivot=init_pivot, max_iter=max_iter, capping=1, full_output=True) eq_(res.num_iter, max_iter) eq_(res.init, init_pivot - 1)
def anti_coordination(N, v): payoff_array = np.empty((2, ) * N) payoff_array[0, :] = 1 payoff_array[1, :] = 0 payoff_array[1].flat[0] = v g = NormalFormGame((Player(payoff_array), ) * N) return g
def setUp(self): def anti_coordination(N, v): payoff_array = np.empty((2, ) * N) payoff_array[0, :] = 1 payoff_array[1, :] = 0 payoff_array[1].flat[0] = v g = NormalFormGame((Player(payoff_array), ) * N) return g def p_star(N, v): # Unique symmetric NE mixed action: [p_star, 1-p_star] return 1 / (v**(1 / (N - 1))) def epsilon_nash_interval(N, v, epsilon): # Necessary, but not sufficient, condition: lb < p < ub lb = p_star(N, v) - epsilon / ((N - 1) * (v**(1 / (N - 1)) - 1)) ub = p_star(N, v) + epsilon / (N - 1) return lb, ub self.game_dicts = [] v = 2 epsilon = 1e-5 Ns = [2, 3, 4] for N in Ns: g = anti_coordination(N, v) lb, ub = epsilon_nash_interval(N, v, epsilon) d = {'g': g, 'epsilon': epsilon, 'lb': lb, 'ub': ub} self.game_dicts.append(d) self.bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] self.g = NormalFormGame(self.bimatrix)
def test_best_response_selection_no_indptr(): bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] g = NormalFormGame(bimatrix) test_obj = _best_response_selection([1 / 3, 1 / 3, 1 / 3, 1 / 2, 1 / 2], g) expected_output = np.array([0., 1., 0., 0., 1.]) assert_array_equal(test_obj, expected_output)
def test_normalformgame_payoff_profile_array_c_contiguous(): nums_actions = (2, 3, 4) shape = nums_actions + (len(nums_actions), ) payoff_profile_array = \ np.arange(np.prod(shape)).reshape(shape) g = NormalFormGame(payoff_profile_array) for player in g.players: ok_(player.payoff_array.flags['C_CONTIGUOUS'])
def test_normalformgame_input_action_sizes(): g = NormalFormGame((2, 3, 4)) eq_(g.N, 3) # Number of players assert_array_equal(g.players[0].payoff_array, np.zeros((2, 3, 4))) assert_array_equal(g.players[1].payoff_array, np.zeros((3, 4, 2))) assert_array_equal(g.players[2].payoff_array, np.zeros((4, 2, 3)))
def test_normalformgame_setitem(): g = NormalFormGame((2, 2)) g[0, 0] = (0, 10) g[0, 1] = (0, 10) g[1, 0] = (3, 5) g[1, 1] = (-2, 0) assert_array_equal(g.players[0].payoff_array, [[0, 0], [3, -2]]) assert_array_equal(g.players[1].payoff_array, [[10, 5], [10, 0]])
class TestNormalFormGame_3p: """Test the methods of NormalFormGame with three players""" def setUp(self): """Setup a NormalFormGame instance""" payoffs_2opponents = [[[3, 6], [4, 2]], [[1, 0], [5, 7]]] player = Player(payoffs_2opponents) self.g = NormalFormGame([player for i in range(3)]) def test_getitem(self): assert_array_equal(self.g[0, 0, 1], [6, 4, 1]) def test_is_nash_pure(self): ok_(self.g.is_nash((0, 0, 0))) ok_(not self.g.is_nash((0, 0, 1))) def test_is_nash_mixed(self): p = (1 + np.sqrt(65)) / 16 ok_(self.g.is_nash(([1 - p, p], [1 - p, p], [1 - p, p])))
def test_normalformgame_input_action_sizes_1p(): g = NormalFormGame(2) eq_(g.N, 1) # Number of players assert_array_equal( g.players[0].payoff_array, np.zeros(2) )
def setUp(self): self.game_dicts = [] # From von Stengel 2007 in Algorithmic Game Theory bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] NEs_dict = { 0: ([1, 0, 0], [1, 0]), 1: ([0, 1 / 3, 2 / 3], [1 / 3, 2 / 3]) } # init_pivot: NE d = {'g': NormalFormGame(bimatrix), 'NEs_dict': NEs_dict} self.game_dicts.append(d)
def setUp(self): self.game_dicts = [] # From von Stengel 2007 in Algorithmic Game Theory bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] d = { 'g': NormalFormGame(bimatrix), 'NEs': [([1, 0, 0], [1, 0]), ([4 / 5, 1 / 5, 0], [2 / 3, 1 / 3]), ([0, 1 / 3, 2 / 3], [1 / 3, 2 / 3])] } self.game_dicts.append(d) # Degenerate game # NEs ([0, p, 1-p], [1/2, 1/2]), 0 <= p <= 1, are not detected. bimatrix = [[(1, 1), (-1, 0)], [(-1, 0), (1, 0)], [(0, 0), (0, 0)]] d = { 'g': NormalFormGame(bimatrix), 'NEs': [([1, 0, 0], [1, 0]), ([0, 1, 0], [0, 1])] } self.game_dicts.append(d)
def test_tol(self): # Prisoners' Dilemma game with one NE and one epsilon NE epsilon = 1e-08 PD_bimatrix = [[(1, 1), (-2, 1 + epsilon)], [(1 + epsilon, -2), (0, 0)]] NEs = [(1, 1)] epsilon_NEs = [(1, 1), (0, 0)] g = NormalFormGame(PD_bimatrix) for tol, answer in zip([0, epsilon], [NEs, epsilon_NEs]): assert_(sorted(pure_nash_brute(g, tol=tol)) == sorted(answer))
def setUp(self): self.game_dicts = [] # From von Stengel 2007 in Algorithmic Game Theory bimatrix = [[(3, 3), (3, 3)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] NEs_dict = {0: ([0, 1 / 3, 2 / 3], [1 / 3, 2 / 3])} d = { 'g': NormalFormGame(bimatrix), 'NEs_dict': NEs_dict, 'converged': True } self.game_dicts.append(d) # == Examples of cycles by "ad hoc" tie breaking rules == # # Example where tie breaking that picks the variable with # the smallest row index in the tableau leads to cycling A = np.array([[0, 0, 0], [0, 1, 1], [1, 1, 0]]) B = np.array([[1, 0, 1], [1, 1, 0], [0, 0, 2]]) NEs_dict = {0: ([0, 2 / 3, 1 / 3], [0, 1, 0])} d = { 'g': NormalFormGame((Player(A), Player(B))), 'NEs_dict': NEs_dict, 'converged': True } self.game_dicts.append(d) # Example where tie breaking that picks the variable with # the smallest variable index in the tableau leads to cycling perm = [2, 0, 1] C = A[:, perm] D = B[perm, :] NEs_dict = {0: ([0, 2 / 3, 1 / 3], [0, 0, 1])} d = { 'g': NormalFormGame((Player(C), Player(D))), 'NEs_dict': NEs_dict, 'converged': True } self.game_dicts.append(d)
def setup(self): self.game_dicts = [] # From von Stengel 2007 in Algorithmic Game Theory bimatrix = [[(3, 3), (3, 2)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] d = { 'g': NormalFormGame(bimatrix), 'NEs': [([1, 0, 0], [1, 0]), ([4 / 5, 1 / 5, 0], [2 / 3, 1 / 3]), ([0, 1 / 3, 2 / 3], [1 / 3, 2 / 3])] } self.game_dicts.append(d) # Degenerate game bimatrix = [[(3, 3), (3, 3)], [(2, 2), (5, 6)], [(0, 3), (6, 1)]] d = { 'g': NormalFormGame(bimatrix), 'NEs': [([1, 0, 0], [1, 0]), ([1, 0, 0], [2 / 3, 1 / 3]), ([0, 1 / 3, 2 / 3], [1 / 3, 2 / 3])] } self.game_dicts.append(d)
class TestNormalFormGame_Asym2p: """Test the methods of NormalFormGame with asymmetric two players""" def setUp(self): """Setup a NormalFormGame instance""" self.BoS_bimatrix = np.array([[(3, 2), (1, 1)], [(0, 0), (2, 3)]]) self.g = NormalFormGame(self.BoS_bimatrix) def test_getitem(self): action_profile = (1, 0) assert_array_equal(self.g[action_profile], self.BoS_bimatrix[action_profile]) def test_delete_action(self): action_to_delete = 0 for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, action_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), action_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i) ) def test_is_nash_pure(self): ok_(not self.g.is_nash((1, 0))) def test_is_nash_mixed(self): ok_(self.g.is_nash(([3/4, 1/4], [1/4, 3/4]))) def test_payoff_arrays(self): assert_array_equal( self.g.payoff_arrays[0], self.BoS_bimatrix[:, :, 0] ) assert_array_equal( self.g.payoff_arrays[1], self.BoS_bimatrix[:, :, 1].T )
def test_vertex_enumeration_qhull_options(): # Degenerate game, player 0's actions reordered bimatrix = [[(0, 3), (6, 1)], [(2, 2), (5, 6)], [(3, 3), (3, 3)]] g = NormalFormGame(bimatrix) NEs_expected = [([0, 0, 1], [1, 0]), ([0, 0, 1], [2 / 3, 1 / 3]), ([2 / 3, 1 / 3, 0], [1 / 3, 2 / 3])] qhull_options = 'QJ' NEs_computed = vertex_enumeration(g, qhull_options=qhull_options) assert_(len(NEs_computed) == len(NEs_expected)) for NEs in (NEs_computed, NEs_expected): NEs.sort(key=lambda x: (list(x[1]), list(x[0]))) for actions_computed, actions in zip(NEs_computed, NEs_expected): for action_computed, action in zip(actions_computed, actions): assert_allclose(action_computed, action, atol=1e-10)
class TestNormalFormGame_1p: """Test for trivial NormalFormGame with a single player""" def setUp(self): """Setup a NormalFormGame instance""" data = [[0], [1], [1]] self.g = NormalFormGame(data) def test_construction(self): """Trivial game: construction""" ok_(self.g.N == 1) assert_array_equal(self.g.players[0].payoff_array, [0, 1, 1]) def test_getitem(self): """Trivial game: __getitem__""" eq_(self.g[0], 0) def test_delete_action(self): actions_to_delete = [1, 2] for i, player in enumerate(self.g.players): g_new = self.g.delete_action(i, actions_to_delete) actions_to_remain = \ np.setdiff1d(np.arange(player.num_actions), actions_to_delete) assert_array_equal( g_new.payoff_profile_array, self.g.payoff_profile_array.take(actions_to_remain, axis=i) ) def test_is_nash_pure(self): """Trivial game: is_nash with pure action""" ok_(self.g.is_nash((1,))) ok_(not self.g.is_nash((0,))) def test_is_nash_mixed(self): """Trivial game: is_nash with mixed action""" ok_(self.g.is_nash(([0, 1/2, 1/2],)))
def setUp(self): """Setup a NormalFormGame instance""" data = [[0], [1], [1]] self.g = NormalFormGame(data)
def setUp(self): """Setup a NormalFormGame instance""" self.BoS_bimatrix = np.array([[(3, 2), (1, 1)], [(0, 0), (2, 3)]]) self.g = NormalFormGame(self.BoS_bimatrix)
def setUp(self): """Setup a NormalFormGame instance""" matching_pennies_bimatrix = [[(1, -1), (-1, 1)], [(-1, 1), (1, -1)]] self.g = NormalFormGame(matching_pennies_bimatrix)
def setUp(self): """Setup a NormalFormGame instance""" coordination_game_matrix = [[4, 0], [3, 2]] self.g = NormalFormGame(coordination_game_matrix)