Merge pull request #272 from marcharper/220-2

Rebase 220 onto master

Author: drvinceknight

axelrod/eigen.py

@@ -0,0 +1,85 @@
+"""
+Compute the principal eigenvector of a matrix using power iteration.
+
+See also numpy.linalg.eig which calculates all the eigenvalues and
+eigenvectors.
+"""
+
+import numpy
+
+
+def normalise(nvec):
+    """Normalises the given numpy array."""
+    return nvec / numpy.sqrt(numpy.dot(nvec, nvec))
+
+
+def squared_error(vector_1, vector_2, sqrt=True):
+    """Computes the squared error between two numpy arrays."""
+    diff = vector_1 - vector_2
+    s = numpy.dot(diff, diff)
+    if sqrt:
+        return numpy.sqrt(s)
+    return s
+
+
+def power_iteration(mat, initial=None):
+    """
+    Generator of successive approximations.
+
+    Params
+    ------
+    mat: numpy.matrix
+        The matrix to use for multiplication iteration
+    initial: numpy.array, None
+        The initial state. Will be set to numpy.array([1, 1, ...]) if None
+
+    Yields
+    ------
+    Successive powers (mat ^ k) * initial
+    """
+
+    if initial is None:
+        size = mat.shape[0]
+        initial = normalise(numpy.ones(size))
+    vec = initial
+    while True:
+        vec = normalise(numpy.dot(mat, vec))
+        yield vec
+
+
+def principal_eigenvector(mat, maximum_iterations=None, max_error=1e-8):
+    """
+    Computes the (normalised) principal eigenvector of the given matrix.
+
+    Params
+    ------
+    mat: numpy.matrix
+        The matrix to use for multiplication iteration
+    initial: numpy.array, None
+        The initial state. Will be set to numpy.array([1, 1, ...]) if None
+    maximum_iterations: int, None
+        The maximum number of iterations of the approximation
+    max_error: float, 1e-8
+        Exit criterion -- error threshold of the difference of successive steps
+    """
+
+    mat_ = numpy.matrix(mat)
+    size = mat_.shape[0]
+    initial = numpy.ones(size)
+
+    # Power iteration
+    if not maximum_iterations:
+        maximum_iterations = float('inf')
+    last = initial
+    for i, vector in enumerate(power_iteration(mat, initial=initial)):
+        if i > maximum_iterations:
+            break
+        if squared_error(vector, last) < max_error:
+            break
+        last = vector
+    # Compute the eigenvalue (Rayleigh quotient)
+    eigenvalue = numpy.dot(
+        numpy.dot(mat_, vector), vector) / numpy.dot(vector, vector)
+    # Liberate the eigenvalue from numpy
+    eigenvalue = float(eigenvalue)
+    return (vector, eigenvalue)

axelrod/plot.py

@@ -10,11 +10,7 @@
 class Plot(object):
 
     def __init__(self, result_set):
-        if result_set._finalised:
-            self.result_set = result_set
-        else:
-            raise AttributeError(
-                "No payoffs list has been passed to this ResultSet object.")
+        self.result_set = result_set
         # self._nplayers = self.result_set.nplayers
         self.matplotlib_installed = matplotlib_installed
 

axelrod/result_set.py

@@ -22,80 +22,51 @@ def median(lst):
 class ResultSet(object):
     """A class to hold the results of a tournament."""
 
-    unfinalised_error_msg = 'payoffs_list has not been set.'
-
-    def __init__(self, players, turns, repetitions):
+    def __init__(self, players, turns, repetitions, outcome):
         self.players = players
         self.nplayers = len(players)
         self.turns = turns
         self.repetitions = repetitions
-        self._init_results()
-        self._finalised = False
-
-    # payoffs_list is the only property with a setter method.
-    #
-    # Setting payoffs_list calls methods to set all the other
-    # properties on the instance (result, scores, ranking, ranked_names,
-    # payoff_matrix, payoff_stddevs).
-    #
-    # The getter methods on those other properties will return an error
-    # if payoffs_list has not been set.
-
-    @property
-    def payoffs_list(self):
-        return self._payoffs_list
-
-    @payoffs_list.setter
-    def payoffs_list(self, payoffs_list):
-        self._payoffs_list = payoffs_list
-        self._update_results()
-        self._finalised = True
-        self._scores = self._generate_scores()
-        self._normalised_scores = self._generate_normalised_scores()
-        self._ranking = self._generate_ranking(self.scores)
-        self._ranked_names = self._generate_ranked_names(self.ranking)
-        self._payoff_matrix, self._payoff_stddevs = self._generate_payoff_matrix()
-
-    @payoffs_list.deleter
-    def payoffs_list(self):
-        del(self._payoffs_list)
-        self._init_results()
-        self._finalised = False
-
-    @property
-    def results(self):
-        if self._finalised:
-            return self._results
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _init_results(self):
+        self.outcome = outcome
+        self.results = self._results(outcome)
+        if 'payoff' in self.results:
+            self.scores = self._scores(self.results['payoff'])
+            self.normalised_scores = self._normalised_scores(self.scores)
+            self.ranking = self._ranking(self.scores)
+            self.ranked_names = self._ranked_names(self.ranking)
+            self.payoff_matrix, self.payoff_stddevs = (
+                self._payoff_matrix(self.results['payoff']))
+        if 'cooperation' in self.results:
+            self.cooperation = self._cooperation(self.results['cooperation'])
+            self.normalised_cooperation = (
+                self._normalised_cooperation(self.cooperation))
+
+    def _null_matrix(self):
         plist = list(range(self.nplayers))
         replist = list(range(self.repetitions))
-        self._results = [[[0 for r in replist] for j in plist] for i in plist]
-
-    def _update_results(self):
-        for index, payoffs in enumerate(self.payoffs_list):
-            for i in range(len(self.players)):
-                for j in range(len(self.players)):
-                    self._results[i][j][index] = payoffs[i][j]
-
-    @property
-    def scores(self):
-        if self._finalised:
-            return self._scores
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _generate_scores(self):
-        """Return normalized scores based on the results.
-
-        Originally there were no self-interactions, so the code here was rewritten
-        to exclude those from the generated score. To include self-interactions,
-        remove the condition on ip and ires and fix the normalization factor.
+        return [[[0 for r in replist] for j in plist] for i in plist]
+
+    def _results(self, outcome):
+        results = {}
+        for result_type, result_list in outcome.items():
+            matrix = self._null_matrix()
+            for index, result_matrix in enumerate(result_list):
+                for i in range(len(self.players)):
+                    for j in range(len(self.players)):
+                        matrix[i][j][index] = result_matrix[i][j]
+                results[result_type] = matrix
+        return results
+
+    def _scores(self, payoff):
+        """Return scores based on the results.
+
+        Originally there were no self-interactions, so the code here was
+        rewritten to exclude those from the generated score. To include
+        self-interactions, remove the condition on ip and ires and fix the
+        normalization factor.
         """
         scores = []
-        for ires, res in enumerate(self.results):
+        for ires, res in enumerate(payoff):
             scores.append([])
             for irep in range(self.repetitions):
                 scores[-1].append(0)
@@ -104,26 +75,12 @@ def _generate_scores(self):
                         scores[-1][-1] += res[ip][irep]
         return scores
 
-    @property
-    def normalised_scores(self):
-        if self._finalised:
-            return self._normalised_scores
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _generate_normalised_scores(self):
+    def _normalised_scores(self, scores):
         normalisation = self.turns * (self.nplayers - 1)
         return [
-            [1.0 * s / normalisation for s in r] for r in self.scores]
+            [1.0 * s / normalisation for s in r] for r in scores]
 
-    @property
-    def ranking(self):
-        if self._finalised:
-            return self._ranking
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _generate_ranking(self, scores):
+    def _ranking(self, scores):
         """
         Returns a list of players (their index within the
         players list rather than a player instance)
@@ -134,37 +91,16 @@ def _generate_ranking(self, scores):
             key=lambda i: -median(scores[i]))
         return ranking
 
-    @property
-    def ranked_names(self):
-        if self._finalised:
-            return self._ranked_names
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _generate_ranked_names(self, ranking):
+    def _ranked_names(self, ranking):
         """Returns a list of players names sorted by their ranked order."""
         ranked_names = [str(self.players[i]) for i in ranking]
         return ranked_names
 
-    @property
-    def payoff_matrix(self):
-        if self._finalised:
-            return self._payoff_matrix
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    @property
-    def payoff_stddevs(self):
-        if self._finalised:
-            return self._payoff_stddevs
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
-
-    def _generate_payoff_matrix(self):
+    def _payoff_matrix(self, payoff):
         """Returns a per-turn averaged payoff matrix and its stddevs."""
         averages = []
         stddevs = []
-        for res in self.results:
+        for res in payoff:
             averages.append([])
             stddevs.append([])
             for s in res:
@@ -176,15 +112,22 @@ def _generate_payoff_matrix(self):
                 stddevs[-1].append(dev)
         return averages, stddevs
 
+    def _cooperation(self, results):
+        return[[sum(element) for element in row] for row in results]
+
+    def _normalised_cooperation(self, cooperation):
+        normalisation = self.turns * self.repetitions
+        return[
+            [1.0 * element / normalisation for element in row]
+            for row in cooperation]
+
     def csv(self):
-        if self._finalised:
-            csv_string = StringIO()
-            header = ",".join(self.ranked_names) + "\n"
-            csv_string.write(header)
-            writer = csv.writer(csv_string, lineterminator="\n")
-            for irep in range(self.repetitions):
-                data = [self.normalised_scores[rank][irep] for rank in self.ranking]
-                writer.writerow(list(map(str, data)))
-            return csv_string.getvalue()
-        else:
-            raise AttributeError(self.unfinalised_error_msg)
+        csv_string = StringIO()
+        header = ",".join(self.ranked_names) + "\n"
+        csv_string.write(header)
+        writer = csv.writer(csv_string, lineterminator="\n")
+        for irep in range(self.repetitions):
+            data = [self.normalised_scores[rank][irep]
+                    for rank in self.ranking]
+            writer.writerow(list(map(str, data)))
+        return csv_string.getvalue()