Merge pull request #1218 from Axelrod-Python/fix-numpy-depreciation

Fix numpy depreciation: `np.matrix -> np.array`

Author: meatballs

.prepare-commit-msg.py

@@ -30,18 +30,20 @@
 # e.g. for a branch named 'issue-123', the commit message will start with
 # '[#123]'
 # If you wish to use a diferent prefix on branch names, change it here.
-issue_prefix = 'issue-'
+issue_prefix = "issue-"
 
 commit_msg_filepath = sys.argv[1]
-branch = check_output(
-    ['git', 'symbolic-ref', '--short', 'HEAD']
-).strip().decode(encoding='UTF-8')
+branch = (
+    check_output(["git", "symbolic-ref", "--short", "HEAD"])
+    .strip()
+    .decode(encoding="UTF-8")
+)
 
 if branch.startswith(issue_prefix):
-    issue_number = re.match('%s(.*)' % issue_prefix, branch).group(1)
+    issue_number = re.match("%s(.*)" % issue_prefix, branch).group(1)
     print("prepare-commit-msg: Prepending [#%s] to commit message" % issue_number)
 
-    with open(commit_msg_filepath, 'r+') as f:
+    with open(commit_msg_filepath, "r+") as f:
         content = f.read()
         f.seek(0, 0)
         f.write("[#%s] %s" % (issue_number, content))

axelrod/eigen.py

@@ -13,24 +13,24 @@
 def _normalise(nvec: numpy.ndarray) -> numpy.ndarray:
     """Normalises the given numpy array."""
     with numpy.errstate(invalid="ignore"):
-        result = nvec / numpy.sqrt(numpy.dot(nvec, nvec))
+        result = nvec / numpy.sqrt((nvec @ nvec))
     return result
 
 
 def _squared_error(vector_1: numpy.ndarray, vector_2: numpy.ndarray) -> float:
     """Computes the squared error between two numpy arrays."""
     diff = vector_1 - vector_2
-    s = numpy.dot(diff, diff)
+    s = diff @ diff
     return numpy.sqrt(s)
 
 
-def _power_iteration(mat: numpy.matrix, initial: numpy.ndarray) -> numpy.ndarray:
+def _power_iteration(mat: numpy.array, initial: numpy.ndarray) -> numpy.ndarray:
     """
     Generator of successive approximations.
 
     Params
     ------
-    mat: numpy.matrix
+    mat: numpy.array
         The matrix to use for multiplication iteration
     initial: numpy.array, None
         The initial state. Will be set to numpy.array([1, 1, ...]) if None
@@ -47,14 +47,14 @@ def _power_iteration(mat: numpy.matrix, initial: numpy.ndarray) -> numpy.ndarray
 
 
 def principal_eigenvector(
-    mat: numpy.matrix, maximum_iterations=1000, max_error=1e-3
+    mat: numpy.array, maximum_iterations=1000, max_error=1e-3
 ) -> Tuple[numpy.ndarray, float]:
     """
     Computes the (normalised) principal eigenvector of the given matrix.
 
     Params
     ------
-    mat: numpy.matrix
+    mat: numpy.array
         The matrix to use for multiplication iteration
     initial: numpy.array, None
         The initial state. Will be set to numpy.array([1, 1, ...]) if None
@@ -71,7 +71,7 @@ def principal_eigenvector(
         Eigenvalue corresonding to the returned eigenvector
     """
 
-    mat_ = numpy.matrix(mat)
+    mat_ = numpy.array(mat)
     size = mat_.shape[0]
     initial = numpy.ones(size)
 
@@ -86,7 +86,7 @@ def principal_eigenvector(
             break
         last = vector
     # Compute the eigenvalue (Rayleigh quotient)
-    eigenvalue = numpy.dot(numpy.dot(mat_, vector), vector) / numpy.dot(vector, vector)
+    eigenvalue = ((mat_ @ vector) @ vector) / (vector @ vector)
     # Liberate the eigenvalue from numpy
     eigenvalue = float(eigenvalue)
     return vector, eigenvalue

axelrod/graph.py

@@ -115,7 +115,7 @@ def cycle(length, directed=False):
     -------
     a Graph object for the cycle
     """
-    edges = [(i, i+1) for i in range(length-1)]
+    edges = [(i, i + 1) for i in range(length - 1)]
     edges.append((length - 1, 0))
     return Graph(edges=edges, directed=directed)
 
@@ -136,7 +136,7 @@ def complete_graph(size, loops=True):
     -------
     a Graph object for the complete graph
     """
-    edges = [(i, j) for i in range(size) for j in range(i+1, size)]
+    edges = [(i, j) for i in range(size) for j in range(i + 1, size)]
     graph = Graph(edges=edges, directed=False)
 
     if loops:

axelrod/moran.py

@@ -156,9 +156,7 @@ def __init__(
         self.fitness_transformation = fitness_transformation
         # Map players to graph vertices
         self.locations = sorted(interaction_graph.vertices)
-        self.index = dict(
-            zip(sorted(interaction_graph.vertices), range(len(players)))
-        )
+        self.index = dict(zip(sorted(interaction_graph.vertices), range(len(players))))
 
     def set_players(self) -> None:
         """Copy the initial players into the first population."""

axelrod/strategies/human.py

@@ -22,8 +22,7 @@ def validate(self, document) -> None:
         text = document.text
 
         if text and text.upper() not in ["C", "D"]:
-            raise ValidationError(message="Action must be C or D",
-                                  cursor_position=0)
+            raise ValidationError(message="Action must be C or D", cursor_position=0)
 
 
 class Human(Player):

axelrod/tests/unit/test_eigen.py

@@ -16,26 +16,28 @@ def test_identity_matrices(self):
             assert_array_almost_equal(evector, _normalise(numpy.ones(size)))
 
     def test_2x2_matrix(self):
-        mat = [[2, 1], [1, 2]]
+        mat = numpy.array([[2, 1], [1, 2]])
         evector, evalue = principal_eigenvector(mat)
         self.assertAlmostEqual(evalue, 3)
         assert_array_almost_equal(evector, numpy.dot(mat, evector) / evalue)
-        assert_array_almost_equal(evector, _normalise([1, 1]))
+        assert_array_almost_equal(evector, _normalise(numpy.array([1, 1])))
 
     def test_3x3_matrix(self):
-        mat = [[1, 2, 0], [-2, 1, 2], [1, 3, 1]]
+        mat = numpy.array([[1, 2, 0], [-2, 1, 2], [1, 3, 1]])
         evector, evalue = principal_eigenvector(
             mat, maximum_iterations=None, max_error=1e-10
         )
         self.assertAlmostEqual(evalue, 3)
         assert_array_almost_equal(evector, numpy.dot(mat, evector) / evalue)
-        assert_array_almost_equal(evector, _normalise([0.5, 0.5, 1]))
+        assert_array_almost_equal(evector, _normalise(numpy.array([0.5, 0.5, 1])))
 
     def test_4x4_matrix(self):
-        mat = [[2, 0, 0, 0], [1, 2, 0, 0], [0, 1, 3, 0], [0, 0, 1, 3]]
+        mat = numpy.array([[2, 0, 0, 0], [1, 2, 0, 0], [0, 1, 3, 0], [0, 0, 1, 3]])
         evector, evalue = principal_eigenvector(
             mat, maximum_iterations=None, max_error=1e-10
         )
         self.assertAlmostEqual(evalue, 3, places=3)
         assert_array_almost_equal(evector, numpy.dot(mat, evector) / evalue)
-        assert_array_almost_equal(evector, _normalise([0, 0, 0, 1]), decimal=4)
+        assert_array_almost_equal(
+            evector, _normalise(numpy.array([0, 0, 0, 1])), decimal=4
+        )

axelrod/tests/unit/test_graph.py

@@ -5,7 +5,6 @@
 
 
 class TestGraph(unittest.TestCase):
-
     def assert_out_mapping(self, g, expected_out_mapping):
         self.assertDictEqual(g.out_mapping, expected_out_mapping)
         for node, out_dict in expected_out_mapping.items():
@@ -97,7 +96,6 @@ def test_add_loops_with_existing_loop_and_using_strings(self):
 
 
 class TestCycle(unittest.TestCase):
-
     def test_length_1_directed(self):
         g = graph.cycle(1, directed=True)
         self.assertEqual(g.vertices, [0])
@@ -124,7 +122,7 @@ def test_length_3_directed(self):
         g = graph.cycle(3, directed=True)
         self.assertEqual(g.vertices, [0, 1, 2])
         self.assertEqual(g.edges, [(0, 1), (1, 2), (2, 0)])
-        
+
     def test_length_3_undirected(self):
         g = graph.cycle(3, directed=False)
         edges = [(0, 1), (1, 0), (1, 2), (2, 1), (2, 0), (0, 2)]
@@ -156,7 +154,6 @@ def test_length_4_undirected(self):
 
 
 class TestComplete(unittest.TestCase):
-
     def test_size_2(self):
         g = graph.complete_graph(2, loops=False)
         self.assertEqual(g.vertices, [0, 1])
@@ -209,7 +206,7 @@ def test_size_2_with_loops(self):
         self.assertEqual(g.vertices, [0, 1])
         self.assertEqual(g.edges, [(0, 1), (1, 0), (0, 0), (1, 1)])
         self.assertEqual(g.directed, False)
-        
+
     def test_size_3_with_loops(self):
         g = graph.complete_graph(3, loops=True)
         self.assertEqual(g.vertices, [0, 1, 2])