From 0b6e486f52b6c42f78ba408543be0cc4b66fada7 Mon Sep 17 00:00:00 2001 From: Michael Orlitzky Date: Sun, 13 Nov 2016 14:51:27 -0500 Subject: [PATCH] Rename epsilon_scale() to tolerance_scale(). --- dunshire/games.py | 24 +++++++++++------------- test/symmetric_linear_game_test.py | 12 ++++++------ 2 files changed, 17 insertions(+), 19 deletions(-) diff --git a/dunshire/games.py b/dunshire/games.py index 719198b..07a70b0 100644 --- a/dunshire/games.py +++ b/dunshire/games.py @@ -9,9 +9,9 @@ from .cones import CartesianProduct from .errors import GameUnsolvableException, PoorScalingException from .matrices import (append_col, append_row, condition_number, identity, inner_product, norm, specnorm) -from . import options +from .options import ABS_TOL, FLOAT_FORMAT, DEBUG_FLOAT_FORMAT -printing.options['dformat'] = options.FLOAT_FORMAT +printing.options['dformat'] = FLOAT_FORMAT class Solution: @@ -854,13 +854,13 @@ class SymmetricLinearGame: self._L_specnorm_value = specnorm(self.L()) return self._L_specnorm_value - def epsilon_scale(self, solution): + def tolerance_scale(self, solution): # Don't return anything smaller than 1... we can't go below # out "minimum tolerance." norm_p1_opt = norm(solution.player1_optimal()) norm_p2_opt = norm(solution.player2_optimal()) scale = self._L_specnorm()*(norm_p1_opt + norm_p2_opt) - return max(1, scale) + return max(1, scale/2.0) def solution(self): @@ -1032,7 +1032,7 @@ class SymmetricLinearGame: # Oops, CVXOPT tried to take the square root of a # negative number. Report some details about the game # rather than just the underlying CVXOPT crash. - printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT + printing.options['dformat'] = DEBUG_FLOAT_FORMAT raise PoorScalingException(self) else: raise error @@ -1057,7 +1057,7 @@ class SymmetricLinearGame: # that CVXOPT is convinced the problem is infeasible (and that # cannot happen). if soln_dict['status'] in ['primal infeasible', 'dual infeasible']: - printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT + printing.options['dformat'] = DEBUG_FLOAT_FORMAT raise GameUnsolvableException(self, soln_dict) # For the game value, we could use any of: @@ -1085,14 +1085,14 @@ class SymmetricLinearGame: # 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) > self.epsilon_scale(soln)*options.ABS_TOL: - printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT + if abs(p1_value - p2_value) > self.tolerance_scale(soln)*ABS_TOL: + printing.options['dformat'] = DEBUG_FLOAT_FORMAT raise GameUnsolvableException(self, soln_dict) # And we also check that the points it gave us belong to the # cone, just in case... if (p1_optimal not in self._K) or (p2_optimal not in self._K): - printing.options['dformat'] = options.DEBUG_FLOAT_FORMAT + printing.options['dformat'] = DEBUG_FLOAT_FORMAT raise GameUnsolvableException(self, soln_dict) return soln @@ -1126,10 +1126,8 @@ class SymmetricLinearGame: >>> e1 = [1] >>> e2 = e1 >>> SLG = SymmetricLinearGame(L, K, e1, e2) - >>> actual = SLG.condition() - >>> expected = 1.8090169943749477 - >>> abs(actual - expected) < options.ABS_TOL - True + >>> SLG.condition() + 1.809... """ return (condition_number(self._G()) + condition_number(self.A()))/2 diff --git a/test/symmetric_linear_game_test.py b/test/symmetric_linear_game_test.py index 067aaa1..b9c29fe 100644 --- a/test/symmetric_linear_game_test.py +++ b/test/symmetric_linear_game_test.py @@ -141,8 +141,8 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 soln2 = H.solution() value1 = soln1.game_value() value2 = soln2.game_value() - modifier1 = G.epsilon_scale(soln1) - modifier2 = H.epsilon_scale(soln2) + modifier1 = G.tolerance_scale(soln1) + modifier2 = H.tolerance_scale(soln2) modifier = max(modifier1, modifier2) self.assert_within_tol(alpha*value1, value2, modifier) @@ -182,7 +182,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 (alpha, H) = random_translation(G) value2 = H.solution().game_value() - modifier = G.epsilon_scale(soln1) + modifier = G.tolerance_scale(soln1) self.assert_within_tol(value1 + alpha, value2, modifier) # Make sure the same optimal pair works. @@ -225,7 +225,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 y_bar = soln1.player2_optimal() soln2 = H.solution() - mod = G.epsilon_scale(soln1) + 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 @@ -265,7 +265,7 @@ 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) - modifier = G.epsilon_scale(soln) + modifier = G.tolerance_scale(soln) self.assert_within_tol(ip1, 0, modifier) self.assert_within_tol(ip2, 0, modifier) @@ -324,7 +324,7 @@ class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 self.assertTrue(negative_stable) dualsoln = G.dual().solution() - mod = G.epsilon_scale(soln) + mod = G.tolerance_scale(soln) self.assert_within_tol(dualsoln.game_value(), soln.game_value(), mod) -- 2.43.2