From 017893e782d1747e1f031131077a40a48f882e86 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 11 May 2015 14:32:48 +0200
Subject: treatment of empty spike trains in isi functions

---
 test/test_empty.py | 62 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 62 insertions(+)
 create mode 100644 test/test_empty.py

(limited to 'test/test_empty.py')

diff --git a/test/test_empty.py b/test/test_empty.py
new file mode 100644
index 0000000..22982c7
--- /dev/null
+++ b/test/test_empty.py
@@ -0,0 +1,62 @@
+""" test_empty.py
+
+Tests the distance measure for empty spike trains
+
+Copyright 2014, Mario Mulansky <mario.mulansky@gmx.net>
+
+Distributed under the BSD License
+
+"""
+
+from __future__ import print_function
+import numpy as np
+from copy import copy
+from numpy.testing import assert_equal, assert_almost_equal, \
+    assert_array_equal, assert_array_almost_equal
+
+import pyspike as spk
+from pyspike import SpikeTrain
+
+
+def test_get_non_empty():
+    st = SpikeTrain([], edges=(0.0, 1.0))
+    spikes = st.get_spikes_non_empty()
+    assert_array_equal(spikes, [0.0, 1.0])
+
+    st = SpikeTrain([0.5, ], edges=(0.0, 1.0))
+    spikes = st.get_spikes_non_empty()
+    assert_array_equal(spikes, [0.0, 0.5, 1.0])
+
+
+def test_isi_empty():
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([], edges=(0.0, 1.0))
+    d = spk.isi_distance(st1, st2)
+    assert_equal(d, 0.0)
+    prof = spk.isi_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 1.0])
+    assert_array_equal(prof.y, [0.0, ])
+
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.isi_distance(st1, st2)
+    assert_equal(d, 0.6*0.4+0.4*0.6)
+    prof = spk.isi_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 0.4, 1.0])
+    assert_array_equal(prof.y, [0.6, 0.4])
+
+    st1 = SpikeTrain([0.6, ], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.isi_distance(st1, st2)
+    assert_almost_equal(d, 0.2/0.6*0.4 + 0.0 + 0.2/0.6*0.4, decimal=15)
+    prof = spk.isi_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_almost_equal(prof.x, [0.0, 0.4, 0.6, 1.0], decimal=15)
+    assert_array_almost_equal(prof.y, [0.2/0.6, 0.0, 0.2/0.6], decimal=15)
+
+
+if __name__ == "__main__":
+    test_get_non_empty()
+    test_isi_empty()
-- 
cgit v1.2.3


From b6521869cad89eae119391557bfa57e818dc9894 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 11 May 2015 15:54:19 +0200
Subject: treatment of empty spike trains in spike distance

---
 pyspike/spike_distance.py | 13 +++++++------
 test/test_empty.py        | 48 ++++++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 54 insertions(+), 7 deletions(-)

(limited to 'test/test_empty.py')

diff --git a/pyspike/spike_distance.py b/pyspike/spike_distance.py
index d727fa2..ac2d260 100644
--- a/pyspike/spike_distance.py
+++ b/pyspike/spike_distance.py
@@ -41,10 +41,11 @@ Falling back to slow python backend.")
         from cython.python_backend import spike_distance_python \
             as spike_profile_impl
 
-    times, y_starts, y_ends = spike_profile_impl(spike_train1.spikes,
-                                                 spike_train2.spikes,
-                                                 spike_train1.t_start,
-                                                 spike_train1.t_end)
+    times, y_starts, y_ends = spike_profile_impl(
+        spike_train1.get_spikes_non_empty(),
+        spike_train2.get_spikes_non_empty(),
+        spike_train1.t_start, spike_train1.t_end)
+
     return PieceWiseLinFunc(times, y_starts, y_ends)
 
 
@@ -74,8 +75,8 @@ def spike_distance(spike_train1, spike_train2, interval=None):
         try:
             from cython.cython_distances import spike_distance_cython \
                 as spike_distance_impl
-            return spike_distance_impl(spike_train1.spikes,
-                                       spike_train2.spikes,
+            return spike_distance_impl(spike_train1.get_spikes_non_empty(),
+                                       spike_train2.get_spikes_non_empty(),
                                        spike_train1.t_start,
                                        spike_train1.t_end)
         except ImportError:
diff --git a/test/test_empty.py b/test/test_empty.py
index 22982c7..e08bd1a 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -10,7 +10,6 @@ Distributed under the BSD License
 
 from __future__ import print_function
 import numpy as np
-from copy import copy
 from numpy.testing import assert_equal, assert_almost_equal, \
     assert_array_equal, assert_array_almost_equal
 
@@ -57,6 +56,53 @@ def test_isi_empty():
     assert_array_almost_equal(prof.y, [0.2/0.6, 0.0, 0.2/0.6], decimal=15)
 
 
+def test_spike_empty():
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([], edges=(0.0, 1.0))
+    d = spk.spike_distance(st1, st2)
+    assert_equal(d, 0.0)
+    prof = spk.spike_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 1.0])
+    assert_array_equal(prof.y1, [0.0, ])
+    assert_array_equal(prof.y2, [0.0, ])
+
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.spike_distance(st1, st2)
+    assert_almost_equal(d, 0.4*0.4*1.0/(0.4+1.0)**2 + 0.6*0.4*1.0/(0.6+1.0)**2,
+                        decimal=15)
+    prof = spk.spike_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 0.4, 1.0])
+    assert_array_almost_equal(prof.y1, [0.0, 2*0.4*1.0/(0.6+1.0)**2],
+                              decimal=15)
+    assert_array_almost_equal(prof.y2, [2*0.4*1.0/(0.4+1.0)**2, 0.0],
+                              decimal=15)
+
+    st1 = SpikeTrain([0.6, ], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.spike_distance(st1, st2)
+    s1 = np.array([0.0, 0.4*0.2/0.6, 0.2, 0.0])
+    s2 = np.array([0.0, 0.2, 0.2*0.4/0.6, 0.0])
+    isi1 = np.array([0.6, 0.6, 0.4])
+    isi2 = np.array([0.4, 0.6, 0.6])
+    expected_y1 = (s1[:-1]*isi2+s2[:-1]*isi1) / (0.5*(isi1+isi2)**2)
+    expected_y2 = (s1[1:]*isi2+s2[1:]*isi1) / (0.5*(isi1+isi2)**2)
+    expected_times = np.array([0.0, 0.4, 0.6, 1.0])
+    expected_spike_val = sum((expected_times[1:] - expected_times[:-1]) *
+                             (expected_y1+expected_y2)/2)
+    expected_spike_val /= (expected_times[-1]-expected_times[0])
+
+    assert_almost_equal(d, expected_spike_val, decimal=15)
+    prof = spk.spike_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_almost_equal(prof.x, [0.0, 0.4, 0.6, 1.0], decimal=15)
+    assert_array_almost_equal(prof.y1, expected_y1, decimal=15)
+    assert_array_almost_equal(prof.y2, expected_y2, decimal=15)
+
+
 if __name__ == "__main__":
     test_get_non_empty()
     test_isi_empty()
+    test_spike_empty()
-- 
cgit v1.2.3


From 3b10b416940ae674df6d9dff8cdddc31085d8cf5 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 11 May 2015 17:03:29 +0200
Subject: updated copyright year

---
 test/test_empty.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'test/test_empty.py')

diff --git a/test/test_empty.py b/test/test_empty.py
index e08bd1a..42c3716 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -2,7 +2,7 @@
 
 Tests the distance measure for empty spike trains
 
-Copyright 2014, Mario Mulansky <mario.mulansky@gmx.net>
+Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
 
 Distributed under the BSD License
 
-- 
cgit v1.2.3


From bec2529367f1bdd5dac6d6fbaec560a30feec3c7 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 11 May 2015 17:41:08 +0200
Subject: treatment of empty spike trains in spike sync

---
 pyspike/DiscreteFunc.py             |  4 ++++
 pyspike/cython/cython_distances.pyx | 13 +++++++++----
 pyspike/cython/cython_profiles.pyx  |  9 +++++----
 pyspike/cython/python_backend.py    |  2 +-
 test/test_empty.py                  | 39 +++++++++++++++++++++++++++++++++++++
 5 files changed, 58 insertions(+), 9 deletions(-)

(limited to 'test/test_empty.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index dfe2cab..6ade87e 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -136,6 +136,10 @@ class DiscreteFunc(object):
         :rtype: pair of float
         """
 
+        if len(self.y) <= 2:
+            # no actual values in the profile, return spike sync of 0
+            return 0.0, 1.0
+
         def get_indices(ival):
             """ Retuns the indeces surrounding the given interval"""
             start_ind = np.searchsorted(self.x, ival[0], side='right')
diff --git a/pyspike/cython/cython_distances.pyx b/pyspike/cython/cython_distances.pyx
index bf90638..16780f2 100644
--- a/pyspike/cython/cython_distances.pyx
+++ b/pyspike/cython/cython_distances.pyx
@@ -333,8 +333,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
 # get_tau
 ############################################################
 cdef inline double get_tau(double[:] spikes1, double[:] spikes2,
-                           int i, int j, double max_tau):
-    cdef double m = 1E100   # some huge number
+                           int i, int j, double interval, double max_tau):
+    cdef double m = interval   # use interval length as initial tau
     cdef int N1 = spikes1.shape[0]-1  # len(spikes1)-1
     cdef int N2 = spikes2.shape[0]-1  # len(spikes2)-1
     if i < N1 and i > -1:
@@ -363,12 +363,13 @@ def coincidence_value_cython(double[:] spikes1, double[:] spikes2,
     cdef int j = -1
     cdef double coinc = 0.0
     cdef double mp = 0.0
+    cdef double interval = t_end - t_start
     cdef double tau
     while i + j < N1 + N2 - 2:
         if (i < N1-1) and (j == N2-1 or spikes1[i+1] < spikes2[j+1]):
             i += 1
             mp += 1
-            tau = get_tau(spikes1, spikes2, i, j, max_tau)
+            tau = get_tau(spikes1, spikes2, i, j, interval, max_tau)
             if j > -1 and spikes1[i]-spikes2[j] < tau:
                 # coincidence between the current spike and the previous spike
                 # both get marked with 1
@@ -376,7 +377,7 @@ def coincidence_value_cython(double[:] spikes1, double[:] spikes2,
         elif (j < N2-1) and (i == N1-1 or spikes1[i+1] > spikes2[j+1]):
             j += 1
             mp += 1
-            tau = get_tau(spikes1, spikes2, i, j, max_tau)
+            tau = get_tau(spikes1, spikes2, i, j, interval, max_tau)
             if i > -1 and spikes2[j]-spikes1[i] < tau:
                 # coincidence between the current spike and the previous spike
                 # both get marked with 1
@@ -389,4 +390,8 @@ def coincidence_value_cython(double[:] spikes1, double[:] spikes2,
             mp += 2
             coinc += 2
 
+    if coinc == 0 and mp == 0:
+        # empty spike trains -> set mp to one to avoid 0/0
+        mp = 1
+
     return coinc, mp
diff --git a/pyspike/cython/cython_profiles.pyx b/pyspike/cython/cython_profiles.pyx
index 3690091..d937a02 100644
--- a/pyspike/cython/cython_profiles.pyx
+++ b/pyspike/cython/cython_profiles.pyx
@@ -345,8 +345,8 @@ def spike_profile_cython(double[:] t1, double[:] t2,
 # get_tau
 ############################################################
 cdef inline double get_tau(double[:] spikes1, double[:] spikes2,
-                           int i, int j, double max_tau):
-    cdef double m = 1E100   # some huge number
+                           int i, int j, double interval, double max_tau):
+    cdef double m = interval   # use interval as initial tau
     cdef int N1 = spikes1.shape[0]-1  # len(spikes1)-1
     cdef int N2 = spikes2.shape[0]-1  # len(spikes2)-1
     if i < N1 and i > -1:
@@ -377,12 +377,13 @@ def coincidence_profile_cython(double[:] spikes1, double[:] spikes2,
     cdef double[:] st = np.zeros(N1 + N2 + 2)  # spike times
     cdef double[:] c = np.zeros(N1 + N2 + 2)   # coincidences
     cdef double[:] mp = np.ones(N1 + N2 + 2)   # multiplicity
+    cdef double interval = t_end - t_start
     cdef double tau
     while i + j < N1 + N2 - 2:
         if (i < N1-1) and (j == N2-1 or spikes1[i+1] < spikes2[j+1]):
             i += 1
             n += 1
-            tau = get_tau(spikes1, spikes2, i, j, max_tau)
+            tau = get_tau(spikes1, spikes2, i, j, interval, max_tau)
             st[n] = spikes1[i]
             if j > -1 and spikes1[i]-spikes2[j] < tau:
                 # coincidence between the current spike and the previous spike
@@ -392,7 +393,7 @@ def coincidence_profile_cython(double[:] spikes1, double[:] spikes2,
         elif (j < N2-1) and (i == N1-1 or spikes1[i+1] > spikes2[j+1]):
             j += 1
             n += 1
-            tau = get_tau(spikes1, spikes2, i, j, max_tau)
+            tau = get_tau(spikes1, spikes2, i, j, interval, max_tau)
             st[n] = spikes2[j]
             if i > -1 and spikes2[j]-spikes1[i] < tau:
                 # coincidence between the current spike and the previous spike
diff --git a/pyspike/cython/python_backend.py b/pyspike/cython/python_backend.py
index 1fd8c42..830dc69 100644
--- a/pyspike/cython/python_backend.py
+++ b/pyspike/cython/python_backend.py
@@ -340,7 +340,7 @@ def cumulative_sync_python(spikes1, spikes2):
 def coincidence_python(spikes1, spikes2, t_start, t_end, max_tau):
 
     def get_tau(spikes1, spikes2, i, j, max_tau):
-        m = 1E100   # some huge number
+        m = t_end - t_start   # use interval as initial tau
         if i < len(spikes1)-1 and i > -1:
             m = min(m, spikes1[i+1]-spikes1[i])
         if j < len(spikes2)-1 and j > -1:
diff --git a/test/test_empty.py b/test/test_empty.py
index 42c3716..b31d8a4 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -102,7 +102,46 @@ def test_spike_empty():
     assert_array_almost_equal(prof.y2, expected_y2, decimal=15)
 
 
+def test_spike_sync_empty():
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([], edges=(0.0, 1.0))
+    d = spk.spike_sync(st1, st2)
+    assert_equal(d, 0.0)
+    prof = spk.spike_sync_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 1.0])
+    assert_array_equal(prof.y, [0.0, 0.0])
+
+    st1 = SpikeTrain([], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.spike_sync(st1, st2)
+    assert_equal(d, 0.0)
+    prof = spk.spike_sync_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_equal(prof.x, [0.0, 0.4, 1.0])
+    assert_array_equal(prof.y, [0.0, 0.0, 0.0])
+
+    st1 = SpikeTrain([0.6, ], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
+    d = spk.spike_sync(st1, st2)
+    assert_almost_equal(d, 1.0, decimal=15)
+    prof = spk.spike_sync_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    assert_array_almost_equal(prof.x, [0.0, 0.4, 0.6, 1.0], decimal=15)
+    assert_array_almost_equal(prof.y, [1.0, 1.0, 1.0, 1.0], decimal=15)
+
+    st1 = SpikeTrain([0.2, ], edges=(0.0, 1.0))
+    st2 = SpikeTrain([0.8, ], edges=(0.0, 1.0))
+    d = spk.spike_sync(st1, st2)
+    assert_almost_equal(d, 0.0, decimal=15)
+    prof = spk.spike_sync_profile(st1, st2)
+    assert_equal(d, prof.avrg())
+    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)
+
+
 if __name__ == "__main__":
     test_get_non_empty()
     test_isi_empty()
     test_spike_empty()
+    test_spike_sync_empty()
-- 
cgit v1.2.3


From a35402c208bd0ad31e5e60b6ddc55a3470e7bdde Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 11 May 2015 17:54:02 +0200
Subject: bugfix: spike_sync=1 for empty spike trains

---
 pyspike/DiscreteFunc.py             |  4 ++--
 pyspike/cython/cython_distances.pyx |  3 ++-
 pyspike/cython/cython_profiles.pyx  | 12 ++++++++----
 pyspike/cython/python_backend.py    | 12 ++++++++----
 test/test_empty.py                  |  4 ++--
 5 files changed, 22 insertions(+), 13 deletions(-)

(limited to 'test/test_empty.py')

diff --git a/pyspike/DiscreteFunc.py b/pyspike/DiscreteFunc.py
index 6ade87e..17153ee 100644
--- a/pyspike/DiscreteFunc.py
+++ b/pyspike/DiscreteFunc.py
@@ -137,8 +137,8 @@ class DiscreteFunc(object):
         """
 
         if len(self.y) <= 2:
-            # no actual values in the profile, return spike sync of 0
-            return 0.0, 1.0
+            # no actual values in the profile, return spike sync of 1
+            return 1.0, 1.0
 
         def get_indices(ival):
             """ Retuns the indeces surrounding the given interval"""
diff --git a/pyspike/cython/cython_distances.pyx b/pyspike/cython/cython_distances.pyx
index 16780f2..c4f2349 100644
--- a/pyspike/cython/cython_distances.pyx
+++ b/pyspike/cython/cython_distances.pyx
@@ -391,7 +391,8 @@ def coincidence_value_cython(double[:] spikes1, double[:] spikes2,
             coinc += 2
 
     if coinc == 0 and mp == 0:
-        # empty spike trains -> set mp to one to avoid 0/0
+        # empty spike trains -> spike sync = 1 by definition
+        coinc = 1
         mp = 1
 
     return coinc, mp
diff --git a/pyspike/cython/cython_profiles.pyx b/pyspike/cython/cython_profiles.pyx
index d937a02..f9893eb 100644
--- a/pyspike/cython/cython_profiles.pyx
+++ b/pyspike/cython/cython_profiles.pyx
@@ -416,9 +416,13 @@ def coincidence_profile_cython(double[:] spikes1, double[:] spikes2,
 
     st[0] = t_start
     st[len(st)-1] = t_end
-    c[0] = c[1]
-    c[len(c)-1] = c[len(c)-2]
-    mp[0] = mp[1]
-    mp[len(mp)-1] = mp[len(mp)-2]
+    if N1 + N2 > 0:
+        c[0] = c[1]
+        c[len(c)-1] = c[len(c)-2]
+        mp[0] = mp[1]
+        mp[len(mp)-1] = mp[len(mp)-2]
+    else:
+        c[0] = 1
+        c[1] = 1
 
     return st, c, mp
diff --git a/pyspike/cython/python_backend.py b/pyspike/cython/python_backend.py
index 830dc69..69a420f 100644
--- a/pyspike/cython/python_backend.py
+++ b/pyspike/cython/python_backend.py
@@ -399,10 +399,14 @@ def coincidence_python(spikes1, spikes2, t_start, t_end, max_tau):
 
     st[0] = t_start
     st[len(st)-1] = t_end
-    c[0] = c[1]
-    c[len(c)-1] = c[len(c)-2]
-    mp[0] = mp[1]
-    mp[len(mp)-1] = mp[len(mp)-2]
+    if N1 + N2 > 0:
+        c[0] = c[1]
+        c[len(c)-1] = c[len(c)-2]
+        mp[0] = mp[1]
+        mp[len(mp)-1] = mp[len(mp)-2]
+    else:
+        c[0] = 1
+        c[1] = 1
 
     return st, c, mp
 
diff --git a/test/test_empty.py b/test/test_empty.py
index b31d8a4..48be25d 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -106,11 +106,11 @@ def test_spike_sync_empty():
     st1 = SpikeTrain([], edges=(0.0, 1.0))
     st2 = SpikeTrain([], edges=(0.0, 1.0))
     d = spk.spike_sync(st1, st2)
-    assert_equal(d, 0.0)
+    assert_equal(d, 1.0)
     prof = spk.spike_sync_profile(st1, st2)
     assert_equal(d, prof.avrg())
     assert_array_equal(prof.x, [0.0, 1.0])
-    assert_array_equal(prof.y, [0.0, 0.0])
+    assert_array_equal(prof.y, [1.0, 1.0])
 
     st1 = SpikeTrain([], edges=(0.0, 1.0))
     st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
-- 
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 'test/test_empty.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 b970055641b215d30b671ee810e29c6a55e6214a Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Mon, 14 Dec 2015 14:23:02 +0100
Subject: improved edge correction for spike distance

Improvement following Eeros suggestions to use auxiliary spike at the edges
consistently with the corresponding corrected ISI intervals.
---
 pyspike/cython/cython_distances.pyx | 55 +++++++++++++++++++++------------
 pyspike/cython/cython_profiles.pyx  | 61 +++++++++++++++++++++++++------------
 test/test_distance.py               | 50 ++++++++++++++++++++++++++----
 test/test_empty.py                  |  4 +--
 4 files changed, 122 insertions(+), 48 deletions(-)

(limited to 'test/test_empty.py')

diff --git a/pyspike/cython/cython_distances.pyx b/pyspike/cython/cython_distances.pyx
index c4f2349..41baa60 100644
--- a/pyspike/cython/cython_distances.pyx
+++ b/pyspike/cython/cython_distances.pyx
@@ -176,6 +176,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
     cdef double t_p1, t_f1, t_p2, t_f2, dt_p1, dt_p2, dt_f1, dt_f2
     cdef double isi1, isi2, s1, s2
     cdef double y_start, y_end, t_last, t_current, spike_value
+    cdef double[:] t_aux1 = np.empty(2)
+    cdef double[:] t_aux2 = np.empty(2)
     
     spike_value = 0.0
 
@@ -184,19 +186,27 @@ def spike_distance_cython(double[:] t1, double[:] t2,
 
     with nogil: # release the interpreter to allow multithreading
         t_last = t_start
-        t_p1 = t_start
-        t_p2 = t_start
+        # t_p1 = t_start
+        # t_p2 = t_start
+        # auxiliary spikes for edge correction - consistent with first/last ISI 
+        t_aux1[0] = fmin(t_start, t1[0]-(t1[1]-t1[0]))
+        t_aux1[1] = fmax(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2]))
+        t_aux2[0] = fmin(t_start, t2[0]-(t2[1]-t2[0]))
+        t_aux2[1] = fmax(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2]))
+        t_p1 = t_start if (t1[0] == t_start) else t_aux1[0]
+        t_p2 = t_start if (t2[0] == t_start) else t_aux2[0]
         if t1[0] > t_start:
             # dt_p1 = t2[0]-t_start
             t_f1 = t1[0]
-            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_start, t_end)
+            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
             isi1 = fmax(t_f1-t_start, t1[1]-t1[0])
             dt_p1 = dt_f1
-            s1 = dt_p1*(t_f1-t_start)/isi1
+            # s1 = dt_p1*(t_f1-t_start)/isi1
+            s1 = dt_p1
             index1 = -1
         else:
             t_f1 = t1[1]
-            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_start, t_end)
+            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
             dt_p1 = 0.0
             isi1 = t1[1]-t1[0]
             s1 = dt_p1
@@ -204,14 +214,15 @@ def spike_distance_cython(double[:] t1, double[:] t2,
         if t2[0] > t_start:
             # dt_p1 = t2[0]-t_start
             t_f2 = t2[0]
-            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_start, t_end)
+            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = dt_f2
             isi2 = fmax(t_f2-t_start, t2[1]-t2[0])
-            s2 = dt_p2*(t_f2-t_start)/isi2
+            # s2 = dt_p2*(t_f2-t_start)/isi2
+            s2 = dt_p2
             index2 = -1
         else:
             t_f2 = t2[1]
-            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_start, t_end)
+            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = 0.0
             isi2 = t2[1]-t2[0]
             s2 = dt_p2
@@ -233,7 +244,7 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 if index1 < N1-1:
                     t_f1 = t1[index1+1]
                 else:
-                    t_f1 = t_end
+                    t_f1 = t_aux1[1]
                 t_curr =  t_p1
                 s2 = (dt_p2*(t_f2-t_p1) + dt_f2*(t_p1-t_p2)) / isi2
                 y_end = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1, isi2)
@@ -243,14 +254,16 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 # now the next interval start value
                 if index1 < N1-1:
                     dt_f1 = get_min_dist_cython(t_f1, t2, N2, index2,
-                                                t_start, t_end)
+                                                t_aux2[0], t_aux2[1])
                     isi1 = t_f1-t_p1
                     s1 = dt_p1
                 else:
                     dt_f1 = dt_p1
                     isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
                     # s1 needs adjustment due to change of isi1
-                    s1 = dt_p1*(t_end-t1[N1-1])/isi1
+                    # s1 = dt_p1*(t_end-t1[N1-1])/isi1
+                    # Eero's correction: no adjustment
+                    s1 = dt_p1
                 # s2 is the same as above, thus we can compute y2 immediately
                 y_start = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1, isi2)
             elif (index2 < N2-1) and (t_f1 > t_f2 or index1 == N1-1):
@@ -264,7 +277,7 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                 else:
-                    t_f2 = t_end
+                    t_f2 = t_aux2[1]
                 t_curr = t_p2
                 s1 = (dt_p1*(t_f1-t_p2) + dt_f1*(t_p2-t_p1)) / isi1
                 y_end = (s1*isi2 + s2*isi1) / isi_avrg_cython(isi1, isi2)
@@ -274,14 +287,16 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 # now the next interval start value
                 if index2 < N2-1:
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
-                                                t_start, t_end)
+                                                t_aux1[0], t_aux1[1])
                     isi2 = t_f2-t_p2
                     s2 = dt_p2
                 else:
                     dt_f2 = dt_p2
                     isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
                     # s2 needs adjustment due to change of isi2
-                    s2 = dt_p2*(t_end-t2[N2-1])/isi2
+                    # s2 = dt_p2*(t_end-t2[N2-1])/isi2
+                    # Eero's correction: no adjustment
+                    s2 = dt_p2
                 # s1 is the same as above, thus we can compute y2 immediately
                 y_start = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1, isi2)
             else: # t_f1 == t_f2 - generate only one event
@@ -298,27 +313,27 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 if index1 < N1-1:
                     t_f1 = t1[index1+1]
                     dt_f1 = get_min_dist_cython(t_f1, t2, N2, index2,
-                                                t_start, t_end)
+                                                t_aux2[0], t_aux2[1])
                     isi1 = t_f1 - t_p1
                 else:
-                    t_f1 = t_end
+                    t_f1 = t_aux1[1]
                     dt_f1 = dt_p1
                     isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
-                                                t_start, t_end)
+                                                t_aux1[0], t_aux1[1])
                     isi2 = t_f2 - t_p2
                 else:
-                    t_f2 = t_end
+                    t_f2 = t_aux2[1]
                     dt_f2 = dt_p2
                     isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
             index += 1
             t_last = t_curr
         # isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
         # isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
-        s1 = dt_f1*(t_end-t1[N1-1])/isi1
-        s2 = dt_f2*(t_end-t2[N2-1])/isi2
+        s1 = dt_f1 # *(t_end-t1[N1-1])/isi1
+        s2 = dt_f2 # *(t_end-t2[N2-1])/isi2
         y_end = (s1*isi2 + s2*isi1) / isi_avrg_cython(isi1, isi2)
         spike_value += 0.5*(y_start + y_end) * (t_end - t_last)
     # end nogil
diff --git a/pyspike/cython/cython_profiles.pyx b/pyspike/cython/cython_profiles.pyx
index f9893eb..f08de6e 100644
--- a/pyspike/cython/cython_profiles.pyx
+++ b/pyspike/cython/cython_profiles.pyx
@@ -181,6 +181,8 @@ def spike_profile_cython(double[:] t1, double[:] t2,
     cdef double[:] spike_events
     cdef double[:] y_starts
     cdef double[:] y_ends
+    cdef double[:] t_aux1 = np.empty(2)
+    cdef double[:] t_aux2 = np.empty(2)
 
     cdef int N1, N2, index1, index2, index
     cdef double t_p1, t_f1, t_p2, t_f2, dt_p1, dt_p2, dt_f1, dt_f2
@@ -189,6 +191,10 @@ def spike_profile_cython(double[:] t1, double[:] t2,
     N1 = len(t1)
     N2 = len(t2)
 
+    # we can assume at least two spikes per spike train
+    assert N1 > 1
+    assert N2 > 1
+
     spike_events = np.empty(N1+N2+2)
 
     y_starts = np.empty(len(spike_events)-1)
@@ -196,19 +202,27 @@ def spike_profile_cython(double[:] t1, double[:] t2,
 
     with nogil: # release the interpreter to allow multithreading
         spike_events[0] = t_start
-        t_p1 = t_start
-        t_p2 = t_start
+        # t_p1 = t_start
+        # t_p2 = t_start
+        # auxiliary spikes for edge correction - consistent with first/last ISI 
+        t_aux1[0] = fmin(t_start, t1[0]-(t1[1]-t1[0]))
+        t_aux1[1] = fmax(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2]))
+        t_aux2[0] = fmin(t_start, t2[0]-(t2[1]-t2[0]))
+        t_aux2[1] = fmax(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2]))
+        t_p1 = t_start if (t1[0] == t_start) else t_aux1[0]
+        t_p2 = t_start if (t2[0] == t_start) else t_aux2[0]
         if t1[0] > t_start:
             # dt_p1 = t2[0]-t_start
             t_f1 = t1[0]
-            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_start, t_end)
+            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
             isi1 = fmax(t_f1-t_start, t1[1]-t1[0])
             dt_p1 = dt_f1
-            s1 = dt_p1*(t_f1-t_start)/isi1
+            # s1 = dt_p1*(t_f1-t_start)/isi1
+            s1 = dt_p1
             index1 = -1
         else:
             t_f1 = t1[1]
-            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_start, t_end)
+            dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
             dt_p1 = 0.0
             isi1 = t1[1]-t1[0]
             s1 = dt_p1
@@ -216,14 +230,15 @@ def spike_profile_cython(double[:] t1, double[:] t2,
         if t2[0] > t_start:
             # dt_p1 = t2[0]-t_start
             t_f2 = t2[0]
-            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_start, t_end)
+            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = dt_f2
             isi2 = fmax(t_f2-t_start, t2[1]-t2[0])
-            s2 = dt_p2*(t_f2-t_start)/isi2
+            # s2 = dt_p2*(t_f2-t_start)/isi2
+            s2 = dt_p2
             index2 = -1
         else:
             t_f2 = t2[1]
-            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_start, t_end)
+            dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = 0.0
             isi2 = t2[1]-t2[0]
             s2 = dt_p2
@@ -245,7 +260,7 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 if index1 < N1-1:
                     t_f1 = t1[index1+1]
                 else:
-                    t_f1 = t_end
+                    t_f1 = t_aux1[1]
                 spike_events[index] = t_p1
                 s2 = (dt_p2*(t_f2-t_p1) + dt_f2*(t_p1-t_p2)) / isi2
                 y_ends[index-1] = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1,
@@ -253,14 +268,16 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 # now the next interval start value
                 if index1 < N1-1:
                     dt_f1 = get_min_dist_cython(t_f1, t2, N2, index2,
-                                                t_start, t_end)
+                                                t_aux2[0], t_aux2[1])
                     isi1 = t_f1-t_p1
                     s1 = dt_p1
                 else:
                     dt_f1 = dt_p1
                     isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
                     # s1 needs adjustment due to change of isi1
-                    s1 = dt_p1*(t_end-t1[N1-1])/isi1
+                    # s1 = dt_p1*(t_end-t1[N1-1])/isi1
+                    # Eero's correction: no adjustment
+                    s1 = dt_p1
                 # s2 is the same as above, thus we can compute y2 immediately
                 y_starts[index] = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1,
                                                                       isi2)
@@ -275,7 +292,7 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                 else:
-                    t_f2 = t_end
+                    t_f2 = t_aux2[1]
                 spike_events[index] = t_p2
                 s1 = (dt_p1*(t_f1-t_p2) + dt_f1*(t_p2-t_p1)) / isi1
                 y_ends[index-1] = (s1*isi2 + s2*isi1) / isi_avrg_cython(isi1,
@@ -283,14 +300,16 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 # now the next interval start value
                 if index2 < N2-1:
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
-                                                t_start, t_end)
+                                                t_aux1[0], t_aux1[1])
                     isi2 = t_f2-t_p2
                     s2 = dt_p2
                 else:
                     dt_f2 = dt_p2
                     isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
                     # s2 needs adjustment due to change of isi2
-                    s2 = dt_p2*(t_end-t2[N2-1])/isi2
+                    # s2 = dt_p2*(t_end-t2[N2-1])/isi2
+                    # Eero's correction: no adjustment
+                    s2 = dt_p2
                 # s2 is the same as above, thus we can compute y2 immediately
                 y_starts[index] = (s1*isi2 + s2*isi1)/isi_avrg_cython(isi1, isi2)
             else: # t_f1 == t_f2 - generate only one event
@@ -306,19 +325,19 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 if index1 < N1-1:
                     t_f1 = t1[index1+1]
                     dt_f1 = get_min_dist_cython(t_f1, t2, N2, index2,
-                                                t_start, t_end)
+                                                t_aux2[0], t_aux2[1])
                     isi1 = t_f1 - t_p1
                 else:
-                    t_f1 = t_end
+                    t_f1 = t_aux1[1]
                     dt_f1 = dt_p1
                     isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
-                                                t_start, t_end)
+                                                t_aux1[0], t_aux1[1])
                     isi2 = t_f2 - t_p2
                 else:
-                    t_f2 = t_end
+                    t_f2 = t_aux2[1]
                     dt_f2 = dt_p2
                     isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
             index += 1
@@ -330,8 +349,10 @@ def spike_profile_cython(double[:] t1, double[:] t2,
             # the ending value of the last interval
             isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
             isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
-            s1 = dt_f1*(t_end-t1[N1-1])/isi1
-            s2 = dt_f2*(t_end-t2[N2-1])/isi2
+            # s1 = dt_f1*(t_end-t1[N1-1])/isi1
+            # s2 = dt_f2*(t_end-t2[N2-1])/isi2
+            s1 = dt_f1
+            s2 = dt_f2
             y_ends[index-1] = (s1*isi2 + s2*isi1) / isi_avrg_cython(isi1, isi2)
     # end nogil
 
diff --git a/test/test_distance.py b/test/test_distance.py
index e45ac16..626b438 100644
--- a/test/test_distance.py
+++ b/test/test_distance.py
@@ -36,6 +36,7 @@ def test_isi():
     f = spk.isi_profile(t1, t2)
 
     # print("ISI: ", f.y)
+    print("ISI value:", expected_isi_val)
 
     assert_equal(f.x, expected_times)
     assert_array_almost_equal(f.y, expected_isi, decimal=15)
@@ -73,8 +74,19 @@ def test_spike():
 
     assert_equal(f.x, expected_times)
 
-    assert_almost_equal(f.avrg(), 1.6624149659863946e-01, decimal=15)
-    assert_almost_equal(f.y2[-1], 0.1394558, decimal=6)
+    # from SPIKY:
+    y_all = np.array([0.000000000000000000, 0.555555555555555580,
+                      0.222222222222222210, 0.305555555555555580,
+                      0.255102040816326536, 0.000000000000000000,
+                      0.000000000000000000, 0.255102040816326536,
+                      0.255102040816326536, 0.285714285714285698,
+                      0.285714285714285698, 0.285714285714285698])
+
+    #assert_array_almost_equal(f.y1, y_all[::2])
+    assert_array_almost_equal(f.y2, y_all[1::2])
+
+    assert_almost_equal(f.avrg(), 0.186309523809523814, decimal=15)
+    assert_equal(spk.spike_distance(t1, t2), f.avrg())
 
     t1 = SpikeTrain([0.2, 0.4, 0.6, 0.7], 1.0)
     t2 = SpikeTrain([0.3, 0.45, 0.8, 0.9, 0.95], 1.0)
@@ -99,6 +111,8 @@ def test_spike():
                              (expected_y1+expected_y2)/2)
     expected_spike_val /= (expected_times[-1]-expected_times[0])
 
+    print("SPIKE value:", expected_spike_val)
+
     f = spk.spike_profile(t1, t2)
 
     assert_equal(f.x, expected_times)
@@ -117,9 +131,14 @@ def test_spike():
     # for left and right values
     s1_r = np.array([0.1, (0.1*0.1+0.1*0.1)/0.2, 0.1, 0.0, 0.0, 0.0, 0.0])
     s1_l = np.array([0.1, (0.1*0.1+0.1*0.1)/0.2, 0.1, 0.0, 0.0, 0.0, 0.0])
-    s2_r = np.array([0.1*0.1/0.3, 0.1*0.3/0.3, 0.1*0.2/0.3,
+    # s2_r = np.array([0.1*0.1/0.3, 0.1*0.3/0.3, 0.1*0.2/0.3,
+    #                  0.0, 0.1, 0.0, 0.0])
+    # s2_l = np.array([0.1*0.1/0.3, 0.1*0.1/0.3, 0.1*0.2/0.3, 0.0,
+    #                  0.1, 0.0, 0.0])
+    # eero's edge correction:
+    s2_r = np.array([0.1, 0.1*0.3/0.3, 0.1*0.2/0.3,
                      0.0, 0.1, 0.0, 0.0])
-    s2_l = np.array([0.1*0.1/0.3, 0.1*0.1/0.3, 0.1*0.2/0.3, 0.0,
+    s2_l = np.array([0.1, 0.1*0.3/0.3, 0.1*0.2/0.3, 0.0,
                      0.1, 0.0, 0.0])
     isi1 = np.array([0.2, 0.2, 0.2, 0.2, 0.2, 0.4])
     isi2 = np.array([0.3, 0.3, 0.3, 0.1, 0.1, 0.4])
@@ -345,7 +364,7 @@ def test_regression_spiky():
     assert_equal(isi_profile.y, 0.1/1.1 * np.ones_like(isi_profile.y))
 
     spike_dist = spk.spike_distance(st1, st2)
-    assert_equal(spike_dist, 2.1105878248735391e-01)
+    assert_equal(spike_dist, 0.211058782487353908)
 
     spike_sync = spk.spike_sync(st1, st2)
     assert_equal(spike_sync, 8.6956521739130432e-01)
@@ -363,12 +382,31 @@ def test_regression_spiky():
 
     spike_dist = spk.spike_distance_multi(spike_trains)
     # get the full precision from SPIKY
-    assert_almost_equal(spike_dist, 2.4432433330596512e-01, decimal=15)
+    assert_almost_equal(spike_dist, 0.25188056475463755, decimal=15)
 
     spike_sync = spk.spike_sync_multi(spike_trains)
     # get the full precision from SPIKY
     assert_equal(spike_sync, 0.7183531505298066)
 
+    # Eero's edge correction example
+    st1 = SpikeTrain([0.5, 1.5, 2.5], 6.0)
+    st2 = SpikeTrain([3.5, 4.5, 5.5], 6.0)
+
+    f = spk.spike_profile(st1, st2)
+
+    expected_times = np.array([0.0, 0.5, 1.5, 2.5, 3.5, 4.5, 5.5, 6.0])
+    y_all = np.array([0.271604938271605, 0.271604938271605, 0.271604938271605,
+                      0.617283950617284, 0.617283950617284, 0.444444444444444,
+                      0.285714285714286, 0.285714285714286, 0.444444444444444,
+                      0.617283950617284, 0.617283950617284, 0.271604938271605,
+                      0.271604938271605, 0.271604938271605])
+    expected_y1 = y_all[::2]
+    expected_y2 = y_all[1::2]
+
+    assert_equal(f.x, expected_times)
+    assert_array_almost_equal(f.y1, expected_y1, decimal=14)
+    assert_array_almost_equal(f.y2, expected_y2, decimal=14)
+
 
 def test_multi_variate_subsets():
     spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
diff --git a/test/test_empty.py b/test/test_empty.py
index af7fb36..5a0042f 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -70,8 +70,8 @@ def test_spike_empty():
     st1 = SpikeTrain([], edges=(0.0, 1.0))
     st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
     d = spk.spike_distance(st1, st2)
-    assert_almost_equal(d, 0.4*0.4*1.0/(0.4+1.0)**2 + 0.6*0.4*1.0/(0.6+1.0)**2,
-                        decimal=15)
+    d_expect = 0.4*0.4*1.0/(0.4+1.0)**2 + 0.6*0.4*1.0/(0.6+1.0)**2
+    assert_almost_equal(d, d_expect, decimal=15)
     prof = spk.spike_profile(st1, st2)
     assert_equal(d, prof.avrg())
     assert_array_equal(prof.x, [0.0, 0.4, 1.0])
-- 
cgit v1.2.3


From e32272f4540de347abcc548a94239b625458b3a6 Mon Sep 17 00:00:00 2001
From: Mario Mulansky <mario.mulansky@gmx.net>
Date: Tue, 22 Dec 2015 18:15:59 +0100
Subject: changed edge correction for single spikes

Spike trains with single spikes now only get auxiliary spikes at the edges
for the SPIKE distance instead of real spikes before.
---
 pyspike/SpikeTrain.py               |  2 +-
 pyspike/cython/cython_distances.pyx | 89 ++++++++++++++++++++++---------------
 pyspike/cython/cython_profiles.pyx  | 67 +++++++++++++++-------------
 pyspike/cython/python_backend.py    | 68 +++++++++++++---------------
 test/test_empty.py                  | 16 ++++---
 5 files changed, 130 insertions(+), 112 deletions(-)

(limited to 'test/test_empty.py')

diff --git a/pyspike/SpikeTrain.py b/pyspike/SpikeTrain.py
index 4b59a5d..19f2419 100644
--- a/pyspike/SpikeTrain.py
+++ b/pyspike/SpikeTrain.py
@@ -68,7 +68,7 @@ class SpikeTrain(object):
         """Returns the spikes of this spike train with auxiliary spikes in case
         of empty spike trains.
         """
-        if len(self.spikes) < 2:
+        if len(self.spikes) < 1:
             return np.unique(np.insert([self.t_start, self.t_end], 1,
                                        self.spikes))
         else:
diff --git a/pyspike/cython/cython_distances.pyx b/pyspike/cython/cython_distances.pyx
index 6c6e7e5..7dc9cb9 100644
--- a/pyspike/cython/cython_distances.pyx
+++ b/pyspike/cython/cython_distances.pyx
@@ -55,20 +55,27 @@ def isi_distance_cython(double[:] s1, double[:] s2,
     N2 = len(s2)
 
     # first interspike interval - check if a spike exists at the start time
+    # and also account for spike trains with single spikes
     if s1[0] > t_start:
-        # edge correction
-        nu1 = fmax(s1[0]-t_start, s1[1]-s1[0])
+        # edge correction for the first interspike interval: 
+        # take the maximum of the distance from the beginning to the first
+        # spike and the interval between the first two spikes.
+        # if there is only one spike, take the its distance to the beginning
+        nu1 = fmax(s1[0]-t_start, s1[1]-s1[0]) if N1 > 1 else s1[0]-t_start
         index1 = -1
     else:
-        nu1 = s1[1]-s1[0]
+        # if the first spike is exactly at the start, take the distance
+        # to the next spike. If this is the only spike, take the distance to
+        # the end.
+        nu1 = s1[1]-s1[0] if N1 > 1 else t_end-s1[0]
         index1 = 0
 
     if s2[0] > t_start:
-        # edge correction
-        nu2 = fmax(s2[0]-t_start, s2[1]-s2[0])
+        # edge correction as above
+        nu2 = fmax(s2[0]-t_start, s2[1]-s2[0]) if N2 > 1 else s2[0]-t_start
         index2 = -1
     else:
-        nu2 = s2[1]-s2[0]
+        nu2 = s2[1]-s2[0] if N2 > 1 else t_end-s2[0]
         index2 = 0
 
     last_t = t_start
@@ -86,8 +93,12 @@ def isi_distance_cython(double[:] s1, double[:] s2,
                 if index1 < N1-1:
                     nu1 = s1[index1+1]-s1[index1]
                 else:
-                    # edge correction
-                    nu1 = fmax(t_end-s1[index1], nu1)
+                    # edge correction for the last ISI: 
+                    # take the max of the distance of the last
+                    # spike to the end and the previous ISI. If there was only
+                    # one spike, always take the distance to the end.
+                    nu1 = fmax(t_end-s1[index1], nu1) if N1 > 1 \
+                          else t_end-s1[index1]
             elif (index2 < N2-1) and ((index1 == N1-1) or
                                       (s1[index1+1] > s2[index2+1])):
                 index2 += 1
@@ -95,8 +106,9 @@ def isi_distance_cython(double[:] s1, double[:] s2,
                 if index2 < N2-1:
                     nu2 = s2[index2+1]-s2[index2]
                 else:
-                    # edge correction
-                    nu2 = fmax(t_end-s2[index2], nu2)
+                    # edge correction for the end as above
+                    nu2 = fmax(t_end-s2[index2], nu2) if N2 > 1 \
+                          else t_end-s2[index2]
             else: # s1[index1+1] == s2[index2+1]
                 index1 += 1
                 index2 += 1
@@ -104,13 +116,15 @@ def isi_distance_cython(double[:] s1, double[:] s2,
                 if index1 < N1-1:
                     nu1 = s1[index1+1]-s1[index1]
                 else:
-                    # edge correction
-                    nu1 = fmax(t_end-s1[index1], nu1)
+                    # edge correction for the end as above
+                    nu1 = fmax(t_end-s1[index1], nu1) if N1 > 1 \
+                          else t_end-s1[index1]
                 if index2 < N2-1:
                     nu2 = s2[index2+1]-s2[index2]
                 else:
-                    # edge correction
-                    nu2 = fmax(t_end-s2[index2], nu2)
+                    # edge correction for the end as above
+                    nu2 = fmax(t_end-s2[index2], nu2) if N2 > 1 \
+                          else t_end-s2[index2]
             # compute the corresponding isi-distance
             isi_value += curr_isi * (curr_t - last_t)
             curr_isi = fabs(nu1 - nu2) / fmax(nu1, nu2)
@@ -184,16 +198,18 @@ def spike_distance_cython(double[:] t1, double[:] t2,
     N1 = len(t1)
     N2 = len(t2)
 
-    # with nogil: # release the interpreter to allow multithreading
-    if True:
+    # we can assume at least one spikes per spike train
+    assert N1 > 0
+    assert N2 > 0
+
+
+    with nogil: # release the interpreter to allow multithreading
         t_last = t_start
-        # t_p1 = t_start
-        # t_p2 = t_start
         # auxiliary spikes for edge correction - consistent with first/last ISI 
-        t_aux1[0] = fmin(t_start, t1[0]-(t1[1]-t1[0]))
-        t_aux1[1] = fmax(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2]))
-        t_aux2[0] = fmin(t_start, t2[0]-(t2[1]-t2[0]))
-        t_aux2[1] = fmax(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2]))
+        t_aux1[0] = fmin(t_start, 2*t1[0]-t1[1]) if N1 > 1 else t_start
+        t_aux1[1] = fmax(t_end, 2*t1[N1-1]-t1[N1-2]) if N1 > 1 else t_end
+        t_aux2[0] = fmin(t_start, 2*t2[0]-t2[1]) if N2 > 1 else t_start
+        t_aux2[1] = fmax(t_end, 2*t2[N2-1]+-t2[N2-2]) if N2 > 1 else t_end
         # print "aux spikes %.15f, %.15f ; %.15f, %.15f" % (t_aux1[0], t_aux1[1], t_aux2[0], t_aux2[1])
         t_p1 = t_start if (t1[0] == t_start) else t_aux1[0]
         t_p2 = t_start if (t2[0] == t_start) else t_aux2[0]
@@ -201,17 +217,16 @@ def spike_distance_cython(double[:] t1, double[:] t2,
             # dt_p1 = t2[0]-t_start
             t_f1 = t1[0]
             dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
-            isi1 = fmax(t_f1-t_start, t1[1]-t1[0])
+            isi1 = fmax(t_f1-t_start, t1[1]-t1[0]) if N1 > 1 else t_f1-t_start
             dt_p1 = dt_f1
             # s1 = dt_p1*(t_f1-t_start)/isi1
             s1 = dt_p1
             index1 = -1
-        else:
-            t_f1 = t1[1]
+        else:  # t1[0] == t_start
+            t_f1 = t1[1] if N1 > 1 else t_end
             dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
-            # dt_p1 = t_start-t_p2  # 0.0
             dt_p1 = get_min_dist_cython(t_p1, t2, N2, 0, t_aux2[0], t_aux2[1])
-            isi1 = t1[1]-t1[0]
+            isi1 = t_f1-t1[0]
             s1 = dt_p1
             index1 = 0
         if t2[0] > t_start:
@@ -219,16 +234,16 @@ def spike_distance_cython(double[:] t1, double[:] t2,
             t_f2 = t2[0]
             dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = dt_f2
-            isi2 = fmax(t_f2-t_start, t2[1]-t2[0])
+            isi2 = fmax(t_f2-t_start, t2[1]-t2[0]) if N2 > 1 else t_f2-t_start
             # s2 = dt_p2*(t_f2-t_start)/isi2
             s2 = dt_p2
             index2 = -1
-        else:
-            t_f2 = t2[1]
+        else:  # t2[0] == t_start
+            t_f2 = t2[1] if N2 > 1 else t_end
             dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             # dt_p2 = t_start-t_p1  # 0.0
             dt_p2 = get_min_dist_cython(t_p2, t1, N1, 0, t_aux1[0], t_aux1[1])
-            isi2 = t2[1]-t2[0]
+            isi2 = t_f2-t2[0]
             s2 = dt_p2
             index2 = 0
 
@@ -263,7 +278,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                     s1 = dt_p1
                 else:
                     dt_f1 = dt_p1
-                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                           else t_end-t1[N1-1]
                     # s1 needs adjustment due to change of isi1
                     # s1 = dt_p1*(t_end-t1[N1-1])/isi1
                     # Eero's correction: no adjustment
@@ -296,7 +312,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                     s2 = dt_p2
                 else:
                     dt_f2 = dt_p2
-                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                           else t_end-t2[N2-1]
                     # s2 needs adjustment due to change of isi2
                     # s2 = dt_p2*(t_end-t2[N2-1])/isi2
                     # Eero's correction: no adjustment
@@ -322,7 +339,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 else:
                     t_f1 = t_aux1[1]
                     dt_f1 = dt_p1
-                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                           else t_end-t1[N1-1]
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
@@ -331,7 +349,8 @@ def spike_distance_cython(double[:] t1, double[:] t2,
                 else:
                     t_f2 = t_aux2[1]
                     dt_f2 = dt_p2
-                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                           else t_end-t2[N2-1]
             index += 1
             t_last = t_curr
         # isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
diff --git a/pyspike/cython/cython_profiles.pyx b/pyspike/cython/cython_profiles.pyx
index f08de6e..4a42cdb 100644
--- a/pyspike/cython/cython_profiles.pyx
+++ b/pyspike/cython/cython_profiles.pyx
@@ -63,18 +63,18 @@ def isi_profile_cython(double[:] s1, double[:] s2,
     # first interspike interval - check if a spike exists at the start time
     if s1[0] > t_start:
         # edge correction
-        nu1 = fmax(s1[0]-t_start, s1[1]-s1[0])
+        nu1 = fmax(s1[0]-t_start, s1[1]-s1[0]) if N1 > 1 else s1[0]-t_start
         index1 = -1
     else:
-        nu1 = s1[1]-s1[0]
+        nu1 = s1[1]-s1[0] if N1 > 1 else t_end-s1[0]
         index1 = 0
 
     if s2[0] > t_start:
         # edge correction
-        nu2 = fmax(s2[0]-t_start, s2[1]-s2[0])
+        nu2 = fmax(s2[0]-t_start, s2[1]-s2[0]) if N2 > 1 else s2[0]-t_start
         index2 = -1
     else:
-        nu2 = s2[1]-s2[0]
+        nu2 = s2[1]-s2[0] if N2 > 1 else t_end-s2[0]
         index2 = 0
 
     isi_values[0] = fabs(nu1-nu2)/fmax(nu1, nu2)
@@ -92,7 +92,8 @@ def isi_profile_cython(double[:] s1, double[:] s2,
                     nu1 = s1[index1+1]-s1[index1]
                 else:
                     # edge correction
-                    nu1 = fmax(t_end-s1[index1], nu1)
+                    nu1 = fmax(t_end-s1[index1], nu1) if N1 > 1 \
+                          else t_end-s1[index1]
             elif (index2 < N2-1) and ((index1 == N1-1) or
                                       (s1[index1+1] > s2[index2+1])):
                 index2 += 1
@@ -101,7 +102,8 @@ def isi_profile_cython(double[:] s1, double[:] s2,
                     nu2 = s2[index2+1]-s2[index2]
                 else:
                     # edge correction
-                    nu2 = fmax(t_end-s2[index2], nu2)
+                    nu2 = fmax(t_end-s2[index2], nu2) if N2 > 1 \
+                          else t_end-s2[index2]
             else: # s1[index1+1] == s2[index2+1]
                 index1 += 1
                 index2 += 1
@@ -110,12 +112,14 @@ def isi_profile_cython(double[:] s1, double[:] s2,
                     nu1 = s1[index1+1]-s1[index1]
                 else:
                     # edge correction
-                    nu1 = fmax(t_end-s1[index1], nu1)
+                    nu1 = fmax(t_end-s1[index1], nu1) if N1 > 1 \
+                          else t_end-s1[index1]
                 if index2 < N2-1:
                     nu2 = s2[index2+1]-s2[index2]
                 else:
                     # edge correction
-                    nu2 = fmax(t_end-s2[index2], nu2)
+                    nu2 = fmax(t_end-s2[index2], nu2) if N2 > 1 \
+                          else t_end-s2[index2]
             # compute the corresponding isi-distance
             isi_values[index] = fabs(nu1 - nu2) / fmax(nu1, nu2)
             index += 1
@@ -191,9 +195,9 @@ def spike_profile_cython(double[:] t1, double[:] t2,
     N1 = len(t1)
     N2 = len(t2)
 
-    # we can assume at least two spikes per spike train
-    assert N1 > 1
-    assert N2 > 1
+    # we can assume at least one spikes per spike train
+    assert N1 > 0
+    assert N2 > 0
 
     spike_events = np.empty(N1+N2+2)
 
@@ -205,26 +209,26 @@ def spike_profile_cython(double[:] t1, double[:] t2,
         # t_p1 = t_start
         # t_p2 = t_start
         # auxiliary spikes for edge correction - consistent with first/last ISI 
-        t_aux1[0] = fmin(t_start, t1[0]-(t1[1]-t1[0]))
-        t_aux1[1] = fmax(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2]))
-        t_aux2[0] = fmin(t_start, t2[0]-(t2[1]-t2[0]))
-        t_aux2[1] = fmax(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2]))
+        t_aux1[0] = fmin(t_start, 2*t1[0]-t1[1]) if N1 > 1 else t_start
+        t_aux1[1] = fmax(t_end, 2*t1[N1-1]-t1[N1-2]) if N1 > 1 else t_end
+        t_aux2[0] = fmin(t_start, 2*t2[0]-t2[1]) if N2 > 1 else t_start
+        t_aux2[1] = fmax(t_end, 2*t2[N2-1]-t2[N2-2]) if N2 > 1 else t_end
         t_p1 = t_start if (t1[0] == t_start) else t_aux1[0]
         t_p2 = t_start if (t2[0] == t_start) else t_aux2[0]
         if t1[0] > t_start:
             # dt_p1 = t2[0]-t_start
             t_f1 = t1[0]
             dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
-            isi1 = fmax(t_f1-t_start, t1[1]-t1[0])
+            isi1 = fmax(t_f1-t_start, t1[1]-t1[0]) if N1 > 1 else t_f1-t_start
             dt_p1 = dt_f1
             # s1 = dt_p1*(t_f1-t_start)/isi1
             s1 = dt_p1
             index1 = -1
         else:
-            t_f1 = t1[1]
+            t_f1 = t1[1] if N1 > 1 else t_end
             dt_f1 = get_min_dist_cython(t_f1, t2, N2, 0, t_aux2[0], t_aux2[1])
-            dt_p1 = 0.0
-            isi1 = t1[1]-t1[0]
+            dt_p1 = get_min_dist_cython(t_p1, t2, N2, 0, t_aux2[0], t_aux2[1])
+            isi1 = t_f1-t1[0]
             s1 = dt_p1
             index1 = 0
         if t2[0] > t_start:
@@ -232,15 +236,15 @@ def spike_profile_cython(double[:] t1, double[:] t2,
             t_f2 = t2[0]
             dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
             dt_p2 = dt_f2
-            isi2 = fmax(t_f2-t_start, t2[1]-t2[0])
+            isi2 = fmax(t_f2-t_start, t2[1]-t2[0]) if N2 > 1 else t_f2-t_start
             # s2 = dt_p2*(t_f2-t_start)/isi2
             s2 = dt_p2
             index2 = -1
         else:
-            t_f2 = t2[1]
+            t_f2 = t2[1] if N2 > 1 else t_end
             dt_f2 = get_min_dist_cython(t_f2, t1, N1, 0, t_aux1[0], t_aux1[1])
-            dt_p2 = 0.0
-            isi2 = t2[1]-t2[0]
+            dt_p2 = get_min_dist_cython(t_p2, t1, N1, 0, t_aux1[0], t_aux1[1])
+            isi2 = t_f2-t2[0]
             s2 = dt_p2
             index2 = 0
 
@@ -273,7 +277,8 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                     s1 = dt_p1
                 else:
                     dt_f1 = dt_p1
-                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                           else t_end-t1[N1-1]
                     # s1 needs adjustment due to change of isi1
                     # s1 = dt_p1*(t_end-t1[N1-1])/isi1
                     # Eero's correction: no adjustment
@@ -305,7 +310,8 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                     s2 = dt_p2
                 else:
                     dt_f2 = dt_p2
-                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                           else t_end-t2[N2-1]
                     # s2 needs adjustment due to change of isi2
                     # s2 = dt_p2*(t_end-t2[N2-1])/isi2
                     # Eero's correction: no adjustment
@@ -330,7 +336,8 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 else:
                     t_f1 = t_aux1[1]
                     dt_f1 = dt_p1
-                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                    isi1 = fmax(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                           else t_end-t1[N1-1]
                 if index2 < N2-1:
                     t_f2 = t2[index2+1]
                     dt_f2 = get_min_dist_cython(t_f2, t1, N1, index1,
@@ -339,18 +346,14 @@ def spike_profile_cython(double[:] t1, double[:] t2,
                 else:
                     t_f2 = t_aux2[1]
                     dt_f2 = dt_p2
-                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                    isi2 = fmax(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                           else t_end-t2[N2-1]
             index += 1
         # the last event is the interval end
         if spike_events[index-1] == t_end:
             index -= 1
         else:
             spike_events[index] = t_end
-            # the ending value of the last interval
-            isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
-            isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
-            # s1 = dt_f1*(t_end-t1[N1-1])/isi1
-            # s2 = dt_f2*(t_end-t2[N2-1])/isi2
             s1 = dt_f1
             s2 = dt_f2
             y_ends[index-1] = (s1*isi2 + s2*isi1) / isi_avrg_cython(isi1, isi2)
diff --git a/pyspike/cython/python_backend.py b/pyspike/cython/python_backend.py
index cf898d7..a1e3a65 100644
--- a/pyspike/cython/python_backend.py
+++ b/pyspike/cython/python_backend.py
@@ -28,17 +28,17 @@ def isi_distance_python(s1, s2, t_start, t_end):
     isi_values = np.empty(len(spike_events) - 1)
     if s1[0] > t_start:
         # edge correction
-        nu1 = max(s1[0] - t_start, s1[1] - s1[0])
+        nu1 = max(s1[0] - t_start, s1[1] - s1[0]) if N1 > 1 else s1[0]-t_start
         index1 = -1
     else:
-        nu1 = s1[1] - s1[0]
+        nu1 = s1[1] - s1[0] if N1 > 1 else t_end-s1[0]
         index1 = 0
     if s2[0] > t_start:
         # edge correction
-        nu2 = max(s2[0] - t_start, s2[1] - s2[0])
+        nu2 = max(s2[0] - t_start, s2[1] - s2[0]) if N2 > 1 else s2[0]-t_start
         index2 = -1
     else:
-        nu2 = s2[1] - s2[0]
+        nu2 = s2[1] - s2[0] if N2 > 1 else t_end-s2[0]
         index2 = 0
 
     isi_values[0] = abs(nu1 - nu2) / max(nu1, nu2)
@@ -52,7 +52,8 @@ def isi_distance_python(s1, s2, t_start, t_end):
                 nu1 = s1[index1+1]-s1[index1]
             else:
                 # edge correction
-                nu1 = max(t_end-s1[N1-1], s1[N1-1]-s1[N1-2])
+                nu1 = max(t_end-s1[N1-1], s1[N1-1]-s1[N1-2]) if N1 > 1 \
+                    else t_end-s1[N1-1]
 
         elif (index2 < N2-1) and (index1 == N1-1 or
                                   s1[index1+1] > s2[index2+1]):
@@ -62,7 +63,8 @@ def isi_distance_python(s1, s2, t_start, t_end):
                 nu2 = s2[index2+1]-s2[index2]
             else:
                 # edge correction
-                nu2 = max(t_end-s2[N2-1], s2[N2-1]-s2[N2-2])
+                nu2 = max(t_end-s2[N2-1], s2[N2-1]-s2[N2-2]) if N2 > 1 \
+                    else t_end-s2[N2-1]
 
         else:  # s1[index1 + 1] == s2[index2 + 1]
             index1 += 1
@@ -72,12 +74,14 @@ def isi_distance_python(s1, s2, t_start, t_end):
                 nu1 = s1[index1+1]-s1[index1]
             else:
                 # edge correction
-                nu1 = max(t_end-s1[N1-1], s1[N1-1]-s1[N1-2])
+                nu1 = max(t_end-s1[N1-1], s1[N1-1]-s1[N1-2]) if N1 > 1 \
+                    else t_end-s1[N1-1]
             if index2 < N2-1:
                 nu2 = s2[index2+1]-s2[index2]
             else:
                 # edge correction
-                nu2 = max(t_end-s2[N2-1], s2[N2-1]-s2[N2-2])
+                nu2 = max(t_end-s2[N2-1], s2[N2-1]-s2[N2-2]) if N2 > 1 \
+                    else t_end-s2[N2-1]
         # compute the corresponding isi-distance
         isi_values[index] = abs(nu1 - nu2) / \
             max(nu1, nu2)
@@ -146,10 +150,10 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
 
     t_aux1 = np.zeros(2)
     t_aux2 = np.zeros(2)
-    t_aux1[0] = min(t_start, t1[0]-(t1[1]-t1[0]))
-    t_aux1[1] = max(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2]))
-    t_aux2[0] = min(t_start, t2[0]-(t2[1]-t2[0]))
-    t_aux2[1] = max(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2]))
+    t_aux1[0] = min(t_start, t1[0]-(t1[1]-t1[0])) if N1 > 1 else t_start
+    t_aux1[1] = max(t_end, t1[N1-1]+(t1[N1-1]-t1[N1-2])) if N1 > 1 else t_end
+    t_aux2[0] = min(t_start, t2[0]-(t2[1]-t2[0])) if N2 > 1 else t_start
+    t_aux2[1] = max(t_end, t2[N2-1]+(t2[N2-1]-t2[N2-2])) if N2 > 1 else t_end
     t_p1 = t_start if (t1[0] == t_start) else t_aux1[0]
     t_p2 = t_start if (t2[0] == t_start) else t_aux2[0]
 
@@ -160,16 +164,16 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
         t_f1 = t1[0]
         dt_f1 = get_min_dist(t_f1, t2, 0, t_aux2[0], t_aux2[1])
         dt_p1 = dt_f1
-        isi1 = max(t_f1-t_start, t1[1]-t1[0])
+        isi1 = max(t_f1-t_start, t1[1]-t1[0]) if N1 > 1 else t_f1-t_start
         # s1 = dt_p1*(t_f1-t_start)/isi1
         s1 = dt_p1
         index1 = -1
     else:
         # dt_p1 = t_start-t_p2
+        t_f1 = t1[1] if N1 > 1 else t_end
         dt_p1 = get_min_dist(t_p1, t2, 0, t_aux2[0], t_aux2[1])
-        t_f1 = t1[1]
         dt_f1 = get_min_dist(t_f1, t2, 0, t_aux2[0], t_aux2[1])
-        isi1 = t1[1]-t1[0]
+        isi1 = t_f1-t1[0]
         s1 = dt_p1
         index1 = 0
     if t2[0] > t_start:
@@ -177,23 +181,18 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
         t_f2 = t2[0]
         dt_f2 = get_min_dist(t_f2, t1, 0, t_aux1[0], t_aux1[1])
         dt_p2 = dt_f2
-        isi2 = max(t_f2-t_start, t2[1]-t2[0])
+        isi2 = max(t_f2-t_start, t2[1]-t2[0]) if N2 > 1 else t_f2-t_start
         # s2 = dt_p2*(t_f2-t_start)/isi2
         s2 = dt_p2
         index2 = -1
     else:
-        dt_p2 = t_start-t_p1
+        t_f2 = t2[1] if N2 > 1 else t_end
         dt_p2 = get_min_dist(t_p2, t1, 0, t_aux1[0], t_aux1[1])
-        t_f2 = t2[1]
         dt_f2 = get_min_dist(t_f2, t1, 0, t_aux1[0], t_aux1[1])
-        isi2 = t2[1]-t2[0]
+        isi2 = t_f2-t2[0]
         s2 = dt_p2
         index2 = 0
 
-    # print "t_p1:", repr(t_p1), ", t_f1:", repr(t_f1), ", dt_p1:", repr(dt_p1), ", dt_f1:", repr(dt_f1)
-    # print "t_p2:", repr(t_p2), ", t_f2:", repr(t_f2), ", dt_p2:", repr(dt_p2), ", dt_f2:", repr(dt_f2)
-    # print "s1: ", repr(s1), ", s2:", repr(s2)
-
     y_starts[0] = (s1*isi2 + s2*isi1) / (0.5*(isi1+isi2)**2)
     index = 1
 
@@ -221,7 +220,8 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
                 s1 = dt_p1
             else:
                 dt_f1 = dt_p1
-                isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                    else t_end-t1[N1-1]
                 # s1 needs adjustment due to change of isi1
                 # s1 = dt_p1*(t_end-t1[N1-1])/isi1
                 # Eero's correction: no adjustment
@@ -250,7 +250,8 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
                 s2 = dt_p2
             else:
                 dt_f2 = dt_p2
-                isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                    else t_end-t2[N2-1]
                 # s2 needs adjustment due to change of isi2
                 # s2 = dt_p2*(t_end-t2[N2-1])/isi2
                 # Eero's adjustment: no correction
@@ -274,7 +275,8 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
             else:
                 t_f1 = t_aux1[1]
                 dt_f1 = dt_p1
-                isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
+                isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2]) if N1 > 1 \
+                    else t_end-t1[N1-1]
             if index2 < N2-1:
                 t_f2 = t2[index2+1]
                 dt_f2 = get_min_dist(t_f2, t1, index1, t_aux1[0], t_aux1[1])
@@ -282,29 +284,19 @@ def spike_distance_python(spikes1, spikes2, t_start, t_end):
             else:
                 t_f2 = t_aux2[1]
                 dt_f2 = dt_p2
-                isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
+                isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2]) if N2 > 1 \
+                    else t_end-t2[N2-1]
         index += 1
 
-        # print "t_p1:", repr(t_p1), ", t_f1:", repr(t_f1), ", dt_p1:", repr(dt_p1), ", dt_f1:", repr(dt_f1)
-        # print "t_p2:", repr(t_p2), ", t_f2:", repr(t_f2), ", dt_p2:", repr(dt_p2), ", dt_f2:", repr(dt_f2)
-        # print "s1: ", repr(s1), ", s2:", repr(s2)
-
     # the last event is the interval end
     if spike_events[index-1] == t_end:
         index -= 1
     else:
         spike_events[index] = t_end
-        # the ending value of the last interval
-        isi1 = max(t_end-t1[N1-1], t1[N1-1]-t1[N1-2])
-        isi2 = max(t_end-t2[N2-1], t2[N2-1]-t2[N2-2])
         s1 = dt_f1  # *(t_end-t1[N1-1])/isi1
         s2 = dt_f2  # *(t_end-t2[N2-1])/isi2
         y_ends[index-1] = (s1*isi2 + s2*isi1) / (0.5*(isi1+isi2)**2)
 
-    # print "t_p1:", repr(t_p1), ", t_f1:", repr(t_f1), ", dt_p1:", repr(dt_p1), ", dt_f1:", repr(dt_f1)
-    # print "t_p2:", repr(t_p2), ", t_f2:", repr(t_f2), ", dt_p2:", repr(dt_p2), ", dt_f2:", repr(dt_f2)
-    # print "s1: ", repr(s1), ", s2:", repr(s2)
-
     # use only the data added above
     # could be less than original length due to equal spike times
     return spike_events[:index+1], y_starts[:index], y_ends[:index]
diff --git a/test/test_empty.py b/test/test_empty.py
index 5a0042f..4d0a5cf 100644
--- a/test/test_empty.py
+++ b/test/test_empty.py
@@ -24,7 +24,9 @@ def test_get_non_empty():
 
     st = SpikeTrain([0.5, ], edges=(0.0, 1.0))
     spikes = st.get_spikes_non_empty()
-    assert_array_equal(spikes, [0.0, 0.5, 1.0])
+    # assert_array_equal(spikes, [0.0, 0.5, 1.0])
+    # spike trains with one spike don't get edge spikes anymore
+    assert_array_equal(spikes, [0.5, ])
 
 
 def test_isi_empty():
@@ -70,21 +72,23 @@ def test_spike_empty():
     st1 = SpikeTrain([], edges=(0.0, 1.0))
     st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
     d = spk.spike_distance(st1, st2)
-    d_expect = 0.4*0.4*1.0/(0.4+1.0)**2 + 0.6*0.4*1.0/(0.6+1.0)**2
+    d_expect = 2*0.4*0.4*1.0/(0.4+1.0)**2 + 2*0.6*0.4*1.0/(0.6+1.0)**2
     assert_almost_equal(d, d_expect, decimal=15)
     prof = spk.spike_profile(st1, st2)
     assert_equal(d, prof.avrg())
     assert_array_equal(prof.x, [0.0, 0.4, 1.0])
-    assert_array_almost_equal(prof.y1, [0.0, 2*0.4*1.0/(0.6+1.0)**2],
+    assert_array_almost_equal(prof.y1, [2*0.4*1.0/(0.4+1.0)**2,
+                                        2*0.4*1.0/(0.6+1.0)**2],
                               decimal=15)
-    assert_array_almost_equal(prof.y2, [2*0.4*1.0/(0.4+1.0)**2, 0.0],
+    assert_array_almost_equal(prof.y2, [2*0.4*1.0/(0.4+1.0)**2,
+                                        2*0.4*1.0/(0.6+1.0)**2],
                               decimal=15)
 
     st1 = SpikeTrain([0.6, ], edges=(0.0, 1.0))
     st2 = SpikeTrain([0.4, ], edges=(0.0, 1.0))
     d = spk.spike_distance(st1, st2)
-    s1 = np.array([0.0, 0.4*0.2/0.6, 0.2, 0.0])
-    s2 = np.array([0.0, 0.2, 0.2*0.4/0.6, 0.0])
+    s1 = np.array([0.2, 0.2, 0.2, 0.2])
+    s2 = np.array([0.2, 0.2, 0.2, 0.2])
     isi1 = np.array([0.6, 0.6, 0.4])
     isi2 = np.array([0.4, 0.6, 0.6])
     expected_y1 = (s1[:-1]*isi2+s2[:-1]*isi1) / (0.5*(isi1+isi2)**2)
-- 
cgit v1.2.3