From: Michael Orlitzky Date: Sat, 15 Oct 2016 23:49:48 +0000 (-0400) Subject: Move unit test code into its own file (unders test/ instead of src/). X-Git-Tag: 0.1.0~128 X-Git-Url: https://gitweb.michael.orlitzky.com/?a=commitdiff_plain;h=e56739b9f432a5f2dce0223158de946b3db6c0e5;p=dunshire.git Move unit test code into its own file (unders test/ instead of src/). --- diff --git a/src/dunshire/games.py b/src/dunshire/games.py index 05ab58c..92a3ffe 100644 --- a/src/dunshire/games.py +++ b/src/dunshire/games.py @@ -5,17 +5,10 @@ This module contains the main :class:`SymmetricLinearGame` class that knows how to solve a linear game. """ -# These few are used only for tests. -from math import sqrt -from random import randint, uniform -from unittest import TestCase - -# These are mostly actually needed. from cvxopt import matrix, printing, solvers -from .cones import CartesianProduct, IceCream, NonnegativeOrthant +from .cones import CartesianProduct from .errors import GameUnsolvableException -from .matrices import (append_col, append_row, eigenvalues_re, identity, - inner_product, norm) +from .matrices import append_col, append_row, identity from . import options printing.options['dformat'] = options.FLOAT_FORMAT @@ -211,6 +204,7 @@ class SymmetricLinearGame: Examples -------- + >>> from dunshire import * >>> K = NonnegativeOrthant(3) >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]] >>> e1 = [1,1,1] @@ -231,6 +225,7 @@ class SymmetricLinearGame: Lists can (and probably should) be used for every argument:: + >>> from dunshire import * >>> K = NonnegativeOrthant(2) >>> L = [[1,0],[0,1]] >>> e1 = [1,1] @@ -252,6 +247,7 @@ class SymmetricLinearGame: >>> import cvxopt >>> import numpy + >>> from dunshire import * >>> K = NonnegativeOrthant(2) >>> L = [[1,0],[0,1]] >>> e1 = cvxopt.matrix([1,1]) @@ -272,6 +268,7 @@ class SymmetricLinearGame: otherwise indexed by columns:: >>> import cvxopt + >>> from dunshire import * >>> K = NonnegativeOrthant(2) >>> L = [[1,2],[3,4]] >>> e1 = [1,1] @@ -360,6 +357,7 @@ class SymmetricLinearGame: This example is computed in Gowda and Ravindran in the section "The value of a Z-transformation":: + >>> from dunshire import * >>> K = NonnegativeOrthant(3) >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]] >>> e1 = [1,1,1] @@ -379,6 +377,7 @@ class SymmetricLinearGame: The value of the following game can be computed using the fact that the identity is invertible:: + >>> from dunshire import * >>> K = NonnegativeOrthant(3) >>> L = [[1,0,0],[0,1,0],[0,0,1]] >>> e1 = [1,2,3] @@ -469,6 +468,7 @@ class SymmetricLinearGame: Examples -------- + >>> from dunshire import * >>> K = NonnegativeOrthant(3) >>> L = [[1,-5,-15],[-1,2,-3],[-12,-15,1]] >>> e1 = [1,1,1] @@ -495,401 +495,3 @@ class SymmetricLinearGame: self._K, self._e2, self._e1) - - - -def _random_matrix(dims): - """ - Generate a random square (``dims``-by-``dims``) matrix. This is used - only by the :class:`SymmetricLinearGameTest` class. - """ - return matrix([[uniform(-10, 10) for i in range(dims)] - for j in range(dims)]) - -def _random_nonnegative_matrix(dims): - """ - Generate a random square (``dims``-by-``dims``) matrix with - nonnegative entries. This is used only by the - :class:`SymmetricLinearGameTest` class. - """ - L = _random_matrix(dims) - return matrix([abs(entry) for entry in L], (dims, dims)) - -def _random_diagonal_matrix(dims): - """ - Generate a random square (``dims``-by-``dims``) matrix with nonzero - entries only on the diagonal. This is used only by the - :class:`SymmetricLinearGameTest` class. - """ - return matrix([[uniform(-10, 10)*int(i == j) for i in range(dims)] - for j in range(dims)]) - - -def _random_skew_symmetric_matrix(dims): - """ - Generate a random skew-symmetrix (``dims``-by-``dims``) matrix. - - Examples - -------- - - >>> A = _random_skew_symmetric_matrix(randint(1, 10)) - >>> norm(A + A.trans()) < options.ABS_TOL - True - - """ - strict_ut = [[uniform(-10, 10)*int(i < j) for i in range(dims)] - for j in range(dims)] - - strict_ut = matrix(strict_ut, (dims, dims)) - return strict_ut - strict_ut.trans() - - -def _random_lyapunov_like_icecream(dims): - """ - Generate a random Lyapunov-like matrix over the ice-cream cone in - ``dims`` dimensions. - """ - a = matrix([uniform(-10, 10)], (1, 1)) - b = matrix([uniform(-10, 10) for idx in range(dims-1)], (dims-1, 1)) - D = _random_skew_symmetric_matrix(dims-1) + a*identity(dims-1) - row1 = append_col(a, b.trans()) - row2 = append_col(b, D) - return append_row(row1, row2) - - -def _random_orthant_params(): - """ - Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a - random game over the nonnegative orthant. This is only used by - the :class:`SymmetricLinearGameTest` class. - """ - ambient_dim = randint(1, 10) - K = NonnegativeOrthant(ambient_dim) - e1 = [uniform(0.5, 10) for idx in range(K.dimension())] - e2 = [uniform(0.5, 10) for idx in range(K.dimension())] - L = _random_matrix(K.dimension()) - return (L, K, matrix(e1), matrix(e2)) - - -def _random_icecream_params(): - """ - Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a - random game over the ice cream cone. This is only used by - the :class:`SymmetricLinearGameTest` class. - """ - # Use a minimum dimension of two to avoid divide-by-zero in - # the fudge factor we make up later. - ambient_dim = randint(2, 10) - K = IceCream(ambient_dim) - e1 = [1] # Set the "height" of e1 to one - e2 = [1] # And the same for e2 - - # If we choose the rest of the components of e1,e2 randomly - # between 0 and 1, then the largest the squared norm of the - # non-height part of e1,e2 could be is the 1*(dim(K) - 1). We - # need to make it less than one (the height of the cone) so - # that the whole thing is in the cone. The norm of the - # non-height part is sqrt(dim(K) - 1), and we can divide by - # twice that. - fudge_factor = 1.0 / (2.0*sqrt(K.dimension() - 1.0)) - e1 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)] - e2 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)] - L = _random_matrix(K.dimension()) - - return (L, K, matrix(e1), matrix(e2)) - - -# Tell pylint to shut up about the large number of methods. -class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 - """ - Tests for the SymmetricLinearGame and Solution classes. - """ - def assert_within_tol(self, first, second): - """ - Test that ``first`` and ``second`` are equal within our default - tolerance. - """ - self.assertTrue(abs(first - second) < options.ABS_TOL) - - - def assert_norm_within_tol(self, first, second): - """ - Test that ``first`` and ``second`` vectors are equal in the - sense that the norm of their difference is within our default - tolerance. - """ - self.assert_within_tol(norm(first - second), 0) - - - def assert_solution_exists(self, L, K, e1, e2): - """ - Given the parameters needed to construct a SymmetricLinearGame, - ensure that that game has a solution. - """ - # The matrix() constructor assumes that ``L`` is a list of - # columns, so we transpose it to agree with what - # SymmetricLinearGame() thinks. - G = SymmetricLinearGame(L.trans(), K, e1, e2) - soln = G.solution() - - expected = inner_product(L*soln.player1_optimal(), - soln.player2_optimal()) - self.assert_within_tol(soln.game_value(), expected) - - - def test_solution_exists_orthant(self): - """ - Every linear game has a solution, so we should be able to solve - every symmetric linear game over the NonnegativeOrthant. Pick - some parameters randomly and give it a shot. The resulting - optimal solutions should give us the optimal game value when we - apply the payoff operator to them. - """ - (L, K, e1, e2) = _random_orthant_params() - self.assert_solution_exists(L, K, e1, e2) - - - def test_solution_exists_icecream(self): - """ - Like :meth:`test_solution_exists_nonnegative_orthant`, except - over the ice cream cone. - """ - (L, K, e1, e2) = _random_icecream_params() - self.assert_solution_exists(L, K, e1, e2) - - - def test_negative_value_z_operator(self): - """ - Test the example given in Gowda/Ravindran of a Z-matrix with - negative game value on the nonnegative orthant. - """ - K = NonnegativeOrthant(2) - e1 = [1, 1] - e2 = e1 - L = [[1, -2], [-2, 1]] - G = SymmetricLinearGame(L, K, e1, e2) - self.assertTrue(G.solution().game_value() < -options.ABS_TOL) - - - def assert_scaling_works(self, L, K, e1, e2): - """ - Test that scaling ``L`` by a nonnegative number scales the value - of the game by the same number. - """ - game1 = SymmetricLinearGame(L, K, e1, e2) - value1 = game1.solution().game_value() - - alpha = uniform(0.1, 10) - game2 = SymmetricLinearGame(alpha*L, K, e1, e2) - value2 = game2.solution().game_value() - self.assert_within_tol(alpha*value1, value2) - - - def test_scaling_orthant(self): - """ - Test that scaling ``L`` by a nonnegative number scales the value - of the game by the same number over the nonnegative orthant. - """ - (L, K, e1, e2) = _random_orthant_params() - self.assert_scaling_works(L, K, e1, e2) - - - def test_scaling_icecream(self): - """ - The same test as :meth:`test_nonnegative_scaling_orthant`, - except over the ice cream cone. - """ - (L, K, e1, e2) = _random_icecream_params() - self.assert_scaling_works(L, K, e1, e2) - - - def assert_translation_works(self, L, K, e1, e2): - """ - Check that translating ``L`` by alpha*(e1*e2.trans()) increases - the value of the associated game by alpha. - """ - # We need to use ``L`` later, so make sure we transpose it - # before passing it in as a column-indexed matrix. - game1 = SymmetricLinearGame(L.trans(), K, e1, e2) - soln1 = game1.solution() - value1 = soln1.game_value() - x_bar = soln1.player1_optimal() - y_bar = soln1.player2_optimal() - - alpha = uniform(-10, 10) - tensor_prod = e1*e2.trans() - - # This is the "correct" representation of ``M``, but COLUMN - # indexed... - M = L + alpha*tensor_prod - - # so we have to transpose it when we feed it to the constructor. - game2 = SymmetricLinearGame(M.trans(), K, e1, e2) - value2 = game2.solution().game_value() - - self.assert_within_tol(value1 + alpha, value2) - - # Make sure the same optimal pair works. - self.assert_within_tol(value2, inner_product(M*x_bar, y_bar)) - - - def test_translation_orthant(self): - """ - Test that translation works over the nonnegative orthant. - """ - (L, K, e1, e2) = _random_orthant_params() - self.assert_translation_works(L, K, e1, e2) - - - def test_translation_icecream(self): - """ - The same as :meth:`test_translation_orthant`, except over the - ice cream cone. - """ - (L, K, e1, e2) = _random_icecream_params() - self.assert_translation_works(L, K, e1, e2) - - - def assert_opposite_game_works(self, L, K, e1, e2): - """ - Check the value of the "opposite" game that gives rise to a - value that is the negation of the original game. Comes from - some corollary. - """ - # We need to use ``L`` later, so make sure we transpose it - # before passing it in as a column-indexed matrix. - game1 = SymmetricLinearGame(L.trans(), K, e1, e2) - - # This is the "correct" representation of ``M``, but - # COLUMN indexed... - M = -L.trans() - - # so we have to transpose it when we feed it to the constructor. - game2 = SymmetricLinearGame(M.trans(), K, e2, e1) - - soln1 = game1.solution() - x_bar = soln1.player1_optimal() - y_bar = soln1.player2_optimal() - soln2 = game2.solution() - - self.assert_within_tol(-soln1.game_value(), soln2.game_value()) - - # Make sure the switched optimal pair works. - self.assert_within_tol(soln2.game_value(), - inner_product(M*y_bar, x_bar)) - - - def test_opposite_game_orthant(self): - """ - Test the value of the "opposite" game over the nonnegative - orthant. - """ - (L, K, e1, e2) = _random_orthant_params() - self.assert_opposite_game_works(L, K, e1, e2) - - - def test_opposite_game_icecream(self): - """ - Like :meth:`test_opposite_game_orthant`, except over the - ice-cream cone. - """ - (L, K, e1, e2) = _random_icecream_params() - self.assert_opposite_game_works(L, K, e1, e2) - - - def assert_orthogonality(self, L, K, e1, e2): - """ - Two orthogonality relations hold at an optimal solution, and we - check them here. - """ - # We need to use ``L`` later, so make sure we transpose it - # before passing it in as a column-indexed matrix. - game = SymmetricLinearGame(L.trans(), K, e1, e2) - soln = game.solution() - x_bar = soln.player1_optimal() - y_bar = soln.player2_optimal() - value = soln.game_value() - - ip1 = inner_product(y_bar, L*x_bar - value*e1) - self.assert_within_tol(ip1, 0) - - ip2 = inner_product(value*e2 - L.trans()*y_bar, x_bar) - self.assert_within_tol(ip2, 0) - - - def test_orthogonality_orthant(self): - """ - Check the orthgonality relationships that hold for a solution - over the nonnegative orthant. - """ - (L, K, e1, e2) = _random_orthant_params() - self.assert_orthogonality(L, K, e1, e2) - - - def test_orthogonality_icecream(self): - """ - Check the orthgonality relationships that hold for a solution - over the ice-cream cone. - """ - (L, K, e1, e2) = _random_icecream_params() - self.assert_orthogonality(L, K, e1, e2) - - - def test_positive_operator_value(self): - """ - Test that a positive operator on the nonnegative orthant gives - rise to a a game with a nonnegative value. - - This test theoretically applies to the ice-cream cone as well, - but we don't know how to make positive operators on that cone. - """ - (K, e1, e2) = _random_orthant_params()[1:] - L = _random_nonnegative_matrix(K.dimension()) - - game = SymmetricLinearGame(L, K, e1, e2) - self.assertTrue(game.solution().game_value() >= -options.ABS_TOL) - - - def assert_lyapunov_works(self, L, K, e1, e2): - """ - Check that Lyapunov games act the way we expect. - """ - game = SymmetricLinearGame(L, K, e1, e2) - soln = game.solution() - - # We only check for positive/negative stability if the game - # value is not basically zero. If the value is that close to - # zero, we just won't check any assertions. - eigs = eigenvalues_re(L) - if soln.game_value() > options.ABS_TOL: - # L should be positive stable - positive_stable = all([eig > -options.ABS_TOL for eig in eigs]) - self.assertTrue(positive_stable) - elif soln.game_value() < -options.ABS_TOL: - # L should be negative stable - negative_stable = all([eig < options.ABS_TOL for eig in eigs]) - self.assertTrue(negative_stable) - - # The dual game's value should always equal the primal's. - dualsoln = game.dual().solution() - self.assert_within_tol(dualsoln.game_value(), soln.game_value()) - - - def test_lyapunov_orthant(self): - """ - Test that a Lyapunov game on the nonnegative orthant works. - """ - (K, e1, e2) = _random_orthant_params()[1:] - L = _random_diagonal_matrix(K.dimension()) - - self.assert_lyapunov_works(L, K, e1, e2) - - - def test_lyapunov_icecream(self): - """ - Test that a Lyapunov game on the ice-cream cone works. - """ - (K, e1, e2) = _random_icecream_params()[1:] - L = _random_lyapunov_like_icecream(K.dimension()) - - self.assert_lyapunov_works(L, K, e1, e2) diff --git a/test/suite.py b/test/suite.py index 7051b9c..4025647 100644 --- a/test/suite.py +++ b/test/suite.py @@ -15,12 +15,14 @@ from dunshire import cones from dunshire import errors from dunshire import matrices from dunshire import games +import symmetric_linear_game_test suite = TestSuite() suite.addTest(DocTestSuite(cones)) suite.addTest(DocTestSuite(errors)) suite.addTest(DocTestSuite(matrices)) suite.addTest(DocTestSuite(games)) -suite.addTest(TestLoader().loadTestsFromModule(games)) -runner = TextTestRunner(verbosity=2) +suite.addTest(DocTestSuite(symmetric_linear_game_test)) +suite.addTest(TestLoader().loadTestsFromModule(symmetric_linear_game_test)) +runner = TextTestRunner(verbosity=1) runner.run(suite) diff --git a/test/symmetric_linear_game_test.py b/test/symmetric_linear_game_test.py new file mode 100644 index 0000000..5adbb2d --- /dev/null +++ b/test/symmetric_linear_game_test.py @@ -0,0 +1,408 @@ +# These few are used only for tests. +from math import sqrt +from random import randint, uniform +from unittest import TestCase + +from cvxopt import matrix +from dunshire.cones import NonnegativeOrthant, IceCream +from dunshire.games import SymmetricLinearGame +from dunshire.matrices import (append_col, append_row, eigenvalues_re, + identity, inner_product) +from dunshire import options + +def _random_matrix(dims): + """ + Generate a random square (``dims``-by-``dims``) matrix. This is used + only by the :class:`SymmetricLinearGameTest` class. + """ + return matrix([[uniform(-10, 10) for i in range(dims)] + for j in range(dims)]) + +def _random_nonnegative_matrix(dims): + """ + Generate a random square (``dims``-by-``dims``) matrix with + nonnegative entries. This is used only by the + :class:`SymmetricLinearGameTest` class. + """ + L = _random_matrix(dims) + return matrix([abs(entry) for entry in L], (dims, dims)) + +def _random_diagonal_matrix(dims): + """ + Generate a random square (``dims``-by-``dims``) matrix with nonzero + entries only on the diagonal. This is used only by the + :class:`SymmetricLinearGameTest` class. + """ + return matrix([[uniform(-10, 10)*int(i == j) for i in range(dims)] + for j in range(dims)]) + + +def _random_skew_symmetric_matrix(dims): + """ + Generate a random skew-symmetrix (``dims``-by-``dims``) matrix. + + Examples + -------- + + >>> from dunshire.matrices import norm + >>> A = _random_skew_symmetric_matrix(randint(1, 10)) + >>> norm(A + A.trans()) < options.ABS_TOL + True + + """ + strict_ut = [[uniform(-10, 10)*int(i < j) for i in range(dims)] + for j in range(dims)] + + strict_ut = matrix(strict_ut, (dims, dims)) + return strict_ut - strict_ut.trans() + + +def _random_lyapunov_like_icecream(dims): + """ + Generate a random Lyapunov-like matrix over the ice-cream cone in + ``dims`` dimensions. + """ + a = matrix([uniform(-10, 10)], (1, 1)) + b = matrix([uniform(-10, 10) for idx in range(dims-1)], (dims-1, 1)) + D = _random_skew_symmetric_matrix(dims-1) + a*identity(dims-1) + row1 = append_col(a, b.trans()) + row2 = append_col(b, D) + return append_row(row1, row2) + + +def _random_orthant_params(): + """ + Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a + random game over the nonnegative orthant. This is only used by + the :class:`SymmetricLinearGameTest` class. + """ + ambient_dim = randint(1, 10) + K = NonnegativeOrthant(ambient_dim) + e1 = [uniform(0.5, 10) for idx in range(K.dimension())] + e2 = [uniform(0.5, 10) for idx in range(K.dimension())] + L = _random_matrix(K.dimension()) + return (L, K, matrix(e1), matrix(e2)) + + +def _random_icecream_params(): + """ + Generate the ``L``, ``K``, ``e1``, and ``e2`` parameters for a + random game over the ice cream cone. This is only used by + the :class:`SymmetricLinearGameTest` class. + """ + # Use a minimum dimension of two to avoid divide-by-zero in + # the fudge factor we make up later. + ambient_dim = randint(2, 10) + K = IceCream(ambient_dim) + e1 = [1] # Set the "height" of e1 to one + e2 = [1] # And the same for e2 + + # If we choose the rest of the components of e1,e2 randomly + # between 0 and 1, then the largest the squared norm of the + # non-height part of e1,e2 could be is the 1*(dim(K) - 1). We + # need to make it less than one (the height of the cone) so + # that the whole thing is in the cone. The norm of the + # non-height part is sqrt(dim(K) - 1), and we can divide by + # twice that. + fudge_factor = 1.0 / (2.0*sqrt(K.dimension() - 1.0)) + e1 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)] + e2 += [fudge_factor*uniform(0, 1) for idx in range(K.dimension() - 1)] + L = _random_matrix(K.dimension()) + + return (L, K, matrix(e1), matrix(e2)) + + +# Tell pylint to shut up about the large number of methods. +class SymmetricLinearGameTest(TestCase): # pylint: disable=R0904 + """ + Tests for the SymmetricLinearGame and Solution classes. + """ + def assert_within_tol(self, first, second): + """ + Test that ``first`` and ``second`` are equal within our default + tolerance. + """ + self.assertTrue(abs(first - second) < options.ABS_TOL) + + + def assert_norm_within_tol(self, first, second): + """ + Test that ``first`` and ``second`` vectors are equal in the + sense that the norm of their difference is within our default + tolerance. + """ + self.assert_within_tol(norm(first - second), 0) + + + def assert_solution_exists(self, L, K, e1, e2): + """ + Given the parameters needed to construct a SymmetricLinearGame, + ensure that that game has a solution. + """ + # The matrix() constructor assumes that ``L`` is a list of + # columns, so we transpose it to agree with what + # SymmetricLinearGame() thinks. + G = SymmetricLinearGame(L.trans(), K, e1, e2) + soln = G.solution() + + expected = inner_product(L*soln.player1_optimal(), + soln.player2_optimal()) + self.assert_within_tol(soln.game_value(), expected) + + + def test_solution_exists_orthant(self): + """ + Every linear game has a solution, so we should be able to solve + every symmetric linear game over the NonnegativeOrthant. Pick + some parameters randomly and give it a shot. The resulting + optimal solutions should give us the optimal game value when we + apply the payoff operator to them. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_solution_exists(L, K, e1, e2) + + + def test_solution_exists_icecream(self): + """ + Like :meth:`test_solution_exists_nonnegative_orthant`, except + over the ice cream cone. + """ + (L, K, e1, e2) = _random_icecream_params() + self.assert_solution_exists(L, K, e1, e2) + + + def test_negative_value_z_operator(self): + """ + Test the example given in Gowda/Ravindran of a Z-matrix with + negative game value on the nonnegative orthant. + """ + K = NonnegativeOrthant(2) + e1 = [1, 1] + e2 = e1 + L = [[1, -2], [-2, 1]] + G = SymmetricLinearGame(L, K, e1, e2) + self.assertTrue(G.solution().game_value() < -options.ABS_TOL) + + + def assert_scaling_works(self, L, K, e1, e2): + """ + Test that scaling ``L`` by a nonnegative number scales the value + of the game by the same number. + """ + game1 = SymmetricLinearGame(L, K, e1, e2) + value1 = game1.solution().game_value() + + alpha = uniform(0.1, 10) + game2 = SymmetricLinearGame(alpha*L, K, e1, e2) + value2 = game2.solution().game_value() + self.assert_within_tol(alpha*value1, value2) + + + def test_scaling_orthant(self): + """ + Test that scaling ``L`` by a nonnegative number scales the value + of the game by the same number over the nonnegative orthant. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_scaling_works(L, K, e1, e2) + + + def test_scaling_icecream(self): + """ + The same test as :meth:`test_nonnegative_scaling_orthant`, + except over the ice cream cone. + """ + (L, K, e1, e2) = _random_icecream_params() + self.assert_scaling_works(L, K, e1, e2) + + + def assert_translation_works(self, L, K, e1, e2): + """ + Check that translating ``L`` by alpha*(e1*e2.trans()) increases + the value of the associated game by alpha. + """ + # We need to use ``L`` later, so make sure we transpose it + # before passing it in as a column-indexed matrix. + game1 = SymmetricLinearGame(L.trans(), K, e1, e2) + soln1 = game1.solution() + value1 = soln1.game_value() + x_bar = soln1.player1_optimal() + y_bar = soln1.player2_optimal() + + alpha = uniform(-10, 10) + tensor_prod = e1*e2.trans() + + # This is the "correct" representation of ``M``, but COLUMN + # indexed... + M = L + alpha*tensor_prod + + # so we have to transpose it when we feed it to the constructor. + game2 = SymmetricLinearGame(M.trans(), K, e1, e2) + value2 = game2.solution().game_value() + + self.assert_within_tol(value1 + alpha, value2) + + # Make sure the same optimal pair works. + self.assert_within_tol(value2, inner_product(M*x_bar, y_bar)) + + + def test_translation_orthant(self): + """ + Test that translation works over the nonnegative orthant. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_translation_works(L, K, e1, e2) + + + def test_translation_icecream(self): + """ + The same as :meth:`test_translation_orthant`, except over the + ice cream cone. + """ + (L, K, e1, e2) = _random_icecream_params() + self.assert_translation_works(L, K, e1, e2) + + + def assert_opposite_game_works(self, L, K, e1, e2): + """ + Check the value of the "opposite" game that gives rise to a + value that is the negation of the original game. Comes from + some corollary. + """ + # We need to use ``L`` later, so make sure we transpose it + # before passing it in as a column-indexed matrix. + game1 = SymmetricLinearGame(L.trans(), K, e1, e2) + + # This is the "correct" representation of ``M``, but + # COLUMN indexed... + M = -L.trans() + + # so we have to transpose it when we feed it to the constructor. + game2 = SymmetricLinearGame(M.trans(), K, e2, e1) + + soln1 = game1.solution() + x_bar = soln1.player1_optimal() + y_bar = soln1.player2_optimal() + soln2 = game2.solution() + + self.assert_within_tol(-soln1.game_value(), soln2.game_value()) + + # Make sure the switched optimal pair works. + self.assert_within_tol(soln2.game_value(), + inner_product(M*y_bar, x_bar)) + + + def test_opposite_game_orthant(self): + """ + Test the value of the "opposite" game over the nonnegative + orthant. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_opposite_game_works(L, K, e1, e2) + + + def test_opposite_game_icecream(self): + """ + Like :meth:`test_opposite_game_orthant`, except over the + ice-cream cone. + """ + (L, K, e1, e2) = _random_icecream_params() + self.assert_opposite_game_works(L, K, e1, e2) + + + def assert_orthogonality(self, L, K, e1, e2): + """ + Two orthogonality relations hold at an optimal solution, and we + check them here. + """ + # We need to use ``L`` later, so make sure we transpose it + # before passing it in as a column-indexed matrix. + game = SymmetricLinearGame(L.trans(), K, e1, e2) + soln = game.solution() + x_bar = soln.player1_optimal() + y_bar = soln.player2_optimal() + value = soln.game_value() + + ip1 = inner_product(y_bar, L*x_bar - value*e1) + self.assert_within_tol(ip1, 0) + + ip2 = inner_product(value*e2 - L.trans()*y_bar, x_bar) + self.assert_within_tol(ip2, 0) + + + def test_orthogonality_orthant(self): + """ + Check the orthgonality relationships that hold for a solution + over the nonnegative orthant. + """ + (L, K, e1, e2) = _random_orthant_params() + self.assert_orthogonality(L, K, e1, e2) + + + def test_orthogonality_icecream(self): + """ + Check the orthgonality relationships that hold for a solution + over the ice-cream cone. + """ + (L, K, e1, e2) = _random_icecream_params() + self.assert_orthogonality(L, K, e1, e2) + + + def test_positive_operator_value(self): + """ + Test that a positive operator on the nonnegative orthant gives + rise to a a game with a nonnegative value. + + This test theoretically applies to the ice-cream cone as well, + but we don't know how to make positive operators on that cone. + """ + (K, e1, e2) = _random_orthant_params()[1:] + L = _random_nonnegative_matrix(K.dimension()) + + game = SymmetricLinearGame(L, K, e1, e2) + self.assertTrue(game.solution().game_value() >= -options.ABS_TOL) + + + def assert_lyapunov_works(self, L, K, e1, e2): + """ + Check that Lyapunov games act the way we expect. + """ + game = SymmetricLinearGame(L, K, e1, e2) + soln = game.solution() + + # We only check for positive/negative stability if the game + # value is not basically zero. If the value is that close to + # zero, we just won't check any assertions. + eigs = eigenvalues_re(L) + if soln.game_value() > options.ABS_TOL: + # L should be positive stable + positive_stable = all([eig > -options.ABS_TOL for eig in eigs]) + self.assertTrue(positive_stable) + elif soln.game_value() < -options.ABS_TOL: + # L should be negative stable + negative_stable = all([eig < options.ABS_TOL for eig in eigs]) + self.assertTrue(negative_stable) + + # The dual game's value should always equal the primal's. + dualsoln = game.dual().solution() + self.assert_within_tol(dualsoln.game_value(), soln.game_value()) + + + def test_lyapunov_orthant(self): + """ + Test that a Lyapunov game on the nonnegative orthant works. + """ + (K, e1, e2) = _random_orthant_params()[1:] + L = _random_diagonal_matrix(K.dimension()) + + self.assert_lyapunov_works(L, K, e1, e2) + + + def test_lyapunov_icecream(self): + """ + Test that a Lyapunov game on the ice-cream cone works. + """ + (K, e1, e2) = _random_icecream_params()[1:] + L = _random_lyapunov_like_icecream(K.dimension()) + + self.assert_lyapunov_works(L, K, e1, e2)