MetaWinnerDeterministic and MetaWinnerStochastic

Author: marcharper

axelrod/strategies/__init__.py

@@ -9,10 +9,10 @@
 from .meta import (
     MetaHunter, MetaHunterAggressive, MetaPlayer, MetaMajority,
     MetaMajorityMemoryOne, MetaMajorityFiniteMemory, MetaMajorityLongMemory,
-    MetaMinority, MetaMixer, MetaWinner,
-    MetaWinnerMemoryOne, MetaWinnerFiniteMemory, MetaWinnerLongMemory,
-    MetaWinnerEnsemble, MWEDeterministic, MWEFast, MWEFiniteMemory,
-    MWELongMemory, MWEMemoryOne, MWERandom, MWEStochastic
+    MetaMinority, MetaMixer, MetaWinner, MetaWinnerDeterministic,
+    MetaWinnerEnsemble, MetaWinnerMemoryOne, MetaWinnerFiniteMemory,
+    MetaWinnerLongMemory, MetaWinnerStochastic, MWEDeterministic, MWEFast,
+    MWEFiniteMemory, MWELongMemory, MWEMemoryOne, MWERandom, MWEStochastic
     )
 
 all_strategies += [MetaHunter,
@@ -24,10 +24,12 @@
                    MetaMinority,
                    MetaMixer,
                    MetaWinner,
+                   MetaWinnerDeterministic,
                    MetaWinnerEnsemble,
                    MetaWinnerMemoryOne,
                    MetaWinnerFiniteMemory,
                    MetaWinnerLongMemory,
+                   MetaWinnerStochastic,
                    MWEDeterministic,
                    MWEFast,
                    MWEFiniteMemory,

axelrod/strategies/meta.py

@@ -283,27 +283,39 @@ def __init__(self):
         super(MetaMajorityMemoryOne, self).__init__(team=team)
 
 
-class MetaWinnerMemoryOne(MetaWinner):
-    """MetaWinner with the team of Memory One players"""
+class MetaMajorityFiniteMemory(MetaMajority):
+    """MetaMajority with the team of Finite Memory Players"""
 
-    name = "Meta Winner Memory One"
+    name = "Meta Majority Finite Memory"
 
     @init_args
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier['memory_depth'] <= 1]
-        super(MetaWinnerMemoryOne, self).__init__(team=team)
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
+                < float('inf')]
+        super(MetaMajorityFiniteMemory, self).__init__(team=team)
 
 
-class MetaMajorityFiniteMemory(MetaMajority):
-    """MetaMajority with the team of Finite Memory Players"""
+class MetaMajorityLongMemory(MetaMajority):
+    """MetaMajority with the team of Long (infinite) Memory Players"""
 
-    name = "Meta Majority Finite Memory"
+    name = "Meta Majority Long Memory"
 
     @init_args
     def __init__(self):
         team = [s for s in ordinary_strategies if s().classifier['memory_depth']
-                < float('inf')]
-        super(MetaMajorityFiniteMemory, self).__init__(team=team)
+                == float('inf')]
+        super(MetaMajorityLongMemory, self).__init__(team=team)
+
+
+class MetaWinnerMemoryOne(MetaWinner):
+    """MetaWinner with the team of Memory One players"""
+
+    name = "Meta Winner Memory One"
+
+    @init_args
+    def __init__(self):
+        team = [s for s in ordinary_strategies if s().classifier['memory_depth'] <= 1]
+        super(MetaWinnerMemoryOne, self).__init__(team=team)
 
 
 class MetaWinnerFiniteMemory(MetaWinner):
@@ -318,28 +330,40 @@ def __init__(self):
         super(MetaWinnerFiniteMemory, self).__init__(team=team)
 
 
-class MetaMajorityLongMemory(MetaMajority):
-    """MetaMajority with the team of Long (infinite) Memory Players"""
+class MetaWinnerLongMemory(MetaWinner):
+    """MetaWinner with the team of Long (infinite) Memory Players"""
 
-    name = "Meta Majority Long Memory"
+    name = "Meta Winner Long Memory"
 
     @init_args
     def __init__(self):
         team = [s for s in ordinary_strategies if s().classifier['memory_depth']
                 == float('inf')]
-        super(MetaMajorityLongMemory, self).__init__(team=team)
+        super(MetaWinnerLongMemory, self).__init__(team=team)
 
 
-class MetaWinnerLongMemory(MetaWinner):
-    """MetaWinner with the team of Long (infinite) Memory Players"""
+class MetaWinnerDeterministic(MetaWinner):
+    """Meta Winner Ensemble with the team of Deterministic Players."""
 
-    name = "Meta Winner Long Memory"
+    name = "Meta Winner Deterministic"
 
     @init_args
     def __init__(self):
-        team = [s for s in ordinary_strategies if s().classifier['memory_depth']
-                == float('inf')]
-        super(MetaWinnerLongMemory, self).__init__(team=team)
+        team = [s for s in ordinary_strategies if
+                not s().classifier['stochastic']]
+        super(MetaWinnerDeterministic, self).__init__(team=team)
+
+
+class MetaWinnerStochastic(MetaWinner):
+    """Meta Winner Ensemble with the team of Stochastic Players."""
+
+    name = "Meta Winner Stochastic"
+
+    @init_args
+    def __init__(self):
+        team = [s for s in ordinary_strategies if
+                s().classifier['stochastic']]
+        super(MetaWinnerStochastic, self).__init__(team=team)
 
 
 class MetaMixer(MetaPlayer):

axelrod/tests/unit/test_meta.py

@@ -270,15 +270,15 @@ def test_strategy(self):
         self.first_play_test(C)
 
 
-class TestMetaWinnerMemoryOne(TestMetaPlayer):
-    name = "Meta Winner Memory One"
-    player = axelrod.MetaWinnerMemoryOne
+class TestMetaMajorityFiniteMemory(TestMetaPlayer):
+    name = "Meta Majority Finite Memory"
+    player = axelrod.MetaMajorityFiniteMemory
     expected_classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': True,
-        'makes_use_of': set(['game']),
         'long_run_time': True,
         'inspects_source': False,
+        'makes_use_of': {'game'},
         'manipulates_source': False,
         'manipulates_state': False
     }
@@ -287,15 +287,32 @@ def test_strategy(self):
         self.first_play_test(C)
 
 
-class TestMetaMajorityFiniteMemory(TestMetaPlayer):
-    name = "Meta Majority Finite Memory"
-    player = axelrod.MetaMajorityFiniteMemory
+class TestMetaMajorityLongMemory(TestMetaPlayer):
+    name = "Meta Majority Long Memory"
+    player = axelrod.MetaMajorityLongMemory
     expected_classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': True,
         'long_run_time': True,
         'inspects_source': False,
-        'makes_use_of': {'game'},
+        'makes_use_of': {'game', 'length'},
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+
+
+class TestMetaWinnerMemoryOne(TestMetaPlayer):
+    name = "Meta Winner Memory One"
+    player = axelrod.MetaWinnerMemoryOne
+    expected_classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': True,
+        'makes_use_of': set(['game']),
+        'long_run_time': True,
+        'inspects_source': False,
         'manipulates_source': False,
         'manipulates_state': False
     }
@@ -321,9 +338,9 @@ def test_strategy(self):
         self.first_play_test(C)
 
 
-class TestMetaMajorityLongMemory(TestMetaPlayer):
-    name = "Meta Majority Long Memory"
-    player = axelrod.MetaMajorityLongMemory
+class TestMetaWinnerLongMemory(TestMetaPlayer):
+    name = "Meta Winner Long Memory"
+    player = axelrod.MetaWinnerLongMemory
     expected_classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': True,
@@ -338,9 +355,26 @@ def test_strategy(self):
         self.first_play_test(C)
 
 
-class TestMetaWinnerLongMemory(TestMetaPlayer):
-    name = "Meta Winner Long Memory"
-    player = axelrod.MetaWinnerLongMemory
+class TestMetaWinnerDeterministic(TestMetaPlayer):
+    name = "Meta Winner Deterministic"
+    player = axelrod.MetaWinnerDeterministic
+    expected_classifier = {
+        'memory_depth': float('inf'),  # Long memory
+        'stochastic': False,
+        'long_run_time': True,
+        'inspects_source': False,
+        'makes_use_of': {'game', 'length'},
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        self.first_play_test(C)
+
+
+class TestMetaWinnerStochastic(TestMetaPlayer):
+    name = "Meta Winner Stochastic"
+    player = axelrod.MetaWinnerStochastic
     expected_classifier = {
         'memory_depth': float('inf'),  # Long memory
         'stochastic': True,

docs/tutorials/advanced/classification_of_strategies.rst

@@ -47,7 +47,7 @@ strategies::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    56
+    57
 
 
 Or, to find out how many strategies only use 1 turn worth of memory to
@@ -81,7 +81,7 @@ length of each match of the tournament::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    17
+    19
 
 Note that in the filterset dictionary, the value for the 'makes_use_of' key
 must be a list. Here is how we might identify the number of strategies that use
@@ -92,7 +92,7 @@ both the length of the tournament and the game being played::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    11
+    13
 
 Some strategies have been classified as having a particularly long run time::
 
@@ -101,7 +101,7 @@ Some strategies have been classified as having a particularly long run time::
     ... }
     >>> strategies = axl.filtered_strategies(filterset)
     >>> len(strategies)
-    18
+    20
 
 Strategies that :code:`manipulate_source`, :code:`manipulate_state`
 and/or :code:`inspect_source` return :code:`False` for the :code:`obey_axelrod`