from cvxopt import matrix, printing, solvers
-from cones import CartesianProduct, NonnegativeOrthant
-from matrices import append_cols, append_row, identity
+from cones import CartesianProduct
+from matrices import append_col, append_row, identity
+
+printing.options['dformat'] = '%.7f'
+solvers.options['show_progress'] = False
class SymmetricLinearGame:
"""
as a column vector.
"""
- self._K = K
- self._C = CartesianProduct(NonnegativeOrthant(2), K, K)
- n = self._K.dimension()
- self._L = matrix(L, (n,n))
- self._e1 = matrix(e1, (n,1)) # TODO: check that e1 and e2
- self._e2 = matrix(e2, (n,1)) # are in the interior of K...
- self._h = matrix(0, (self._C.dimension(),1), 'd')
- self._b = matrix(1, (1,1), 'd')
- self._c = matrix([-1,1] + ([0]*n), (n+2,1), 'd')
- self._G = append_row(-identity(n+2),
- append_cols([self._e1, -self._e1, -self._L]))
- self._A = matrix([0,0] + e1, (1, n+2), 'd')
-
- def e1(self):
- return self._e1
-
- def e2(self):
- return self._e2
-
- def L(self):
- return self._L
-
- def h(self):
- return self._h
-
- def b(self):
- return self._b
-
- def c(self):
- return self._c
-
- def G(self):
- return self._G
-
- def A(self):
- return self._A
-
- def C(self):
- return self._C
+ self._K = K
+ self._C = CartesianProduct(K, K)
+ self._e1 = matrix(e1, (K.dimension(), 1))
+ self._e2 = matrix(e2, (K.dimension(), 1))
+
+ if not K.contains_strict(self._e1):
+ raise ValueError('the point e1 must lie in the interior of K')
+ if not K.contains_strict(self._e2):
+ raise ValueError('the point e2 must lie in the interior of K')
+
+ self._L = matrix(L, (K.dimension(), K.dimension()))
+ self._b = matrix([1], tc='d')
+ # A column of zeros that fits K.
+ zero = matrix(0, (K.dimension(), 1), tc='d')
+ self._h = matrix([zero, zero])
+ self._c = matrix([-1, zero])
+ self._G = append_row(append_col(zero, -identity(K.dimension())),
+ append_col(self._e1, -self._L))
+ self._A = matrix([0, self._e1], (1, K.dimension() + 1), 'd')
+
+ def solution(self):
+ soln = solvers.conelp(self._c,
+ self._G,
+ self._h,
+ self._C.cvxopt_dims(),
+ self._A,
+ self._b)
+ return soln
def solve(self):
- solvers.options['show_progress'] = False
- soln = solvers.conelp(self.c(),
- self.G(),
- self.h(),
- self.C().cvxopt_dims(),
- self.A(),
- self.b())
-
- printing.options['dformat'] = '%.7f'
- value = soln['x'][0] - soln['x'][1]
- print('Value of the game: {:f}'.format(value))
-
- opt1 = soln['x'][2:]
- print('Optimal strategy (player one):')
- print(opt1)
+ soln = self.solution()
- #opt2 = soln['y'][2:]
- #print('Optimal strategy (player two):')
- #print(opt2)
+ print('Value of the game (player one): {:f}'.format(soln['x'][0]))
+ print('Optimal strategy (player one):')
+ print(soln['x'][1:])
- return soln
+ print('Value of the game (player two): {:f}'.format(soln['y'][0]))
+ print('Optimal strategy (player two):')
+ print(soln['z'][self._K.dimension():])