Rename epsilon_scale() to tolerance_scale().

[dunshire.git] / dunshire / games.py

diff --git a/dunshire/games.py b/dunshire/games.py
index cfb62a33d8a2666828323019729af0f1b5ab99d7..07a70b0a2b651a40c207d5d3bcdfd807d55f92df 100644 (file)
--- 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):
@@ -977,6 +977,44 @@ class SymmetricLinearGame:
               [2.506...]
               [0.000...]
 
+        This is another one that was difficult numerically, and caused
+        trouble even after we fixed the first two::
+
+            >>> from dunshire import *
+            >>> L = [[57.22233908627052301199, 41.70631373437460354126],
+            ...      [83.04512571985074487202, 57.82581810406928468637]]
+            >>> K = NonnegativeOrthant(2)
+            >>> e1 = [7.31887017043399268346, 0.89744171905822367474]
+            >>> e2 = [0.11099824781179848388, 6.12564670639315345113]
+            >>> SLG = SymmetricLinearGame(L,K,e1,e2)
+            >>> print(SLG.solution())
+            Game value: 70.437...
+            Player 1 optimal:
+              [9.009...]
+              [0.000...]
+            Player 2 optimal:
+              [0.136...]
+              [0.000...]
+
+        And finally, here's one that returns an "optimal" solution, but
+        whose primal/dual objective function values are far apart::
+
+            >>> from dunshire import *
+            >>> L = [[ 6.49260076597376212248, -0.60528030227678542019],
+            ...      [ 2.59896077096751731972, -0.97685530240286766457]]
+            >>> K = IceCream(2)
+            >>> e1 = [1, 0.43749513972645248661]
+            >>> e2 = [1, 0.46008379832200291260]
+            >>> SLG = SymmetricLinearGame(L, K, e1, e2)
+            >>> print(SLG.solution())
+            Game value: 11.596...
+            Player 1 optimal:
+              [ 1.852...]
+              [-1.852...]
+            Player 2 optimal:
+              [ 1.777...]
+              [-1.777...]
+
         """
         try:
             opts = {'show_progress': False}
@@ -994,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
@@ -1019,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:
@@ -1047,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
@@ -1088,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