Spike Order support (#39)0.6.0

* reorganized directionality module

* further refactoring of directionality

* completed python directionality backend

* added SPIKE-Sync based filtering

new function filter_by_spike_sync removes spikes that have a multi-variate
Spike Sync value below some threshold

not yet fully tested, python backend missing.

* spike sync filtering, cython sim ann

Added function for filtering out events based on a threshold for the spike
sync values. Usefull for focusing on synchronous events during directionality
analysis.
Also added cython version of simulated annealing for performance.

* added coincidence single profile to python backend

missing function in python backend added, identified and fixed a bug in the
implementation as well

* updated test case to new spike sync behavior

* python3 fixes

* another python3 fix

* reorganized directionality module

* further refactoring of directionality

* completed python directionality backend

* added SPIKE-Sync based filtering

new function filter_by_spike_sync removes spikes that have a multi-variate
Spike Sync value below some threshold

not yet fully tested, python backend missing.

* spike sync filtering, cython sim ann

Added function for filtering out events based on a threshold for the spike
sync values. Usefull for focusing on synchronous events during directionality
analysis.
Also added cython version of simulated annealing for performance.

* added coincidence single profile to python backend

missing function in python backend added, identified and fixed a bug in the
implementation as well

* updated test case to new spike sync behavior

* python3 fixes

* another python3 fix

* Fix absolute imports in directionality measures

* remove commented code

* Add directionality to docs, bump version

* Clean up directionality module, add doxy.

* Remove debug print from tests

* Fix bug in calling Python backend

* Fix incorrect integrals in PieceWiseConstFunc (#36)

* Add (some currently failing) tests for PieceWiseConstFunc.integral

* Fix implementation of PieceWiseConstFunc.integral

Just by adding a special condition for when we are only taking an
integral "between" two edges of a PieceWiseConstFunc
All tests now pass.
Fixes #33.

* Add PieceWiseConstFunc.integral tests for ValueError

* Add testing bounds of integral
* Raise ValueError in function implementation

* Fix incorrect integrals in PieceWiseLinFunc (#38)

Integrals of piece-wise linear functions were incorrect if the
requested interval lies completely between two support points.
This has been fixed, and a unit test exercising this behavior
was added.

Fixes #38

* Add Spike Order example and Tutorial section

Adds an example computing spike order profile and the optimal
spike train order. Also adds a section on spike train order to the
tutorial.

1 files changed, 95 insertions, 0 deletions

diff --git a/test/test_sync_filter.py b/test/test_sync_filter.py
new file mode 100644
index 0000000..e259903
--- /dev/null
+++ b/test/test_sync_filter.py
@@ -0,0 +1,95 @@
+""" test_sync_filter.py
+
+Tests the spike sync based filtering
+
+Copyright 2015, Mario Mulansky <mario.mulansky@gmx.net>
+
+Distributed under the BSD License
+
+"""
+
+from __future__ import print_function
+import numpy as np
+from numpy.testing import assert_equal, assert_almost_equal, \
+    assert_array_almost_equal
+
+import pyspike as spk
+from pyspike import SpikeTrain
+
+
+def test_single_prof():
+    st1 = np.array([1.0, 2.0, 3.0, 4.0])
+    st2 = np.array([1.1, 2.1, 3.8])
+    st3 = np.array([0.9, 3.1, 4.1])
+
+    # cython implementation
+    try:
+        from pyspike.cython.cython_profiles import \
+            coincidence_single_profile_cython as coincidence_impl
+    except ImportError:
+        from pyspike.cython.python_backend import \
+            coincidence_single_python as coincidence_impl
+
+    sync_prof = spk.spike_sync_profile(SpikeTrain(st1, 5.0),
+                                       SpikeTrain(st2, 5.0))
+
+    coincidences = np.array(coincidence_impl(st1, st2, 0, 5.0, 0.0))
+    print(coincidences)
+    for i, t in enumerate(st1):
+        assert_equal(coincidences[i], sync_prof.y[sync_prof.x == t],
+                     "At index %d" % i)
+
+    coincidences = np.array(coincidence_impl(st2, st1, 0, 5.0, 0.0))
+    for i, t in enumerate(st2):
+        assert_equal(coincidences[i], sync_prof.y[sync_prof.x == t],
+                     "At index %d" % i)
+
+    sync_prof = spk.spike_sync_profile(SpikeTrain(st1, 5.0),
+                                       SpikeTrain(st3, 5.0))
+
+    coincidences = np.array(coincidence_impl(st1, st3, 0, 5.0, 0.0))
+    for i, t in enumerate(st1):
+        assert_equal(coincidences[i], sync_prof.y[sync_prof.x == t],
+                     "At index %d" % i)
+
+    st1 = np.array([1.0, 2.0, 3.0, 4.0])
+    st2 = np.array([1.0, 2.0, 4.0])
+
+    sync_prof = spk.spike_sync_profile(SpikeTrain(st1, 5.0),
+                                       SpikeTrain(st2, 5.0))
+
+    coincidences = np.array(coincidence_impl(st1, st2, 0, 5.0, 0.0))
+    for i, t in enumerate(st1):
+        expected = sync_prof.y[sync_prof.x == t]/sync_prof.mp[sync_prof.x == t]
+        assert_equal(coincidences[i], expected,
+                     "At index %d" % i)
+
+
+def test_filter():
+    st1 = SpikeTrain(np.array([1.0, 2.0, 3.0, 4.0]), 5.0)
+    st2 = SpikeTrain(np.array([1.1, 2.1, 3.8]), 5.0)
+    st3 = SpikeTrain(np.array([0.9, 3.1, 4.1]), 5.0)
+
+    # filtered_spike_trains = spk.filter_by_spike_sync([st1, st2], 0.5)
+
+    # assert_equal(filtered_spike_trains[0].spikes, [1.0, 2.0, 4.0])
+    # assert_equal(filtered_spike_trains[1].spikes, [1.1, 2.1, 3.8])
+
+    # filtered_spike_trains = spk.filter_by_spike_sync([st2, st1], 0.5)
+
+    # assert_equal(filtered_spike_trains[0].spikes, [1.1, 2.1, 3.8])
+    # assert_equal(filtered_spike_trains[1].spikes, [1.0, 2.0, 4.0])
+
+    filtered_spike_trains = spk.filter_by_spike_sync([st1, st2, st3], 0.75)
+
+    for st in filtered_spike_trains:
+        print(st.spikes)
+
+    assert_equal(filtered_spike_trains[0].spikes, [1.0, 4.0])
+    assert_equal(filtered_spike_trains[1].spikes, [1.1, 3.8])
+    assert_equal(filtered_spike_trains[2].spikes, [0.9, 4.1])
+
+
+if __name__ == "main":
+    test_single_prof()
+    test_filter()