Move NashResult to utilities.py

Author: oyamad

quantecon/game_theory/lemke_howson.py

@@ -7,6 +7,7 @@
 """
 import numpy as np
 from numba import jit
+from .utilities import NashResult
 
 
 TOL_PIV = 1e-10
@@ -119,7 +120,7 @@ def lemke_howson(g, init_pivot=0, max_iter=10**6, capping=None,
     try:
         N = g.N
     except:
-        raise TypeError('input must be a 2-player NormalFormGame')
+        raise TypeError('g must be a 2-player NormalFormGame')
     if N != 2:
         raise NotImplementedError('Implemented only for 2-player games')
 
@@ -153,7 +154,7 @@ def lemke_howson(g, init_pivot=0, max_iter=10**6, capping=None,
                      converged=converged,
                      num_iter=num_iter,
                      max_iter=max_iter,
-                     init_pivot=init_pivot_used)
+                     init=init_pivot_used)
 
     return NE, res
 
@@ -598,48 +599,3 @@ def get_mixed_actions(tableaux, bases):
             out[start:stop] /= sum_
 
     return out[:nums_actions[0]], out[nums_actions[0]:]
-
-
-class NashResult(dict):
-    """
-    Contain the information about the result of Nash equilibrium
-    computation.
-
-    Attributes
-    ----------
-    NE : tuple(ndarray(float, ndim=1))
-        Computed Nash equilibrium.
-
-    converged : bool
-        Whether the routine has converged.
-
-    num_iter : int
-        Total number of iterations.
-
-    max_iter : int
-        Maximum number of iterations.
-
-    init_pivot : int
-        Initial pivot used.
-
-    """
-    # This is sourced from sicpy.optimize.OptimizeResult.
-    def __getattr__(self, name):
-        try:
-            return self[name]
-        except KeyError:
-            raise AttributeError(name)
-
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-    def __repr__(self):
-        if self.keys():
-            m = max(map(len, list(self.keys()))) + 1
-            return '\n'.join([k.rjust(m) + ': ' + repr(v)
-                              for k, v in sorted(self.items())])
-        else:
-            return self.__class__.__name__ + "()"
-
-    def __dir__(self):
-        return self.keys()

quantecon/game_theory/mclennan_tourky.py

@@ -10,6 +10,7 @@
 import numpy as np
 from ..compute_fp import _compute_fixed_point_ig
 from .normal_form_game import pure2mixed
+from .utilities import NashResult
 
 
 def mclennan_tourky(g, init=None, epsilon=1e-3, max_iter=200,
@@ -297,48 +298,3 @@ def _flatten_action_profile(action_profile, indptr):
         out[indptr[i]:indptr[i+1]] = mixed_action
 
     return out
-
-
-class NashResult(dict):
-    """
-    Contain the information about the result of Nash equilibrium
-    computation.
-
-    Attributes
-    ----------
-    NE : tuple(ndarray(float, ndim=1))
-        Computed Nash equilibrium.
-
-    converged : bool
-        Whether the routine has converged.
-
-    num_iter : int
-        Number of iterations.
-
-    max_iter : int
-        Maximum number of iterations.
-
-    init_action_profile : array_like
-        Initial action profile used.
-
-    """
-    # This is sourced from sicpy.optimize.OptimizeResult.
-    def __getattr__(self, name):
-        try:
-            return self[name]
-        except KeyError:
-            raise AttributeError(name)
-
-    __setattr__ = dict.__setitem__
-    __delattr__ = dict.__delitem__
-
-    def __repr__(self):
-        if self.keys():
-            m = max(map(len, list(self.keys()))) + 1
-            return '\n'.join([k.rjust(m) + ': ' + repr(v)
-                              for k, v in sorted(self.items())])
-        else:
-            return self.__class__.__name__ + "()"
-
-    def __dir__(self):
-        return self.keys()

quantecon/game_theory/tests/test_lemke_howson.py

@@ -100,14 +100,14 @@ def test_lemke_howson_capping():
                                  capping=max_iter, full_output=True)
         for action0, action1 in zip(NE0, NE1):
             assert_allclose(action0, action1)
-        eq_(res0.init_pivot, res1.init_pivot)
+        eq_(res0.init, res1.init)
 
     init_pivot = 1
     max_iter = m+n
     NE, res = lemke_howson(g, init_pivot=init_pivot, max_iter=max_iter,
                            capping=1, full_output=True)
     eq_(res.num_iter, max_iter)
-    eq_(res.init_pivot, init_pivot-1)
+    eq_(res.init, init_pivot-1)
 
 
 if __name__ == '__main__':

quantecon/game_theory/utilities.py

@@ -0,0 +1,53 @@
+"""
+Utility routines for the game_theory submodule
+
+"""
+class NashResult(dict):
+    """
+    Contain the information about the result of Nash equilibrium
+    computation.
+
+    Attributes
+    ----------
+    NE : tuple(ndarray(float, ndim=1))
+        Computed Nash equilibrium.
+
+    converged : bool
+        Whether the routine has converged.
+
+    num_iter : int
+        Number of iterations.
+
+    max_iter : int
+        Maximum number of iterations.
+
+    init : scalar or array_like
+        Initial condition used.
+
+    Notes
+    -----
+    This is sourced from `sicpy.optimize.OptimizeResult`.
+
+    There may be additional attributes not listed above depending of the
+    routine.
+
+    """
+    def __getattr__(self, name):
+        try:
+            return self[name]
+        except KeyError:
+            raise AttributeError(name)
+
+    __setattr__ = dict.__setitem__
+    __delattr__ = dict.__delitem__
+
+    def __repr__(self):
+        if self.keys():
+            m = max(map(len, list(self.keys()))) + 1
+            return '\n'.join([k.rjust(m) + ': ' + repr(v)
+                              for k, v in sorted(self.items())])
+        else:
+            return self.__class__.__name__ + "()"
+
+    def __dir__(self):
+        return self.keys()