From 5119d47d0f00c3f7203cf94460730b59a7e473ec Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Tue, 7 Jul 2015 18:55:32 +0200
Subject: add disable_backend_warning property

Users can now disable the warning messages produced when the cython backend is
not available by writing
spk.disable_backend_warning = True
in the beginning
---
 pyspike/DiscreteFunc.py | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

(limited to 'pyspike/DiscreteFunc.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index 17153ee..a8c054e 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -6,6 +6,7 @@ from __future__ import print_function
 
 import numpy as np
 import collections
+import pyspike
 
 
 ##############################################################
@@ -202,7 +203,8 @@ class DiscreteFunc(object):
             from cython.cython_add import add_discrete_function_cython as \
                 add_discrete_function_impl
         except ImportError:
-            print("Warning: add_discrete_function_cython not found. Make \
+            if not(pyspike.disable_backend_warning):
+                print("Warning: add_discrete_function_cython not found. Make \
 sure that PySpike is installed by running\n\
 'python setup.py build_ext --inplace'! \
 \n Falling back to slow python backend.")
-- 
cgit v1.2.3


From 0d7255c1fb7398720de10653efee617075c30892 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 17 Aug 2015 15:05:08 +0200
Subject: fix for #14

test case and fix for Issue #14. Spike-Sync function now correctly deal with
empty intervals as well.
---
 pyspike/DiscreteFunc.py | 43 +++++++++++++++++++++++--------------------
 test/test_empty.py      | 12 ++++++++++++
 2 files changed, 35 insertions(+), 20 deletions(-)

(limited to 'pyspike/DiscreteFunc.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index a8c054e..4fd496d 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -137,9 +137,8 @@ class DiscreteFunc(object):
         :rtype: pair of float
         """
 
-        if len(self.y) <= 2:
-            # no actual values in the profile, return spike sync of 1
-            return 1.0, 1.0
+        value = 0.0
+        multiplicity = 0.0
 
         def get_indices(ival):
             """ Retuns the indeces surrounding the given interval"""
@@ -152,25 +151,29 @@ class DiscreteFunc(object):
         if interval is None:
             # no interval given, integrate over the whole spike train
             # don't count the first value, which is zero by definition
-            return (1.0 * np.sum(self.y[1:-1]), np.sum(self.mp[1:-1]))
-
-        # check if interval is as sequence
-        assert isinstance(interval, collections.Sequence), \
-            "Invalid value for `interval`. None, Sequence or Tuple expected."
-        # check if interval is a sequence of intervals
-        if not isinstance(interval[0], collections.Sequence):
-            # find the indices corresponding to the interval
-            start_ind, end_ind = get_indices(interval)
-            return (np.sum(self.y[start_ind:end_ind]),
-                    np.sum(self.mp[start_ind:end_ind]))
+            value = 1.0 * np.sum(self.y[1:-1])
+            multiplicity = np.sum(self.mp[1:-1])
         else:
-            value = 0.0
-            multiplicity = 0.0
-            for ival in interval:
+            # check if interval is as sequence
+            assert isinstance(interval, collections.Sequence), \
+                "Invalid value for `interval`. None, Sequence or Tuple \
+expected."
+            # check if interval is a sequence of intervals
+            if not isinstance(interval[0], collections.Sequence):
                 # find the indices corresponding to the interval
-                start_ind, end_ind = get_indices(ival)
-                value += np.sum(self.y[start_ind:end_ind])
-                multiplicity += np.sum(self.mp[start_ind:end_ind])
+                start_ind, end_ind = get_indices(interval)
+                value = np.sum(self.y[start_ind:end_ind])
+                multiplicity = np.sum(self.mp[start_ind:end_ind])
+            else:
+                for ival in interval:
+                    # find the indices corresponding to the interval
+                    start_ind, end_ind = get_indices(ival)
+                    value += np.sum(self.y[start_ind:end_ind])
+                    multiplicity += np.sum(self.mp[start_ind:end_ind])
+        if multiplicity == 0.0:
+            # empty profile, return spike sync of 1
+            value = 1.0
+            multiplicity = 1.0
         return (value, multiplicity)
 
     def avrg(self, interval=None):
diff --git a/test/test_empty.py b/test/test_empty.py
index 48be25d..af7fb36 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -139,6 +139,18 @@ def test_spike_sync_empty():
     assert_array_almost_equal(prof.x, [0.0, 0.2, 0.8, 1.0], decimal=15)
     assert_array_almost_equal(prof.y, [0.0, 0.0, 0.0, 0.0], decimal=15)
 
+    # test with empty intervals
+    st1 = SpikeTrain([2.0, 5.0], [0, 10.0])
+    st2 = SpikeTrain([2.1, 7.0], [0, 10.0])
+    st3 = SpikeTrain([5.1, 6.0], [0, 10.0])
+    res = spk.spike_sync_profile(st1, st2).avrg(interval=[3.0, 4.0])
+    assert_equal(res, 1.0)
+    res = spk.spike_sync(st1, st2, interval=[3.0, 4.0])
+    assert_equal(res, 1.0)
+
+    sync_matrix = spk.spike_sync_matrix([st1, st2, st3], interval=[3.0, 4.0])
+    assert_array_equal(sync_matrix, np.ones((3, 3)) - np.diag(np.ones(3)))
+
 
 if __name__ == "__main__":
     test_get_non_empty()
-- 
cgit v1.2.3


From 083a75679a2b15cceb13fa80ff1bb9277bd729d5 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 17 Aug 2015 17:48:06 +0200
Subject: major renaming of spike train order functions

---
 pyspike/DiscreteFunc.py                            |   7 +-
 pyspike/directionality/__init__.py                 |  12 +-
 .../cython/cython_directionality.pyx               |  24 +-
 pyspike/directionality/spike_delay_asymmetry.py    | 266 ---------------------
 pyspike/directionality/spike_train_order.py        | 265 ++++++++++++++++++++
 test/test_spike_delay_asymmetry.py                 |   9 +-
 6 files changed, 292 insertions(+), 291 deletions(-)
 delete mode 100644 pyspike/directionality/spike_delay_asymmetry.py
 create mode 100644 pyspike/directionality/spike_train_order.py

(limited to 'pyspike/DiscreteFunc.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index 4fd496d..9cc7bd5 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -176,7 +176,7 @@ expected."
             multiplicity = 1.0
         return (value, multiplicity)
 
-    def avrg(self, interval=None):
+    def avrg(self, interval=None, normalize=True):
         """ Computes the average of the interval sequence:
         :math:`a = 1/N \\sum f_n` where N is the number of intervals.
 
@@ -189,7 +189,10 @@ expected."
         :rtype: float
         """
         val, mp = self.integral(interval)
-        return val/mp
+        if normalize:
+            return val/mp
+        else:
+            return val
 
     def add(self, f):
         """ Adds another `DiscreteFunc` function to this function.
diff --git a/pyspike/directionality/__init__.py b/pyspike/directionality/__init__.py
index 9a45b54..6f74c50 100644
--- a/pyspike/directionality/__init__.py
+++ b/pyspike/directionality/__init__.py
@@ -4,10 +4,10 @@ Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
 Distributed under the BSD License
 """
 
-__all__ = ["spike_delay_asymmetry"]
+__all__ = ["spike_train_order"]
 
-from spike_delay_asymmetry import spike_delay_asymmetry_profile, \
-    spike_delay_asymmetry, spike_delay_asymmetry_profile_multi, \
-    spike_delay_asymmetry_matrix, spike_delay_asymmetry_full, \
-    optimal_asymmetry_order, optimal_asymmetry_order_from_D, \
-    permutate_asymmetry_matrix
+from spike_train_order import spike_train_order_profile, \
+    spike_train_order, spike_train_order_profile_multi, \
+    spike_train_order_matrix, spike_order_values, \
+    optimal_spike_train_order, optimal_spike_train_order_from_matrix, \
+    permutate_matrix
diff --git a/pyspike/directionality/cython/cython_directionality.pyx b/pyspike/directionality/cython/cython_directionality.pyx
index 3936372..e1f63c4 100644
--- a/pyspike/directionality/cython/cython_directionality.pyx
+++ b/pyspike/directionality/cython/cython_directionality.pyx
@@ -61,11 +61,11 @@ cdef inline double get_tau(double[:] spikes1, double[:] spikes2,
 
 
 ############################################################
-# spike_delay_asymmetry_profile_cython
+# spike_train_order_profile_cython
 ############################################################
-def spike_delay_asymmetry_profile_cython(double[:] spikes1, double[:] spikes2,
-                                         double t_start, double t_end,
-                                         double max_tau):
+def spike_train_order_profile_cython(double[:] spikes1, double[:] spikes2,
+                                     double t_start, double t_end,
+                                     double max_tau):
 
     cdef int N1 = len(spikes1)
     cdef int N2 = len(spikes2)
@@ -130,12 +130,12 @@ def spike_delay_asymmetry_profile_cython(double[:] spikes1, double[:] spikes2,
 
 
 ############################################################
-# spike_delay_dual_profile_cython
+# spike_order_values_cython
 ############################################################
-def spike_delay_dual_profile_cython(double[:] spikes1,
-                                    double[:] spikes2,
-                                    double t_start, double t_end,
-                                    double max_tau):
+def spike_order_values_cython(double[:] spikes1,
+                              double[:] spikes2,
+                              double t_start, double t_end,
+                              double max_tau):
 
     cdef int N1 = len(spikes1)
     cdef int N2 = len(spikes2)
@@ -176,10 +176,10 @@ def spike_delay_dual_profile_cython(double[:] spikes1,
 
 
 ############################################################
-# spike_delay_asymmetry_cython
+# spike_train_order_cython
 ############################################################
-def spike_delay_asymmetry_cython(double[:] spikes1, double[:] spikes2,
-                                 double t_start, double t_end, double max_tau):
+def spike_train_order_cython(double[:] spikes1, double[:] spikes2,
+                             double t_start, double t_end, double max_tau):
 
     cdef int N1 = len(spikes1)
     cdef int N2 = len(spikes2)
diff --git a/pyspike/directionality/spike_delay_asymmetry.py b/pyspike/directionality/spike_delay_asymmetry.py
deleted file mode 100644
index 7da49ee..0000000
--- a/pyspike/directionality/spike_delay_asymmetry.py
+++ /dev/null
@@ -1,266 +0,0 @@
-# Module containing functions to compute multivariate spike delay asymmetry
-# Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
-# Distributed under the BSD License
-
-import numpy as np
-from math import exp
-from functools import partial
-# import pyspike
-from pyspike import DiscreteFunc
-from pyspike.generic import _generic_profile_multi
-
-
-############################################################
-# spike_delay_asymmetry_profile
-############################################################
-def spike_delay_asymmetry_profile(spike_train1, spike_train2, max_tau=None):
-    """ Computes the spike delay asymmetry profile A(t) of the two given
-    spike trains. Returns the profile as a DiscreteFunction object.
-
-    :param spike_train1: First spike train.
-    :type spike_train1: :class:`pyspike.SpikeTrain`
-    :param spike_train2: Second spike train.
-    :type spike_train2: :class:`pyspike.SpikeTrain`
-    :param max_tau: Maximum coincidence window size. If 0 or `None`, the
-                    coincidence window has no upper bound.
-    :returns: The spike-distance profile :math:`S_{sync}(t)`.
-    :rtype: :class:`pyspike.function.DiscreteFunction`
-
-    """
-    # check whether the spike trains are defined for the same interval
-    assert spike_train1.t_start == spike_train2.t_start, \
-        "Given spike trains are not defined on the same interval!"
-    assert spike_train1.t_end == spike_train2.t_end, \
-        "Given spike trains are not defined on the same interval!"
-
-    # cython implementation
-    try:
-        from cython.cython_directionality import \
-            spike_delay_asymmetry_profile_cython as \
-            spike_delay_asymmetry_profile_impl
-    except ImportError:
-        raise NotImplementedError()
-#         if not(pyspike.disable_backend_warning):
-#             print("Warning: spike_distance_cython not found. Make sure that \
-# PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
-# Falling back to slow python backend.")
-#         # use python backend
-#         from cython.python_backend import coincidence_python \
-#             as coincidence_profile_impl
-
-    if max_tau is None:
-        max_tau = 0.0
-
-    times, coincidences, multiplicity \
-        = spike_delay_asymmetry_profile_impl(spike_train1.spikes,
-                                             spike_train2.spikes,
-                                             spike_train1.t_start,
-                                             spike_train1.t_end,
-                                             max_tau)
-
-    return DiscreteFunc(times, coincidences, multiplicity)
-
-
-############################################################
-# spike_delay_asymmetry
-############################################################
-def spike_delay_asymmetry(spike_train1, spike_train2, normalize=True,
-                          interval=None, max_tau=None):
-    """ Computes the overall spike delay asymmetry value for two spike trains.
-    """
-    if interval is None:
-        # distance over the whole interval is requested: use specific function
-        # for optimal performance
-        try:
-            from cython.cython_directionality import \
-                spike_delay_asymmetry_cython as spike_delay_impl
-            if max_tau is None:
-                max_tau = 0.0
-            c, mp = spike_delay_impl(spike_train1.spikes,
-                                     spike_train2.spikes,
-                                     spike_train1.t_start,
-                                     spike_train1.t_end,
-                                     max_tau)
-            if normalize:
-                return 1.0*c/mp
-            else:
-                return c
-        except ImportError:
-            # Cython backend not available: fall back to profile averaging
-            raise NotImplementedError()
-            # return spike_sync_profile(spike_train1, spike_train2,
-            #                           max_tau).integral(interval)
-    else:
-        # some specific interval is provided: not yet implemented
-        raise NotImplementedError()
-
-
-############################################################
-# spike_delay_asymmetry_profile_multi
-############################################################
-def spike_delay_asymmetry_profile_multi(spike_trains, indices=None,
-                                        max_tau=None):
-    """ Computes the multi-variate spike delay asymmetry profile for a set of
-    spike trains. For each spike in the set of spike trains, the multi-variate
-    profile is defined as the sum of asymmetry values divided by the number of
-    spike trains pairs involving the spike train of containing this spike,
-    which is the number of spike trains minus one (N-1).
-
-    :param spike_trains: list of :class:`pyspike.SpikeTrain`
-    :param indices: list of indices defining which spike trains to use,
-                    if None all given spike trains are used (default=None)
-    :type indices: list or None
-    :param max_tau: Maximum coincidence window size. If 0 or `None`, the
-                    coincidence window has no upper bound.
-    :returns: The multi-variate spike sync profile :math:`<S_{sync}>(t)`
-    :rtype: :class:`pyspike.function.DiscreteFunction`
-
-    """
-    prof_func = partial(spike_delay_asymmetry_profile, max_tau=max_tau)
-    average_prof, M = _generic_profile_multi(spike_trains, prof_func,
-                                             indices)
-    # average_dist.mul_scalar(1.0/M)  # no normalization here!
-    return average_prof
-
-
-############################################################
-# spike_delay_asymmetry_matrix
-############################################################
-def spike_delay_asymmetry_matrix(spike_trains, normalize=True, indices=None,
-                                 interval=None, max_tau=None):
-    """ Computes the spike delay asymmetry matrix for the given spike trains.
-    """
-    if indices is None:
-        indices = np.arange(len(spike_trains))
-    indices = np.array(indices)
-    # check validity of indices
-    assert (indices < len(spike_trains)).all() and (indices >= 0).all(), \
-        "Invalid index list."
-    # generate a list of possible index pairs
-    pairs = [(indices[i], j) for i in range(len(indices))
-             for j in indices[i+1:]]
-
-    distance_matrix = np.zeros((len(indices), len(indices)))
-    for i, j in pairs:
-        d = spike_delay_asymmetry(spike_trains[i], spike_trains[j], normalize,
-                                  interval, max_tau=max_tau)
-        distance_matrix[i, j] = d
-        distance_matrix[j, i] = -d
-    return distance_matrix
-
-
-############################################################
-# spike_delay_asymmetry_full
-############################################################
-def spike_delay_asymmetry_full(spike_trains, indices=None,
-                               interval=None, max_tau=None):
-    """ Computes the spike train symmetry value for each spike in each spike
-    train.
-    """
-    if indices is None:
-        indices = np.arange(len(spike_trains))
-    indices = np.array(indices)
-    # check validity of indices
-    assert (indices < len(spike_trains)).all() and (indices >= 0).all(), \
-        "Invalid index list."
-    # list of arrays for reulting asymmetry values
-    asymmetry_list = [np.zeros_like(st.spikes) for st in spike_trains]
-    # generate a list of possible index pairs
-    pairs = [(indices[i], j) for i in range(len(indices))
-             for j in indices[i+1:]]
-
-    # cython implementation
-    try:
-        from cython.cython_directionality import \
-            spike_delay_dual_profile_cython as \
-            sda_dual_profile_impl
-    except ImportError:
-        raise NotImplementedError()
-#         if not(pyspike.disable_backend_warning):
-#             print("Warning: spike_distance_cython not found. Make sure that \
-# PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
-# Falling back to slow python backend.")
-#         # use python backend
-#         from cython.python_backend import coincidence_python \
-#             as coincidence_profile_impl
-
-    if max_tau is None:
-        max_tau = 0.0
-
-    for i, j in pairs:
-        a1, a2 = sda_dual_profile_impl(spike_trains[i].spikes,
-                                       spike_trains[j].spikes,
-                                       spike_trains[i].t_start,
-                                       spike_trains[i].t_end,
-                                       max_tau)
-        asymmetry_list[i] += a1
-        asymmetry_list[j] += a2
-    for a in asymmetry_list:
-        a /= len(spike_trains)-1
-    return asymmetry_list
-
-
-############################################################
-# optimal_asymmetry_order_from_D
-############################################################
-def optimal_asymmetry_order_from_D(D, full_output=False):
-    """ finds the best sorting via simulated annealing.
-    Returns the optimal permutation p and A value.
-    Internal function, don't call directly! Use optimal_asymmetry_order
-    instead.
-    """
-    N = len(D)
-    A = np.sum(np.triu(D, 0))
-
-    p = np.arange(N)
-
-    T = 2*np.max(D)    # starting temperature
-    T_end = 1E-5 * T   # final temperature
-    alpha = 0.9        # cooling factor
-    total_iter = 0
-    while T > T_end:
-        iterations = 0
-        succ_iter = 0
-        while iterations < 100*N and succ_iter < 10*N:
-            # exchange two rows and cols
-            ind1 = np.random.randint(N-1)
-            delta_A = -2*D[p[ind1], p[ind1+1]]
-            if delta_A > 0.0 or exp(delta_A/T) > np.random.random():
-                # swap indices
-                p[ind1], p[ind1+1] = p[ind1+1], p[ind1]
-                A += delta_A
-                succ_iter += 1
-            iterations += 1
-        total_iter += iterations
-        T *= alpha   # cool down
-        if succ_iter == 0:
-            break
-    if full_output:
-        return p, A, total_iter
-    else:
-        return p, A
-
-
-############################################################
-# optimal_asymmetry_order
-############################################################
-def optimal_asymmetry_order(spike_trains,  indices=None, interval=None,
-                            max_tau=None, full_output=False):
-    """ finds the best sorting of the given spike trains via simulated
-    annealing.
-    Returns the optimal permutation p and A value.
-    """
-    D = spike_delay_asymmetry_matrix(spike_trains, indices, interval, max_tau)
-    return optimal_asymmetry_order_from_D(D, full_output)
-
-
-############################################################
-# reorder_asymmetry_matrix
-############################################################
-def permutate_asymmetry_matrix(D, p):
-    N = len(D)
-    D_p = np.empty_like(D)
-    for n in xrange(N):
-        for m in xrange(N):
-            D_p[n, m] = D[p[n], p[m]]
-    return D_p
diff --git a/pyspike/directionality/spike_train_order.py b/pyspike/directionality/spike_train_order.py
new file mode 100644
index 0000000..f8c8615
--- /dev/null
+++ b/pyspike/directionality/spike_train_order.py
@@ -0,0 +1,265 @@
+# Module containing functions to compute multivariate spike train order
+# Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
+# Distributed under the BSD License
+
+import numpy as np
+from math import exp
+from functools import partial
+# import pyspike
+from pyspike import DiscreteFunc
+from pyspike.generic import _generic_profile_multi
+
+
+############################################################
+# spike_train_order_profile
+############################################################
+def spike_train_order_profile(spike_train1, spike_train2, max_tau=None):
+    """ Computes the spike delay asymmetry profile A(t) of the two given
+    spike trains. Returns the profile as a DiscreteFunction object.
+
+    :param spike_train1: First spike train.
+    :type spike_train1: :class:`pyspike.SpikeTrain`
+    :param spike_train2: Second spike train.
+    :type spike_train2: :class:`pyspike.SpikeTrain`
+    :param max_tau: Maximum coincidence window size. If 0 or `None`, the
+                    coincidence window has no upper bound.
+    :returns: The spike-distance profile :math:`S_{sync}(t)`.
+    :rtype: :class:`pyspike.function.DiscreteFunction`
+
+    """
+    # check whether the spike trains are defined for the same interval
+    assert spike_train1.t_start == spike_train2.t_start, \
+        "Given spike trains are not defined on the same interval!"
+    assert spike_train1.t_end == spike_train2.t_end, \
+        "Given spike trains are not defined on the same interval!"
+
+    # cython implementation
+    try:
+        from cython.cython_directionality import \
+            spike_train_order_profile_cython as \
+            spike_train_order_profile_impl
+    except ImportError:
+        raise NotImplementedError()
+#         if not(pyspike.disable_backend_warning):
+#             print("Warning: spike_distance_cython not found. Make sure that \
+# PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
+# Falling back to slow python backend.")
+#         # use python backend
+#         from cython.python_backend import coincidence_python \
+#             as coincidence_profile_impl
+
+    if max_tau is None:
+        max_tau = 0.0
+
+    times, coincidences, multiplicity \
+        = spike_train_order_profile_impl(spike_train1.spikes,
+                                         spike_train2.spikes,
+                                         spike_train1.t_start,
+                                         spike_train1.t_end,
+                                         max_tau)
+
+    return DiscreteFunc(times, coincidences, multiplicity)
+
+
+############################################################
+# spike_train_order
+############################################################
+def spike_train_order(spike_train1, spike_train2, normalize=True,
+                      interval=None, max_tau=None):
+    """ Computes the overall spike delay asymmetry value for two spike trains.
+    """
+    if interval is None:
+        # distance over the whole interval is requested: use specific function
+        # for optimal performance
+        try:
+            from cython.cython_directionality import \
+                spike_train_order_cython as spike_train_order_impl
+            if max_tau is None:
+                max_tau = 0.0
+            c, mp = spike_train_order_impl(spike_train1.spikes,
+                                           spike_train2.spikes,
+                                           spike_train1.t_start,
+                                           spike_train1.t_end,
+                                           max_tau)
+            if normalize:
+                return 1.0*c/mp
+            else:
+                return c
+        except ImportError:
+            # Cython backend not available: fall back to profile averaging
+            raise NotImplementedError()
+            # return spike_sync_profile(spike_train1, spike_train2,
+            #                           max_tau).integral(interval)
+    else:
+        # some specific interval is provided: not yet implemented
+        raise NotImplementedError()
+
+
+############################################################
+# spike_train_order_profile_multi
+############################################################
+def spike_train_order_profile_multi(spike_trains, indices=None,
+                                    max_tau=None):
+    """ Computes the multi-variate spike delay asymmetry profile for a set of
+    spike trains. For each spike in the set of spike trains, the multi-variate
+    profile is defined as the sum of asymmetry values divided by the number of
+    spike trains pairs involving the spike train of containing this spike,
+    which is the number of spike trains minus one (N-1).
+
+    :param spike_trains: list of :class:`pyspike.SpikeTrain`
+    :param indices: list of indices defining which spike trains to use,
+                    if None all given spike trains are used (default=None)
+    :type indices: list or None
+    :param max_tau: Maximum coincidence window size. If 0 or `None`, the
+                    coincidence window has no upper bound.
+    :returns: The multi-variate spike sync profile :math:`<S_{sync}>(t)`
+    :rtype: :class:`pyspike.function.DiscreteFunction`
+
+    """
+    prof_func = partial(spike_train_order_profile, max_tau=max_tau)
+    average_prof, M = _generic_profile_multi(spike_trains, prof_func,
+                                             indices)
+    # average_dist.mul_scalar(1.0/M)  # no normalization here!
+    return average_prof
+
+
+############################################################
+# spike_train_order_matrix
+############################################################
+def spike_train_order_matrix(spike_trains, normalize=True, indices=None,
+                             interval=None, max_tau=None):
+    """ Computes the spike delay asymmetry matrix for the given spike trains.
+    """
+    if indices is None:
+        indices = np.arange(len(spike_trains))
+    indices = np.array(indices)
+    # check validity of indices
+    assert (indices < len(spike_trains)).all() and (indices >= 0).all(), \
+        "Invalid index list."
+    # generate a list of possible index pairs
+    pairs = [(indices[i], j) for i in range(len(indices))
+             for j in indices[i+1:]]
+
+    distance_matrix = np.zeros((len(indices), len(indices)))
+    for i, j in pairs:
+        d = spike_train_order(spike_trains[i], spike_trains[j], normalize,
+                              interval, max_tau=max_tau)
+        distance_matrix[i, j] = d
+        distance_matrix[j, i] = -d
+    return distance_matrix
+
+
+############################################################
+# spike_order_values
+############################################################
+def spike_order_values(spike_trains, indices=None,
+                       interval=None, max_tau=None):
+    """ Computes the spike train symmetry value for each spike in each spike
+    train.
+    """
+    if indices is None:
+        indices = np.arange(len(spike_trains))
+    indices = np.array(indices)
+    # check validity of indices
+    assert (indices < len(spike_trains)).all() and (indices >= 0).all(), \
+        "Invalid index list."
+    # list of arrays for reulting asymmetry values
+    asymmetry_list = [np.zeros_like(st.spikes) for st in spike_trains]
+    # generate a list of possible index pairs
+    pairs = [(indices[i], j) for i in range(len(indices))
+             for j in indices[i+1:]]
+
+    # cython implementation
+    try:
+        from cython.cython_directionality import \
+            spike_order_values_cython as spike_order_values_impl
+    except ImportError:
+        raise NotImplementedError()
+#         if not(pyspike.disable_backend_warning):
+#             print("Warning: spike_distance_cython not found. Make sure that \
+# PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
+# Falling back to slow python backend.")
+#         # use python backend
+#         from cython.python_backend import coincidence_python \
+#             as coincidence_profile_impl
+
+    if max_tau is None:
+        max_tau = 0.0
+
+    for i, j in pairs:
+        a1, a2 = spike_order_values_impl(spike_trains[i].spikes,
+                                         spike_trains[j].spikes,
+                                         spike_trains[i].t_start,
+                                         spike_trains[i].t_end,
+                                         max_tau)
+        asymmetry_list[i] += a1
+        asymmetry_list[j] += a2
+    for a in asymmetry_list:
+        a /= len(spike_trains)-1
+    return asymmetry_list
+
+
+############################################################
+# optimal_asymmetry_order_from_matrix
+############################################################
+def optimal_spike_train_order_from_matrix(D, full_output=False):
+    """ finds the best sorting via simulated annealing.
+    Returns the optimal permutation p and A value.
+    Internal function, don't call directly! Use optimal_asymmetry_order
+    instead.
+    """
+    N = len(D)
+    A = np.sum(np.triu(D, 0))
+
+    p = np.arange(N)
+
+    T = 2*np.max(D)    # starting temperature
+    T_end = 1E-5 * T   # final temperature
+    alpha = 0.9        # cooling factor
+    total_iter = 0
+    while T > T_end:
+        iterations = 0
+        succ_iter = 0
+        while iterations < 100*N and succ_iter < 10*N:
+            # exchange two rows and cols
+            ind1 = np.random.randint(N-1)
+            delta_A = -2*D[p[ind1], p[ind1+1]]
+            if delta_A > 0.0 or exp(delta_A/T) > np.random.random():
+                # swap indices
+                p[ind1], p[ind1+1] = p[ind1+1], p[ind1]
+                A += delta_A
+                succ_iter += 1
+            iterations += 1
+        total_iter += iterations
+        T *= alpha   # cool down
+        if succ_iter == 0:
+            break
+    if full_output:
+        return p, A, total_iter
+    else:
+        return p, A
+
+
+############################################################
+# optimal_spike_train_order
+############################################################
+def optimal_spike_train_order(spike_trains,  indices=None, interval=None,
+                              max_tau=None, full_output=False):
+    """ finds the best sorting of the given spike trains via simulated
+    annealing.
+    Returns the optimal permutation p and A value.
+    """
+    D = spike_train_order_matrix(spike_trains, indices, interval, max_tau)
+    return optimal_asymmetry_order_from_matrix(D, full_output)
+
+
+############################################################
+# permutate_matrix
+############################################################
+def permutate_matrix(D, p):
+    N = len(D)
+    D_p = np.empty_like(D)
+    for n in xrange(N):
+        for m in xrange(N):
+            D_p[n, m] = D[p[n], p[m]]
+    return D_p
diff --git a/test/test_spike_delay_asymmetry.py b/test/test_spike_delay_asymmetry.py
index 93c18de..9de16e5 100644
--- a/test/test_spike_delay_asymmetry.py
+++ b/test/test_spike_delay_asymmetry.py
@@ -23,13 +23,12 @@ def test_profile():
     expected_y = np.array([1, 1, 1, 1, 1, 0, 0])
     expected_mp = np.array([1, 1, 1, 1, 1, 2, 2])
 
-    f = spk.drct.spike_delay_asymmetry_profile(st1, st2)
+    f = spk.drct.spike_train_order_profile(st1, st2)
 
     assert f.almost_equal(DiscreteFunc(expected_x, expected_y, expected_mp))
     assert_almost_equal(f.avrg(), 2.0/3.0)
-    assert_almost_equal(spk.drct.spike_delay_asymmetry(st1, st2), 2.0/3.0)
-    assert_almost_equal(spk.drct.spike_delay_asymmetry(st1, st2,
-                                                       normalize=False),
+    assert_almost_equal(spk.drct.spike_train_order(st1, st2), 2.0/3.0)
+    assert_almost_equal(spk.drct.spike_train_order(st1, st2, normalize=False),
                         4.0)
 
     st3 = SpikeTrain([105, 195, 500], [0, 1000])
@@ -37,5 +36,5 @@ def test_profile():
     expected_y = np.array([1, 1, 1, -1, -1, 0, 0, 0])
     expected_mp = np.array([1, 1, 1, 1, 1, 1, 1, 1])
 
-    f = spk.drct.spike_delay_asymmetry_profile(st1, st3)
+    f = spk.drct.spike_train_order_profile(st1, st3)
     assert f.almost_equal(DiscreteFunc(expected_x, expected_y, expected_mp))
-- 
cgit v1.2.3


From eeb4918ec2181f136e85bce976ec46a35a74b8f1 Mon Sep 17 00:00:00 2001
From: Igor Gnatenko <i.gnatenko.brain@gmail.com>
Date: Sun, 13 Dec 2015 10:55:30 +0100
Subject: py3: absolute_import

Signed-off-by: Igor Gnatenko <i.gnatenko.brain@gmail.com>
---
 pyspike/DiscreteFunc.py                     |  6 +++---
 pyspike/PieceWiseConstFunc.py               |  6 +++---
 pyspike/PieceWiseLinFunc.py                 |  8 ++++----
 pyspike/__init__.py                         | 22 ++++++++++++----------
 pyspike/directionality/__init__.py          |  4 +++-
 pyspike/directionality/spike_train_order.py | 12 +++++++-----
 pyspike/isi_distance.py                     |  8 +++++---
 pyspike/spike_distance.py                   |  8 +++++---
 pyspike/spike_sync.py                       |  8 +++++---
 9 files changed, 47 insertions(+), 35 deletions(-)

(limited to 'pyspike/DiscreteFunc.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index 9cc7bd5..55c0bc8 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -2,7 +2,7 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
-from __future__ import print_function
+from __future__ import absolute_import, print_function
 
 import numpy as np
 import collections
@@ -206,7 +206,7 @@ expected."
 
         # cython version
         try:
-            from cython.cython_add import add_discrete_function_cython as \
+            from .cython.cython_add import add_discrete_function_cython as \
                 add_discrete_function_impl
         except ImportError:
             if not(pyspike.disable_backend_warning):
@@ -215,7 +215,7 @@ sure that PySpike is installed by running\n\
 'python setup.py build_ext --inplace'! \
 \n Falling back to slow python backend.")
             # use python backend
-            from cython.python_backend import add_discrete_function_python as \
+            from .cython.python_backend import add_discrete_function_python as \
                 add_discrete_function_impl
 
         self.x, self.y, self.mp = \
diff --git a/pyspike/PieceWiseConstFunc.py b/pyspike/PieceWiseConstFunc.py
index 23ff536..5ce5f27 100644
--- a/pyspike/PieceWiseConstFunc.py
+++ b/pyspike/PieceWiseConstFunc.py
@@ -2,7 +2,7 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
-from __future__ import print_function
+from __future__ import absolute_import, print_function
 
 import numpy as np
 import collections
@@ -189,7 +189,7 @@ class PieceWiseConstFunc(object):
 
         # cython version
         try:
-            from cython.cython_add import add_piece_wise_const_cython as \
+            from .cython.cython_add import add_piece_wise_const_cython as \
                 add_piece_wise_const_impl
         except ImportError:
             if not(pyspike.disable_backend_warning):
@@ -198,7 +198,7 @@ sure that PySpike is installed by running\n \
 'python setup.py build_ext --inplace'! \
 \n Falling back to slow python backend.")
             # use python backend
-            from cython.python_backend import add_piece_wise_const_python as \
+            from .cython.python_backend import add_piece_wise_const_python as \
                 add_piece_wise_const_impl
 
         self.x, self.y = add_piece_wise_const_impl(self.x, self.y, f.x, f.y)
diff --git a/pyspike/PieceWiseLinFunc.py b/pyspike/PieceWiseLinFunc.py
index 0d51c76..8145e63 100644
--- a/pyspike/PieceWiseLinFunc.py
+++ b/pyspike/PieceWiseLinFunc.py
@@ -2,7 +2,7 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
-from __future__ import print_function
+from __future__ import absolute_import, print_function
 
 import numpy as np
 import collections
@@ -222,13 +222,13 @@ class PieceWiseLinFunc:
         assert self.x[-1] == f.x[-1], "The functions have different intervals"
 
         # python implementation
-        # from python_backend import add_piece_wise_lin_python
+        # from .python_backend import add_piece_wise_lin_python
         # self.x, self.y1, self.y2 = add_piece_wise_lin_python(
         #     self.x, self.y1, self.y2, f.x, f.y1, f.y2)
 
         # cython version
         try:
-            from cython.cython_add import add_piece_wise_lin_cython as \
+            from .cython.cython_add import add_piece_wise_lin_cython as \
                 add_piece_wise_lin_impl
         except ImportError:
             if not(pyspike.disable_backend_warning):
@@ -237,7 +237,7 @@ sure that PySpike is installed by running\n \
 'python setup.py build_ext --inplace'! \n \
 Falling back to slow python backend.")
             # use python backend
-            from cython.python_backend import add_piece_wise_lin_python as \
+            from .cython.python_backend import add_piece_wise_lin_python as \
                 add_piece_wise_lin_impl
 
         self.x, self.y1, self.y2 = add_piece_wise_lin_impl(
diff --git a/pyspike/__init__.py b/pyspike/__init__.py
index 8d92ea4..335b1d3 100644
--- a/pyspike/__init__.py
+++ b/pyspike/__init__.py
@@ -4,27 +4,29 @@ Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 Distributed under the BSD License
 """
 
+from __future__ import absolute_import
+
 __all__ = ["isi_distance", "spike_distance", "spike_sync", "psth",
            "spikes", "SpikeTrain", "PieceWiseConstFunc", "PieceWiseLinFunc",
            "DiscreteFunc", "directionality"]
 
-from PieceWiseConstFunc import PieceWiseConstFunc
-from PieceWiseLinFunc import PieceWiseLinFunc
-from DiscreteFunc import DiscreteFunc
-from SpikeTrain import SpikeTrain
+from .PieceWiseConstFunc import PieceWiseConstFunc
+from .PieceWiseLinFunc import PieceWiseLinFunc
+from .DiscreteFunc import DiscreteFunc
+from .SpikeTrain import SpikeTrain
 
-from isi_distance import isi_profile, isi_distance, isi_profile_multi,\
+from .isi_distance import isi_profile, isi_distance, isi_profile_multi,\
     isi_distance_multi, isi_distance_matrix
-from spike_distance import spike_profile, spike_distance, spike_profile_multi,\
+from .spike_distance import spike_profile, spike_distance, spike_profile_multi,\
     spike_distance_multi, spike_distance_matrix
-from spike_sync import spike_sync_profile, spike_sync,\
+from .spike_sync import spike_sync_profile, spike_sync,\
     spike_sync_profile_multi, spike_sync_multi, spike_sync_matrix
-from psth import psth
+from .psth import psth
 
-from spikes import load_spike_trains_from_txt, spike_train_from_string, \
+from .spikes import load_spike_trains_from_txt, spike_train_from_string, \
     merge_spike_trains, generate_poisson_spikes
 
-import directionality as drct
+from . import directionality as drct
 
 # define the __version__ following
 # http://stackoverflow.com/questions/17583443
diff --git a/pyspike/directionality/__init__.py b/pyspike/directionality/__init__.py
index 6f74c50..6ea38b2 100644
--- a/pyspike/directionality/__init__.py
+++ b/pyspike/directionality/__init__.py
@@ -4,9 +4,11 @@ Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
 Distributed under the BSD License
 """
 
+from __future__ import absolute_import
+
 __all__ = ["spike_train_order"]
 
-from spike_train_order import spike_train_order_profile, \
+from .spike_train_order import spike_train_order_profile, \
     spike_train_order, spike_train_order_profile_multi, \
     spike_train_order_matrix, spike_order_values, \
     optimal_spike_train_order, optimal_spike_train_order_from_matrix, \
diff --git a/pyspike/directionality/spike_train_order.py b/pyspike/directionality/spike_train_order.py
index 892ffd0..44d931d 100644
--- a/pyspike/directionality/spike_train_order.py
+++ b/pyspike/directionality/spike_train_order.py
@@ -2,6 +2,8 @@
 # Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
+from __future__ import absolute_import
+
 import numpy as np
 from math import exp
 from functools import partial
@@ -35,7 +37,7 @@ def spike_train_order_profile(spike_train1, spike_train2, max_tau=None):
 
     # cython implementation
     try:
-        from cython.cython_directionality import \
+        from .cython.cython_directionality import \
             spike_train_order_profile_cython as \
             spike_train_order_profile_impl
     except ImportError:
@@ -45,7 +47,7 @@ def spike_train_order_profile(spike_train1, spike_train2, max_tau=None):
 PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
 Falling back to slow python backend.")
         # use python backend
-        from cython.directionality_python_backend import \
+        from .cython.directionality_python_backend import \
             spike_train_order_python as spike_train_order_profile_impl
 
     if max_tau is None:
@@ -72,7 +74,7 @@ def spike_train_order(spike_train1, spike_train2, normalize=True,
         # distance over the whole interval is requested: use specific function
         # for optimal performance
         try:
-            from cython.cython_directionality import \
+            from .cython.cython_directionality import \
                 spike_train_order_cython as spike_train_order_impl
             if max_tau is None:
                 max_tau = 0.0
@@ -170,7 +172,7 @@ def spike_order_values(spike_trains, indices=None,
 
     # cython implementation
     try:
-        from cython.cython_directionality import \
+        from .cython.cython_directionality import \
             spike_order_values_cython as spike_order_values_impl
     except ImportError:
         raise NotImplementedError()
@@ -179,7 +181,7 @@ def spike_order_values(spike_trains, indices=None,
 # PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
 # Falling back to slow python backend.")
 #         # use python backend
-#         from cython.python_backend import coincidence_python \
+#         from .cython.python_backend import coincidence_python \
 #             as coincidence_profile_impl
 
     if max_tau is None:
diff --git a/pyspike/isi_distance.py b/pyspike/isi_distance.py
index e50f203..0ae7393 100644
--- a/pyspike/isi_distance.py
+++ b/pyspike/isi_distance.py
@@ -2,6 +2,8 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
+from __future__ import absolute_import
+
 import pyspike
 from pyspike import PieceWiseConstFunc
 from pyspike.generic import _generic_profile_multi, _generic_distance_multi, \
@@ -32,7 +34,7 @@ def isi_profile(spike_train1, spike_train2):
 
     # load cython implementation
     try:
-        from cython.cython_profiles import isi_profile_cython \
+        from .cython.cython_profiles import isi_profile_cython \
             as isi_profile_impl
     except ImportError:
         if not(pyspike.disable_backend_warning):
@@ -40,7 +42,7 @@ def isi_profile(spike_train1, spike_train2):
 PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
 Falling back to slow python backend.")
         # use python backend
-        from cython.python_backend import isi_distance_python \
+        from .cython.python_backend import isi_distance_python \
             as isi_profile_impl
 
     times, values = isi_profile_impl(spike_train1.get_spikes_non_empty(),
@@ -74,7 +76,7 @@ def isi_distance(spike_train1, spike_train2, interval=None):
         # distance over the whole interval is requested: use specific function
         # for optimal performance
         try:
-            from cython.cython_distances import isi_distance_cython \
+            from .cython.cython_distances import isi_distance_cython \
                 as isi_distance_impl
 
             return isi_distance_impl(spike_train1.get_spikes_non_empty(),
diff --git a/pyspike/spike_distance.py b/pyspike/spike_distance.py
index feea0c1..e418283 100644
--- a/pyspike/spike_distance.py
+++ b/pyspike/spike_distance.py
@@ -2,6 +2,8 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
+from __future__ import absolute_import
+
 import pyspike
 from pyspike import PieceWiseLinFunc
 from pyspike.generic import _generic_profile_multi, _generic_distance_multi, \
@@ -32,7 +34,7 @@ def spike_profile(spike_train1, spike_train2):
 
     # cython implementation
     try:
-        from cython.cython_profiles import spike_profile_cython \
+        from .cython.cython_profiles import spike_profile_cython \
             as spike_profile_impl
     except ImportError:
         if not(pyspike.disable_backend_warning):
@@ -40,7 +42,7 @@ def spike_profile(spike_train1, spike_train2):
 PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
 Falling back to slow python backend.")
         # use python backend
-        from cython.python_backend import spike_distance_python \
+        from .cython.python_backend import spike_distance_python \
             as spike_profile_impl
 
     times, y_starts, y_ends = spike_profile_impl(
@@ -76,7 +78,7 @@ def spike_distance(spike_train1, spike_train2, interval=None):
         # distance over the whole interval is requested: use specific function
         # for optimal performance
         try:
-            from cython.cython_distances import spike_distance_cython \
+            from .cython.cython_distances import spike_distance_cython \
                 as spike_distance_impl
             return spike_distance_impl(spike_train1.get_spikes_non_empty(),
                                        spike_train2.get_spikes_non_empty(),
diff --git a/pyspike/spike_sync.py b/pyspike/spike_sync.py
index 10ebdc7..3dc29ff 100644
--- a/pyspike/spike_sync.py
+++ b/pyspike/spike_sync.py
@@ -3,6 +3,8 @@
 # Copyright 2014-2015, Mario Mulansky <mario.mulansky@gmx.net>
 # Distributed under the BSD License
 
+from __future__ import absolute_import
+
 import numpy as np
 from functools import partial
 import pyspike
@@ -37,7 +39,7 @@ def spike_sync_profile(spike_train1, spike_train2, max_tau=None):
 
     # cython implementation
     try:
-        from cython.cython_profiles import coincidence_profile_cython \
+        from .cython.cython_profiles import coincidence_profile_cython \
             as coincidence_profile_impl
     except ImportError:
         if not(pyspike.disable_backend_warning):
@@ -45,7 +47,7 @@ def spike_sync_profile(spike_train1, spike_train2, max_tau=None):
 PySpike is installed by running\n 'python setup.py build_ext --inplace'!\n \
 Falling back to slow python backend.")
         # use python backend
-        from cython.python_backend import coincidence_python \
+        from .cython.python_backend import coincidence_python \
             as coincidence_profile_impl
 
     if max_tau is None:
@@ -73,7 +75,7 @@ def _spike_sync_values(spike_train1, spike_train2, interval, max_tau):
         # distance over the whole interval is requested: use specific function
         # for optimal performance
         try:
-            from cython.cython_distances import coincidence_value_cython \
+            from .cython.cython_distances import coincidence_value_cython \
                 as coincidence_value_impl
             if max_tau is None:
                 max_tau = 0.0
-- 
cgit v1.2.3


From 2c42e59e5097d3b9745e6eae2bee8f1ff27f7e09 Mon Sep 17 00:00:00 2001
From: Igor Gnatenko <i.gnatenko.brain@gmail.com>
Date: Sun, 13 Dec 2015 10:57:12 +0100
Subject: py3: xrange() -> range()

Signed-off-by: Igor Gnatenko <i.gnatenko.brain@gmail.com>
---
 examples/multivariate.py                    | 2 +-
 examples/performance.py                     | 2 +-
 pyspike/DiscreteFunc.py                     | 4 ++--
 pyspike/directionality/spike_train_order.py | 4 ++--
 pyspike/generic.py                          | 4 ++--
 pyspike/psth.py                             | 2 +-
 test/test_distance.py                       | 6 +++---
 7 files changed, 12 insertions(+), 12 deletions(-)

(limited to 'pyspike/DiscreteFunc.py')

diff --git a/examples/multivariate.py b/examples/multivariate.py
index 9a44758..93f8516 100644
--- a/examples/multivariate.py
+++ b/examples/multivariate.py
@@ -24,7 +24,7 @@ t_loading = time.clock()
 
 print("Number of spike trains: %d" % len(spike_trains))
 num_of_spikes = sum([len(spike_trains[i])
-                     for i in xrange(len(spike_trains))])
+                     for i in range(len(spike_trains))])
 print("Number of spikes: %d" % num_of_spikes)
 
 # calculate the multivariate spike distance
diff --git a/examples/performance.py b/examples/performance.py
index d0c3b91..ec6c830 100644
--- a/examples/performance.py
+++ b/examples/performance.py
@@ -26,7 +26,7 @@ print("%d spike trains with %d spikes" % (M, int(r*T)))
 spike_trains = []
 
 t_start = datetime.now()
-for i in xrange(M):
+for i in range(M):
     spike_trains.append(spk.generate_poisson_spikes(r, T))
 t_end = datetime.now()
 runtime = (t_end-t_start).total_seconds()
diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index 55c0bc8..fe97bc2 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -80,7 +80,7 @@ class DiscreteFunc(object):
             expected_mp = (averaging_window_size+1) * int(self.mp[0])
             y_plot = np.zeros_like(self.y)
             # compute the values in a loop, could be done in cython if required
-            for i in xrange(len(y_plot)):
+            for i in range(len(y_plot)):
 
                 if self.mp[i] >= expected_mp:
                     # the current value contains already all the wanted
@@ -244,7 +244,7 @@ def average_profile(profiles):
     assert len(profiles) > 1
 
     avrg_profile = profiles[0].copy()
-    for i in xrange(1, len(profiles)):
+    for i in range(1, len(profiles)):
         avrg_profile.add(profiles[i])
     avrg_profile.mul_scalar(1.0/len(profiles))  # normalize
 
diff --git a/pyspike/directionality/spike_train_order.py b/pyspike/directionality/spike_train_order.py
index 44d931d..e6c9830 100644
--- a/pyspike/directionality/spike_train_order.py
+++ b/pyspike/directionality/spike_train_order.py
@@ -260,7 +260,7 @@ def optimal_spike_train_order(spike_trains,  indices=None, interval=None,
 def permutate_matrix(D, p):
     N = len(D)
     D_p = np.empty_like(D)
-    for n in xrange(N):
-        for m in xrange(N):
+    for n in range(N):
+        for m in range(N):
             D_p[n, m] = D[p[n], p[m]]
     return D_p
diff --git a/pyspike/generic.py b/pyspike/generic.py
index 904c3c2..81ae660 100644
--- a/pyspike/generic.py
+++ b/pyspike/generic.py
@@ -137,8 +137,8 @@ def _generic_distance_matrix(spike_trains, dist_function,
     assert (indices < len(spike_trains)).all() and (indices >= 0).all(), \
         "Invalid index list."
     # generate a list of possible index pairs
-    pairs = [(i, j) for i in xrange(len(indices))
-             for j in xrange(i+1, len(indices))]
+    pairs = [(i, j) for i in range(len(indices))
+             for j in range(i+1, len(indices))]
 
     distance_matrix = np.zeros((len(indices), len(indices)))
     for i, j in pairs:
diff --git a/pyspike/psth.py b/pyspike/psth.py
index 4027215..7cf1140 100644
--- a/pyspike/psth.py
+++ b/pyspike/psth.py
@@ -24,7 +24,7 @@ def psth(spike_trains, bin_size):
 
     # N = len(spike_trains)
     combined_spike_train = spike_trains[0].spikes
-    for i in xrange(1, len(spike_trains)):
+    for i in range(1, len(spike_trains)):
         combined_spike_train = np.append(combined_spike_train,
                                          spike_trains[i].spikes)
 
diff --git a/test/test_distance.py b/test/test_distance.py
index e45ac16..d5bce30 100644
--- a/test/test_distance.py
+++ b/test/test_distance.py
@@ -309,10 +309,10 @@ def check_dist_matrix(dist_func, dist_matrix_func):
 
     f_matrix = dist_matrix_func(spike_trains)
     # check zero diagonal
-    for i in xrange(4):
+    for i in range(4):
         assert_equal(0.0, f_matrix[i, i])
-    for i in xrange(4):
-        for j in xrange(i+1, 4):
+    for i in range(4):
+        for j in range(i+1, 4):
             assert_equal(f_matrix[i, j], f_matrix[j, i])
     assert_equal(f12, f_matrix[1, 0])
     assert_equal(f13, f_matrix[2, 0])
-- 
cgit v1.2.3