+
+ def dual(self):
+ """
+ Return the dual game to this game.
+
+ EXAMPLES:
+
+ >>> from cones import NonnegativeOrthant
+ >>> K = NonnegativeOrthant(3)
+ >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]]
+ >>> e1 = [1,1,1]
+ >>> e2 = [1,2,3]
+ >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+ >>> print(SLG.dual())
+ The linear game (L, K, e1, e2) where
+ L = [ 1 -1 -12]
+ [ -5 2 -15]
+ [-15 -3 1],
+ K = Nonnegative orthant in the real 3-space,
+ e1 = [ 1]
+ [ 2]
+ [ 3],
+ e2 = [ 1]
+ [ 1]
+ [ 1].
+
+ """
+ return SymmetricLinearGame(self._L, # It will be transposed in __init__().
+ self._K, # Since "K" is symmetric.
+ self._e2,
+ self._e1)
+
+
+class SymmetricLinearGameTest(TestCase):
+ """
+ Tests for the SymmetricLinearGame and Solution classes.
+ """
+
+ def assert_within_tol(self, first, second):
+ """
+ Test that ``first`` and ``second`` are equal within our default
+ tolerance.
+ """
+ self.assertTrue(abs(first - second) < options.ABS_TOL)
+
+
+ def assert_solution_exists(self, L, K, e1, e2):
+ """
+ Given the parameters needed to construct a SymmetricLinearGame,
+ ensure that that game has a solution.
+ """
+ G = SymmetricLinearGame(L, K, e1, e2)
+ soln = G.solution()
+ L_matrix = matrix(L).trans()
+ expected = inner_product(L_matrix*soln.player1_optimal(),
+ soln.player2_optimal())
+ self.assert_within_tol(soln.game_value(), expected)
+
+ def test_solution_exists_nonnegative_orthant(self):
+ """
+ Every linear game has a solution, so we should be able to solve
+ every symmetric linear game over the NonnegativeOrthant. Pick
+ some parameters randomly and give it a shot. The resulting
+ optimal solutions should give us the optimal game value when we
+ apply the payoff operator to them.
+ """
+ ambient_dim = randint(1, 10)
+ K = NonnegativeOrthant(ambient_dim)
+ e1 = [uniform(0.1, 10) for idx in range(K.dimension())]
+ e2 = [uniform(0.1, 10) for idx in range(K.dimension())]
+ L = [[uniform(-10, 10) for i in range(K.dimension())]
+ for j in range(K.dimension())]
+ self.assert_solution_exists(L, K, e1, e2)
+
+ def test_solution_exists_ice_cream(self):
+ """
+ Like :meth:`test_solution_exists_nonnegative_orthant`, except
+ over the ice cream cone.
+ """
+ # Use a minimum dimension of two to avoid divide-by-zero in
+ # the fudge factor we make up later.
+ ambient_dim = randint(2, 10)
+ K = IceCream(ambient_dim)
+ e1 = [1]
+ e2 = [1]
+ # If we choose the rest of the components of e1,e2 randomly
+ # between 0 and 1, then the largest the squared norm of the
+ # non-height part of e1,e2 could be is the 1*(dim(K) - 1). We
+ # need to make it less than one (the height of the cone) so
+ # that the whole thing is in the cone. The norm of the
+ # non-height part is sqrt(dim(K) - 1), and we can divide by
+ # twice that.
+ fudge_factor = 1.0 / (2.0*sqrt(K.dimension() - 1.0))
+ e1 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)]
+ e2 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)]
+ L = [[uniform(-10, 10) for i in range(K.dimension())]
+ for j in range(K.dimension())]
+ self.assert_solution_exists(L, K, e1, e2)
+