Add new strategy SelfSteem

axelrod/strategies/_strategies.py

@@ -67,6 +67,7 @@
     Retaliate, Retaliate2, Retaliate3, LimitedRetaliate, LimitedRetaliate2,
     LimitedRetaliate3)
 from .sequence_player import SequencePlayer, ThueMorse, ThueMorseInverse
+from .selfsteem import SelfSteem
 from .shortmem import ShortMem
 from .titfortat import (
     TitForTat, TitFor2Tats, TwoTitsForTat, Bully, SneakyTitForTat,
@@ -210,6 +211,7 @@
     RevisedDowning,
     Ripoff,
     RiskyQLearner,
+    SelfSteem,
     ShortMem,
     Shubik,
     SlowTitForTwoTats,

axelrod/strategies/selfsteem.py

@@ -0,0 +1,49 @@
+from axelrod.actions import Action, Actions
+from axelrod.player import Player
+
+from math import pi, sin
+import random
+
+C, D = Actions.C, Actions.D
+
+
+class SelfSteem(Player):
+    """
+    This strategy is based on the feeling with the same name.
+    It is modeled on the sine curve(f = sin( 2* pi * n / 10 )), which varies
+    with the current iteration.
+
+    If f > 0.95, 'ego' of the algorithm is inflated; always defects.
+    If 0.95 > |f| > 0.3, rational behavior; follows TitForTat algortithm.
+    If 0.3 > f > -0.3; random behavior.
+    If f < -0.95, algorithm is at rock bottom; always cooperates.
+    """
+
+    name = 'SelfSteem'
+    classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'long_run_time': False,
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def strategy(self, opponent: Player) -> Action:
+        turns_number = len(self.history)
+        sine_value =  sin(2*pi*turns_number/10)
+
+        if sine_value > 0.95:
+            return D
+
+        elif abs(sine_value) < 0.95 and abs(sine_value) > 0.3:
+            return opponent.history[-1]
+
+        elif sine_value < 0.3 and sine_value > -0.3:
+            return random.choice((C, D))
+
+        else:
+            return C
+
+

axelrod/tests/unit/test_selfesteem.py

@@ -0,0 +1,37 @@
+"""Tests for the SelfSteem strategy."""
+
+import axelrod
+import random
+from .test_player import TestPlayer
+
+C, D = axelrod.Actions.C, axelrod.Actions.D
+
+class TestSelfSteem(TestPlayer):
+
+    name = "SelfSteem"
+    player = axelrod.SelfSteem
+    expected_classifier = {
+        'memory_depth': 1,
+        'stochastic': False,
+        'makes_use_of': set(),
+        'inspects_source': False,
+        'manipulates_source': False,
+        'manipulates_state': False
+    }
+
+    def test_strategy(self):
+        # Check for f > 0.95
+        self.responses_test([D], [C] * 2 , [C] * 2 )
+        self.responses_test([D], [C] * 13, [C] * 13)
+
+        # Check for f < -0.95
+        self.responses_test([C], [C] * 7, [C] * 7)
+        self.responses_test([C], [C] * 18, [D] * 18)
+
+        # Check for 0.95 > abs(f) > 0.3
+        self.responses_test([C], [C], [C])
+        self.responses_test([D], [C] * 16, [D] * 16)
+        self.responses_test([C], [D] * 9, [C] * 9)
+
+
+