changed function names distance -> profiles,

added distance functions

4 files changed, 103 insertions, 33 deletions

diff --git a/pyspike/__init__.py b/pyspike/__init__.py
index 1bfa7fc..5146507 100644
--- a/pyspike/__init__.py
+++ b/pyspike/__init__.py
@@ -7,7 +7,9 @@ Distributed under the BSD License
 __all__ = ["function", "distances", "spikes"]
 
 from function import PieceWiseConstFunc, PieceWiseLinFunc, average_profile
-from distances import isi_distance, spike_distance, \
-    isi_distance_multi, spike_distance_multi, isi_distance_matrix
+from distances import isi_profile, isi_distance, \
+    spike_profile, spike_distance, \
+    isi_profile_multi, isi_distance_multi, isi_distance_matrix, \
+    spike_profile_multi, spike_distance_multi
 from spikes import add_auxiliary_spikes, load_spike_trains_from_txt, \
     spike_train_from_string, merge_spike_trains
diff --git a/pyspike/distances.py b/pyspike/distances.py
index 4ba2bd3..e50772f 100644
--- a/pyspike/distances.py
+++ b/pyspike/distances.py
@@ -14,9 +14,9 @@ from pyspike import PieceWiseConstFunc, PieceWiseLinFunc
 
 
 ############################################################
-# isi_distance
+# isi_profile
 ############################################################
-def isi_distance(spikes1, spikes2):
+def isi_profile(spikes1, spikes2):
     """ Computes the isi-distance profile S_isi(t) of the two given spike
     trains. Retruns the profile as a PieceWiseConstFunc object. The S_isi
     values are defined positive S_isi(t)>=0.  The spike trains are expected
@@ -41,9 +41,24 @@ def isi_distance(spikes1, spikes2):
 
 
 ############################################################
-# spike_distance
+# isi_distance
 ############################################################
-def spike_distance(spikes1, spikes2):
+def isi_distance(spikes1, spikes2):
+    """ Computes the isi-distance I of the given spike trains. The
+    isi-distance is the integral over the isi distance profile S_isi(t):
+     I = \int_^T S_isi(t) dt.
+    Args:
+    - spikes1, spikes2: ordered arrays of spike times with auxiliary spikes.
+    Returns:
+    - double value: The isi-distance I.
+    """
+    return isi_profile(spikes1, spikes2).avrg()
+
+
+############################################################
+# spike_profile
+############################################################
+def spike_profile(spikes1, spikes2):
     """ Computes the spike-distance profile S_spike(t) of the two given spike
     trains. Returns the profile as a PieceWiseLinFunc object. The S_spike
     values are defined positive S_spike(t)>=0. The spike trains are expected to
@@ -69,11 +84,26 @@ def spike_distance(spikes1, spikes2):
 
 
 ############################################################
-# multi_distance
+# spike_distance
+############################################################
+def spike_distance(spikes1, spikes2):
+    """ Computes the spike-distance S of the given spike trains. The
+    spike-distance is the integral over the isi distance profile S_spike(t):
+     S = \int_^T S_spike(t) dt.
+    Args:
+    - spikes1, spikes2: ordered arrays of spike times with auxiliary spikes.
+    Returns:
+    - double value: The spike-distance S.
+    """
+    return spike_profile(spikes1, spikes2).avrg()
+
+
+############################################################
+# multi_profile
 ############################################################
-def multi_distance(spike_trains, pair_distance_func, indices=None):
+def multi_profile(spike_trains, pair_distance_func, indices=None):
     """ Internal implementation detail, don't call this function directly,
-    use isi_distance_multi or spike_distance_multi instead.
+    use isi_profile_multi or spike_profile_multi instead.
 
     Computes the multi-variate distance for a set of spike-trains using the
     pair_dist_func to compute pair-wise distances. That is it computes the
@@ -159,41 +189,80 @@ def multi_distance_par(spike_trains, pair_distance_func, indices=None):
 
 
 ############################################################
+# isi_profile_multi
+############################################################
+def isi_profile_multi(spike_trains, indices=None):
+    """ computes the multi-variate isi distance profile for a set of spike
+    trains. That is the average isi-distance of all pairs of spike-trains:
+    S_isi(t) = 2/((N(N-1)) sum_{<i,j>} S_{isi}^{i,j},
+    where the sum goes over all pairs <i,j>
+    Args:
+    - spike_trains: list of spike trains
+    - indices: list of indices defining which spike trains to use,
+    if None all given spike trains are used (default=None)
+    Returns:
+    - A PieceWiseConstFunc representing the averaged isi distance S_isi(t)
+    """
+    return multi_profile(spike_trains, isi_profile, indices)
+
+
+############################################################
 # isi_distance_multi
 ############################################################
 def isi_distance_multi(spike_trains, indices=None):
-    """ computes the multi-variate isi-distance for a set of spike-trains. That
-    is the average isi-distance of all pairs of spike-trains:
-    S(t) = 2/((N(N-1)) sum_{<i,j>} S_{i,j},
+    """ computes the multi-variate isi-distance for a set of spike-trains.
+    That is the time average of the multi-variate spike profile:
+    S_isi = \int_0^T 2/((N(N-1)) sum_{<i,j>} S_{isi}^{i,j},
     where the sum goes over all pairs <i,j>
     Args:
     - spike_trains: list of spike trains
     - indices: list of indices defining which spike trains to use,
     if None all given spike trains are used (default=None)
     Returns:
-    - A PieceWiseConstFunc representing the averaged isi distance S
+    - A double value representing the averaged isi distance S_isi
     """
-    return multi_distance(spike_trains, isi_distance, indices)
+    return isi_profile_multi(spike_trains, indices).avrg()
+
+
+############################################################
+# spike_profile_multi
+############################################################
+def spike_profile_multi(spike_trains, indices=None):
+    """ Computes the multi-variate spike distance profile for a set of spike
+    trains. That is the average spike-distance of all pairs of spike-trains:
+    S_spike(t) = 2/((N(N-1)) sum_{<i,j>} S_{spike}^{i, j},
+    where the sum goes over all pairs <i,j>
+    Args:
+    - spike_trains: list of spike trains
+    - indices: list of indices defining which spike-trains to use,
+    if None all given spike trains are used (default=None)
+    Returns:
+    - A PieceWiseLinFunc representing the averaged spike distance S(t)
+    """
+    return multi_profile(spike_trains, spike_profile, indices)
 
 
 ############################################################
 # spike_distance_multi
 ############################################################
 def spike_distance_multi(spike_trains, indices=None):
-    """ computes the multi-variate spike-distance for a set of spike-trains.
-    That is the average spike-distance of all pairs of spike-trains:
-    S(t) = 2/((N(N-1)) sum_{<i,j>} S_{i, j},
+    """ Computes the multi-variate spike distance for a set of spike trains.
+    That is the time average of the multi-variate spike profile:
+    S_{spike} = \int_0^T 2/((N(N-1)) sum_{<i,j>} S_{spike}^{i, j} dt
     where the sum goes over all pairs <i,j>
     Args:
     - spike_trains: list of spike trains
     - indices: list of indices defining which spike-trains to use,
     if None all given spike trains are used (default=None)
     Returns:
-    - A PieceWiseLinFunc representing the averaged spike distance S
+    - A double value representing the averaged spike distance S
     """
-    return multi_distance(spike_trains, spike_distance, indices)
+    return spike_profile_multi(spike_trains, indices).avrg()
 
 
+############################################################
+# isi_distance_matrix
+############################################################
 def isi_distance_matrix(spike_trains, indices=None):
     """ Computes the average isi-distance of all pairs of spike-trains.
     Args:
@@ -212,7 +281,7 @@ def isi_distance_matrix(spike_trains, indices=None):
         "Invalid index list."
     # generate a list of possible index pairs
     pairs = [(i, j) for i in indices for j in indices[i+1:]]
-    
+
     distance_matrix = np.zeros((len(indices), len(indices)))
     for i, j in pairs:
         d = isi_distance(spike_trains[i], spike_trains[j]).avrg()
diff --git a/test/test_distance.py b/test/test_distance.py
index 0695701..81ffe09 100644
--- a/test/test_distance.py
+++ b/test/test_distance.py
@@ -28,7 +28,7 @@ def test_isi():
     
     t1 = spk.add_auxiliary_spikes(t1, 1.0)
     t2 = spk.add_auxiliary_spikes(t2, 1.0)
-    f = spk.isi_distance(t1, t2)
+    f = spk.isi_profile(t1, t2)
 
     # print("ISI: ", f.y)
 
@@ -44,7 +44,7 @@ def test_isi():
 
     t1 = spk.add_auxiliary_spikes(t1, 1.0)
     t2 = spk.add_auxiliary_spikes(t2, 1.0)
-    f = spk.isi_distance(t1, t2)
+    f = spk.isi_profile(t1, t2)
 
     assert_equal(f.x, expected_times)
     assert_array_almost_equal(f.y, expected_isi, decimal=14)
@@ -69,7 +69,7 @@ def test_spike():
 
     t1 = spk.add_auxiliary_spikes(t1, 1.0)
     t2 = spk.add_auxiliary_spikes(t2, 1.0)
-    f = spk.spike_distance(t1, t2)
+    f = spk.spike_profile(t1, t2)
 
     assert_equal(f.x, expected_times)
     assert_array_almost_equal(f.y1, expected_y1, decimal=14)
@@ -89,7 +89,7 @@ def test_spike():
 
     t1 = spk.add_auxiliary_spikes(t1, 1.0)
     t2 = spk.add_auxiliary_spikes(t2, 1.0)
-    f = spk.spike_distance(t1, t2)
+    f = spk.spike_profile(t1, t2)
 
     assert_equal(f.x, expected_times)
     assert_array_almost_equal(f.y1, expected_y1, decimal=14)
@@ -131,23 +131,23 @@ def check_multi_distance(dist_func, dist_func_multi):
 
 
 def test_multi_isi():
-    check_multi_distance(spk.isi_distance, spk.isi_distance_multi)
+    check_multi_distance(spk.isi_profile, spk.isi_profile_multi)
 
 
 def test_multi_spike():
-    check_multi_distance(spk.spike_distance, spk.spike_distance_multi)
+    check_multi_distance(spk.spike_profile, spk.spike_profile_multi)
 
 
 def test_regression_spiky():
-    spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
+    spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
                                                   (0.0, 4000.0))
-    isi_profile = spk.isi_distance_multi(spike_trains)
+    isi_profile = spk.isi_profile_multi(spike_trains)
     isi_dist = isi_profile.avrg()
     print(isi_dist)
     # get the full precision from SPIKY
     # assert_equal(isi_dist, 0.1832)
 
-    spike_profile = spk.spike_distance_multi(spike_trains)
+    spike_profile = spk.spike_profile_multi(spike_trains)
     spike_dist = spike_profile.avrg()
     print(spike_dist)
     # get the full precision from SPIKY
diff --git a/test/test_spikes.py b/test/test_spikes.py
index bf914c0..d650d5d 100644
--- a/test/test_spikes.py
+++ b/test/test_spikes.py
@@ -23,7 +23,7 @@ def test_auxiliary_spikes():
 
 
 def test_load_from_txt():
-    spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
+    spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
                                                   time_interval=(0, 4000))
     assert len(spike_trains) == 40
 
@@ -39,7 +39,7 @@ def test_load_from_txt():
         assert spike_train[-1] == 4000
 
     # load without adding auxiliary spikes
-    spike_trains2 = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
+    spike_trains2 = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
                                                    time_interval=None)
     assert len(spike_trains2) == 40
     # check auxiliary spikes
@@ -64,9 +64,8 @@ def check_merged_spikes(merged_spikes, spike_trains):
 
 def test_merge_spike_trains():
     # first load the data
-    spike_trains = spk.load_spike_trains_from_txt("PySpike_testdata.txt",
+    spike_trains = spk.load_spike_trains_from_txt("test/PySpike_testdata.txt",
                                                   time_interval=(0, 4000))
-    
     spikes = spk.merge_spike_trains([spike_trains[0], spike_trains[1]])
     # test if result is sorted
     assert((spikes == np.sort(spikes)).all())