Fix (or cover up) a bunch of pylint warnings.

diff --git a/makefile b/makefile
index 83b8d8ff1c30ed575fbd91d0db8e877da402f89f..813d7288fec49cb687e49b017145a51d50f74453 100644 (file)
--- a/makefile
+++ b/makefile
@@ -13,7 +13,7 @@ check:
 lint:
        PYTHONPATH="$(SRCDIR)" pylint \
                --reports=n \
 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
                $(SRCS)
 
 .PHONY: clean

diff --git a/src/dunshire/cones.py b/src/dunshire/cones.py
index 870a882423e6180ea0e4256e5f7c05f17aac6d4f..92a03a96245e79db4bce92f013e782c1964bf458 100644 (file)
--- 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
 
         """
             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 3db6dd07c4163ea998fcdb9eb6abfeda17757db2..3c53343175c11421413eed9cfe0ae26518d9799f 100644 (file)
--- 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).
             # 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)
                 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)
 
 
                                    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
     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)
 
 
         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
         """
         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.
         """
         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)
 
 
         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.
         """
         """
         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)
 
 
         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)
         """
         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
         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)
 
 
         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
         """
         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)
         # 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)
 
         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)
 
 
         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.
         """
         """
         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):
 
 
     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))
         """
         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.
         # 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()
         L = matrix(L).trans()

-        E = e1*e2.trans()
+        tensor_prod = e1*e2.trans()
+

         # Likewise, this is the "correct" representation of ``M``, but
         # COLUMN indexed...
         # 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.
 
         # 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.
         """
 
 
     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)
 
 
         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.
         """
         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):
         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))
         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
 
         # 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.
         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):
         """
 
 
     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)
 
 
         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.
         """
         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)
         self.assert_opposite_game_works(L, K, e1, e2)