+
+ def tolerance_scale(self, solution):
+ r"""
+ Return a scaling factor that should be applied to :const:`ABS_TOL`
+ for this game.
+
+ When performing certain comparisons, the default tolerance
+ :const:`ABS_TOL` may not be appropriate. For example, if we expect
+ ``x`` and ``y`` to be within :const:`ABS_TOL` of each other,
+ than the inner product of ``L*x`` and ``y`` can be as far apart
+ as the spectral norm of ``L`` times the sum of the norms of
+ ``x`` and ``y``. Such a comparison is made in :meth:`solution`,
+ and in many of our unit tests.
+
+ The returned scaling factor found from the inner product
+ mentioned above is
+
+ .. math::
+
+ \left\lVert L \right\rVert_{2}
+ \left( \left\lVert \bar{x} \right\rVert
+ + \left\lVert \bar{y} \right\rVert
+ \right),
+
+ where :math:`\bar{x}` and :math:`\bar{y}` are optimal solutions
+ for players one and two respectively. This scaling factor is not
+ formally justified, but attempting anything smaller leads to
+ test failures.
+
+ .. warning::
+
+ Optimal solutions are not unique, so the scaling factor
+ obtained from ``solution`` may not work when comparing other
+ solutions.
+
+ Parameters
+ ----------
+
+ solution : Solution
+ A solution of this game, used to obtain the norms of the
+ optimal strategies.
+
+ Returns
+ -------
+
+ float
+ A scaling factor to be multiplied by :const:`ABS_TOL` when
+ making comparisons involving solutions of this game.
+
+ Examples
+ --------
+
+ The spectral norm of ``L`` in this case is around ``5.464``, and
+ the optimal strategies both have norm one, so we expect the
+ tolerance scale to be somewhere around ``2 * 5.464``, or
+ ``10.929``::
+
+ >>> from dunshire import *
+ >>> L = [[1,2],[3,4]]
+ >>> K = NonnegativeOrthant(2)
+ >>> e1 = [1,1]
+ >>> e2 = e1
+ >>> SLG = SymmetricLinearGame(L,K,e1,e2)
+ >>> SLG.tolerance_scale(SLG.solution())
+ 10.929...
+
+ """