Enable the dual starting point and fix the test tolerance.

We set dualstart=player2_start(), but that caused some tests to fail
as unknown or optimal but not valid. So the new epsilon_scale() method
is used to verify the primal/dual optimal in solution(). After that,
the tests of course fail, because we're accepting much more-wrong
solutions. Incorporating epsilon_scale() into the test suite fixes
that.

diff --git a/dunshire/games.py b/dunshire/games.py
index ae1426a2c611f7e315f94fc5fea0e98f1da0905b..cfb62a33d8a2666828323019729af0f1b5ab99d7 100644 (file)
--- a/dunshire/games.py
+++ b/dunshire/games.py
@@ -13,6 +13,7 @@ from . import options
 
 printing.options['dformat'] = options.FLOAT_FORMAT
 
+
 class Solution:
     """
     A representation of the solution of a linear game. It should contain
@@ -986,6 +987,7 @@ class SymmetricLinearGame:
                                        self.A(),
                                        self.b(),
                                        primalstart=self.player1_start(),
+                                       dualstart=self.player2_start(),
                                        options=opts)
         except ValueError as error:
             if str(error) == 'math domain error':
@@ -1020,6 +1022,20 @@ class SymmetricLinearGame:
             printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
             raise GameUnsolvableException(self, soln_dict)
 
+        # For the game value, we could use any of:
+        #
+        #   * p1_value
+        #   * p2_value
+        #   * (p1_value + p2_value)/2
+        #   * the game payoff
+        #
+        # We want the game value to be the payoff, however, so it
+        # makes the most sense to just use that, even if it means we
+        # can't test the fact that p1_value/p2_value are close to the
+        # payoff.
+        payoff = self.payoff(p1_optimal, p2_optimal)
+        soln = Solution(payoff, p1_optimal, p2_optimal)
+
         # The "optimal" and "unknown" results, we actually treat the
         # same. Even if CVXOPT bails out due to numerical difficulty,
         # it will have some candidate points in mind. If those
@@ -1030,7 +1046,8 @@ class SymmetricLinearGame:
         # close enough (one could be low by ABS_TOL, the other high by
         # it) because otherwise CVXOPT might return "unknown" and give
         # us two points in the cone that are nowhere near optimal.
-        if abs(p1_value - p2_value) > 2*options.ABS_TOL:
+        #
+        if abs(p1_value - p2_value) > self.epsilon_scale(soln)*options.ABS_TOL:
             printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
             raise GameUnsolvableException(self, soln_dict)
 
@@ -1040,19 +1057,7 @@ class SymmetricLinearGame:
             printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT
             raise GameUnsolvableException(self, soln_dict)
 
-        # For the game value, we could use any of:
-        #
-        #   * p1_value
-        #   * p2_value
-        #   * (p1_value + p2_value)/2
-        #   * the game payoff
-        #
-        # We want the game value to be the payoff, however, so it
-        # makes the most sense to just use that, even if it means we
-        # can't test the fact that p1_value/p2_value are close to the
-        # payoff.
-        payoff = self.payoff(p1_optimal, p2_optimal)
-        return Solution(payoff, p1_optimal, p2_optimal)
+        return soln
 
 
     def condition(self):

diff --git a/test/symmetric_linear_game_test.py b/test/symmetric_linear_game_test.py
index 19be8c511f628a41f67baa0877ce37eaee4393ef..067aaa15e6196e6120b9f613f2982847f08e9c71 100644 (file)
--- a/test/symmetric_linear_game_test.py
+++ b/test/symmetric_linear_game_test.py
@@ -137,9 +137,13 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         of the game by the same number.
         """
         (alpha, H) = random_nn_scaling(G)
-        value1 = G.solution().game_value()
-        value2 = H.solution().game_value()
-        modifier = 4*max(abs(alpha), 1)
+        soln1 = G.solution()
+        soln2 = H.solution()
+        value1 = soln1.game_value()
+        value2 = soln2.game_value()
+        modifier1 = G.epsilon_scale(soln1)
+        modifier2 = H.epsilon_scale(soln2)
+        modifier = max(modifier1, modifier2)
         self.assert_within_tol(alpha*value1, value2, modifier)
 
 
@@ -178,7 +182,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         (alpha, H) = random_translation(G)
         value2 = H.solution().game_value()
 
-        modifier = 4*max(abs(alpha), 1)
+        modifier = G.epsilon_scale(soln1)
         self.assert_within_tol(value1 + alpha, value2, modifier)
 
         # Make sure the same optimal pair works.
@@ -221,14 +225,12 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         y_bar = soln1.player2_optimal()
         soln2 = H.solution()
 
-        # The modifier of 4 is because each could be off by 2*ABS_TOL,
-        # which is how far apart the primal/dual objectives have been
-        # observed being.
-        self.assert_within_tol(-soln1.game_value(), soln2.game_value(), 4)
+        mod = G.epsilon_scale(soln1)
+        self.assert_within_tol(-soln1.game_value(), soln2.game_value(), mod)
 
         # Make sure the switched optimal pair works. Since x_bar and
         # y_bar come from G, we use the same modifier.
-        self.assert_within_tol(soln2.game_value(), H.payoff(y_bar, x_bar), 4)
+        self.assert_within_tol(soln2.game_value(), H.payoff(y_bar, x_bar), mod)
 
 
 
@@ -263,13 +265,9 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         ip1 = inner_product(y_bar, G.L()*x_bar - value*G.e1())
         ip2 = inner_product(value*G.e2() - G.L().trans()*y_bar, x_bar)
 
-        # Huh.. well, y_bar and x_bar can each be epsilon away, but
-        # x_bar is scaled by L, so that's (norm(L) + 1), and then
-        # value could be off by epsilon, so that's another norm(e1) or
-        # norm(e2). On the other hand, this test seems to pass most of
-        # the time even with a modifier of one. How about.. four?
-        self.assert_within_tol(ip1, 0, 4)
-        self.assert_within_tol(ip2, 0, 4)
+        modifier = G.epsilon_scale(soln)
+        self.assert_within_tol(ip1, 0, modifier)
+        self.assert_within_tol(ip2, 0, modifier)
 
 
     def test_orthogonality_orthant(self):
@@ -325,11 +323,9 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
             negative_stable = all([eig < options.ABS_TOL for eig in eigs])
             self.assertTrue(negative_stable)
 
-        # The dual game's value should always equal the primal's.
-        # The modifier of 4 is because even though the games are dual,
-        # CVXOPT doesn't know that, and each could be off by 2*ABS_TOL.
         dualsoln = G.dual().solution()
-        self.assert_within_tol(dualsoln.game_value(), soln.game_value(), 4)
+        mod = G.epsilon_scale(soln)
+        self.assert_within_tol(dualsoln.game_value(), soln.game_value(), mod)
 
 
     def test_lyapunov_orthant(self):