Transposition table - caching states goodness

Thanks to that we are never evaluating same state twice, 
which gives a speed up.

examples/Isola.py

@@ -104,6 +104,15 @@ def set_player_cords(self, player, cords):
     def __repr__(self):
         return '\n'.join(['|'.join(row) for row in self.board]) + '\n'
 
+    def __eq__(self, other):
+        return self.board == other.board
+
+    def __ne__(self, other):
+        return not self.__eq__(self, other)
+
+    def __hash__(self):
+        return hash(tuple(tuple(row) for row in self.board))
+
 
 class IsolaMove(Move):
     def __init__(self, from_x, from_y, step_x, step_y, remove_x, remove_y):

examples/TicTacToe.py

@@ -89,6 +89,15 @@ def count_players_on_lines(self, current_player, next_player):
     def __repr__(self):
         return '\n'.join(['|'.join(row) for row in self.board]) + '\n'
 
+    def __eq__(self, other):
+        return self.board == other.board
+
+    def __ne__(self, other):
+        return not self.__eq__(self, other)
+
+    def __hash__(self):
+        return hash(tuple(tuple(row) for row in self.board))
+
 
 class TicTacToeMove(Move):
     def __init__(self, x, y):
@@ -124,8 +133,8 @@ def read(self):
                              "___"
                              "___")
 
-algorithm_1 = Human(PLAYER_1, PLAYER_2, TicTacToeMoveReader(state))
-algorithm_2 = Minimax(PLAYER_2, PLAYER_1, 1)
+algorithm_1 = Minimax(PLAYER_1, PLAYER_2, 10)
+algorithm_2 = Minimax(PLAYER_2, PLAYER_1, 10)
 
 tester = Tester(state, algorithm_1, algorithm_2)
 tester.start()

gtsa/gtsa.py

@@ -2,6 +2,7 @@ class Algorithm(object):
     def __init__(self, our_symbol, enemy_symbol):
         self.our_symbol = our_symbol
         self.enemy_symbol = enemy_symbol
+        self.state_cache = {}
 
     def get_current_player(self):
         return self.our_symbol
@@ -12,6 +13,14 @@ def get_next_player(self):
     def get_move(self, state):
         raise NotImplementedError("Implement get_move in Algorithm subclass")
 
+    def get_cached_goodness(self, state):
+        key = hash(state)
+        return self.state_cache.get(key, None)
+
+    def set_cached_goodness(self, state, goodness):
+        key = hash(state)
+        self.state_cache[key] = goodness
+
     def __repr__(self):
         return "{} {}".format(self.our_symbol, self.enemy_symbol)
 
@@ -52,6 +61,9 @@ def get_move(self, state):
         return best_move
 
     def _minimax(self, state, depth, analyzed_player):
+        cached_goodness = self.get_cached_goodness(state)
+        if cached_goodness:
+            return cached_goodness
         legal_moves = state.get_legal_moves(analyzed_player)
         if depth <= 0 or state.is_terminal(self.our_symbol, self.enemy_symbol):
             return state.get_goodness(self.our_symbol, self.enemy_symbol)
@@ -71,6 +83,7 @@ def _minimax(self, state, depth, analyzed_player):
                 state.undo_move(move, analyzed_player)
                 if best_goodness > goodness:
                     best_goodness = goodness
+        self.set_cached_goodness(state, best_goodness)
         return best_goodness
 
 
@@ -93,6 +106,15 @@ def is_terminal(self, current_player, next_player):
     def __repr__(self):
         raise NotImplementedError("Implement __repr__ in State subclass")
 
+    def __eq__(self, other):
+        raise NotImplementedError("Implement __eq__ in State subclass")
+
+    def __ne__(self, other):
+        raise NotImplementedError("Implement __ne__ in State subclass")
+
+    def __hash__(self):
+        raise NotImplementedError("Implement __hash__ in State subclass")
+
 
 class Move(object):
     def __repr__(self):
@@ -101,6 +123,12 @@ def __repr__(self):
     def __eq__(self, other):
         raise NotImplementedError("Implement __eq__ in Move subclass")
 
+    def __ne__(self, other):
+        raise NotImplementedError("Implement __ne__ in Move subclass")
+
+    def __hash__(self):
+        raise NotImplementedError("Implement __hash__ in State subclass")
+
 
 class MoveReader(object):
     def __init__(self, state):