Add two more tests for nonnegative scaling factors.

diff --git a/src/dunshire/games.py b/src/dunshire/games.py
index 8383a965d26e085e08befbd09f002b4806d312b6..f3d8100665d88c3690d75605ed177988fef6f54e 100644 (file)
--- a/src/dunshire/games.py
+++ b/src/dunshire/games.py
@@ -568,3 +568,59 @@ class SymmetricLinearGameTest(TestCase):
         L = [[1,-2],[-2,1]]
         G = SymmetricLinearGame(L, K, e1, e2)
         self.assertTrue(G.solution().game_value() < -options.ABS_TOL)
+
+
+    def test_nonnegative_scaling_orthant(self):
+        """
+        Test that scaling ``L`` by a nonnegative number scales the value
+        of the game by the same number. Use the nonnegative orthant as
+        our cone.
+        """
+        ambient_dim = randint(1, 10)
+        K = NonnegativeOrthant(ambient_dim)
+        e1 = [uniform(0.1, 10) for idx in range(K.dimension())]
+        e2 = [uniform(0.1, 10) for idx in range(K.dimension())]
+        L = matrix([[uniform(-10, 10) for i in range(K.dimension())]
+                    for j in range(K.dimension())])
+        G1 = SymmetricLinearGame(L, K, e1, e2)
+        value1 = G1.solution().game_value()
+        alpha = uniform(0.1, 10)
+
+        G2 = SymmetricLinearGame(alpha*L, K, e1, e2)
+        value2 = G2.solution().game_value()
+        self.assert_within_tol(alpha*value1, value2)
+
+
+    def test_nonnegative_scaling_icecream(self):
+        """
+        The same test as :meth:`test_nonnegative_scaling_orthant`,
+        except over the ice cream cone.
+        """
+                # 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 = matrix([[uniform(-10, 10) for i in range(K.dimension())]
+                    for j in range(K.dimension())])
+
+        G1 = SymmetricLinearGame(L, K, e1, e2)
+        value1 = G1.solution().game_value()
+        alpha = uniform(0.1, 10)
+
+        G2 = SymmetricLinearGame(alpha*L, K, e1, e2)
+        value2 = G2.solution().game_value()
+        self.assert_within_tol(alpha*value1, value2)
+