X-Git-Url: http://gitweb.michael.orlitzky.com/?a=blobdiff_plain;f=test%2Fsymmetric_linear_game_test.py;h=b9c29fe68056f52da980443809e881ce6faa28ad;hb=0b6e486f52b6c42f78ba408543be0cc4b66fada7;hp=6327592b1268429e53cc54df757b275b5e894ad5;hpb=8371d92c42c7faded26d8ef327129ad6d8c72d73;p=dunshire.git

diff --git a/test/symmetric_linear_game_test.py b/test/symmetric_linear_game_test.py
index 6327592..b9c29fe 100644
--- a/test/symmetric_linear_game_test.py
+++ b/test/symmetric_linear_game_test.py
@@ -74,7 +74,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         s1 = s[0:G.dimension()]
         s2 = s[G.dimension():]
         self.assert_within_tol(norm(G.A()*x - G.b()), 0)
-        self.assertTrue((s1,s2) in G.C())
+        self.assertTrue((s1, s2) in G.C())
 
 
     def test_player1_start_valid_orthant(self):
@@ -97,7 +97,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904
         z = G.player2_start()['z']
         z1 = z[0:G.dimension()]
         z2 = z[G.dimension():]
-        self.assertTrue((z1,z2) in G.C())
+        self.assertTrue((z1, z2) in G.C())
 
 
     def test_player2_start_valid_orthant(self):
@@ -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.tolerance_scale(soln1)
+        modifier2 = H.tolerance_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.tolerance_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.tolerance_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.tolerance_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.tolerance_scale(soln)
+        self.assert_within_tol(dualsoln.game_value(), soln.game_value(), mod)
 
 
     def test_lyapunov_orthant(self):