improved edge correction for spike distance

Improvement following Eeros suggestions to use auxiliary spike at the edges
consistently with the corresponding corrected ISI intervals.

4 files changed, 122 insertions, 48 deletions

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])