From: Michael Orlitzky Date: Wed, 12 Oct 2016 17:16:16 +0000 (-0400) Subject: Fix (or cover up) a bunch of pylint warnings. X-Git-Tag: 0.1.0~157 X-Git-Url: https://gitweb.michael.orlitzky.com/?a=commitdiff_plain;h=556f614c2cbbe91e34967ea78464436413ae1c75;p=dunshire.git Fix (or cover up) a bunch of pylint warnings. --- diff --git a/makefile b/makefile index 83b8d8f..813d728 100644 --- a/makefile +++ b/makefile @@ -13,7 +13,7 @@ check: lint: PYTHONPATH="$(SRCDIR)" pylint \ --reports=n \ - --good-names='b,c,e1,e2,h,A,C,G,K,_K,L,L_matrix,_L,indented_L' \ + --good-names='b,c,e1,e2,h,A,C,G,K,_K,L,L_matrix,_L,indented_L,M' \ $(SRCS) .PHONY: clean diff --git a/src/dunshire/cones.py b/src/dunshire/cones.py index 870a882..92a03a9 100644 --- a/src/dunshire/cones.py +++ b/src/dunshire/cones.py @@ -539,7 +539,7 @@ class CartesianProduct(SymmetricCone): TypeError: the given point has the wrong dimensions """ - return all([p in f for (p,f) in zip(point, self.factors())]) + return all([p in f for (p, f) in zip(point, self.factors())]) diff --git a/src/dunshire/games.py b/src/dunshire/games.py index 3db6dd0..3c53343 100644 --- a/src/dunshire/games.py +++ b/src/dunshire/games.py @@ -454,7 +454,7 @@ class SymmetricLinearGame: # objectives match (within a tolerance) and that the # primal/dual optimal solutions are within the cone (to a # tolerance as well). - if (abs(p1_value - p2_value) > options.ABS_TOL): + if abs(p1_value - p2_value) > options.ABS_TOL: raise GameUnsolvableException(soln_dict) if (p1_optimal not in self._K) or (p2_optimal not in self._K): raise GameUnsolvableException(soln_dict) @@ -503,59 +503,62 @@ class SymmetricLinearGame: self._e1) -class SymmetricLinearGameTest(TestCase): + +def _random_square_matrix(dims): """ - Tests for the SymmetricLinearGame and Solution classes. + Generate a random square (``dims``-by-``dims``) matrix, + represented as a list of rows. This is used only by the + :class:`SymmetricLinearGameTest` class. """ - - def random_square_matrix(self, dims): - """ - Generate a random square (``dims``-by-``dims``) matrix, - represented as a list of rows. - """ - return [[uniform(-10, 10) for i in range(dims)] for j in range(dims)] + return [[uniform(-10, 10) for i in range(dims)] for j in range(dims)] - def random_orthant_params(self): - """ - Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a - random game over the nonnegative orthant. - """ - ambient_dim = randint(1, 10) - K = NonnegativeOrthant(ambient_dim) - e1 = [uniform(0.5, 10) for idx in range(K.dimension())] - e2 = [uniform(0.5, 10) for idx in range(K.dimension())] - L = self.random_square_matrix(K.dimension()) - return (L, K, e1, e2) - - - def random_icecream_params(self): - """ - Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a - random game 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] # Set the "height" of e1 to one - e2 = [1] # And the same for e2 +def _random_orthant_params(): + """ + Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a + random game over the nonnegative orthant. This is only used by + the :class:`SymmetricLinearGameTest` class. + """ + ambient_dim = randint(1, 10) + K = NonnegativeOrthant(ambient_dim) + e1 = [uniform(0.5, 10) for idx in range(K.dimension())] + e2 = [uniform(0.5, 10) for idx in range(K.dimension())] + L = _random_square_matrix(K.dimension()) + return (L, K, e1, e2) - # 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 = self.random_square_matrix(K.dimension()) - return (L, K, e1, e2) +def _random_icecream_params(): + """ + Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a + random game over the ice cream cone. This is only used by + the :class:`SymmetricLinearGameTest` class. + """ + # 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] # Set the "height" of e1 to one + e2 = [1] # And the same for e2 + + # 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 = _random_square_matrix(K.dimension()) + + return (L, K, e1, e2) +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 @@ -590,7 +593,7 @@ class SymmetricLinearGameTest(TestCase): self.assert_within_tol(soln.game_value(), expected) - def test_solution_exists_nonnegative_orthant(self): + def test_solution_exists_orthant(self): """ Every linear game has a solution, so we should be able to solve every symmetric linear game over the NonnegativeOrthant. Pick @@ -598,67 +601,65 @@ class SymmetricLinearGameTest(TestCase): optimal solutions should give us the optimal game value when we apply the payoff operator to them. """ - (L, K, e1, e2) = self.random_orthant_params() + (L, K, e1, e2) = _random_orthant_params() self.assert_solution_exists(L, K, e1, e2) - def test_solution_exists_ice_cream(self): + def test_solution_exists_icecream(self): """ Like :meth:`test_solution_exists_nonnegative_orthant`, except over the ice cream cone. """ - (L, K, e1, e2) = self.random_icecream_params() + (L, K, e1, e2) = _random_icecream_params() self.assert_solution_exists(L, K, e1, e2) - def test_negative_value_Z_operator(self): + def test_negative_value_z_operator(self): """ Test the example given in Gowda/Ravindran of a Z-matrix with negative game value on the nonnegative orthant. """ K = NonnegativeOrthant(2) - e1 = [1,1] + e1 = [1, 1] e2 = e1 - L = [[1,-2],[-2,1]] + L = [[1, -2], [-2, 1]] G = SymmetricLinearGame(L, K, e1, e2) self.assertTrue(G.solution().game_value() < -options.ABS_TOL) - def test_nonnegative_scaling_orthant(self): + def assert_scaling_works(self, L, K, e1, e2): """ Test that scaling ``L`` by a nonnegative number scales the value - of the game by the same number. Use the nonnegative orthant as - our cone. + of the game by the same number. """ - (L, K, e1, e2) = self.random_orthant_params() # Make ``L`` a matrix so that we can scale it by alpha. Its # random, so who cares if it gets transposed. L = matrix(L) - G1 = SymmetricLinearGame(L, K, e1, e2) - value1 = G1.solution().game_value() + game1 = SymmetricLinearGame(L, K, e1, e2) + value1 = game1.solution().game_value() alpha = uniform(0.1, 10) - G2 = SymmetricLinearGame(alpha*L, K, e1, e2) - value2 = G2.solution().game_value() + game2 = SymmetricLinearGame(alpha*L, K, e1, e2) + value2 = game2.solution().game_value() self.assert_within_tol(alpha*value1, value2) - def test_nonnegative_scaling_icecream(self): + def test_scaling_orthant(self): + """ + Test that scaling ``L`` by a nonnegative number scales the value + of the game by the same number over the nonnegative orthant. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_scaling_works(L, K, e1, e2) + + + def test_scaling_icecream(self): """ The same test as :meth:`test_nonnegative_scaling_orthant`, except over the ice cream cone. """ - (L, K, e1, e2) = self.random_icecream_params() - # Make ``L`` a matrix so that we can scale it by alpha. Its - # random, so who cares if it gets transposed. - L = matrix(L) - G1 = SymmetricLinearGame(L, K, e1, e2) - value1 = G1.solution().game_value() - - alpha = uniform(0.1, 10) - G2 = SymmetricLinearGame(alpha*L, K, e1, e2) - value2 = G2.solution().game_value() - self.assert_within_tol(alpha*value1, value2) + (L, K, e1, e2) = _random_icecream_params() + self.assert_scaling_works(L, K, e1, e2) def assert_translation_works(self, L, K, e1, e2): @@ -668,38 +669,38 @@ class SymmetricLinearGameTest(TestCase): """ e1 = matrix(e1, (K.dimension(), 1)) e2 = matrix(e2, (K.dimension(), 1)) - G = SymmetricLinearGame(L, K, e1, e2) - G_soln = G.solution() - value_G = G_soln.game_value() - x_bar = G_soln.player1_optimal() - y_bar = G_soln.player2_optimal() + game1 = SymmetricLinearGame(L, K, e1, e2) + soln1 = game1.solution() + value1 = soln1.game_value() + x_bar = soln1.player1_optimal() + y_bar = soln1.player2_optimal() - alpha = uniform(-10, 10) # Make ``L`` a CVXOPT matrix so that we can do math with # it. Note that this gives us the "correct" representation of # ``L`` (in agreement with what G has), but COLUMN indexed. + alpha = uniform(-10, 10) L = matrix(L).trans() - E = e1*e2.trans() + tensor_prod = e1*e2.trans() + # Likewise, this is the "correct" representation of ``M``, but # COLUMN indexed... - M = L + alpha*E + M = L + alpha*tensor_prod # so we have to transpose it when we feed it to the constructor. - H = SymmetricLinearGame(M.trans(), K, e1, e2) - value_H = H.solution().game_value() + game2 = SymmetricLinearGame(M.trans(), K, e1, e2) + value2 = game2.solution().game_value() - # Make sure the same optimal pair works. - H_payoff = inner_product(M*x_bar, y_bar) + self.assert_within_tol(value1 + alpha, value2) - self.assert_within_tol(value_G + alpha, value_H) - self.assert_within_tol(value_H, H_payoff) + # Make sure the same optimal pair works. + self.assert_within_tol(value2, inner_product(M*x_bar, y_bar)) def test_translation_orthant(self): """ Test that translation works over the nonnegative orthant. """ - (L, K, e1, e2) = self.random_orthant_params() + (L, K, e1, e2) = _random_orthant_params() self.assert_translation_works(L, K, e1, e2) @@ -708,14 +709,19 @@ class SymmetricLinearGameTest(TestCase): The same as :meth:`test_translation_orthant`, except over the ice cream cone. """ - (L, K, e1, e2) = self.random_icecream_params() + (L, K, e1, e2) = _random_icecream_params() self.assert_translation_works(L, K, e1, e2) def assert_opposite_game_works(self, L, K, e1, e2): + """ + Check the value of the "opposite" game that gives rise to a + value that is the negation of the original game. Comes from + some corollary. + """ e1 = matrix(e1, (K.dimension(), 1)) e2 = matrix(e2, (K.dimension(), 1)) - G = SymmetricLinearGame(L, K, e1, e2) + game1 = SymmetricLinearGame(L, K, e1, e2) # Make ``L`` a CVXOPT matrix so that we can do math with # it. Note that this gives us the "correct" representation of @@ -727,27 +733,26 @@ class SymmetricLinearGameTest(TestCase): M = -L.trans() # so we have to transpose it when we feed it to the constructor. - H = SymmetricLinearGame(M.trans(), K, e2, e1) + game2 = SymmetricLinearGame(M.trans(), K, e2, e1) - G_soln = G.solution() - x_bar = G_soln.player1_optimal() - y_bar = G_soln.player2_optimal() - H_soln = H.solution() + soln1 = game1.solution() + x_bar = soln1.player1_optimal() + y_bar = soln1.player2_optimal() + soln2 = game2.solution() - # Make sure the switched optimal pair works. - H_payoff = inner_product(M*y_bar, x_bar) + self.assert_within_tol(-soln1.game_value(), soln2.game_value()) - self.assert_within_tol(-G_soln.game_value(), H_soln.game_value()) - self.assert_within_tol(H_soln.game_value(), H_payoff) + # Make sure the switched optimal pair works. + self.assert_within_tol(soln2.game_value(), + inner_product(M*y_bar, x_bar)) def test_opposite_game_orthant(self): """ - Check the value of the "opposite" game that gives rise to a - value that is the negation of the original game. Comes from - some corollary. + Test the value of the "opposite" game over the nonnegative + orthant. """ - (L, K, e1, e2) = self.random_orthant_params() + (L, K, e1, e2) = _random_orthant_params() self.assert_opposite_game_works(L, K, e1, e2) @@ -756,5 +761,5 @@ class SymmetricLinearGameTest(TestCase): Like :meth:`test_opposite_game_orthant`, except over the ice-cream cone. """ - (L, K, e1, e2) = self.random_icecream_params() + (L, K, e1, e2) = _random_icecream_params() self.assert_opposite_game_works(L, K, e1, e2)