from . import options
printing.options['dformat'] = options.FLOAT_FORMAT
-solvers.options['show_progress'] = options.VERBOSE
-
class Solution:
"""
e2 = [ 1]
[ 2]
[ 3],
- Condition((L, K, e1, e2)) = 31.834895.
+ Condition((L, K, e1, e2)) = 31.834...
Lists can (and probably should) be used for every argument::
[ 1],
e2 = [ 1]
[ 1],
- Condition((L, K, e1, e2)) = 1.707107.
+ Condition((L, K, e1, e2)) = 1.707...
The points ``e1`` and ``e2`` can also be passed as some other
enumerable type (of the correct length) without much harm, since
[ 1],
e2 = [ 1]
[ 1],
- Condition((L, K, e1, e2)) = 1.707107.
+ Condition((L, K, e1, e2)) = 1.707...
However, ``L`` will always be intepreted as a list of rows, even
if it is passed as a :class:`cvxopt.base.matrix` which is
[ 1],
e2 = [ 1]
[ 1],
- Condition((L, K, e1, e2)) = 6.073771.
+ Condition((L, K, e1, e2)) = 6.073...
>>> L = cvxopt.matrix(L)
>>> print(L)
[ 1 3]
[ 1],
e2 = [ 1]
[ 1],
- Condition((L, K, e1, e2)) = 6.073771.
+ Condition((L, K, e1, e2)) = 6.073...
"""
def __init__(self, L, K, e1, e2):
str(self._K),
indented_e1,
indented_e2,
- self._condition())
+ self.condition())
def _zero(self):
>>> print(SLG.solution())
Game value: -6.1724138
Player 1 optimal:
- [ 0.5517241]
- [-0.0000000]
- [ 0.4482759]
+ [ 0.551...]
+ [-0.000...]
+ [ 0.448...]
Player 2 optimal:
- [0.4482759]
- [0.0000000]
- [0.5517241]
+ [0.448...]
+ [0.000...]
+ [0.551...]
The value of the following game can be computed using the fact
that the identity is invertible::
>>> print(SLG.solution())
Game value: 0.0312500
Player 1 optimal:
- [0.0312500]
- [0.0625000]
- [0.0937500]
+ [0.031...]
+ [0.062...]
+ [0.093...]
Player 2 optimal:
- [0.1250000]
- [0.1562500]
- [0.1875000]
+ [0.125...]
+ [0.156...]
+ [0.187...]
"""
# The cone "C" that appears in the statement of the CVXOPT
# Actually solve the thing and obtain a dictionary describing
# what happened.
try:
+ solvers.options['show_progress'] = options.VERBOSE
+ solvers.options['abs_tol'] = options.ABS_TOL
soln_dict = solvers.conelp(c, self._G(), h,
C.cvxopt_dims(), self._A(), b)
except ValueError as e:
# objectives match (within a tolerance) and that the
# primal/dual optimal solutions are within the cone (to a
# tolerance as well).
+ #
+ # The fudge factor of two is basically unjustified, but
+ # makes intuitive sense when you imagine that the primal
+ # value could be under the true optimal by ``ABS_TOL``
+ # and the dual value could be over by the same amount.
+ #
if abs(p1_value - p2_value) > options.ABS_TOL:
raise GameUnsolvableException(self, soln_dict)
if (p1_optimal not in self._K) or (p2_optimal not in self._K):
return Solution(p1_value, p1_optimal, p2_optimal)
- def _condition(self):
+ def condition(self):
r"""
Return the condition number of this game.
>>> e1 = [1]
>>> e2 = e1
>>> SLG = SymmetricLinearGame(L, K, e1, e2)
- >>> actual = SLG._condition()
+ >>> actual = SLG.condition()
>>> expected = 1.8090169943749477
>>> abs(actual - expected) < options.ABS_TOL
True
e2 = [ 1]
[ 1]
[ 1],
- Condition((L, K, e1, e2)) = 44.476765.
+ Condition((L, K, e1, e2)) = 44.476...
"""
# We pass ``self._L`` right back into the constructor, because