Merge from origin

Author: gaffney2010

axelrod/result_set.py

@@ -2,6 +2,7 @@
 import csv
 import itertools
 from multiprocessing import cpu_count
+from typing import List
 import warnings
 
 import numpy as np
@@ -426,7 +427,9 @@ def _build_initial_cooperation_rate(self, interactions_series):
         with warnings.catch_warnings():
             warnings.simplefilter("ignore")
             initial_cooperation_rate = list(
-                np.nan_to_num(np.array(self.initial_cooperation_count) / interactions_array)
+                np.nan_to_num(
+                    np.array(self.initial_cooperation_count) / interactions_array
+                )
             )
             return initial_cooperation_rate
 
@@ -609,6 +612,18 @@ def __eq__(self, other):
             other : axelrod.ResultSet
                 Another results set against which to check equality
         """
+
+        def list_equal_with_nans(v1: List[float], v2: List[float]) -> bool:
+            """Matches lists, accounting for NaNs."""
+            if len(v1) != len(v2):
+                return False
+            for i1, i2 in zip(v1, v2):
+                if np.isnan(i1) and np.isnan(i2):
+                    continue
+                if i1 != i2:
+                    return False
+            return True
+
         return all(
             [
                 self.wins == other.wins,
@@ -628,8 +643,8 @@ def __eq__(self, other):
                 self.cooperating_rating == other.cooperating_rating,
                 self.good_partner_matrix == other.good_partner_matrix,
                 self.good_partner_rating == other.good_partner_rating,
-                self.eigenmoses_rating == other.eigenmoses_rating,
-                self.eigenjesus_rating == other.eigenjesus_rating,
+                list_equal_with_nans(self.eigenmoses_rating, other.eigenmoses_rating),
+                list_equal_with_nans(self.eigenjesus_rating, other.eigenjesus_rating),
             ]
         )
 

axelrod/tests/integration/test_filtering.py

@@ -1,19 +1,19 @@
 import unittest
 import warnings
 
+import axelrod as axl
+from axelrod.tests.property import strategy_lists
+
 from hypothesis import example, given, settings
 from hypothesis.strategies import integers
 
-from axelrod import filtered_strategies, seed, short_run_time_strategies
-from axelrod import Classifiers
-from axelrod.tests.property import strategy_lists
-
 
 class TestFiltersAgainstComprehensions(unittest.TestCase):
     """
     Test that the results of filtering strategies via a filterset dict
     match the results from using a list comprehension.
     """
+
     def setUp(self) -> None:
         # Ignore warnings about classifiers running on instances
         warnings.simplefilter("ignore", category=UserWarning)
@@ -33,9 +33,9 @@ def test_boolean_filtering(self, strategies):
         ]
 
         for classifier in classifiers:
-            comprehension = set(filter(Classifiers[classifier], strategies))
+            comprehension = set(filter(axl.Classifiers[classifier], strategies))
             filterset = {classifier: True}
-        filtered = set(filtered_strategies(filterset, strategies=strategies))
+        filtered = set(axl.filtered_strategies(filterset, strategies=strategies))
         self.assertEqual(comprehension, filtered)
 
     @given(
@@ -48,43 +48,54 @@ def test_boolean_filtering(self, strategies):
         min_memory_depth=float("inf"),
         max_memory_depth=float("inf"),
         memory_depth=float("inf"),
-        strategies=short_run_time_strategies,
+        strategies=axl.short_run_time_strategies,
     )
     @settings(max_examples=5)
     def test_memory_depth_filtering(
-        self, min_memory_depth, max_memory_depth, memory_depth,
-        strategies
+        self, min_memory_depth, max_memory_depth, memory_depth, strategies
     ):
 
         min_comprehension = set(
-            [s for s in strategies if
-             Classifiers["memory_depth"](s) >= min_memory_depth]
+            [
+                s
+                for s in strategies
+                if axl.Classifiers["memory_depth"](s) >= min_memory_depth
+            ]
         )
         min_filterset = {"min_memory_depth": min_memory_depth}
-        min_filtered = set(filtered_strategies(min_filterset,
-                                               strategies=strategies))
+        min_filtered = set(
+            axl.filtered_strategies(min_filterset, strategies=strategies)
+        )
         self.assertEqual(min_comprehension, min_filtered)
 
         max_comprehension = set(
-            [s for s in strategies if
-             Classifiers["memory_depth"](s) <= max_memory_depth]
+            [
+                s
+                for s in strategies
+                if axl.Classifiers["memory_depth"](s) <= max_memory_depth
+            ]
         )
         max_filterset = {"max_memory_depth": max_memory_depth}
-        max_filtered = set(filtered_strategies(max_filterset,
-                                               strategies=strategies))
+        max_filtered = set(
+            axl.filtered_strategies(max_filterset, strategies=strategies)
+        )
         self.assertEqual(max_comprehension, max_filtered)
 
         comprehension = set(
-            [s for s in strategies if
-             Classifiers["memory_depth"](s) == memory_depth]
+            [
+                s
+                for s in strategies
+                if axl.Classifiers["memory_depth"](s) == memory_depth
+            ]
         )
         filterset = {"memory_depth": memory_depth}
-        filtered = set(filtered_strategies(filterset, strategies=strategies))
+        filtered = set(axl.filtered_strategies(filterset, strategies=strategies))
         self.assertEqual(comprehension, filtered)
 
-    @given(seed_=integers(min_value=0, max_value=4294967295),
-           strategies=strategy_lists(min_size=20, max_size=20),
-           )
+    @given(
+        seed_=integers(min_value=0, max_value=4294967295),
+        strategies=strategy_lists(min_size=20, max_size=20),
+    )
     @settings(max_examples=5)
     def test_makes_use_of_filtering(self, seed_, strategies):
         """
@@ -95,16 +106,18 @@ def test_makes_use_of_filtering(self, seed_, strategies):
         classifiers = [["game"], ["length"], ["game", "length"]]
 
         for classifier in classifiers:
-            seed(seed_)
+            axl.seed(seed_)
             comprehension = set(
-                [s for s in strategies if set(classifier).issubset(
-                    set(Classifiers["makes_use_of"](s)))]
+                [
+                    s
+                    for s in strategies
+                    if set(classifier).issubset(set(axl.Classifiers["makes_use_of"](s)))
+                ]
             )
 
-            seed(seed_)
+            axl.seed(seed_)
             filterset = {"makes_use_of": classifier}
-            filtered = set(
-                filtered_strategies(filterset, strategies=strategies))
+            filtered = set(axl.filtered_strategies(filterset, strategies=strategies))
 
             self.assertEqual(
                 comprehension, filtered, msg="classifier: {}".format(classifier)

axelrod/tests/integration/test_matches.py

@@ -1,20 +1,19 @@
 """Tests for some expected match behaviours"""
 import unittest
 
+import axelrod as axl
+from axelrod.tests.property import strategy_lists
+
 from hypothesis import given, settings
 from hypothesis.strategies import integers
 
-import axelrod
-from axelrod import Classifiers
-from axelrod.tests.property import strategy_lists
-
-C, D = axelrod.Action.C, axelrod.Action.D
+C, D = axl.Action.C, axl.Action.D
 
 deterministic_strategies = [
-    s for s in axelrod.short_run_time_strategies if not Classifiers["stochastic"](s())
+    s for s in axl.short_run_time_strategies if not axl.Classifiers["stochastic"](s())
 ]
 stochastic_strategies = [
-    s for s in axelrod.short_run_time_strategies if Classifiers["stochastic"](s())
+    s for s in axl.short_run_time_strategies if axl.Classifiers["stochastic"](s())
 ]
 
 
@@ -30,7 +29,7 @@ def test_outcome_repeats(self, strategies, turns):
         """A test that if we repeat 3 matches with deterministic and well
         behaved strategies then we get the same result"""
         players = [s() for s in strategies]
-        matches = [axelrod.Match(players, turns) for _ in range(3)]
+        matches = [axl.Match(players, turns) for _ in range(3)]
         self.assertEqual(matches[0].play(), matches[1].play())
         self.assertEqual(matches[1].play(), matches[2].play())
 
@@ -47,9 +46,9 @@ def test_outcome_repeats_stochastic(self, strategies, turns, seed):
         same result"""
         results = []
         for _ in range(3):
-            axelrod.seed(seed)
+            axl.seed(seed)
             players = [s() for s in strategies]
-            results.append(axelrod.Match(players, turns).play())
+            results.append(axl.Match(players, turns).play())
 
         self.assertEqual(results[0], results[1])
         self.assertEqual(results[1], results[2])
@@ -58,15 +57,15 @@ def test_matches_with_det_player_for_stochastic_classes(self):
         """A test based on a bug found in the cache.
 
         See: https://github.com/Axelrod-Python/Axelrod/issues/779"""
-        p1 = axelrod.MemoryOnePlayer(four_vector=(0, 0, 0, 0))
-        p2 = axelrod.MemoryOnePlayer(four_vector=(1, 0, 1, 0))
-        p3 = axelrod.MemoryOnePlayer(four_vector=(1, 1, 1, 0))
+        p1 = axl.MemoryOnePlayer(four_vector=(0, 0, 0, 0))
+        p2 = axl.MemoryOnePlayer(four_vector=(1, 0, 1, 0))
+        p3 = axl.MemoryOnePlayer(four_vector=(1, 1, 1, 0))
 
-        m = axelrod.Match((p1, p2), turns=3)
+        m = axl.Match((p1, p2), turns=3)
         self.assertEqual(m.play(), [(C, C), (D, C), (D, D)])
 
-        m = axelrod.Match((p2, p3), turns=3)
+        m = axl.Match((p2, p3), turns=3)
         self.assertEqual(m.play(), [(C, C), (C, C), (C, C)])
 
-        m = axelrod.Match((p1, p3), turns=3)
+        m = axl.Match((p1, p3), turns=3)
         self.assertEqual(m.play(), [(C, C), (D, C), (D, C)])

axelrod/tests/integration/test_names.py

@@ -1,13 +1,13 @@
 import unittest
 
-from axelrod import all_strategies
+import axelrod as axl
 
 
 class TestNames(unittest.TestCase):
     def test_all_strategies_have_names(self):
-        names = [s.name for s in all_strategies if s.name]
-        self.assertEqual(len(names), len(all_strategies))
+        names = [s.name for s in axl.all_strategies if s.name]
+        self.assertEqual(len(names), len(axl.all_strategies))
 
     def test_all_names_are_unique(self):
-        names = set(s.name for s in all_strategies)
-        self.assertEqual(len(names), len(all_strategies))
+        names = set(s.name for s in axl.all_strategies)
+        self.assertEqual(len(names), len(axl.all_strategies))

axelrod/tests/integration/test_sample_tournaments.py

@@ -1,24 +1,24 @@
 import unittest
 
-import axelrod
+import axelrod as axl
 
-C, D = axelrod.Action.C, axelrod.Action.D
+C, D = axl.Action.C, axl.Action.D
 
 
 class TestSampleTournaments(unittest.TestCase):
     @classmethod
     def setUpClass(cls):
-        cls.game = axelrod.Game()
+        cls.game = axl.Game()
 
     @classmethod
     def get_test_outcome(cls, outcome, turns=10):
         # Extract the name of players from the outcome tuples,
         # and initiate the players by getting the classes from axelrod.
         names = [out[0] for out in outcome]
-        players = [getattr(axelrod, n)() for n in names]
+        players = [getattr(axl, n)() for n in names]
 
         # Play the tournament and build the actual outcome tuples.
-        tournament = axelrod.Tournament(
+        tournament = axl.Tournament(
             players=players, game=cls.game, turns=turns, repetitions=1
         )
         results = tournament.play(progress_bar=False)