Add two previously-failing examples as doctests for solution().

[dunshire.git] / dunshire / games.py

diff --git a/dunshire/games.py b/dunshire/games.py
index ae1426a2c611f7e315f94fc5fea0e98f1da0905b..719198b7007896c0eb68df23ab91d6456888fb12 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
@@ -976,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}
@@ -986,6 +1025,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 +1060,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 +1084,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 +1095,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):