Add a unit test for the ice cream cone solution.

[dunshire.git] / src / dunshire / symmetric_linear_game.py

diff --git a/src/dunshire/symmetric_linear_game.py b/src/dunshire/symmetric_linear_game.py
index 857b06447455222995220646b9fdfa56423c84d6..7be55d76ffb36e058b27b85b82dd9caecf2971c5 100644 (file)
--- a/src/dunshire/symmetric_linear_game.py
+++ b/src/dunshire/symmetric_linear_game.py
@@ -5,14 +5,20 @@ This module contains the main SymmetricLinearGame class that knows how
 to solve a linear game.
 """
 
-from cvxopt import matrix, printing, solvers
+# These few are used only for tests.
+from math import sqrt
+from random import randint, uniform
+from unittest import TestCase
 
-from cones import CartesianProduct
+# These are mostly actually needed.
+from cvxopt import matrix, printing, solvers
+from cones import CartesianProduct, IceCream, NonnegativeOrthant
 from errors import GameUnsolvableException
-from matrices import append_col, append_row, identity
+from matrices import append_col, append_row, identity, inner_product
+import options
 
-printing.options['dformat'] = '%.7f'
-solvers.options['show_progress'] = False
+printing.options['dformat'] = options.FLOAT_FORMAT
+solvers.options['show_progress'] = options.VERBOSE
 
 
 class Solution:
@@ -383,3 +389,71 @@ class SymmetricLinearGame:
                                    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)
+